KaitlinCort_RecommendationSystem_FullCode.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kaizengrowth/machine_learning_projects/blob/main/KaitlinCort_RecommendationSystem_FullCode.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pXQzH0nC5JtP"
      },
      "source": [
        "# **Project: Amazon Product Recommendation System**\n",
        "\n",
        "# **Marks: 40**\n",
        "\n",
        "\n",
        "Welcome to the project on Recommendation Systems. We will work with the Amazon product reviews dataset for this project. The dataset contains ratings of different electronic products. It does not include information about the products or reviews to avoid bias while building the model.\n",
        "\n",
        "--------------\n",
        "## **Context:**\n",
        "--------------\n",
        "\n",
        "Today, information is growing exponentially with volume, velocity and variety throughout the globe. This has lead to information overload, and too many choices for the consumer of any business. It represents a real dilemma for these consumers and they often turn to denial. Recommender Systems are one of the best tools that help recommending products to consumers while they are browsing online. Providing personalized recommendations which is most relevant for the user is what's most likely to keep them engaged and help business.\n",
        "\n",
        "E-commerce websites like Amazon, Walmart, Target and Etsy use different recommendation models to provide personalized suggestions to different users. These companies spend millions of dollars to come up with algorithmic techniques that can provide personalized recommendations to their users.\n",
        "\n",
        "Amazon, for example, is well-known for its accurate selection of recommendations in its online site. Amazon's recommendation system is capable of intelligently analyzing and predicting customers' shopping preferences in order to offer them a list of recommended products. Amazon's recommendation algorithm is therefore a key element in using AI to improve the personalization of its website. For example, one of the baseline recommendation models that Amazon uses is item-to-item collaborative filtering, which scales to massive data sets and produces high-quality recommendations in real-time.\n",
        "\n",
        "----------------\n",
        "## **Objective:**\n",
        "----------------\n",
        "\n",
        "You are a Data Science Manager at Amazon, and have been given the task of building a recommendation system to recommend products to customers based on their previous ratings for other products. You have a collection of labeled data of Amazon reviews of products. The goal is to extract meaningful insights from the data and build a recommendation system that helps in recommending products to online consumers.\n",
        "\n",
        "-----------------------------\n",
        "## **Dataset:**\n",
        "-----------------------------\n",
        "\n",
        "The Amazon dataset contains the following attributes:\n",
        "\n",
        "- **userId:** Every user identified with a unique id\n",
        "- **productId:** Every product identified with a unique id\n",
        "- **Rating:** The rating of the corresponding product by the corresponding user\n",
        "- **timestamp:** Time of the rating. We **will not use this column** to solve the current problem"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nmdPxJ2Q7W7p"
      },
      "source": [
        "**Note:** The code has some user defined functions that will be usefull while making recommendations and measure model performance, you can use these functions or can create your own functions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "GZ0YAszcT4zK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ffee2186-451b-46fd-e210-695b5d73ac11"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Ibk07-Cyekt"
      },
      "source": [
        "**Installing surprise library**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "05HQoiZYlsbB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19b5cc1f-318c-4a3d-a9e5-b657e5c3f5cc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting surprise\n",
            "  Downloading surprise-0.1-py2.py3-none-any.whl (1.8 kB)\n",
            "Collecting scikit-surprise (from surprise)\n",
            "  Downloading scikit-surprise-1.1.3.tar.gz (771 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m772.0/772.0 kB\u001b[0m \u001b[31m6.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: joblib>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-surprise->surprise) (1.3.2)\n",
            "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.10/dist-packages (from scikit-surprise->surprise) (1.25.2)\n",
            "Requirement already satisfied: scipy>=1.3.2 in /usr/local/lib/python3.10/dist-packages (from scikit-surprise->surprise) (1.11.4)\n",
            "Building wheels for collected packages: scikit-surprise\n",
            "  Building wheel for scikit-surprise (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for scikit-surprise: filename=scikit_surprise-1.1.3-cp310-cp310-linux_x86_64.whl size=3163008 sha256=f2133c8170b8fb817dbb5eab39b93ad9f023483da218c058057b43f00b1f6522\n",
            "  Stored in directory: /root/.cache/pip/wheels/a5/ca/a8/4e28def53797fdc4363ca4af740db15a9c2f1595ebc51fb445\n",
            "Successfully built scikit-surprise\n",
            "Installing collected packages: scikit-surprise, surprise\n",
            "Successfully installed scikit-surprise-1.1.3 surprise-0.1\n"
          ]
        }
      ],
      "source": [
        "!pip install surprise"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7fIt4jcFIm76"
      },
      "source": [
        "## **Importing the necessary libraries and overview of the dataset**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "jzu2P-TT5JtP"
      },
      "outputs": [],
      "source": [
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "from collections import defaultdict\n",
        "\n",
        "from sklearn.metrics import mean_squared_error\n",
        "from statistics import mean, median"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NrXYJAv95JtP"
      },
      "source": [
        "### **Loading the data**\n",
        "- Import the Dataset\n",
        "- Add column names ['user_id', 'prod_id', 'rating', 'timestamp']\n",
        "- Drop the column timestamp\n",
        "- Copy the data to another DataFrame called **df**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 180,
      "metadata": {
        "id": "JGb-Hk1B5JtP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "47791538-240b-4402-cc19-45973d468031"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<bound method NDFrame.head of                 user_id     prod_id  rating\n",
            "0        A2CX7LUOHB2NDG  0321732944     5.0\n",
            "1        A2NWSAGRHCP8N5  0439886341     1.0\n",
            "2        A2WNBOD3WNDNKT  0439886341     3.0\n",
            "3        A1GI0U4ZRJA8WN  0439886341     1.0\n",
            "4        A1QGNMC6O1VW39  0511189877     5.0\n",
            "...                 ...         ...     ...\n",
            "7824476  A2YZI3C9MOHC0L  BT008UKTMW     5.0\n",
            "7824477  A322MDK0M89RHN  BT008UKTMW     5.0\n",
            "7824478  A1MH90R0ADMIK0  BT008UKTMW     4.0\n",
            "7824479  A10M2KEFPEQDHN  BT008UKTMW     4.0\n",
            "7824480  A2G81TMIOIDEQQ  BT008V9J9U     5.0\n",
            "\n",
            "[7824481 rows x 3 columns]>\n"
          ]
        }
      ],
      "source": [
        "df_initial = pd.read_csv('/content/drive/My Drive/ratings_Electronics.csv')\n",
        "\n",
        "# Adding column names\n",
        "df_initial.columns = ['user_id', 'prod_id', 'rating', 'timestamp']\n",
        "\n",
        "# Dropping the 'timestamp' column\n",
        "df_initial.drop('timestamp', axis=1, inplace=True)\n",
        "\n",
        "# Copying the data to another DataFrame called df\n",
        "df = df_initial.copy()\n",
        "\n",
        "print(df.head)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gzD6yxg5vQpJ",
        "outputId": "64fab943-92a6-49ce-8b01-3b088e8f8625"
      },
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 7824481 entries, 0 to 7824480\n",
            "Data columns (total 3 columns):\n",
            " #   Column   Dtype  \n",
            "---  ------   -----  \n",
            " 0   user_id  object \n",
            " 1   prod_id  object \n",
            " 2   rating   float64\n",
            "dtypes: float64(1), object(2)\n",
            "memory usage: 179.1+ MB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OVQnSG5g_9uX"
      },
      "source": [
        "**As this dataset is very large and has 7,824,482 observations, it is not computationally possible to build a model using this. Moreover, many users have only rated a few products and also some products are rated by very few users. Hence, we can reduce the dataset by considering certain logical assumptions.**\n",
        "\n",
        "Here, we will be taking users who have given at least 50 ratings, and the products that have at least 5 ratings, as when we shop online we prefer to have some number of ratings of a product."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 181,
      "metadata": {
        "id": "4yt9W7Q32EQQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eede07e8-f09c-478b-f6b6-fc5168e984de"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4201696\n"
          ]
        }
      ],
      "source": [
        "# Get the column containing the users\n",
        "users = df.user_id\n",
        "\n",
        "# Create a dictionary from users to their number of ratings\n",
        "ratings_count = dict()\n",
        "\n",
        "for user in users:\n",
        "\n",
        "    # If we already have the user, just add 1 to their rating count\n",
        "    if user in ratings_count:\n",
        "        ratings_count[user] += 1\n",
        "\n",
        "    # Otherwise, set their rating count to 1\n",
        "    else:\n",
        "        ratings_count[user] = 1\n",
        "\n",
        "print(len(ratings_count))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 182,
      "metadata": {
        "id": "19XB60dq2EQR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0842dc24-b6a9-4e62-def8-2f0c3c9e6aa4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Index: 125871 entries, 93 to 7824443\n",
            "Data columns (total 3 columns):\n",
            " #   Column   Non-Null Count   Dtype  \n",
            "---  ------   --------------   -----  \n",
            " 0   user_id  125871 non-null  object \n",
            " 1   prod_id  125871 non-null  object \n",
            " 2   rating   125871 non-null  float64\n",
            "dtypes: float64(1), object(2)\n",
            "memory usage: 3.8+ MB\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "# We want our users to have at least 50 ratings to be considered\n",
        "RATINGS_CUTOFF = 50\n",
        "\n",
        "remove_users = []\n",
        "\n",
        "for user, num_ratings in ratings_count.items():\n",
        "    if num_ratings < RATINGS_CUTOFF:\n",
        "        remove_users.append(user)\n",
        "\n",
        "df = df.loc[ ~ df.user_id.isin(remove_users)]\n",
        "\n",
        "print(df.info())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 183,
      "metadata": {
        "id": "33UzK1D82EQS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c17efb22-995f-4c96-c5ed-2116ae611021"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "48190\n",
            "Product ID: B0088CJT4U, Ratings Count: 206\n",
            "Product ID: B003ES5ZUU, Ratings Count: 184\n",
            "Product ID: B000N99BBC, Ratings Count: 167\n",
            "Product ID: B007WTAJTO, Ratings Count: 164\n",
            "Product ID: B00829TIEK, Ratings Count: 149\n",
            "Product ID: B00829THK0, Ratings Count: 137\n",
            "Product ID: B008DWCRQW, Ratings Count: 137\n",
            "Product ID: B002R5AM7C, Ratings Count: 128\n",
            "Product ID: B004CLYEDC, Ratings Count: 118\n",
            "Product ID: B002SZEOLG, Ratings Count: 113\n"
          ]
        }
      ],
      "source": [
        "# Get the column containing the products\n",
        "prods = df.prod_id\n",
        "\n",
        "# Create a dictionary from products to their number of ratings\n",
        "products_ratings_count = dict()\n",
        "\n",
        "for prod in prods:\n",
        "\n",
        "    # If we already have the product, just add 1 to its rating count\n",
        "    if prod in products_ratings_count:\n",
        "        products_ratings_count[prod] += 1\n",
        "\n",
        "    # Otherwise, set their rating count to 1\n",
        "    else:\n",
        "        products_ratings_count[prod] = 1\n",
        "\n",
        "print(len(products_ratings_count))\n",
        "\n",
        "# Sort the dictionary by its values (ratings count) in reverse order\n",
        "sorted_products_ratings = sorted(products_ratings_count.items(), key=lambda item: item[1], reverse=True)\n",
        "\n",
        "# Print the first 10 keys and their ratings\n",
        "for prod, count in sorted_products_ratings[:10]:\n",
        "    print(f'Product ID: {prod}, Ratings Count: {count}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 184,
      "metadata": {
        "id": "u6YE-lUp2EQT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d1ad442c-75d0-426c-eb61-9314e1da4011"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Index: 65290 entries, 1309 to 7824426\n",
            "Data columns (total 3 columns):\n",
            " #   Column   Non-Null Count  Dtype  \n",
            "---  ------   --------------  -----  \n",
            " 0   user_id  65290 non-null  object \n",
            " 1   prod_id  65290 non-null  object \n",
            " 2   rating   65290 non-null  float64\n",
            "dtypes: float64(1), object(2)\n",
            "memory usage: 2.0+ MB\n",
            "None\n",
            "prod_id\n",
            "B0088CJT4U    206\n",
            "B003ES5ZUU    184\n",
            "B000N99BBC    167\n",
            "B007WTAJTO    164\n",
            "B00829TIEK    149\n",
            "             ... \n",
            "B00368CDH6      5\n",
            "B0036AZA6A      5\n",
            "B0036E8V08      5\n",
            "B0036QL1JY      5\n",
            "B00LGQ6HL8      5\n",
            "Name: rating, Length: 5689, dtype: int64\n"
          ]
        }
      ],
      "source": [
        "# We want our item to have at least 5 ratings to be considered\n",
        "PRODUCTS_RATINGS_CUTOFF = 5\n",
        "\n",
        "remove_products = []\n",
        "\n",
        "for product, num_ratings in products_ratings_count.items():\n",
        "    if num_ratings < PRODUCTS_RATINGS_CUTOFF:\n",
        "        remove_products.append(product)\n",
        "\n",
        "df_final = df.loc[~ df.prod_id.isin(remove_products)]\n",
        "print(df_final.info())\n",
        "\n",
        "sorted_ratings_per_product = df_final.groupby('prod_id')['rating'].count().sort_values(ascending=False)\n",
        "print(sorted_ratings_per_product)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 185,
      "metadata": {
        "id": "aL1JZ00o5JtQ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "372402f6-f84b-403a-dadf-1cfb8ed967aa"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "             user_id     prod_id  rating\n",
              "1309  A3LDPF5FMB782Z  1400501466     5.0\n",
              "1321  A1A5KUIIIHFF4U  1400501466     1.0\n",
              "1334  A2XIOXRRYX0KZY  1400501466     3.0\n",
              "1450   AW3LX47IHPFRL  1400501466     5.0\n",
              "1455  A1E3OB6QMBKRYZ  1400501466     1.0"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-3dabdf89-e889-4646-adcd-75899841a9ee\" class=\"colab-df-container\">\n",
              "    <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>user_id</th>\n",
              "      <th>prod_id</th>\n",
              "      <th>rating</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>1309</th>\n",
              "      <td>A3LDPF5FMB782Z</td>\n",
              "      <td>1400501466</td>\n",
              "      <td>5.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1321</th>\n",
              "      <td>A1A5KUIIIHFF4U</td>\n",
              "      <td>1400501466</td>\n",
              "      <td>1.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1334</th>\n",
              "      <td>A2XIOXRRYX0KZY</td>\n",
              "      <td>1400501466</td>\n",
              "      <td>3.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1450</th>\n",
              "      <td>AW3LX47IHPFRL</td>\n",
              "      <td>1400501466</td>\n",
              "      <td>5.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1455</th>\n",
              "      <td>A1E3OB6QMBKRYZ</td>\n",
              "      <td>1400501466</td>\n",
              "      <td>1.0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-3dabdf89-e889-4646-adcd-75899841a9ee')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-3dabdf89-e889-4646-adcd-75899841a9ee button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-3dabdf89-e889-4646-adcd-75899841a9ee');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-4ec9c7ce-63e6-4644-9b2f-f4ebab239e38\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-4ec9c7ce-63e6-4644-9b2f-f4ebab239e38')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-4ec9c7ce-63e6-4644-9b2f-f4ebab239e38 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "df_final",
              "summary": "{\n  \"name\": \"df_final\",\n  \"rows\": 65290,\n  \"fields\": [\n    {\n      \"column\": \"user_id\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 1540,\n        \"samples\": [\n          \"A1VJ0V58N0698J\",\n          \"A14X244VGHWPSX\",\n          \"A14JBDSWKPKTZA\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"prod_id\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 5689,\n        \"samples\": [\n          \"B005EOWBHC\",\n          \"B00BB72WX4\",\n          \"B00B9AB26G\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"rating\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.9889148020336815,\n        \"min\": 1.0,\n        \"max\": 5.0,\n        \"num_unique_values\": 5,\n        \"samples\": [\n          1.0,\n          2.0,\n          3.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 185
        }
      ],
      "source": [
        "# Print a few rows of the imported dataset\n",
        "df_final.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GuPoy_XfxhXZ"
      },
      "source": [
        "## **Exploratory Data Analysis**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s0d0bWeG-sVB"
      },
      "source": [
        "### **Shape of the data**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qyBVTRDTyek0"
      },
      "source": [
        "### **Check the number of rows and columns and provide observations.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 186,
      "metadata": {
        "id": "fJ4eQKaY5JtQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f6b5331b-7bcf-4f8e-fca7-1fb3ef6907e3"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(65290, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 186
        }
      ],
      "source": [
        "# Check the number of rows and columns and provide observations\n",
        "df_final.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Slp-fgWQ-sVD"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "  * The final dataset, filtered to include only users with 50 or more ratings and products with 5 or more ratings, contains 65,290 entries with three columns (`user_id`, `prod_id`, and `rating`).\n",
        "\n",
        "  * This dataset is now more manageable and relevant for building a recommendation system that focuses on the more actively rated products by the more engaged users, leading to more reliable and meaningful recommendations, since the data reflects more consistent user-product interactions.\n",
        "\n",
        "  * This may help reduce the sparcity in the user-item interaction matrix, which could potentially improve the performance of collaborative filtering models by providing a denser set of user-item interactions to learn from. It could also lead to quicker model training times due to its smaller size.\n",
        "\n",
        "  * By selecting only users who have rated 50 or more products and products that have been rated at least 5 times, the tradeoff is that the model might bias towards more popular products and more active users. This decision could potentially overlook niche products or less active users who might also contribute valuable information to the recommendation system."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lAMWm0nC-sVF"
      },
      "source": [
        "### **Data types**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 187,
      "metadata": {
        "id": "SVrgMkye5JtQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a6f2768e-513f-42ee-c734-56779e9cdb5b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "user_id     object\n",
              "prod_id     object\n",
              "rating     float64\n",
              "dtype: object"
            ]
          },
          "metadata": {},
          "execution_count": 187
        }
      ],
      "source": [
        "# Check Data types and provide observations\n",
        "df_final.dtypes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z4fOE02D-sVF"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* The `user_id` and `prod_id` columns are of object type (strings), containing alphanumeric values.\n",
        "\n",
        "* The `ratings` column is a numeric dating type (float64), ready for statistical analysis."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lTMpOROT-sVG"
      },
      "source": [
        "### **Checking for missing values**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 188,
      "metadata": {
        "id": "vt-VEjMA5JtQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ccc13589-9968-4878-8686-855e4232a9c4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "user_id    0\n",
            "prod_id    0\n",
            "rating     0\n",
            "dtype: int64\n"
          ]
        }
      ],
      "source": [
        "# Check for missing values present and provide observations\n",
        "missing_values = df_final.isnull().sum()\n",
        "print(missing_values)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qMWuBNhI5JtR"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* There are no missing values."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wETrCg48-sVG"
      },
      "source": [
        "### **Summary Statistics**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 189,
      "metadata": {
        "id": "tYm30MXR5JtR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6b0a852b-412e-4a4a-bf21-e3a28e4ec189"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "             rating\n",
            "count  65290.000000\n",
            "mean       4.294808\n",
            "std        0.988915\n",
            "min        1.000000\n",
            "25%        4.000000\n",
            "50%        5.000000\n",
            "75%        5.000000\n",
            "max        5.000000\n"
          ]
        }
      ],
      "source": [
        "# Summary statistics of 'rating' variable and provide observations\n",
        "rating_summary = df_final.describe()\n",
        "print(rating_summary)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VqW50EIJxhXc"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* There are 65,290 ratings in the data set, as previously stated. This substantial count suggests a decently large dataset, which provides a solid basis for any analysis or modeling related to user preferences or product quality.\n",
        "\n",
        "* The high average rating across products of about 4.2948, where the max possible rating is 5, suggests that on average, active users have given positive ratings to frequently rated items.\n",
        "\n",
        "* The low variability of ratings with a standard deviation of about 0.9889, indicates that there is some diversity in how users rate products, but the deviation isn't extremely wide. Most ratings are clustered at the mean value, around the higher end of the 5-point scale.\n",
        "\n",
        "* While there are some unsatisfactory user ratings at the minimum rating of 1, and 25% of ratings are 4 or lower, both the median and the 75% quartile values are at 5. This concentration of 50% or more of the ratings at the highest possible value indicates a heavy skew of the distribution of ratings towards high satisfaction among the filtered dataset. There are far more high ratings (4's and 5's) than low ones (1's and 2's). This may suggest that users who are motivated to rate products do so more often when they have a positive experience, which is a bias to consider when designing and evaluating the recommendation system.\n",
        "\n",
        "* Since half of the ratings are at the highest possible value (5), this could indicate a ceiling effect where the rating scale might not fully capture the variance in user satisfaction, potentially masking finer distinctions in very positive experiences. A more nuanced rating system or additional forms of feedback could provide more detailed insights into user experience.\n",
        "\n",
        "* On the other hand, the concentration of ratings at the upper end of the scale might also indicate that that products are of high quality, and the dataset has successfully filtered for products that are well-received by users. This could be beneficial for a recommendation system, as it suggests that the products included are likely to satisfy other users."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ywyFrZIf5JtR"
      },
      "source": [
        "### **Checking the rating distribution**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 190,
      "metadata": {
        "id": "QbqhbEVe-sVH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "outputId": "1c2e418f-5a76-4fe2-ed80-8410fdaedd06"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Create the bar plot and provide observations\n",
        "rating_counts = df_final['rating'].value_counts().sort_index()\n",
        "\n",
        "plt.figure(figsize=(10, 6))\n",
        "rating_counts.plot(kind='bar')\n",
        "plt.title('Rating Distribution')\n",
        "plt.xlabel('Rating')\n",
        "plt.ylabel('Frequency')\n",
        "plt.xticks(rotation=0)\n",
        "plt.grid(axis='y')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t0jONrQv-sVH"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* There's a clear preference for higher ratings of 4 and 5. The largest number of users have given the highest rating of 5, significantly more than those who have rated 4. This skew towards the right is common in product ratings, where satisfied customers are more likely to submit a rating.\n",
        "\n",
        "* Ratings of 1 and 2 are far less common than higher ratings, indicating there are relatively few negative reviews in the dataset.\n",
        "\n",
        "* A moderate rating of 3, which might be considered neutral or average, is also uncommon, though more common than a 1 or 2."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HefpLdLJxhXd"
      },
      "source": [
        "### **Checking the number of unique users and items in the dataset**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 191,
      "metadata": {
        "id": "NbSom7195JtR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9cb87914-4f64-45f7-b329-c60b5989e59b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Unique users: 1540\n",
            "Unique products: 5689\n",
            "User-product ratio: 3.694155844155844\n",
            "count    1540.000000\n",
            "mean       42.396104\n",
            "std        30.558505\n",
            "min         1.000000\n",
            "25%        23.000000\n",
            "50%        34.000000\n",
            "75%        52.000000\n",
            "max       295.000000\n",
            "Name: prod_id, dtype: float64\n"
          ]
        }
      ],
      "source": [
        "# Number of total rows in the data and number of unique user id and product id in the data\n",
        "unique_users = df_final['user_id'].nunique()\n",
        "unique_products = df_final['prod_id'].nunique()\n",
        "\n",
        "print('Unique users:', unique_users)\n",
        "print('Unique products:', unique_products)\n",
        "print('User-product ratio:', unique_products / unique_users)\n",
        "\n",
        "unique_products_per_user = df_final.groupby('user_id')['prod_id'].nunique()\n",
        "print(unique_products_per_user.describe())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qwgz6CUt-sVI"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* There are 1540 unique users in the dataset and 5689 unique products. The diversity of users and large number of products compared to number of users suggeset a wide variety of items have been rated, offering a rich dataset to analyze for recommendations.\n",
        "\n",
        "* The user-product ratio is approximately 3.6941 products rated per user. However, this metric alone doesn't capture the distriibution of ratings across users fully.\n",
        "\n",
        "* On average, each user has rated about 42.4 unique products. This average is substantially higher than the user-product ratio, indicating that while there may be a general trend of users rating multiple products, the distribution has a long tail, skewed by users who rate a very high number of products.The standard deviation of 30.5585 shows there is significant variability in the number of products rated by individual users. Some users rate many more products than others."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RfDnhSS4-sVI"
      },
      "source": [
        "### **Users with the most number of ratings**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 192,
      "metadata": {
        "id": "n7MX452q5JtR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7e66b7e3-5030-42cd-c391-6610018ac609"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "user_id\n",
            "ADLVFFE4VBT8      295\n",
            "A3OXHLG6DIBRW8    230\n",
            "A1ODOGXEYECQQ8    217\n",
            "A36K2N527TXXJN    212\n",
            "A25C2M3QF9G7OQ    203\n",
            "A680RUE1FDO8B     196\n",
            "A1UQBFCERIP7VJ    193\n",
            "A22CW0ZHY3NJH8    193\n",
            "AWPODHOB4GFWL     184\n",
            "AGVWTYW0ULXHT     179\n",
            "Name: count, dtype: int64\n",
            "Average number of ratings per user: 42.396103896103895\n",
            "Median number of ratings per user: 34.0\n"
          ]
        }
      ],
      "source": [
        "# Top 10 users based on the number of ratings\n",
        "all_users = df_final['user_id'].value_counts()\n",
        "top_10_users = all_users.head(10)\n",
        "\n",
        "print(top_10_users)\n",
        "\n",
        "mean_ratings = all_users.mean()\n",
        "median_ratings = all_users.median()\n",
        "\n",
        "print('Average number of ratings per user:', mean_ratings)\n",
        "print('Median number of ratings per user:', median_ratings)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1X2w_jt9-sVI"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* The list of the top 10 users based on the number of ratings they've provided shows a high level of activity from these individuals, with the most active user having provided 295 ratings and the tenth most active providing 179 ratings. Their activity significantly outpaces the average user's engagement level of 42.40 ratings.\n",
        "\n",
        "* The average (mean) number of ratings per user is approximately 42.4. This average is significantly higher than the median number of ratings per user, which is 34. The difference between the mean and median indicates a right-skewed distribution of ratings per user. In other words, while most users rate a moderate number of products, a small number of highly active users rate many products, pushing the mean higher.\n",
        "\n",
        "* The presence of highly active users might influence the recommendations generated by the system. Their preferences could be overrepresented, introducing bias into analyses and models derived from this data, unless measures are taken to normalize user influence based on user activity levels. Implementing a system where the impact of a user's rating is inversely proportional to their total number of ratings could help balance the influence across all users.\n",
        "\n",
        "* The data suggests an opportunity for personalizing recommendations, given the variability in user activity levels. Understanding and segmenting users based on their rating patterns could lead to more effective recommendation strategies. Balancing the influence of highly active users while ensuring the relevance of recommendations for the broader user base can help achieve high user satisfaction."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EnYTx-Ol-sVg"
      },
      "source": [
        "**Now that we have explored and prepared the data, let's build the first recommendation system.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6xYGrGVy5JtS"
      },
      "source": [
        "## **Model 1: Rank Based Recommendation System**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 193,
      "metadata": {
        "id": "yxZTj1UPxhXh",
        "scrolled": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea2a153b-1528-4ff5-9c2d-80b49cb0a1ce"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "            average_rating  ratings_count\n",
            "prod_id                                  \n",
            "B000FQ2JLW             5.0             19\n",
            "B00ISFNSBW             5.0             18\n",
            "B000IJY8DS             5.0             17\n",
            "B001TH7GUA             5.0             17\n",
            "B00HZWJGS8             5.0             17\n"
          ]
        }
      ],
      "source": [
        "# Calculate the average rating for each product\n",
        "average_product_rating = df_final.groupby('prod_id')['rating'].mean()\n",
        "\n",
        "# Calculate the count of ratings for each product\n",
        "product_ratings_count = df_final.groupby('prod_id')['rating'].count()\n",
        "\n",
        "# Create a dataframe with calculated average and count of ratings\n",
        "product_ratings = pd.DataFrame({\n",
        "    'average_rating': average_product_rating,\n",
        "    'ratings_count': product_ratings_count\n",
        "})\n",
        "\n",
        "# Sort the dataframe by average of ratings in the descending order\n",
        "product_ratings_sorted = product_ratings.sort_values(by=['average_rating', 'ratings_count'], ascending=[False, False])\n",
        "\n",
        "# See the first five records of the \"final_rating\" dataset\n",
        "print(product_ratings_sorted.head())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 194,
      "metadata": {
        "id": "zKU__5s1xhXi"
      },
      "outputs": [],
      "source": [
        "# Defining a function to get the top n products based on the highest average rating and minimum interactions\n",
        "def get_top_n_products(df, min_interactions=5, n=10):\n",
        "  \"\"\"\n",
        "    Get the top n products based on the highest average rating, with a minimum number of interactions.\n",
        "\n",
        "    Parameters:\n",
        "    - df: A pandas DataFrame containing at least 'prod_id' and 'rating'.\n",
        "    - min_interactions: The minimum number of ratings (interactions) a product must have to be considered, set at a default optional value of 5.\n",
        "    - n: The number of top products to return, set at a default optional value of 10.\n",
        "\n",
        "    Returns:\n",
        "    - A DataFrame of the top n products sorted by average rating, considering only those with at least min_interactions.\n",
        "    \"\"\"\n",
        "\n",
        "  product_summary = df.groupby('prod_id')['rating'].agg(['mean', 'count'])\n",
        "  product_summary.columns = ['average_rating', 'ratings_count']\n",
        "\n",
        "  # Finding products with minimum number of interactions\n",
        "  filtered_products = product_summary[product_summary['ratings_count'] >= min_interactions]\n",
        "\n",
        "  # Sort values with respect to average rating\n",
        "  top_products = filtered_products.sort_values(by='average_rating', ascending=False).head(n)\n",
        "\n",
        "  return top_products"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F8l6373PxhXi"
      },
      "source": [
        "### **Recommending top 5 products with 50 minimum interactions based on popularity**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 195,
      "metadata": {
        "id": "dBxdLiM_xhXi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4c70c5c2-d9ce-47ed-877e-0f2c1cc8ef77"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "            average_rating  ratings_count\n",
            "prod_id                                  \n",
            "B001TH7GUU        4.871795             78\n",
            "B003ES5ZUU        4.864130            184\n",
            "B0019EHU8G        4.855556             90\n",
            "B006W8U2MU        4.824561             57\n",
            "B000QUUFRW        4.809524             84\n"
          ]
        }
      ],
      "source": [
        "top_5_products_with_50_min_interactions = get_top_n_products(df_final, 50, 5)\n",
        "\n",
        "print(top_5_products_with_50_min_interactions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l9_xW_UMxhXj"
      },
      "source": [
        "### **Recommending top 5 products with 100 minimum interactions based on popularity**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 196,
      "metadata": {
        "id": "dZgGZCUoxhXj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6d12347f-eaba-4e03-9eeb-a55d26561fff"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "            average_rating  ratings_count\n",
            "prod_id                                  \n",
            "B003ES5ZUU        4.864130            184\n",
            "B000N99BBC        4.772455            167\n",
            "B002WE6D44        4.770000            100\n",
            "B007WTAJTO        4.701220            164\n",
            "B002V88HFE        4.698113            106\n"
          ]
        }
      ],
      "source": [
        "top_5_products_with_100_min_interactions = get_top_n_products(df_final, 100, 5)\n",
        "\n",
        "print(top_5_products_with_100_min_interactions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BL-m68a15JtT",
        "outputId": "69132b0f-8d3f-4798-f6a0-249e17a3c822"
      },
      "source": [
        "We have recommended the **top 5** products by using the popularity recommendation system. Now, let's build a recommendation system using **collaborative filtering.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sJI5kiiGvOOK"
      },
      "source": [
        "## **Model 2: Collaborative Filtering Recommendation System**"
      ]
    },
    {
      "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": "code",
      "execution_count": 23,
      "metadata": {
        "id": "UJ1wEylUpexj"
      },
      "outputs": [],
      "source": [
        "# To compute the accuracy of models\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 tuning model hyperparameters\n",
        "from surprise.model_selection import GridSearchCV\n",
        "\n",
        "# For splitting the rating data in train and test datasets\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 K-Fold cross-validation\n",
        "from surprise.model_selection import KFold\n",
        "\n",
        "# For implementing clustering-based recommendation system\n",
        "from surprise import CoClustering"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "54MqVAtDTsnl"
      },
      "source": [
        "**Before building the recommendation systems, let's  go over some basic terminologies we are going to use:**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qsxb3xhnTsnl"
      },
      "source": [
        "**Relevant item:** An item (product in this case) that is actually **rated higher than the threshold rating** is relevant, if the **actual rating is below the threshold then it is a non-relevant item**.  \n",
        "\n",
        "**Recommended item:** An item that's **predicted rating is higher than the threshold is a recommended item**, if the **predicted rating is below the threshold then that product will not be recommended to the user**.  \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "moyLUHCuTsnl"
      },
      "source": [
        "**False Negative (FN):** It is the **frequency of relevant items that are not recommended to the user**. If the relevant items are not recommended to the user, then the user might not buy the product/item. This would result in the **loss of opportunity for the service provider**, which they would like to minimize.\n",
        "\n",
        "**False Positive (FP):** It is the **frequency of recommended items that are actually not relevant**. In this case, the recommendation system is not doing a good job of finding and recommending the relevant items to the user. This would result in **loss of resources for the service provider**, which they would also like to minimize."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yuvc2VaZTsnl"
      },
      "source": [
        "**Recall:** It is the **fraction of actually relevant items that are recommended to the user**, i.e., if out of 10 relevant products, 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."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8NLc36Y8Tsnm"
      },
      "source": [
        "**While making a recommendation system, it becomes customary to look at the performance of the model. In terms of how many recommendations are relevant and vice-versa, below are some most used performance metrics used in the assessment of recommendation systems.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cqF8fRBqTsnm"
      },
      "source": [
        "### **Precision@k, Recall@ k, and F1-score@k**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "imMJNF0HTsnm"
      },
      "source": [
        "**Precision@k** - It is the **fraction of recommended items that are relevant in `top k` predictions**. The 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",
        "\n",
        "**Recall@k** - It is the **fraction of relevant items that are recommended to the user in `top k` predictions**.\n",
        "\n",
        "**F1-score@k** - It is the **harmonic mean of Precision@k and Recall@k**. When **precision@k and recall@k both seem to be important** then it is useful to use this metric because it is representative of both of them."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jBW4BUhWTsnm"
      },
      "source": [
        "### **Some useful functions**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QOBHKh0eTsnm"
      },
      "source": [
        "- Below function takes the **recommendation model** as input and gives the **precision@k, recall@k, and F1-score@k** for that model.  \n",
        "- To compute **precision and recall**, **top k** predictions are taken under consideration for each user.\n",
        "- We will use the precision and recall to compute the F1-score."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 137,
      "metadata": {
        "id": "Rxn-GahOTsnm"
      },
      "outputs": [],
      "source": [
        "def precision_recall_at_k(model, 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",
        "\n",
        "    # Making predictions on the test data\n",
        "    predictions = model.test(testset)\n",
        "\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. Therefore, we are setting Precision to 0 when n_rec_k is 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. Therefore, we are setting Recall to 0 when n_rel is 0\n",
        "\n",
        "        recalls[uid] = n_rel_and_rec_k / n_rel if n_rel != 0 else 0\n",
        "\n",
        "    # Mean of all the predicted precisions are calculated.\n",
        "    precision = round((sum(prec for prec in precisions.values()) / len(precisions)), 3)\n",
        "\n",
        "    # Mean of all the predicted recalls are calculated.\n",
        "    recall = round((sum(rec for rec in recalls.values()) / len(recalls)), 3)\n",
        "\n",
        "    accuracy.rmse(predictions)\n",
        "\n",
        "    print('Precision: ', precision) # Command to print the overall precision\n",
        "\n",
        "    print('Recall: ', recall) # Command to print the overall recall\n",
        "\n",
        "    print('F_1 score: ', round((2*precision*recall)/(precision+recall), 3)) # Formula to compute the F-1 score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_ZmsamDVyek-"
      },
      "source": [
        "**Hints:**\n",
        "\n",
        "- To compute **precision and recall**, a **threshold of 3.5 and k value of 10 can be considered for the recommended and relevant ratings**.\n",
        "- Think about the performance metric to choose."
      ]
    },
    {
      "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`.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 197,
      "metadata": {
        "id": "rGfYDiOCpe4X"
      },
      "outputs": [],
      "source": [
        "# Instantiating Reader scale with expected rating scale\n",
        "reader = Reader(rating_scale=(1, 5))\n",
        "\n",
        "# Loading the rating dataset\n",
        "data = Dataset.load_from_df(df_final[['user_id', 'prod_id', 'rating']], reader)\n",
        "\n",
        "# Splitting the data into train and test datasets\n",
        "trainset, testset = train_test_split(data, test_size=0.25) # For a 75/25 train/test split"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DmHTEt7TnVNC"
      },
      "source": [
        "Now, we are **ready to build the first baseline similarity-based recommendation system** using the cosine similarity."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SVDfVHB4tQfU"
      },
      "source": [
        "### **Building the user-user Similarity-based Recommendation System**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 198,
      "metadata": {
        "id": "vO3FL7iape8A",
        "scrolled": false,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c9cb2920-0f05-49aa-b58b-19a72073e09b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "RMSE: 1.0266\n",
            "Precision:  0.861\n",
            "Recall:  0.825\n",
            "F_1 score:  0.843\n"
          ]
        }
      ],
      "source": [
        "# Declaring the similarity\n",
        "sim_options_user = {\n",
        "    'name': 'cosine',  # Use cosine similarity\n",
        "    'user_based': True  # Compute similarities between users\n",
        "}\n",
        "\n",
        "# Initialize the KNNBasic model using sim_options declared, Verbose = False, and setting random_state = 1\n",
        "user_model = KNNBasic(sim_options=sim_options_user, verbose=False, random_state=1)\n",
        "\n",
        "# Fit the model on the training data\n",
        "user_model.fit(trainset)\n",
        "\n",
        "# Let us compute precision@k, recall@k, and f_1 score using the precision_recall_at_k function defined above\n",
        "precision_recall_at_k(user_model, k=10, threshold=3.5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nEuJK_A9Tsnn"
      },
      "source": [
        "# Observations:\n",
        "\n",
        "### Root Mean Square Error: 1.0266\n",
        "* RMSE is a measure of the average magnitude of the errors between the predicted ratings and the actual ratings, without considering their direction.\n",
        "* An RMSE of 1.0266 suggests that, on average, the predicted ratings deviate from the actual ratings by about 1 point on the rating scale.\n",
        "* For a typical 5-point rating scale, an RMSE slightly above 1 might indicate room for improvement.\n",
        "\n",
        "### Precision: 0.861\n",
        "* Precision measures the proportion of recommended items that are actually relevant to the user. In this case, a precision of 0.861 indicates that about 86.1% of the items recommended by the system are considered relevant by the users.\n",
        "* High precision indicates that the model is effective at filtering out irrelevant items, ensuring that the recommendations are likely to be of interest to the users.\n",
        "\n",
        "### Recall: 0.825\n",
        "* Recall measures the proportion of relevant items that are recommended by the system. A recall of 0.825 suggests that the system is able to recommend approximately 82.5% of the items that are relevant to the users.\n",
        "* This means that while the system is quite good at identifying items of interest, there is a 17.5% chance that a relevant item will not be recommended.\n",
        "\n",
        "### F_1 Score: 0.843\n",
        "* The F1 score is the harmonic mean of precision and recall, providing a single metric that balances both. The closer the F1 score is to 1, the better the balance between precision and recall.\n",
        "* An F1 score of 0.843 is quite high, indicating that the system has a good balance between not recommending irrelevant items (precision) and not missing out on recommending items that are relevant (recall).\n",
        "\n",
        "---\n",
        "\n",
        "### General Assessment:\n",
        "\n",
        "* The recommendation system demonstrates strong performance in terms of precision and recall. The balance between precision and recall, as evidenced by the F1 score, indicates that the model has been tuned to neither overly prioritize the exclusion of irrelevant items at the expense of missing relevant ones, nor to recommend too broadly at the risk of including many irrelevant items.\n",
        "* While the RMSE indicates that there is some discrepancy between predicted and actual ratings, the high precision and recall suggest that the system is still very effective at identifying which items a user will find relevant, even if the exact rating predictions are not always spot on.\n",
        "* There may be opportunities to further improve the model's RMSE through hyperparameter tuning, or exploring more complex models, but the current performance metrics already indicate a strong recommendation system.\n",
        "\n",
        "Further improvements might focus on reducing the RMSE."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "reFD0-nsnVNC"
      },
      "source": [
        "Let's now **predict rating for a user with `userId=A3LDPF5FMB782Z` and `productId=1400501466`** as shown below. Here the user has already interacted or watched the product with productId '1400501466' and given a rating of 5."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 199,
      "metadata": {
        "id": "Sxd23bZ9pe_x",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8fd6805c-b885-49b6-f853-c0db0ff8edb2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating for user A3LDPF5FMB782Z for product 1400501466 is: 3.8\n"
          ]
        }
      ],
      "source": [
        "# Predicting rating for a sample user with an interacted product\n",
        "user_id = 'A3LDPF5FMB782Z'\n",
        "product_id = '1400501466'\n",
        "\n",
        "prediction1 = user_model.predict(user_id, product_id)\n",
        "estimated_rating1 = prediction1.est\n",
        "\n",
        "print(f'Predicted rating for user {user_id} for product {product_id} is: {estimated_rating1}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ENJcqG_wemRH"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* The predicted rating (3.8) is significantly lower than the actual rating of 5 provided by the user for this product. The recommendation system underestimates the user's enthusiasm for the product.\n",
        "\n",
        "* This shows that the collaborative filtering model has captured some aspects of the user's preferences based on similarities with other users or the product's appeal. However, there are certainly areas for model tuning that could help better capture user preferences or product attributes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cj6ecbglTsno"
      },
      "source": [
        "Below is the **list of users who have not seen the product with product id \"1400501466\"**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 141,
      "metadata": {
        "id": "xCRBMD-RTsno",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "66b01d4e-3b59-4823-9b0e-e58b7c7d1bc7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "User \"A34BZM6S9L7QI4\" has not interacted with product \"1400501466\".\n"
          ]
        }
      ],
      "source": [
        "# Find unique user_id where prod_id is not equal to \"1400501466\"\n",
        "users_not_seen_product = df_final[df_final['prod_id'] != '1400501466']['user_id'].unique()\n",
        "\n",
        "# Check if \"A34BZM6S9L7QI4\" is in the list of users who haven't seen the product\n",
        "if \"A34BZM6S9L7QI4\" in users_not_seen_product:\n",
        "    print(f'User \"A34BZM6S9L7QI4\" has not interacted with product \"1400501466\".')\n",
        "else:\n",
        "    print(f'User \"A34BZM6S9L7QI4\" has already interacted with product \"1400501466\".')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KT42ecaSTsno"
      },
      "source": [
        "* It can be observed from the above list that **user \"A34BZM6S9L7QI4\" has not seen the product with productId \"1400501466\"** as this userId is a part of the above list."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EXSgq8OEnVNE"
      },
      "source": [
        "**Below we are predicting rating for `userId=A34BZM6S9L7QI4` and `prod_id=1400501466`.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 200,
      "metadata": {
        "id": "PbFcBj1PpfEV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3c9fdab-f6e4-47b7-f180-e8cfa6fb5d0e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating for user A34BZM6S9L7QI4 for product 1400501466 is: 3.0\n"
          ]
        }
      ],
      "source": [
        "# Predicting rating for a sample user with a non interacted product\n",
        "user_id2 = 'A34BZM6S9L7QI4'\n",
        "\n",
        "prediction2 = user_model.predict(user_id2, product_id)\n",
        "estimated_rating2 = prediction2.est\n",
        "\n",
        "print(f'Predicted rating for user {user_id2} for product {product_id} is: {estimated_rating2}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "02rwld8yemRI"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* A predicted rating of 3.0 on a scale of 1 to 5 indicates a neutral level of expected satisfaction with this product, which has not yet been reviewed by this user, based on the user-user collaborative filtering model's understanding of the user and other similar users' preferences.\n",
        "\n",
        "* This is lower than the average user rating of 4.294808 and the median user rating of 5.0, indicating that the user is predicted to not like this product."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ejjof6csnVNF"
      },
      "source": [
        "### **Improving similarity-based recommendation system by tuning its hyperparameters**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p2j4VvfQnVNF"
      },
      "source": [
        "Below, we will be tuning hyperparameters for the `KNNBasic` algorithm. Let's try to understand some of the hyperparameters of the KNNBasic algorithm:\n",
        "\n",
        "- **k** (int) – The (max) number of neighbors to take into account for aggregation. 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"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 161,
      "metadata": {
        "id": "9LmPbSUSTsnp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ae0d4c26-56ea-405b-9f17-1df106c1e36a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the pearson similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Estimating biases using als...\n",
            "Computing the pearson_baseline similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Best RMSE score: 0.9702662119878923\n",
            "Best parameter combination: {'k': 40, 'min_k': 5, 'sim_options': {'name': 'cosine', 'user_based': True}}\n"
          ]
        }
      ],
      "source": [
        "# Setting up parameter grid to tune the hyperparameters\n",
        "param_grid = {\n",
        "    'k': [20, 30, 40],\n",
        "    'min_k': [3, 5, 7, 9],\n",
        "    'sim_options': {\n",
        "        'name': ['msd', 'cosine', 'pearson', 'pearson_baseline'],\n",
        "        'user_based': [True]  # Whether the similarity is based on users or items\n",
        "    }\n",
        "}\n",
        "\n",
        "# Performing 3-fold cross-validation to tune the\n",
        "gs = GridSearchCV(KNNBasic, param_grid, measures=['rmse'], cv=3)\n",
        "\n",
        "# Fitting the\n",
        "gs.fit(data)\n",
        "\n",
        "# Best RMSE score\n",
        "best_rmse = gs.best_score['rmse']\n",
        "print(f'Best RMSE score: {best_rmse}')\n",
        "\n",
        "# Combination of parameters that gave the best RMSE\n",
        "best_params = gs.best_params['rmse']\n",
        "print(f'Best parameter combination: {best_params}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L2fHNvu7nVNF"
      },
      "source": [
        "Once the grid search is **complete**, we can get the **optimal values for each of those hyperparameters**.\n",
        "\n",
        "---\n",
        "\n",
        "### Observations\n",
        "\n",
        "* GridSearchCV returned a Best RMSE score of 0.9703 for the following parameter combination: {'k': 40, 'min_k': 5, 'sim_options': {'name': 'cosine', 'user_based': True}}\n",
        "\n",
        "* This is an improvement on the original model's RMSE score of 1.0260."
      ]
    },
    {
      "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**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 166,
      "metadata": {
        "id": "PujRJA8X_JEJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eae06d23-f83b-43bd-9627-baaeaac7d87b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "RMSE: 0.9549\n",
            "Precision:  0.859\n",
            "Recall:  0.855\n",
            "F_1 score:  0.857\n"
          ]
        }
      ],
      "source": [
        "# Using the optimal similarity measure for user-user based collaborative filtering\n",
        "sim_options_optimized = {\n",
        "    'name': 'cosine',  # Optimal similarity measure based on GridSearchCV\n",
        "    'user_based': True  # User-user based collaborative filtering\n",
        "}\n",
        "\n",
        "# Creating an instance of KNNBasic with optimal hyperparameter values\n",
        "user_model_optimized = KNNBasic(k=40, min_k=5, sim_options=sim_options_optimized)\n",
        "\n",
        "# Training the algorithm on the trainset\n",
        "user_model_optimized = user_model_optimized.fit(trainset)\n",
        "\n",
        "# Let us compute precision@k and recall@k also with k =10\n",
        "precision_recall_at_k(user_model_optimized, k=10, threshold=3.5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yHsWvFjKTsnp"
      },
      "source": [
        "# Observations:\n",
        "\n",
        "### RMSE: 0.9549\n",
        "* The Root Mean Square Error (RMSE) of 0.9549 reflects an improvement over the previous model before hyperparameter tuning (1.0260).\n",
        "* The decrease in RMSE in the tuned model suggests that hyperparameter tuning has led to more accurate rating predictions. This means that the model's predicted ratings are closer to the actual ratings provided by users, which is a critical factor for the user's trust in the system.\n",
        "\n",
        "### Precision: 0.859\n",
        "* A precision of 0.859 means that 85.9% of the items recommended by the system are indeed relevant to the users. This is equivalent to the previous precision score of 0.859.\n",
        "\n",
        "### Recall: 0.855\n",
        "* The recall score of 0.855 indicates that the system is able to recommend about 85.5% of the items that are relevant to the users. This is an improvement over the previous Recall score of 0.826.\n",
        "* High recall is important for ensuring that users are exposed to a wide variety of items they might like, and enhancing the user experience by capturing a broader range of products that could potentially be of interest to the user.\n",
        "\n",
        "### F1 Score: 0.857\n",
        "* The F1 score, being the harmonic mean of precision and recall, indicates that the model has improved in balancing performance between the accuracy and completeness. It is better than the previous F_1 score of 0.842, suggesting that the optimized model is now able to recommend more products that may appeal to the user without compromising on the precision of those recommendations.\n",
        "\n",
        "----\n",
        "\n",
        "### General Assessment:\n",
        "The improvements in RMSE, recall, and the F1 score indicate that the hyperparameter tuning process has enhanced the model's overall performance, without any decrease in precision. These improvements suggest that the model should now be more effective in identifying a broader range of relevant items to recommend to users, therefore potentially generating more revenue for the company.\n",
        "\n",
        "<br/>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YhcAXK0CnVNG"
      },
      "source": [
        "### **Steps:**\n",
        "- **Predict rating for the user with `userId=\"A3LDPF5FMB782Z\"`, and `prod_id= \"1400501466\"` using the optimized model**\n",
        "- **Predict rating for `userId=\"A34BZM6S9L7QI4\"` who has not interacted with `prod_id =\"1400501466\"`, by using the optimized model**\n",
        "- **Compare the output with the output from the baseline model**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 167,
      "metadata": {
        "id": "FgV63lHiq1TV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "526691c3-3645-4c3e-84be-76980072d20a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating for user A3LDPF5FMB782Z for product 1400501466 is: 4.291665815753467\n"
          ]
        }
      ],
      "source": [
        "# Use sim_user_user_optimized model to recommend for userId \"A3LDPF5FMB782Z\" and productId 1400501466\n",
        "user_prediction_user1 = user_model_optimized.predict(\"A3LDPF5FMB782Z\", \"1400501466\")\n",
        "print(f'Predicted rating for user A3LDPF5FMB782Z for product 1400501466 is: {user_prediction_user1.est}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 169,
      "metadata": {
        "id": "HXO2Ztjhq1bN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "623e02d4-59d0-4089-91a9-197bc3d61a4d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating for user A34BZM6S9L7QI4 for product 1400501466 is: 4.291665815753467\n"
          ]
        }
      ],
      "source": [
        "# Use sim_user_user_optimized model to recommend for userId \"A34BZM6S9L7QI4\" and productId \"1400501466\"\n",
        "user_prediction_user2 = user_model_optimized.predict(\"A34BZM6S9L7QI4\", \"1400501466\")\n",
        "print(f'Predicted rating for user A34BZM6S9L7QI4 for product 1400501466 is: {user_prediction_user2.est}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s5i-OPprNF2e"
      },
      "source": [
        "### Observations\n",
        "\n",
        "* The predicted ratings for both users \"A3LDPF5FMB782Z\" and \"A34BZM6S9L7QI4\" for the product with ID \"1400501466\" using the optimized model are identical, at approximately 4.2917.\n",
        "\n",
        "* For the first user, this fine-tuned user-user CF model prediction is higher than the previous prediction of 3.8, and closer to the actual rating given by the user, which was 5. We can see that the model has improved in predicting a closer score to the user's actual rating.\n",
        "\n",
        "* For the second user, this fine-tuned user-user CF model prediction of 4.2917 is also higher than the original prediction of 3.0. The new model seems to predict that the two users will give identical ratings to the same product. It could be that these users are deemed very similar by the fine-tuned model.  \n",
        "\n",
        "* If many users highly rate the product or if users have very similar rating patterns, the model might consistently predict a high rating for most users for this product. While high predicted ratings are good, identical predictions for different users might also hint at a challenge in ensuring diverse and personalized recommendations. It might be beneficial to explore additional methods that can introduce more personalization into the recommendations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "op_zwO_FnVNH"
      },
      "source": [
        "### **Identifying similar users to a given user (nearest neighbors)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o2QsfqhanVNH"
      },
      "source": [
        "We can also find out **similar users to a given user** or its **nearest neighbors** based on this KNNBasic algorithm. Below, we are finding the 5 most similar users to the first user in the list with internal id 0, based on the `msd` distance metric."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 201,
      "metadata": {
        "id": "TbFle7cKmBJG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "33756604-2f81-4056-fe7b-07b16c627a44"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "The user_id for the user with internal id 0 is: A2ARDVMUGDFED6\n",
            "The 5 most similar users to user with internal id 0 are: ['A31HOWJKEIY037', 'A2BLFCOPSMBOZ9', 'A1C5WS021EL3WO', 'A22CW0ZHY3NJH8', 'A4D5B7Q8A7PA6']\n"
          ]
        }
      ],
      "source": [
        "# 0 is the inner id of the above user\n",
        "sim_options_msd = {\n",
        "    'name': 'msd',\n",
        "    'user_based': True\n",
        "}\n",
        "\n",
        "model_msd = KNNBasic(sim_options=sim_options_msd)\n",
        "model_msd.fit(trainset)\n",
        "\n",
        "inner_id = 0\n",
        "raw_user_id = trainset.to_raw_uid(inner_id)\n",
        "print(f\"The user_id for the user with internal id {inner_id} is: {raw_user_id}\")\n",
        "\n",
        "# Finding the 5 most similar users to the user with inner id 0\n",
        "neighbors = model_msd.get_neighbors(inner_id, k=5)\n",
        "\n",
        "raw_neighbor_ids = [trainset.to_raw_uid(inner_id) for inner_id in neighbors]\n",
        "\n",
        "print(f\"The 5 most similar users to user with internal id {inner_id} are: {raw_neighbor_ids}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Observations:\n",
        "\n",
        "* Using the KNNBasic algorithm based on the msd distance metric, the 5 most similar users to the user with internal id 0 ('A17Z0LVY96TO53') are identified as: 'AW3LX47IHPFRL', 'A19N3S7CBSU6O7', 'A1VHCO8RQFIGQJ', 'A1OGCPMSIVK7G4', and 'ABVYGB2TKBO8F'.\n",
        "\n",
        "* This could prove useful for double-checking our fine-tuned user-user CF model. Let's see if user 'A3LDPF5FMB782Z' is deemed to be similar to user 'A34BZM6S9L7QI4' using the msd distance metric."
      ],
      "metadata": {
        "id": "-B4SbdzNJFSD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "user1_id = 'A3LDPF5FMB782Z'\n",
        "user2_id = 'A34BZM6S9L7QI4'\n",
        "\n",
        "# Convert the raw user_id to inner_id\n",
        "inner_id1 = trainset.to_inner_uid(user1_id)\n",
        "\n",
        "# Finding the 5 most similar users to the user with user1 with inner_id1\n",
        "neighbors_user1 = model_msd.get_neighbors(inner_id1, k=5)\n",
        "\n",
        "raw_neighbor_ids_user1 = [trainset.to_raw_uid(inner_id1) for inner_id in neighbors_user1]\n",
        "\n",
        "print(f\"The 5 most similar users to user {user1_id} are: {raw_neighbor_ids_user1}\")\n",
        "\n",
        "# Check if user2_id is within the most similar users list\n",
        "if user2_id in raw_neighbor_ids_user1:\n",
        "    print(f\"True, user {user2_id} is within the 5 most similar users to user {user1_id}.\")\n",
        "else:\n",
        "    print(f\"False, user {user2_id} is not within the 5 most similar users to user {user1_id}.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yKELOJk4I_zy",
        "outputId": "210ee5ac-0d1d-4813-ac77-c022348c6586"
      },
      "execution_count": 171,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The 5 most similar users to user A3LDPF5FMB782Z are: ['A3LDPF5FMB782Z', 'A3LDPF5FMB782Z', 'A3LDPF5FMB782Z', 'A3LDPF5FMB782Z', 'A3LDPF5FMB782Z']\n",
            "False, user A34BZM6S9L7QI4 is not within the 5 most similar users to user A3LDPF5FMB782Z.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Observations:\n",
        "\n",
        "* Using the msd distance metric with the KNNBasic Algorithm, we see that user2 is not among the 5 most similar users to user1.\n",
        "\n",
        "* This is concerning because our fine-tuned user-user CF model interprets these two users as being nearly identical in user preference for product `1400501466`.\n",
        "\n",
        "* Let's try again with a larger set of nearest neighbors: 25."
      ],
      "metadata": {
        "id": "obyRDtZNKhnv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Finding the 5 most similar users to the user with user1 with inner_id1\n",
        "neighbors_user1_25 = model_msd.get_neighbors(inner_id1, k=25)\n",
        "\n",
        "raw_neighbor_ids_user1_25 = [trainset.to_raw_uid(inner_id1) for inner_id in neighbors_user1]\n",
        "\n",
        "print(f\"The 25 most similar users to user {user1_id} are: {raw_neighbor_ids_user1_25}\")\n",
        "\n",
        "# Check if user2_id is within the most similar users list\n",
        "if user2_id in raw_neighbor_ids_user1_25:\n",
        "    print(f\"True, user {user2_id} is within the 25 most similar users to user {user1_id}.\")\n",
        "else:\n",
        "    print(f\"False, user {user2_id} is not within the 25 most similar users to user {user1_id}.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AROAgxyjK9To",
        "outputId": "67b7a5fd-31f2-495d-f4a6-cc981f5a31e7"
      },
      "execution_count": 172,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The 25 most similar users to user A3LDPF5FMB782Z are: ['A3LDPF5FMB782Z', 'A3LDPF5FMB782Z', 'A3LDPF5FMB782Z', 'A3LDPF5FMB782Z', 'A3LDPF5FMB782Z']\n",
            "False, user A34BZM6S9L7QI4 is not within the 25 most similar users to user A3LDPF5FMB782Z.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Observation:\n",
        "\n",
        "* It's furthermore concerning that user2 is not within the 25 most similar users to user1.\n",
        "\n",
        "* Given a total filtered user count of 65290, we can broaden the nearest neighbors search further, to check to see if user2 is within 5% of the total count of users, in terms of similarity to user1. Let's run the algorithm again!"
      ],
      "metadata": {
        "id": "4dVcoULOLOmJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "k_5percent = int(62590 * 0.05)   # rounded to the nearest integer for the k parameter in KNNBasic\n",
        "\n",
        "# Finding the 5 most similar users to the user with user1 with inner_id1\n",
        "neighbors_user1_5percent = model_msd.get_neighbors(inner_id1, k=k_5percent)\n",
        "\n",
        "raw_neighbor_ids_user1_5percent = [trainset.to_raw_uid(inner_id1) for inner_id in neighbors_user1]\n",
        "\n",
        "print(f\"The 5% of users most similar to user {user1_id} are: {raw_neighbor_ids_user1_5percent}\")\n",
        "\n",
        "# Check if user2_id is within the most similar users list\n",
        "if user2_id in raw_neighbor_ids_user1_5percent:\n",
        "    print(f\"True, user {user2_id} is within the 5% of users most similar to user {user1_id}.\")\n",
        "else:\n",
        "    print(f\"False, user {user2_id} is not within the 5% of users most similar to user {user1_id}.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H92jNBZsML-N",
        "outputId": "b40387f2-bbf5-4799-b32c-005e419aa753"
      },
      "execution_count": 173,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The 5% of users most similar to user A3LDPF5FMB782Z are: ['A3LDPF5FMB782Z', 'A3LDPF5FMB782Z', 'A3LDPF5FMB782Z', 'A3LDPF5FMB782Z', 'A3LDPF5FMB782Z']\n",
            "False, user A34BZM6S9L7QI4 is not within the 5% of users most similar to user A3LDPF5FMB782Z.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Observations:\n",
        "\n",
        "* It's somewhat concerning that user2 is not even within the nearest 5% of users similar to user1, yet both are assigned the same predicted rating for the product, based on user-user collaborative filtering. This throws a bit of suspicion on the model.\n",
        "\n",
        "* **Has GridSearchCV improved or deteriorated the original model with the optimized parameters it suggested?** The optimized model has a higher RMSE score, recall score and F1 score, than the original model, indicating improved accuracy, coverage, and balance between precision and recall. I will trust that the new model is indeed better than the original model, even though these results, when verified with the msd distance metric for KNNBasic Algorithm, seem to indicate that the new model is somewhat suspect.\n",
        "\n",
        "*We will nevertheless proceed to implement and test the new recommendation algorithm.*"
      ],
      "metadata": {
        "id": "eAw9fWOPNAa7"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z0NsrX_anVNH"
      },
      "source": [
        "\n",
        "\n",
        "----\n",
        "\n",
        "\n",
        "### **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: A user id **against which we want the recommendations**\n",
        "- top_n: The **number of products we want to recommend**\n",
        "- algo: the algorithm we want to use **for predicting the ratings**\n",
        "- The output of the function is a **set of top_n items** recommended for the given user_id based on the given algorithm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 210,
      "metadata": {
        "id": "vW9V1Tk65HlY"
      },
      "outputs": [],
      "source": [
        "def get_recommendations(data, user_id, top_n, algo):\n",
        "  \"\"\"\n",
        "    Generates top_n product recommendations for a given user_id using a specified algorithm (algo).\n",
        "\n",
        "    Parameters:\n",
        "    - data: DataFrame containing 'user_id', 'prod_id', and 'rating' columns.\n",
        "    - user_id: The user ID for whom recommendations are to be generated.\n",
        "    - top_n: The number of recommendations to generate.\n",
        "    - algo: The prediction algorithm to use.\n",
        "\n",
        "    Returns:\n",
        "    - List of tuples with top_n recommended product IDs and their predicted ratings.\n",
        "  \"\"\"\n",
        "  # Error handling: ensure user_id exists in the dataset\n",
        "  if user_id not in data['user_id'].unique():\n",
        "      return \"User ID not found in the dataset.\"\n",
        "\n",
        "  # Get the list of products the user has already interacted with\n",
        "  interacted_products = data[data['user_id'] == user_id]['prod_id'].unique()\n",
        "\n",
        "  # Get a list of all unique products in the dataset\n",
        "  all_products = data['prod_id'].unique()\n",
        "\n",
        "  # Identify products that the user has not interacted with\n",
        "  non_interacted_products = set(all_products) - set(interacted_products)\n",
        "\n",
        "  recommendations = []\n",
        "\n",
        "  # Looping through each of the product ids which user_id has not interacted yet\n",
        "  for item_id in non_interacted_products:\n",
        "\n",
        "      # Predicting the ratings for those non interacted product 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 products"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oj_S7kh4nVNI"
      },
      "source": [
        "**Predicting top 5 products for userId = \"A3LDPF5FMB782Z\" with similarity based recommendation system**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 211,
      "metadata": {
        "id": "qWbR85mI5Hrk"
      },
      "outputs": [],
      "source": [
        "# Making top 5 recommendations for user_id \"A3LDPF5FMB782Z\" with a similarity-based recommendation engine\n",
        "top_5_recommendations_optimized = get_recommendations(df_final, \"A3LDPF5FMB782Z\", 5, user_model_optimized)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 212,
      "metadata": {
        "id": "b5WfIX0Z6_q2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e05bb713-26a0-4e09-a4a4-55704216d88d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "      prod_id  predicted_ratings\n",
            "0  B006EKIQYM                  5\n",
            "1  B00BW6KCTU                  5\n",
            "2  B00E3FHXYO                  5\n",
            "3  B001CCAISE                  5\n",
            "4  B0062EUE54                  5\n"
          ]
        }
      ],
      "source": [
        "# Building the dataframe for above recommendations with columns \"prod_id\" and \"predicted_ratings\"\n",
        "recommendations_df_optimized = pd.DataFrame(top_5_recommendations_optimized, columns=['prod_id', 'predicted_ratings'])\n",
        "\n",
        "print(recommendations_df_optimized)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Compare these results with those of the original, non-optimized model\n",
        "top_5_recommendations_original = get_recommendations(df_final, \"A3LDPF5FMB782Z\", 5, user_model)\n",
        "recommendations_df_original = pd.DataFrame(top_5_recommendations_original, columns=['prod_id', 'predicted_ratings'])\n",
        "\n",
        "print(recommendations_df_original)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ylblZ6TKSIjW",
        "outputId": "708ca71e-cf6b-41cb-fca2-3d1a7d781d8b"
      },
      "execution_count": 213,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "      prod_id  predicted_ratings\n",
            "0  B00KMRGB7C                  5\n",
            "1  B002I3OZ6W                  5\n",
            "2  B003LPUWT0                  5\n",
            "3  B000A5TAT2                  5\n",
            "4  B004TA0AUW                  5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Compare these results with those of the rank-based recommendation model\n",
        "rank_based_top_5 = get_top_n_products(df_final, 5, 5)\n",
        "print(rank_based_top_5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pFwZGlEvtodg",
        "outputId": "3c2073ba-9f79-4f11-d1f6-eadcd782b886"
      },
      "execution_count": 214,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "            average_rating  ratings_count\n",
            "prod_id                                  \n",
            "B00LGQ6HL8             5.0              5\n",
            "B003DZJQQI             5.0             14\n",
            "B005FDXF2C             5.0              7\n",
            "B00I6CVPVC             5.0              7\n",
            "B00B9KOCYA             5.0              8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Observations:\n",
        "\n",
        "* The top 5 products recommended by the optimized user model are totally different than that recommended by the previous (unoptimized) model, indicating that a change in hyperparameters greatly alters the user recommendations.\n",
        "\n",
        "```\n",
        "B00005LEN4\n",
        "B000067RT6                  \n",
        "000V5P90K                 \n",
        "B0019EHU8G                  \n",
        "B001CCAISE                  \n",
        "```\n",
        "\n",
        "* These are also completely different from the top 5 recommendations of the previous rank-based model, with no overlap between any of these models.\n",
        "\n",
        "* Following the process of previous function, I'll now try getting the top 5 recommendations, filtering for products that have 50 or more, or 100 or more recommendations, to compare wtih the lists generated by the rank-based model.\n",
        "\n",
        "Here is a modification of the `get_recommendations()` function with the addition of one argument, setting the minimum number of product recommendations per product, set to a default value of 5."
      ],
      "metadata": {
        "id": "3Dq2_18PSbr7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_recommendations_filtered(data, user_id, algo, top_n=5, min_ratings_count=5):\n",
        "    \"\"\"\n",
        "    Generates top_n product recommendations for a given user_id using a specified algorithm (algo),\n",
        "    considering only products with at least min_interaction_count interactions.\n",
        "\n",
        "    Parameters:\n",
        "    - data: DataFrame containing 'user_id', 'prod_id', and 'rating' columns.\n",
        "    - user_id: The user ID for whom recommendations are to be generated.\n",
        "    - top_n: The number of recommendations to generate.\n",
        "    - algo: The prediction algorithm to use.\n",
        "    - min_ratings_count: The minimum number of interactions a product must have to be considered.\n",
        "\n",
        "    Returns:\n",
        "    - List of tuples with top_n recommended product IDs and their predicted ratings, considering the interaction threshold.\n",
        "    \"\"\"\n",
        "    # Filter data for products meeting the minimum interaction threshold\n",
        "    popular_products = data['prod_id'].value_counts()[data['prod_id'].value_counts() >= min_ratings_count].index.tolist()\n",
        "\n",
        "    # Ensure user_id exists in the dataset\n",
        "    if user_id not in data['user_id'].unique():\n",
        "        return \"User ID not found in the dataset.\"\n",
        "\n",
        "    # Get the list of products the user has already interacted with\n",
        "    interacted_products = data[data['user_id'] == user_id]['prod_id'].unique()\n",
        "\n",
        "    # Identify products that the user has not interacted with and meet the popularity criterion\n",
        "    non_interacted_popular_products = set(popular_products) - set(interacted_products)\n",
        "\n",
        "    recommendations = []\n",
        "    for item_id in non_interacted_popular_products:\n",
        "        # Predict the rating for the user and non-interacted, popular item\n",
        "        est = algo.predict(user_id, item_id).est\n",
        "        recommendations.append((item_id, est))\n",
        "\n",
        "    # Sort the recommendations based on the predicted rating in descending order\n",
        "    recommendations.sort(key=lambda x: x[1], reverse=True)\n",
        "\n",
        "    # Return the top_n recommendations\n",
        "    return recommendations[:top_n]"
      ],
      "metadata": {
        "id": "JOyzaTASvC97"
      },
      "execution_count": 215,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calling the above function for the user \"A3LDPF5FMB782Z\" with the optimized user model with a minimum number of ratings set at 50.\n",
        "optimized_min50 = get_recommendations_filtered(df_final, \"A3LDPF5FMB782Z\", user_model_optimized, 5, 50)\n",
        "print('Optimized model at threshold of 50 recommendations:', optimized_min50)\n",
        "\n",
        "# Comparing this value with the previous, non-optimized user model at a threshold of 50.\n",
        "baseline_min50 = get_recommendations_filtered(df_final, \"A3LDPF5FMB782Z\", user_model, 5, 50)\n",
        "print('Baseline model at threshold of 50 recommendations:', baseline_min50)\n",
        "\n",
        "# Comparing this value with the rank-based model at a threshold of 50.\n",
        "rankbased_min50 = get_top_n_products(df_final, 50, 5)\n",
        "print('Rank-based model at threshold of 50 recommendations:', rankbased_min50)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RKrKjSWzvd24",
        "outputId": "66e78705-3cf5-4ac7-8257-54039e74b685"
      },
      "execution_count": 216,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimized model at threshold of 50 recommendations: [('B0019EHU8G', 5), ('B001TH7GUU', 5), ('B000BQ7GW8', 4.900550800763735), ('B000N99BBC', 4.888888888888889), ('B006W8U2MU', 4.888888888888889)]\n",
            "Baseline model at threshold of 50 recommendations: [('B0019EHU8G', 5), ('B0081FLFQE', 5), ('B009NHWVIA', 5), ('B001TH7GUU', 5), ('B006W8U2MU', 5)]\n",
            "Rank-based model at threshold of 50 recommendations:             average_rating  ratings_count\n",
            "prod_id                                  \n",
            "B001TH7GUU        4.871795             78\n",
            "B003ES5ZUU        4.864130            184\n",
            "B0019EHU8G        4.855556             90\n",
            "B006W8U2MU        4.824561             57\n",
            "B000QUUFRW        4.809524             84\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Observations:\n",
        "* Setting the threshold for the minimum number of product recommendations at 50, we see that all three models recommend 'B0019EHU8G' and 'B001TH7GUU' among the top products, showing that these items are highly rated across different recommendation strategies.  \n",
        "\n",
        "* 'B006W8U2MU' also appears in both the Optimized and Baseline model recommendations.\n",
        "\n",
        "* The Baseline model uniquely recommends 'B0081FLFQE' and 'B009NHWVIA', which do not appear in the other two models' top recommendations. This could indicate that the Optimized model generates superior results that better represent rank-based overall popularity of products.\n",
        "\n",
        "* The Baseline model features more products with perfect predicted ratings (5.0), suggesting it may be more optimistic or less discriminative in its recommendations.\n",
        "\n",
        "* The best model depends on the context. For new users with little to no history (cold start problem), a rank-based approach might be more effective. For users with sufficient interaction data, the optimized personalized user model may be more likely to yield better satisfaction by tailoring recommendations to individual preferences."
      ],
      "metadata": {
        "id": "B3ifl1DAw1ZZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calling the above function for the user \"A3LDPF5FMB782Z\" with the optimized user model with a minimum number of ratings set at 100.\n",
        "optimized_min100 = get_recommendations_filtered(df_final, \"A3LDPF5FMB782Z\", user_model_optimized, 5, 100)\n",
        "print('Optimized model at threshold of 100 recommendations:', optimized_min100)\n",
        "\n",
        "# Comparing this value with the previous, non-optimized user model at a threshold of 100.\n",
        "baseline_min100 = get_recommendations_filtered(df_final, \"A3LDPF5FMB782Z\", user_model, 5, 100)\n",
        "print('Baseline model at threshold of 100 recommendations:', baseline_min100)\n",
        "\n",
        "# Comparing this value with the rank-based model at a threshold of 100.\n",
        "rankbased_min100 = get_top_n_products(df_final, 100, 5)\n",
        "print('Rank-based model at threshold of 100 recommendations:', rankbased_min100)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aXoD0cEOyDKL",
        "outputId": "d92dcc7a-1e00-4e09-d2df-248f70d9c2ac"
      },
      "execution_count": 217,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimized model at threshold of 100 recommendations: [('B000N99BBC', 4.888888888888889), ('B007WTAJTO', 4.848319499433033), ('B003ES5ZUU', 4.81248032739554), ('B00834SJNA', 4.777777777777778), ('B00834SJSK', 4.75152749490835)]\n",
            "Baseline model at threshold of 100 recommendations: [('B000N99BBC', 4.888888888888889), ('B0034CL2ZI', 4.777038101683713), ('B003ES5ZUU', 4.762986430392974), ('B004CLYEDC', 4.7456642477184605), ('B007WTAJTO', 4.7330131826308515)]\n",
            "Rank-based model at threshold of 100 recommendations:             average_rating  ratings_count\n",
            "prod_id                                  \n",
            "B003ES5ZUU        4.864130            184\n",
            "B000N99BBC        4.772455            167\n",
            "B002WE6D44        4.770000            100\n",
            "B007WTAJTO        4.701220            164\n",
            "B002V88HFE        4.698113            106\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Observations:\n",
        "\n",
        "* 'B000N99BBC' remains a top recommendation in both the Optimized and Baseline models when the threshold increases to 100, suggesting strong consistency in its appeal or rating prediction across different model configurations and list lengths.\n",
        "\n",
        "* 'B003ES5ZUU' appears across all three models at both thresholds, highlighting its general popularity and strong appeal.\n",
        "\n",
        "* The appearance of certain products ('B000N99BBC', 'B003ES5ZUU', 'B007WTAJTO') across models and thresholds indicates a stable preference or rating prediction by the models.\n",
        "\n",
        "* The increase in threshold allows for new entries ('B007WTAJTO', 'B00834SJNA', 'B00834SJSK' in the Optimized model; 'B0034CL2ZI', 'B004CLYEDC' in the Baseline model) that were not visible in the top 5 at the 50 recommendations threshold, suggests that these products are highly rated but not as much as ones that are now cut out from the `min50` models, after raising the threshold to 100.\n",
        "\n",
        "* The Rank-based model's top products shift slightly with 'B002WE6D44' and 'B002V88HFE' appearing in the top 5, indicating these products have high average ratings and broader popular appeal with a minimum threshold of 100 ratings."
      ],
      "metadata": {
        "id": "ReeNJW85yY5r"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QgbzJKk7Tsnr"
      },
      "source": [
        "### **Item-Item Similarity-based Collaborative Filtering Recommendation System**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qTJu_2hcTsnr"
      },
      "source": [
        "* Above we have seen **similarity-based collaborative filtering** where similarity is calculated **between users**. Now let us look into similarity-based collaborative filtering where similarity is seen **between items**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 218,
      "metadata": {
        "id": "W5RMcdzjTsns",
        "scrolled": false,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "10102d7f-d013-4853-bbdc-820fe13a7573"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "RMSE: 1.0182\n",
            "Precision:  0.839\n",
            "Recall:  0.801\n",
            "F_1 score:  0.82\n"
          ]
        }
      ],
      "source": [
        "# Declaring the similarity options\n",
        "sim_options_items = {\n",
        "    'name': 'cosine',\n",
        "    'user_based': False  # Compute similarities between items, not users\n",
        "}\n",
        "\n",
        "# KNN algorithm is used to find desired similar items. Use random_state=1\n",
        "baseline_model_items = KNNBasic(sim_options=sim_options_items, random_state=1)\n",
        "\n",
        "# Train the algorithm on the trainset, and predict ratings for the test set\n",
        "baseline_model_items.fit(trainset)\n",
        "\n",
        "# Let us compute precision@k, recall@k, and f_1 score with k = 10\n",
        "precision_recall_at_k(baseline_model_items, k=10, threshold=3.5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ni9LoeUVTsns"
      },
      "source": [
        "# Observations:\n",
        "\n",
        "### RMSE: 1.0182\n",
        "* The Root Mean Square Error (RMSE) of 1.0182 is relatively high compared to the optimized user-user CF model (RMSE: 0.9549), indicating less accuracy in predicting user ratings for items.\n",
        "*  This suggests that item similarities due to shared characteristics may provide a less reliable basis for predicting ratings than user similarities.\n",
        "\n",
        "### Precision: 0.839\n",
        "* With a precision score of 0.839 for the item-item CF model, compared with 0.859 for the optimized user-user CF model,the item model has slightly lower precision compared to the user model. This means that the user model is better at ensuring the relevance of the items it recommends.\n",
        "\n",
        "### Recall: 0.801\n",
        "* The recall of 0.80 in the item-item CF model, compared with 0.855 for the optimized user-user CF model, suggests that the user model is more effective at capturing a broader range of relevant items that users are likely to rate positively. This means that the user model is more comprehensive in identifying items of interest to users.\n",
        "\n",
        "### F1 Score: 0.82\n",
        "* The F1 score of 0.82, which balances precision and recall, is also lower than that of the optimized user-user CF model (0.857). This suggests that, overall, the user model may provide more balanced recommendation performance.\n",
        "\n",
        "---\n",
        "\n",
        "### General Assessment:\n",
        "* The **item-item CF model** performs worse in all metrics: accuracy (lower RMSE), relevance (lower precision), coverage (lower recall), and balance (lower F1 score) -- than the optimized user-user model.\n",
        "\n",
        "* This indicates that the user model is more effective at recommending items that users find relevant and are more likely to enjoy, than the item model."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jFbcDQmxTsns"
      },
      "source": [
        "Let's now **predict a rating for a user with `userId = A3LDPF5FMB782Z` and `prod_Id = 1400501466`** as shown below. Here the user has already interacted or watched the product with productId \"1400501466\"."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 219,
      "metadata": {
        "id": "JsF-aaWYTsns",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "352b6375-11d3-4c55-fa7f-491e2539af1c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating for user A3LDPF5FMB782Z and product 1400501466 is: 4.2272727272727275\n"
          ]
        }
      ],
      "source": [
        "# Predicting rating for a sample user with an interacted product\n",
        "prediction1_items = baseline_model_items.predict(\"A3LDPF5FMB782Z\", \"1400501466\")\n",
        "estimated_rating1_items = prediction1_items.est\n",
        "print(f'Predicted rating for user A3LDPF5FMB782Z and product 1400501466 is: {estimated_rating1_items}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2h0OyDMFTsns"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* This prediction (4.2273) is identical to less than the one made by the fine-tuned user-user CF model (4.2917).\n",
        "\n",
        "* Since we know that the user actually gave a rating of 5, we can say that this item model performs less well than the user model in accurately predicting the user's rating for this product.\n",
        "\n",
        "* This baseline item-item CF model could also be improved with hyperparameter tuning to more accurately predict the user's rating."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BqKGZoAtTsns"
      },
      "source": [
        "Below we are **predicting rating for the `userId = A34BZM6S9L7QI4` and `prod_id = 1400501466`**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 220,
      "metadata": {
        "id": "5yILOxXRTsns",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "08c5118a-5356-4caa-80df-7129ee3d425c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating for user A34BZM6S9L7QI4 and product 1400501466 is: 5\n"
          ]
        }
      ],
      "source": [
        "# Predicting rating for a sample user with a non interacted product\n",
        "prediction2_items = baseline_model_items.predict(\"A34BZM6S9L7QI4\", \"1400501466\")\n",
        "estimated_rating2_items = prediction2_items.est\n",
        "print(f'Predicted rating for user A34BZM6S9L7QI4 and product 1400501466 is: {estimated_rating2_items}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sDKaAveJTsns"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* This prediction (5) for user2 who has not yet rated the product, is higher than earlier predictions made by the fine-tuned user-user CF model (4.2917), and much higher than the baseline user model (3.0).\n",
        "\n",
        "* It's unclear from these statistics alone which model is more accurate for predicting user2's preference."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "meSvpNLj_EjD"
      },
      "source": [
        "### **Hyperparameter tuning the item-item similarity-based model**\n",
        "- Use the following values for the param_grid and tune the model.\n",
        "  - 'k': [10, 20, 30]\n",
        "  - 'min_k': [3, 6, 9]\n",
        "  - 'sim_options': {'name': ['msd', 'cosine']\n",
        "  - 'user_based': [False]\n",
        "- Use GridSearchCV() to tune the model using the 'rmse' measure\n",
        "- Print the best score and best parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 223,
      "metadata": {
        "id": "f5bcZ3HgTsnt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb97fbe3-f047-4dea-9761-6c36a7411911"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Computing the cosine similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "Best RMSE score: 0.9769895426649792\n",
            "Best parameter combination: {'k': 30, 'min_k': 9, 'sim_options': {'name': 'msd', 'user_based': False}}\n"
          ]
        }
      ],
      "source": [
        "# Setting up parameter grid to tune the hyperparameters\n",
        "param_grid = {\n",
        "    'k': [10, 20, 30],\n",
        "    'min_k': [3, 6, 9],\n",
        "    'sim_options': {\n",
        "        'name': ['msd', 'cosine'],\n",
        "        'user_based': [False]\n",
        "    }\n",
        "}\n",
        "\n",
        "# Performing 3-fold cross validation to tune the hyperparameters\n",
        "gs_items = GridSearchCV(KNNBasic, param_grid, measures=['rmse'], cv=3)\n",
        "\n",
        "# Fitting the data\n",
        "gs_items.fit(data)\n",
        "\n",
        "# Find the best RMSE score\n",
        "best_rmse_items = gs_items.best_score['rmse']\n",
        "print(f'Best RMSE score: {best_rmse_items}')\n",
        "\n",
        "# Find the combination of parameters that gave the best RMSE score\n",
        "best_params_items = gs_items.best_params['rmse']\n",
        "print(f'Best parameter combination: {best_params_items}')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1psOlx6zTsnt"
      },
      "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": "JrSTaQemTsnt"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* GridSearchCV output the following best parameter combination for the best RMSE score of 0.9770, which performs less accurately than the optimized user model RMSE score (0.9549).\n",
        "\n",
        "* It suggests using the `msd` distance calculation over the `cosine` calculation, which we used previously in the baseline item-item CF model.\n",
        "\n",
        "```\n",
        "{'k': 30, 'min_k': 9, 'sim_options': {'name': 'msd', 'user_based': False}}\n",
        "```\n",
        "\n",
        "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",
        "<br/>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kOS9Dwnd_LN6"
      },
      "source": [
        "### **Use the best parameters from GridSearchCV to build the optimized item-item similarity-based model. Compare the performance of the optimized model with the baseline model.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 224,
      "metadata": {
        "id": "dSeiM1qeTsnt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82fcb071-773d-4b0c-d774-93a1ae7c9746"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "RMSE: 0.9664\n",
            "Precision:  0.839\n",
            "Recall:  0.846\n",
            "F_1 score:  0.842\n"
          ]
        }
      ],
      "source": [
        "# Using the optimal similarity measure for item-item based collaborative filtering\n",
        "sim_options_optimized_items = {\n",
        "    'name': 'msd',\n",
        "    'user_based': False\n",
        "}\n",
        "\n",
        "# Creating an instance of KNNBasic with optimal hyperparameter values\n",
        "item_model_optimized = KNNBasic(k=30, min_k=9, sim_options=sim_options_optimized_items)\n",
        "\n",
        "# Training the algorithm on the trainset\n",
        "item_model_optimized = item_model_optimized.fit(trainset)\n",
        "\n",
        "# Let us compute precision@k and recall@k, f1_score and RMSE\n",
        "precision_recall_at_k(item_model_optimized, k=10, threshold=3.5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZCXKnMI8Tsnt"
      },
      "source": [
        "# Observations\n",
        "\n",
        "### RMSE: 0.9664\n",
        "* With the optimized item-item CF model, we are able to attain an RMSE accuracy score of 0.9664, which is slightly lower than the optimized user-user CF model RMSE score of 0.9549. But it is an improvement over the previous item model RMSE score of 1.0182.\n",
        "* Considering the rating scale of 1 to 5, this level of RMSE indicates a relatively good fit, though there's room for improvement.\n",
        "\n",
        "### Precision: 0.839\n",
        "* The optimized item precision score of 0.839 is lower than that of the optimized user model (0.859). But it is a slight improvement over the previous item model precision score of 0.839.\n",
        "* Since 83.9% of the items recommended by the model are relevant to the users, this can be considered a strong result, suggesting that the model is quite effective at filtering out items that users are unlikely to be interested in.\n",
        "\n",
        "### Recall: 0.846\n",
        "* The optimized item recall score of 0.846 is lower than that of the optimized user model (0.855). But it is a big improvement over the previous item model recall score of 0.801.\n",
        "* Since the model is able to capture 84.6% of the items relevant to users, this can be considered a strong result, suggesting that the model is quite effective at minimizing the chance of missing out on recommending items that users would appreciate.\n",
        "\n",
        "### F_1 Score: 0.842\n",
        "* The optimized item recall score of 0.842 is lower than that of the optimized user model (0.857). But it is an improvement over the previous item model F1 score of 0.82.\n",
        "* An F1 score of 0.842 is also very good, indicating that the model maintains a strong balance between precision and recall, to ensure both relevance (precision) and comprehensiveness (recall) in the recommendations provided.\n",
        "\n",
        "### General Assessment\n",
        "Although the optimized item-item CF model is not as performant as the optimized user-user CF model, it performs better than the baseline model, and outputs fairly strong results."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sbcj_H94Tsnt"
      },
      "source": [
        "### **Steps:**\n",
        "- **Predict rating for the user with `userId=\"A3LDPF5FMB782Z\"`, and `prod_id= \"1400501466\"` using the optimized model**\n",
        "- **Predict rating for `userId=\"A34BZM6S9L7QI4\"` who has not interacted with `prod_id =\"1400501466\"`, by using the optimized model**\n",
        "- **Compare the output with the output from the baseline model**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 225,
      "metadata": {
        "id": "gIBRRvdoTsnt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0d68e151-6e6c-45c9-e5ff-b36ae9e5c991"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating for user \"A3LDPF5FMB782Z\" and product \"1400501466\" is: 4.629964608729846\n"
          ]
        }
      ],
      "source": [
        "# Use item_model_optimized to recommend for userId \"A3LDPF5FMB782Z\" and productId \"1400501466\"\n",
        "item_prediction_optimized = item_model_optimized.predict(\"A3LDPF5FMB782Z\", \"1400501466\")\n",
        "print(f'Predicted rating for user \"A3LDPF5FMB782Z\" and product \"1400501466\" is: {item_prediction_optimized.est}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 227,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xo3VdTpjtCdG",
        "outputId": "5a5561f0-0399-4ae8-c981-b7ed81219a1b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating for user \"A34BZM6S9L7QI4\" and product \"1400501466\" is: 4.292115097923091\n"
          ]
        }
      ],
      "source": [
        "# Use item_model_optimized to recommend for userId \"A34BZM6S9L7QI4\" and productId \"1400501466\"\n",
        "item_prediction_optimized2 = item_model_optimized.predict(\"A34BZM6S9L7QI4\", \"1400501466\")\n",
        "print(f'Predicted rating for user \"A34BZM6S9L7QI4\" and product \"1400501466\" is: {item_prediction_optimized2.est}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WhMMyg0AtCdH"
      },
      "source": [
        "### Observations:\n",
        "\n",
        "* The prediction of 4.63 for the known user1 \"A3LDPF5FMB782Z\" and product \"1400501466\" is the closest we have so far to the actual user rating of 5.0\n",
        "\n",
        "* This optimized item model actually generated a score for this user and product that is more accurate than the optimized user model. Success!\n",
        "\n",
        "* The slightly lower prediction of 4.2921 for unknown user2 \"A34BZM6S9L7QI4\" and the product falls in line with the most common finding in previous models, predicting that user2 would have a lesser preference for this product than user1.\n",
        "\n",
        "* This adjusted (lower) preference for user2 corrects for the overestimation of the baseline item model (5.0) and seems to indicate better predictive performance for unknown users.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MDlNB7tnTsnu"
      },
      "source": [
        "### **Identifying similar items to a given item (nearest neighbors)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RLdDiFA6Tsnu"
      },
      "source": [
        "We can also find out **similar items** to a given item or its nearest neighbors based on this **KNNBasic algorithm**. Below we are finding the 5 most similar items to the item with internal id 0 based on the `msd` distance metric."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 231,
      "metadata": {
        "id": "ZRJS4oDFTsnu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a36ebb3-2cbc-4e66-9aa2-539945cba61e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Computing the msd similarity matrix...\n",
            "Done computing similarity matrix.\n",
            "The item_id for the item with internal id 0 is: A2ARDVMUGDFED6\n",
            "According to the optimized item-item model, the 5 most similar items to the item with internal id 0 are: ['AEJAGHLC675A7', 'A1QRST0A3IQIEF', 'A19RW25Q6206I3', 'A1MZL91Z44RN06', 'A3OXHLG6DIBRW8']\n"
          ]
        }
      ],
      "source": [
        "# 0 is the inner id of the above user\n",
        "model_msd_items = KNNBasic(sim_options=sim_options_optimized_items)\n",
        "model_msd_items.fit(trainset)\n",
        "\n",
        "inner_id = 0\n",
        "raw_item_id = trainset.to_raw_uid(inner_id)\n",
        "print(f\"The item_id for the item with internal id {inner_id} is: {raw_item_id}\")\n",
        "\n",
        "# Finding the 5 most similar users to the user with inner id 0\n",
        "neighbors_items = model_msd_items.get_neighbors(inner_id, k=5)\n",
        "\n",
        "raw_neighbor_ids_items = [trainset.to_raw_uid(inner_id) for inner_id in neighbors_items]\n",
        "\n",
        "print(f\"According to the optimized item-item model, the 5 most similar items to the item with internal id {inner_id} are: {raw_neighbor_ids_items}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-utTaQX8tCdH"
      },
      "source": [
        "**Predicting top 5 products for userId = \"A1A5KUIIIHFF4U\" with similarity based recommendation system.**\n",
        "\n",
        "**Hint:** Use the get_recommendations() function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 249,
      "metadata": {
        "id": "rzoEbuZFTsnu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "06ffd0df-3499-495e-9c4f-5c690f6f0b12"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Top 5 recommendations at threshold of 5 recommendations: [('B0018O9JIG', 5), ('B004N625C8', 5), ('B00722JCMQ', 5), ('B003B41XYO', 5), ('B001S2PPT0', 5)]\n",
            "Top 5 recommendations at threshold of 50 recommendations: [('B001CHHVCU', 5), ('B0082E9K7U', 5), ('B00829THK0', 5), ('B000VX6XL6', 5), ('B0063705PE', 5)]\n",
            "Top 5 recommendationsat threshold of 100 recommendations: [('B007WTAJTO', 5), ('B002WE6D44', 5), ('B004T9RR6I', 5), ('B00829TIEK', 5), ('B00829THK0', 5)]\n"
          ]
        }
      ],
      "source": [
        "# Making top 5 recommendations for user_id A1A5KUIIIHFF4U with similarity-based recommendation engine.\n",
        "# Setting a minimum number of ratings set at 5.\n",
        "optimized_items_min5 = get_recommendations_filtered(df_final, \"A1A5KUIIIHFF4U\", model_msd_items, 5, 5)\n",
        "print('Top 5 recommendations at threshold of 5 recommendations:', optimized_items_min5)\n",
        "\n",
        "# Setting a minimum number of ratings set at 50.\n",
        "optimized_items_min50 = get_recommendations_filtered(df_final, \"A1A5KUIIIHFF4U\", model_msd_items, 5, 50)\n",
        "print('Top 5 recommendations at threshold of 50 recommendations:', optimized_items_min50)\n",
        "\n",
        "# Setting a minimum number of ratings set at 50.\n",
        "optimized_items_min100 = get_recommendations_filtered(df_final, \"A1A5KUIIIHFF4U\", model_msd_items, 5, 100)\n",
        "print('Top 5 recommendationsat threshold of 100 recommendations:', optimized_items_min100)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Observations\n",
        "\n",
        "* **Threshold of 5 recommendations:**\n",
        "\n",
        "B0018O9JIG, B004N625C8, B00722JCMQ, B003B41XYO, B001S2PPT0\n",
        "\n",
        "* **Threshold of 50 recommendations:**\n",
        "\n",
        "B001CHHVCU, B0082E9K7U, B00829THK0, B000VX6XL6, B0063705PE\n",
        "\n",
        "* **Threshold of 100 recommendations:**\n",
        "\n",
        "B007WTAJTO, B002WE6D44, B004T9RR6I, B00829TIEK, B00829THK0\n",
        "\n",
        "<br/>\n",
        "\n",
        "### **Comparison:**\n",
        "\n",
        "* All recommended products across the three thresholds have been assigned a perfect predicted rating of 5. The assignment of a perfect rating to so many items raises questions about the granularity and differentiation capability of the recommendation system based on user product rating alone.\n",
        "\n",
        "* The sets of top 5 recommended products change with the increase in threshold, indicating a broad pool of items that are equally rated at the top by the recommendation system. Only one product, 'B00829THK0', appears in both the 50 and 100 recommendation thresholds, suggesting some consistency in the system's preference across different levels of recommendation depth.\n",
        "\n",
        "* This adheres to the pattern of distribution of 1-5 reviews across all products, with far more items getting high ratings of 4 and 5 than low ratings of 1 and 2. The probability of getting high ratings in the first five reviews is higher than the average rating after the 50th or 100th review. That is to say, accumulating more ratings increases the chance of getting lower reviews.\n",
        "\n",
        "* This may be due to some inherent bias in the way products accumulate ratings. The first few ratings may be from friends of the product owner, and may skew towards being high. Additional reviews come from a larger pool of general viewers.\n",
        "\n",
        "* In choosing a set of top 5 recommendations that may most fairly represent products the user is likely to prefer, I would use the threshold of 50 recommendations. It is enough recommendations to ensure that the reviews come from a general user base, so they are less likely to be skewed by the first few users, but not too high a threshhold for ratings that it excludes niche products with fewer reviews."
      ],
      "metadata": {
        "id": "45oxxthcBCeL"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 250,
      "metadata": {
        "id": "_kXVTiysTsnv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5dac3a8a-277a-4266-9537-d3df114e6745"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Top 5 recommendations with a minimum of 50 reviews:\n",
            "\n",
            "\n",
            "      prod_id  predicted_rating  review_count\n",
            "2  B00829THK0                 5           137\n",
            "3  B000VX6XL6                 5            70\n",
            "0  B001CHHVCU                 5            67\n",
            "1  B0082E9K7U                 5            64\n",
            "4  B0063705PE                 5            52\n"
          ]
        }
      ],
      "source": [
        "# Sort the ratings in descending order by count:\n",
        "# Calculate the number of reviews per product\n",
        "review_counts = df_final.groupby('prod_id').size().reset_index(name='review_count')\n",
        "\n",
        "# Convert recommendations list to DataFrame for merging (example for optimized_items_min50)\n",
        "recommendations_df_min50 = pd.DataFrame(optimized_items_min50, columns=['prod_id', 'predicted_rating'])\n",
        "\n",
        "# Merge the recommendations with the review counts\n",
        "recommendations_with_counts_min50 = recommendations_df_min50.merge(review_counts, on='prod_id')\n",
        "\n",
        "print(\"Top 5 recommendations with a minimum of 50 reviews:\")\n",
        "print('\\n')\n",
        "\n",
        "# Sort the recommendations by review count\n",
        "sorted_recommendations_min50 = recommendations_with_counts_min50.sort_values(by='review_count', ascending=False)\n",
        "print(sorted_recommendations_min50)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Other dataframes with a threshhold of 5 and a threshhold of 100 reviews\n",
        "\n",
        "# Threshold of 5 minimum reviews\n",
        "recommendations_df_min5 = pd.DataFrame(optimized_items_min5, columns=['prod_id', 'predicted_rating'])\n",
        "recommendations_with_counts_min5 = recommendations_df_min50.merge(review_counts, on='prod_id')\n",
        "print(\"Top 5 recommendations with a minimum of 5 reviews:\")\n",
        "print('\\n')\n",
        "sorted_recommendations_min5 = recommendations_with_counts_min5.sort_values(by='review_count', ascending=False)\n",
        "print(sorted_recommendations_min5)\n",
        "\n",
        "print('\\n')\n",
        "print('\\n')\n",
        "\n",
        "# Threshold of 100 minimum reviews\n",
        "recommendations_df_min100 = pd.DataFrame(optimized_items_min100, columns=['prod_id', 'predicted_rating'])\n",
        "recommendations_with_counts_min100 = recommendations_df_min100.merge(review_counts, on='prod_id')\n",
        "print(\"Top 5 recommendations with a minimum of 100 reviews:\")\n",
        "print('\\n')\n",
        "sorted_recommendations_min100 = recommendations_with_counts_min100.sort_values(by='review_count', ascending=False)\n",
        "print(sorted_recommendations_min100)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Unc3p6YwEZBl",
        "outputId": "cfbeb30a-10e6-45e2-f041-f038122a51f2"
      },
      "execution_count": 251,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Top 5 recommendations with a minimum of 5 reviews:\n",
            "\n",
            "\n",
            "      prod_id  predicted_rating  review_count\n",
            "2  B00829THK0                 5           137\n",
            "3  B000VX6XL6                 5            70\n",
            "0  B001CHHVCU                 5            67\n",
            "1  B0082E9K7U                 5            64\n",
            "4  B0063705PE                 5            52\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "Top 5 recommendations with a minimum of 100 reviews:\n",
            "\n",
            "\n",
            "      prod_id  predicted_rating  review_count\n",
            "0  B007WTAJTO                 5           164\n",
            "3  B00829TIEK                 5           149\n",
            "4  B00829THK0                 5           137\n",
            "2  B004T9RR6I                 5           109\n",
            "1  B002WE6D44                 5           100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Observations:\n",
        "\n",
        "After sorting the dataframes by an additional column of `review_count`, we can now see that the top 5 recommendation lists are actually the same for the threshold of 5 minimum reviews and that of 50 minimum reviews. The difference in display in the prior step was actually due to all top products having the same predicted ratings.\n",
        "\n",
        "Sorting by `review_count`, I now have two dataframes of recommendations, one at the threshold of 50 and the other at the threshold of 100. As previously stated, we will select the threshold of 50 for being a good middleground for what I intuitively have decided is the most accurate prediction of top 5 recommendations for the user. I will now drop the `review_count` column in the `min50` dataframe, and return the output in the requested:"
      ],
      "metadata": {
        "id": "bHsS9qOzJa-Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sorted_recommendations_min50.drop('review_count', axis=1, inplace=True)\n",
        "print(sorted_recommendations_min50)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_06rBzr1KsCq",
        "outputId": "1c8cef6e-952e-4c86-ea9f-3baed162e0ec"
      },
      "execution_count": 252,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "      prod_id  predicted_rating\n",
            "2  B00829THK0                 5\n",
            "3  B000VX6XL6                 5\n",
            "0  B001CHHVCU                 5\n",
            "1  B0082E9K7U                 5\n",
            "4  B0063705PE                 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DHzmYvs0Tsnv"
      },
      "source": [
        "Now as we have seen **similarity-based collaborative filtering algorithms**, let us now get into **model-based collaborative filtering algorithms**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rKgJpSA9vOOL"
      },
      "source": [
        "### **Model 3: Model-Based Collaborative Filtering - Matrix Factorization**"
      ]
    },
    {
      "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": "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": "code",
      "execution_count": 264,
      "metadata": {
        "id": "07-2PT5Ssjqm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e0185b1f-2013-4619-d842-673756a9831a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "RMSE: 0.9126\n",
            "Precision:  0.842\n",
            "Recall:  0.841\n",
            "F_1 score:  0.841\n"
          ]
        }
      ],
      "source": [
        "from surprise import SVD, Dataset, Reader, accuracy\n",
        "from surprise.model_selection import train_test_split\n",
        "from collections import defaultdict\n",
        "\n",
        "reader = Reader(rating_scale=(1, 5))\n",
        "data = Dataset.load_from_df(df_final[['user_id', 'prod_id', 'rating']], reader)\n",
        "trainset, testset = train_test_split(data, test_size=0.25, random_state=1)\n",
        "\n",
        "svd_model = SVD(random_state=1)\n",
        "svd_model.fit(trainset)\n",
        "\n",
        "# Use the function precision_recall_at_k to compute precision@k, recall@k, F1-Score, and RMSE\n",
        "precision_recall_at_k(svd_model, k=10, threshold=3.5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BQ6fTuCDnVNL"
      },
      "source": [
        "# Observations:\n",
        "\n",
        "### RMSE: 0.9126\n",
        "* The SVD model has a better RMSE score than the optimized user-user CF model (RMSE: 0.9549), our highest performing model so far.\n",
        "* This indicates that the SVD model is more accurate in predicting the exact ratings users would give to items. Do we have a new winner?\n",
        "\n",
        "### Precision: 0.842\n",
        "* The SVD model achieved a lower precision of 0.842 than that of the optimized user model (0.859).\n",
        "* Despite the SVD model's higher accuracy in rating predictions, the optimized user model is slightly better at filtering out irrelevant recommendations.\n",
        "\n",
        "### Recall: 0.841\n",
        "* The SVD model achieved a recall of 0.841, which is lower than the recall score of the optimized user model (0.855)\n",
        "* The optimized user model is slightly more comprehensive in capturing a broader range of items that users would like.\n",
        "\n",
        "### F1 Score: 0.841\n",
        "* The SVD model has an F1 score of 0.841, balancing precision and recall effectively. But this is lower than the optimized user model's recall score of 0.857.\n",
        "* The optimized user model achieves a slightly better balance between precision and recall than the SVD model.\n",
        "\n",
        "\n",
        "### General Assessment\n",
        "* The SVD model excels in predicting ratings with higher accuracy (lower RMSE) but slightly lags behind the optimized user model in terms of precision, recall, and the F1 score.\n",
        "* The optimized user model shows a somewhat less accurate rating prediction capability (higher RMSE) but outperforms the SVD model in relevance and coverage of recommendations.\n",
        "* If predicting the exact ratings is critical, the SVD model might be preferred. However, if the goal is to maximize the relevance and coverage of recommendations, the optimized user model could be more suitable.\n",
        "* This indicates that we can further tune the hyperparameters of the SVD model to achieve a more optimized model that may exceed the performance of the optimized user model.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ABvxjSEjtCdH"
      },
      "source": [
        "**Let's now predict the rating for a user with `userId = \"A3LDPF5FMB782Z\"` and `prod_id = \"1400501466`.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 265,
      "metadata": {
        "id": "yWIhfdxXsjqm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d813e410-1b9e-4384-80e2-c31c48943dda"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating: 4.0636214055362645\n"
          ]
        }
      ],
      "source": [
        "# Making prediction\n",
        "svd_prediction = svd_model.predict(\"A3LDPF5FMB782Z\", \"1400501466\")\n",
        "print(f'Predicted rating: {svd_prediction.est}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oIjzqDY5nVNM"
      },
      "source": [
        "### Observation:\n",
        "\n",
        "The SVD model's predicted rating for user1 of 4.0636 is further from the actual rating (5.0) than the optimized user model (4.2917) and the optimized item model (4.63).\n",
        "\n",
        "The item-item CF model still takes the lead in most accurately predicting this user's rating of the product."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I1aYxVeMnVNM"
      },
      "source": [
        "**Below we are predicting rating for the `userId = \"A34BZM6S9L7QI4\"` and `productId = \"1400501466\"`.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 266,
      "metadata": {
        "id": "APm-uMSvcAMf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b09804e-487b-41e0-a2f6-bda2fb340fe0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating: 4.062013995343408\n"
          ]
        }
      ],
      "source": [
        "# Making prediction\n",
        "svd_prediction2 = svd_model.predict(\"A34BZM6S9L7QI4\", \"1400501466\")\n",
        "print(f'Predicted rating: {svd_prediction2.est}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NEL6dy3wnVNM"
      },
      "source": [
        "### Observation:\n",
        "\n",
        "The SVD model predicts a slightly lower rating for untested user2 (4.062), which is in line with the prediction of most other previous models."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x13Eb9Owvpcw"
      },
      "source": [
        "### **Improving Matrix Factorization based recommendation system by tuning its hyperparameters**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iQcDPhhcnVNN"
      },
      "source": [
        "Below we will be tuning only three hyperparameters:\n",
        "- **n_epochs**: The number of iterations of the SGD algorithm.\n",
        "- **lr_all**: The learning rate for all parameters.\n",
        "- **reg_all**: The regularization term for all parameters."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 267,
      "metadata": {
        "id": "4bM81V_hvtwv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cda0a95b-e0cd-4ae1-cb25-5ed65280db2c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best RMSE score: 0.8994924650097246\n",
            "Best parameter combination: {'n_epochs': 20, 'lr_all': 0.01, 'reg_all': 0.4}\n"
          ]
        }
      ],
      "source": [
        "# Set the parameter space to tune\n",
        "param_grid_svd = {\n",
        "    'n_epochs': [5, 10, 20],\n",
        "    'lr_all': [0.002, 0.005, 0.01],\n",
        "    'reg_all': [0.02, 0.1, 0.4]\n",
        "}\n",
        "\n",
        "# Performing 3-fold gridsearch cross-validation\n",
        "gs_svd = GridSearchCV(SVD, param_grid_svd, measures=['rmse'], cv=3)\n",
        "\n",
        "# Fitting data\n",
        "gs_svd.fit(data)\n",
        "\n",
        "# Best RMSE score\n",
        "best_rmse_svd = gs_svd.best_score['rmse']\n",
        "print(f'Best RMSE score: {best_rmse_svd}')\n",
        "\n",
        "# Combination of parameters that gave the best RMSE score\n",
        "best_params_svd = gs_svd.best_params['rmse']\n",
        "print(f'Best parameter combination: {best_params_svd}')\n"
      ]
    },
    {
      "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": 268,
      "metadata": {
        "id": "TA_7xe-nnhuu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c694008f-ced8-40bb-b58b-74f953c0df6a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "RMSE: 0.9048\n",
            "Precision:  0.847\n",
            "Recall:  0.848\n",
            "F_1 score:  0.847\n"
          ]
        }
      ],
      "source": [
        "# Build the optimized SVD model using optimal hyperparameter search. Use random_state=1\n",
        "optimized_svd_model = SVD(n_epochs=20, lr_all=0.01, reg_all=0.4, random_state=1)\n",
        "\n",
        "# Train the algorithm on the trainset\n",
        "optimized_svd_model.fit(trainset)\n",
        "\n",
        "# Use the function precision_recall_at_k to compute precision@k, recall@k, F1-Score, and RMSE\n",
        "precision_recall_at_k(optimized_svd_model, 10, 3.5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9HJvPsjITsny"
      },
      "source": [
        "# Observations:\n",
        "\n",
        "### RMSE: 0.9048\n",
        "* **Baseline SVD Model:** 0.9126\n",
        "* **Optimized User Model:** 0.9549\n",
        "* The SVD model has a lower RMSE compared to the optimized user model, indicating that it's generally more accurate in predicting the exact ratings users would give to items.\n",
        "\n",
        "\n",
        "### Precision:  0.847\n",
        "* **Baseline SVD Model:** 0.842\n",
        "* **Optimized User Model:** 0.859\n",
        "* The optimized user model still exhibits slightly higher precision than the SVD model, meaning that a higher proportion of the items recommended by the optimized user model are relevant to the users.\n",
        "\n",
        "### Recall:  0.848\n",
        "* **Baseline SVD Model:** 0.841\n",
        "* **Optimized User Model:** 0.855\n",
        "* The optimized user model also demonstrates a slightly higher recall, meaning it's marginally better at identifying all relevant items that should be recommended to the users.\n",
        "\n",
        "\n",
        "### F_1 score:  0.847\n",
        "* **Baseline SVD Model:** 0.841\n",
        "* **Optimized User Model:** 0.857\n",
        "* The F_1 score is also higher in the optimized user model, suggesting that, overall, the optimized user model maintains a better balance between precision and recall.\n",
        "\n",
        "### General Assessment\n",
        "* The optimized SVD Model is the best model we've tested so far performance in terms of accuracy, as demonstrated by its lowest RMSE score, making it a strong choice for applications where predicting the exact rating value is crucial.\n",
        "\n",
        "* By tuning the hyperparameters, we've improved the performance of the SVD model on all metrics: accuracy, precision, recall and balance.\n",
        "\n",
        "* However, the optimized user-user CF model continues to outperform the optimized SVD model in precision, recall, and F1 score, making it more effective at identifying and recommending relevant items to users. This model would still be preferable in practical use, where the goal is to maximize user satisfaction and engagement through relevant recommendations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vnlAoriWtCdI"
      },
      "source": [
        "### **Steps:**\n",
        "- **Predict rating for the user with `userId=\"A3LDPF5FMB782Z\"`, and `prod_id= \"1400501466\"` using the optimized model**\n",
        "- **Predict rating for `userId=\"A34BZM6S9L7QI4\"` who has not interacted with `prod_id =\"1400501466\"`, by using the optimized model**\n",
        "- **Compare the output with the output from the baseline model**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 269,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JFTp96-ZtCdI",
        "outputId": "bb75071f-b098-44f9-af7f-db0523e84805"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating: 3.964193196853725\n"
          ]
        }
      ],
      "source": [
        "# Use optimized_svd_model model to recommend for userId \"A3LDPF5FMB782Z\" and productId \"1400501466\"\n",
        "optimized_svd_prediction = optimized_svd_model.predict(\"A3LDPF5FMB782Z\", \"1400501466\")\n",
        "print(f'Predicted rating: {optimized_svd_prediction.est}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 270,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cJzY1vWvtCdI",
        "outputId": "69da50e0-ac62-49a5-904f-183627f2d029"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted rating: 4.066507004863809\n"
          ]
        }
      ],
      "source": [
        "# Use optimized_svd_model model to recommend for userId \"A34BZM6S9L7QI4\" and productId \"1400501466\"\n",
        "optimized_svd_prediction2 = optimized_svd_model.predict(\"A34BZM6S9L7QI4\", \"1400501466\")\n",
        "print(f'Predicted rating: {optimized_svd_prediction2.est}')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Observations:\n",
        "\n",
        "* The optimized SVD model actually performs more poorly (3.9642) than the baseline SVD model (4.0636) when it comes to accurately predicting the rating of user1 (5.0) for the product. It far underperforms the optimized item model (4.63) and the optimized user model (4.2917) in this particular prediction.\n",
        "\n",
        "* The optimized SVD model's prediction of 4.0665 for user2's rating, which is slightly above user1's rating, goes against most of the ratings of other previous models."
      ],
      "metadata": {
        "id": "T8D_aGAxUau7"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nnwPwgjB8DwS"
      },
      "source": [
        "### **Conclusion and Recommendations**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xuqnifw9NF2p"
      },
      "source": [
        "### Conclusions\n",
        "* **The Optimized User-User CF Model** stands out as the best overall model considering precision, recall, and F1 scores. This indicates its effectiveness in matching users with products they are likely to enjoy, based on similarities between users' behavior and preferences.\n",
        "\n",
        "* **The Optimized Item-Item CF Model**, on the other hand, excels in accurately predicting the rating a given user \"A3LDPF5FMB782Z\" might assign to the product \"1400501466\". This model's strength lies in identifying products similar to those a user has already liked, potentially offering a more personalized recommendation in this case.\n",
        "\n",
        "* **The SVD Matrix Factorization Model** shows promise in terms of improved accuracy of predicting scores, although this was not demonstrated in the test case of user \"A3LDPF5FMB782Z\" with product \"1400501466\".\n",
        "\n",
        "\n",
        "# Recommendations\n",
        "\n",
        "1. **Hybrid Approach:** Consider implementing a hybrid recommendation system that leverages both user-user and item-item CF models. Use the user-user CF model to generate a broad set of relevant item recommendations based on user similarities. Then, refine these recommendations with the item-item CF model to ensure the highest personalized relevance, especially for users with unique tastes. You may want to verify these selections with the SVD Model.\n",
        "\n",
        "2. **Contextual Recommendations:** For new users or those with sparse interaction history, rely more on the rankings-based model to suggest popular or trending items among all users. As users interact more with the platform, gradually shift towards the user-user CF model and/or the item-item CF model, to personalize recommendations based on their specific interactions and ratings.\n",
        "\n",
        "3. **A/B Testing:** Regularly conduct A/B testing to evaluate the effectiveness of the hybrid recommendation system versus singular models. Supplement the data you currently have with user metrics, such as click-through rates and longer-term engagement metrics, such as retention rate and conversion rate to purchase.\n",
        "\n",
        "4. **User Feedback Loop:** Incorporate mechanisms for capturing explicit feedback (e.g., likes/dislikes, rating prompts) as well as implicit feedback (e.g., time spent on product pages, purchase history) to continuously refine and personalize the recommendation models. If qualitative data is provided in reviews, employ methods for NLP and sentiment analysis to further extract valuable data that would provide nuance to the broadly skewed user product ratings, which fail to disambiguate preference in about 50% of the data.\n",
        "\n",
        "5. **Exploration:** To balance between recommending proven favorites and discovering new interests, implement an exploration strategy that occasionally introduces less obvious recommendations. This can help in uncovering hidden preferences and keeping the recommendation experience fresh and engaging. It may also help uncover more dissimilarities between users.\n",
        "\n",
        "6. **Performance Monitoring:** Continuously monitor the performance of the recommendation system, including tracking anomalies in recommendation patterns, user feedback, and changes in user behavior.\n",
        "\n",
        "7. **Transparency and Control:** Offer users some degree of transparency and control over their recommendations. Features such as \"Why was this recommended?\" along with the ability for users to explicitly adjust preference settings or filter criteria may enhance user trust and satisfaction with the recommendation system overall,\n",
        "\n",
        "Implementing these recommendations can help Amazon create a more engaging, personalized, and effective product recommendation system on its website, ultimately enhancing user satisfaction, increasing sales, and fostering long-term user loyalty."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "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.9.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}