movielens-xgb2-user-item-id.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Movielens-1M using PIML Xgboost User-Item** \n",
    "Compare the prediction with RankFM. Use XGBoost classification, regression and ranker."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Data Loading and Processing**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import numpy as np\n",
    "\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user_id</th>\n",
       "      <th>item_id</th>\n",
       "      <th>rating</th>\n",
       "      <th>timestamp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1193</td>\n",
       "      <td>5</td>\n",
       "      <td>978300760</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>661</td>\n",
       "      <td>3</td>\n",
       "      <td>978302109</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>914</td>\n",
       "      <td>3</td>\n",
       "      <td>978301968</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>3408</td>\n",
       "      <td>4</td>\n",
       "      <td>978300275</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>2355</td>\n",
       "      <td>5</td>\n",
       "      <td>978824291</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1000204</th>\n",
       "      <td>6040</td>\n",
       "      <td>1091</td>\n",
       "      <td>1</td>\n",
       "      <td>956716541</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1000205</th>\n",
       "      <td>6040</td>\n",
       "      <td>1094</td>\n",
       "      <td>5</td>\n",
       "      <td>956704887</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1000206</th>\n",
       "      <td>6040</td>\n",
       "      <td>562</td>\n",
       "      <td>5</td>\n",
       "      <td>956704746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1000207</th>\n",
       "      <td>6040</td>\n",
       "      <td>1096</td>\n",
       "      <td>4</td>\n",
       "      <td>956715648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1000208</th>\n",
       "      <td>6040</td>\n",
       "      <td>1097</td>\n",
       "      <td>4</td>\n",
       "      <td>956715569</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1000209 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         user_id  item_id  rating  timestamp\n",
       "0              1     1193       5  978300760\n",
       "1              1      661       3  978302109\n",
       "2              1      914       3  978301968\n",
       "3              1     3408       4  978300275\n",
       "4              1     2355       5  978824291\n",
       "...          ...      ...     ...        ...\n",
       "1000204     6040     1091       1  956716541\n",
       "1000205     6040     1094       5  956704887\n",
       "1000206     6040      562       5  956704746\n",
       "1000207     6040     1096       4  956715648\n",
       "1000208     6040     1097       4  956715569\n",
       "\n",
       "[1000209 rows x 4 columns]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rating = pd.read_csv(\"ml-1m/ratings.dat\", names=[\"user_id\", \"item_id\", \"rating\", \"timestamp\"], delimiter=\"::\", engine=\"python\")\n",
    "rating.columns = ['user_id','item_id','rating','timestamp']\n",
    "rating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "interactions shape (1000209, 4)\n",
      "interaction unique users 6040\n",
      "interaction unique items 3706\n"
     ]
    }
   ],
   "source": [
    "unique_users = rating.user_id.nunique()\n",
    "unique_items = rating.item_id.nunique()\n",
    "\n",
    "print(f\"interactions shape {rating.shape}\")\n",
    "print(f\"interaction unique users {unique_users}\")\n",
    "print(f\"interaction unique items {unique_items}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "interaction matrix sparsity: 95.5%\n"
     ]
    }
   ],
   "source": [
    "sparsity = 1 - (len(rating)/(unique_users * unique_items))\n",
    "print(f\"interaction matrix sparsity: {round(100 * sparsity, 1)}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "rating.drop(['timestamp'], axis=1, inplace=True)\n",
    "\n",
    "# set all positive interactions to 1\n",
    "df_classification = rating.copy()\n",
    "df_classification['interaction'] = 1\n",
    "df_classification.drop(['rating'], axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Classification Approach**\n",
    "in RankFM, all dataset is positive interaction. To make it as classification prediction, balanced synthesis negative interaction added"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "all_users = df_classification.user_id.unique()\n",
    "all_items = df_classification.item_id.unique()\n",
    "\n",
    "negative_instances = []\n",
    "\n",
    "for user in all_users:\n",
    "    user_interacted_item = df_classification[df_classification.user_id == user]['item_id'].unique()\n",
    "    non_interacted_items = set(all_items) - set(user_interacted_item)\n",
    "    for item in non_interacted_items:\n",
    "        negative_instances.append([user, item, 0])\n",
    "\n",
    "num_negatives = len(rating[df_classification['interaction'] == 1])\n",
    "sampled_negatives = random.sample(negative_instances, num_negatives)\n",
    "\n",
    "df_negatives = pd.DataFrame(sampled_negatives, columns=['user_id', 'item_id', 'interaction'])\n",
    "df_negatives\n",
    "\n",
    "columns = ['user_id', 'item_id', 'interaction']\n",
    "balanced_df = pd.concat([df_classification[columns], df_negatives[columns]]).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = balanced_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Preparation with PIML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "from piml import Experiment\n",
    "from piml.models import XGB2Regressor, XGB2Classifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "user_item = df[['user_id', 'item_id']]\n",
    "\n",
    "# Prepare the features and labels\n",
    "X = df.drop(['interaction'], axis=1)\n",
    "y = df['interaction']\n",
    "\n",
    "# Perform train-test split\n",
    "train_x, test_x, train_y, test_y, user_item_train, user_item_test = train_test_split(\n",
    "    X, y, user_item, test_size=0.25, random_state=42\n",
    ")\n",
    "\n",
    "# Get the indices for train and test sets\n",
    "train_indices = np.array(train_x.index)\n",
    "test_indices = np.array(test_x.index)\n",
    "\n",
    "exp = Experiment(highcode_only=True)\n",
    "exp.data_loader(data=df, silent=True)\n",
    "exp.data_summary(feature_exclude=[], silent=True)\n",
    "exp.data_prepare(target='interaction', task_type='classification', train_idx=train_indices, test_idx=test_indices, silent=True)\n",
    "# exp.feature_select(threshold=0.98, method=\"pfi\", figsize=(6, 5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train shape: (1500313, 2)\n",
      "valid shape: (500105, 2)\n",
      "train users: 6040\n",
      "valid users: 6040\n",
      "cold-start users: set()\n",
      "train items: 3706\n",
      "valid items: 3706\n",
      "cold-start items: set()\n"
     ]
    }
   ],
   "source": [
    "print(\"train shape: {}\".format(train_x.shape))\n",
    "print(\"valid shape: {}\".format(test_x.shape))\n",
    "\n",
    "train_users = np.sort(user_item_train.user_id.unique())\n",
    "valid_users = np.sort(user_item_test.user_id.unique())\n",
    "cold_start_users = set(valid_users) - set(train_users)\n",
    "\n",
    "train_items = np.sort(user_item_train.item_id.unique())\n",
    "valid_items = np.sort(user_item_test.item_id.unique())\n",
    "cold_start_items = set(valid_items) - set(train_items)\n",
    "\n",
    "print(\"train users: {}\".format(len(train_users)))\n",
    "print(\"valid users: {}\".format(len(valid_users)))\n",
    "print(\"cold-start users: {}\".format(cold_start_users))\n",
    "\n",
    "print(\"train items: {}\".format(len(train_items)))\n",
    "print(\"valid items: {}\".format(len(valid_items)))\n",
    "print(\"cold-start items: {}\".format(cold_start_items))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ACC</th>\n",
       "      <th>AUC</th>\n",
       "      <th>F1</th>\n",
       "      <th>LogLoss</th>\n",
       "      <th>Brier</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Train</th>\n",
       "      <td>0.6100</td>\n",
       "      <td>0.6563</td>\n",
       "      <td>0.5987</td>\n",
       "      <td>0.6569</td>\n",
       "      <td>0.2325</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Test</th>\n",
       "      <td>0.6097</td>\n",
       "      <td>0.6566</td>\n",
       "      <td>0.5994</td>\n",
       "      <td>0.6568</td>\n",
       "      <td>0.2324</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gap</th>\n",
       "      <td>-0.0003</td>\n",
       "      <td>0.0003</td>\n",
       "      <td>0.0007</td>\n",
       "      <td>-0.0001</td>\n",
       "      <td>-0.0001</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           ACC     AUC      F1  LogLoss    Brier\n",
       "                                                \n",
       "Train   0.6100  0.6563  0.5987   0.6569   0.2325\n",
       "Test    0.6097  0.6566  0.5994   0.6568   0.2324\n",
       "Gap    -0.0003  0.0003  0.0007  -0.0001  -0.0001"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "exp.model_train(model=XGB2Classifier(), name=\"XGB2\")\n",
    "exp.model_diagnose(model=\"XGB2\", show=\"accuracy_table\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exp.model_interpret(model=\"XGB2\", show=\"global_ei\", figsize=(5, 4))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exp.model_interpret(model=\"XGB2\", show=\"global_fi\", figsize=(5, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exp.model_interpret(model=\"XGB2\", show=\"local_ei\", sample_id=0, original_scale=True, figsize=(5, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exp.model_interpret(model=\"XGB2\", show=\"local_fi\", sample_id=0, original_scale=True, figsize=(5, 4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use RankFM Validation Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train shape: (750042, 2)\n",
      "valid shape: (250167, 2)\n",
      "train users: 6040\n",
      "valid users: 6040\n",
      "cold-start users: set()\n",
      "train items: 3670\n",
      "valid items: 3507\n",
      "cold-start items: {3842, 2308, 2438, 3220, 3607, 2584, 1820, 2845, 2591, 545, 1316, 2214, 1832, 1579, 3376, 1714, 1843, 2226, 2742, 311, 826, 2235, 3517, 1470, 576, 2895, 601, 3291, 989, 1630, 2909, 868, 2277, 2039, 3065, 2556}\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "\n",
    "interactions = rating.copy()\n",
    "interactions['random'] = np.random.random(size=len(interactions))\n",
    "test_pct = 0.25\n",
    "\n",
    "train_mask = interactions['random'] <  (1 - test_pct)\n",
    "valid_mask = interactions['random'] >= (1 - test_pct)\n",
    "\n",
    "interactions_train = interactions[train_mask][['user_id', 'item_id']]\n",
    "interactions_valid = interactions[valid_mask][['user_id', 'item_id']]\n",
    "\n",
    "train_users = np.sort(interactions_train.user_id.unique())\n",
    "valid_users = np.sort(interactions_valid.user_id.unique())\n",
    "cold_start_users = set(valid_users) - set(train_users)\n",
    "\n",
    "train_items = np.sort(interactions_train.item_id.unique())\n",
    "valid_items = np.sort(interactions_valid.item_id.unique())\n",
    "cold_start_items = set(valid_items) - set(train_items)\n",
    "\n",
    "print(\"train shape: {}\".format(interactions_train.shape))\n",
    "print(\"valid shape: {}\".format(interactions_valid.shape))\n",
    "\n",
    "print(\"train users: {}\".format(len(train_users)))\n",
    "print(\"valid users: {}\".format(len(valid_users)))\n",
    "print(\"cold-start users: {}\".format(cold_start_users))\n",
    "\n",
    "print(\"train items: {}\".format(len(train_items)))\n",
    "print(\"valid items: {}\".format(len(valid_items)))\n",
    "print(\"cold-start items: {}\".format(cold_start_items))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Predict on test data  \n",
    "Make the top-10 K "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = 10\n",
    "\n",
    "def pivot_table_recommendation(recommendation):\n",
    "    # Pivot the data to get a wide format DataFrame with one row per user and top 10 movie recommendations\n",
    "    pv_rec = recommendation.pivot(index='user_id', columns='rank', values='item_id').reset_index()\n",
    "\n",
    "    # Set user_id as the index\n",
    "    pv_rec.set_index('user_id', inplace=True)\n",
    "\n",
    "    # Remove the 'rank' column\n",
    "    pv_rec.columns.name = None\n",
    "    pv_rec.columns = [f'{int(rank)}' for rank in pv_rec.columns]\n",
    "    pv_rec.index.name = None\n",
    "\n",
    "    return pv_rec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Predict on Test Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2027</td>\n",
       "      <td>921</td>\n",
       "      <td>1246</td>\n",
       "      <td>1306</td>\n",
       "      <td>353</td>\n",
       "      <td>2692</td>\n",
       "      <td>1101</td>\n",
       "      <td>3268</td>\n",
       "      <td>1207</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>366</td>\n",
       "      <td>21</td>\n",
       "      <td>1253</td>\n",
       "      <td>356</td>\n",
       "      <td>1197</td>\n",
       "      <td>1351</td>\n",
       "      <td>1207</td>\n",
       "      <td>1245</td>\n",
       "      <td>2427</td>\n",
       "      <td>1198</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1259</td>\n",
       "      <td>1394</td>\n",
       "      <td>2400</td>\n",
       "      <td>2921</td>\n",
       "      <td>1995</td>\n",
       "      <td>1251</td>\n",
       "      <td>1088</td>\n",
       "      <td>372</td>\n",
       "      <td>42</td>\n",
       "      <td>2507</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1954</td>\n",
       "      <td>1349</td>\n",
       "      <td>1238</td>\n",
       "      <td>1187</td>\n",
       "      <td>1036</td>\n",
       "      <td>1214</td>\n",
       "      <td>1391</td>\n",
       "      <td>373</td>\n",
       "      <td>1386</td>\n",
       "      <td>3802</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>593</td>\n",
       "      <td>2427</td>\n",
       "      <td>1095</td>\n",
       "      <td>32</td>\n",
       "      <td>1218</td>\n",
       "      <td>1335</td>\n",
       "      <td>2428</td>\n",
       "      <td>1392</td>\n",
       "      <td>916</td>\n",
       "      <td>1089</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      1     2     3     4     5     6     7     8     9    10\n",
       "1  2027   921  1246  1306   353  2692  1101  3268  1207     1\n",
       "2   366    21  1253   356  1197  1351  1207  1245  2427  1198\n",
       "3  1259  1394  2400  2921  1995  1251  1088   372    42  2507\n",
       "4  1954  1349  1238  1187  1036  1214  1391   373  1386  3802\n",
       "5   593  2427  1095    32  1218  1335  2428  1392   916  1089"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test = user_item_test\n",
    "dpredict = df_test\n",
    "\n",
    "xgb2 = exp.get_model(\"XGB2\")\n",
    "\n",
    "# Predict the interaction probabilities\n",
    "df_test['predicted_interaction'] = xgb2.predict(dpredict)\n",
    "\n",
    "# Rank the predictions\n",
    "df_test['rank'] = df_test.groupby('user_id')['predicted_interaction'].rank(method='first', ascending=False)\n",
    "\n",
    "# Filter to get top 10 predictions for each user\n",
    "top_10_recommendations = df_test[df_test['rank'] <= 10]\n",
    "\n",
    "# Pivot the data to get a wide format DataFrame with one row per user and top 10 movie recommendations\n",
    "pivot_recommendations = pivot_table_recommendation(top_10_recommendations)\n",
    "pivot_recommendations.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notes:** \n",
    "- RankFM able to generate movie_id based on user_id input, while XGBoost is predict the interaction given user_id and movie_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Predict on RankFM Validation dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2398.0</td>\n",
       "      <td>48.0</td>\n",
       "      <td>2692.0</td>\n",
       "      <td>1246.0</td>\n",
       "      <td>661.0</td>\n",
       "      <td>2804.0</td>\n",
       "      <td>938.0</td>\n",
       "      <td>588.0</td>\n",
       "      <td>1907.0</td>\n",
       "      <td>783.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1357.0</td>\n",
       "      <td>2916.0</td>\n",
       "      <td>1213.0</td>\n",
       "      <td>1293.0</td>\n",
       "      <td>3257.0</td>\n",
       "      <td>2028.0</td>\n",
       "      <td>1084.0</td>\n",
       "      <td>1265.0</td>\n",
       "      <td>1193.0</td>\n",
       "      <td>590.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1079.0</td>\n",
       "      <td>1580.0</td>\n",
       "      <td>1968.0</td>\n",
       "      <td>3421.0</td>\n",
       "      <td>1641.0</td>\n",
       "      <td>3534.0</td>\n",
       "      <td>3868.0</td>\n",
       "      <td>653.0</td>\n",
       "      <td>2167.0</td>\n",
       "      <td>3114.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1196.0</td>\n",
       "      <td>1198.0</td>\n",
       "      <td>1387.0</td>\n",
       "      <td>480.0</td>\n",
       "      <td>3418.0</td>\n",
       "      <td>2366.0</td>\n",
       "      <td>3527.0</td>\n",
       "      <td>2947.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1392.0</td>\n",
       "      <td>1191.0</td>\n",
       "      <td>2427.0</td>\n",
       "      <td>908.0</td>\n",
       "      <td>265.0</td>\n",
       "      <td>2029.0</td>\n",
       "      <td>1089.0</td>\n",
       "      <td>913.0</td>\n",
       "      <td>3266.0</td>\n",
       "      <td>2395.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        1       2       3       4       5       6       7       8       9  \\\n",
       "1  2398.0    48.0  2692.0  1246.0   661.0  2804.0   938.0   588.0  1907.0   \n",
       "2  1357.0  2916.0  1213.0  1293.0  3257.0  2028.0  1084.0  1265.0  1193.0   \n",
       "3  1079.0  1580.0  1968.0  3421.0  1641.0  3534.0  3868.0   653.0  2167.0   \n",
       "4  1196.0  1198.0  1387.0   480.0  3418.0  2366.0  3527.0  2947.0     NaN   \n",
       "5  1392.0  1191.0  2427.0   908.0   265.0  2029.0  1089.0   913.0  3266.0   \n",
       "\n",
       "       10  \n",
       "1   783.0  \n",
       "2   590.0  \n",
       "3  3114.0  \n",
       "4     NaN  \n",
       "5  2395.0  "
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test = interactions_valid.copy()\n",
    "\n",
    "dpredict = df_test\n",
    "\n",
    "xgb2 = exp.get_model(\"XGB2\")\n",
    "\n",
    "# Predict the interaction probabilities\n",
    "df_test['predicted_interaction'] = xgb2.predict(dpredict)\n",
    "\n",
    "# Rank the predictions\n",
    "df_test['rank'] = df_test.groupby('user_id')['predicted_interaction'].rank(method='first', ascending=False)\n",
    "\n",
    "# Filter to get top 10 predictions for each user\n",
    "top_10_recommendations = df_test[df_test['rank'] <= 10]\n",
    "\n",
    "# Pivot the data to get a wide format DataFrame with one row per user and top 10 movie recommendations\n",
    "pivot_recommendations = pivot_table_recommendation(top_10_recommendations)\n",
    "pivot_recommendations.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notes:** \n",
    "- The results is looks totally differences than RankFM and few is NaN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVALUATION CLASSIFICATION TESTSET ONLY\n",
      "\n",
      "hit_rate: 1.000\n",
      "reciprocal_rank: 1.000\n",
      "dcg: 4.315\n",
      "precision: 0.928\n",
      "recall: 0.510\n"
     ]
    }
   ],
   "source": [
    "k = 10\n",
    "\n",
    "test_users_items = df_test.groupby('user_id')['item_id'].apply(set).to_dict()\n",
    "test_users = list(test_users_items.keys())\n",
    "comm_user = pivot_recommendations.index.values\n",
    "\n",
    "def hit_rate():\n",
    "    hit_rate = np.mean([int(len(set(pivot_recommendations.loc[u]) & test_users_items[u]) > 0) for u in comm_user])\n",
    "    return hit_rate\n",
    "\n",
    "def reciprocal_rank():\n",
    "    match_indexes = [np.where(pivot_recommendations.loc[u].isin(set(pivot_recommendations.loc[u]) & test_users_items[u]))[0] for u in comm_user]\n",
    "    reciprocal_rank = np.mean([1 / (np.min(index) + 1) if len(index) > 0 else 0 for index in match_indexes])\n",
    "\n",
    "    return reciprocal_rank\n",
    "\n",
    "def dcg():\n",
    "    match_indexes = [np.where(pivot_recommendations.loc[u].isin(set(pivot_recommendations.loc[u]) & test_users_items[u]))[0] for u in comm_user]\n",
    "    discounted_cumulative_gain = np.mean([np.sum(1 / np.log2(index + 2)) if len(index) > 0 else 0 for index in match_indexes])\n",
    "    \n",
    "    return discounted_cumulative_gain\n",
    "\n",
    "def precision():\n",
    "    precision = np.mean([len(set(pivot_recommendations.loc[u]) & test_users_items[u]) / len(pivot_recommendations.loc[u]) for u in comm_user])\n",
    "\n",
    "    return precision\n",
    "\n",
    "def recall():\n",
    "    recall = np.mean([len(set(pivot_recommendations.loc[u]) & test_users_items[u]) / len(test_users_items[u]) for u in comm_user])\n",
    "\n",
    "    return recall\n",
    "\n",
    "print(\"EVALUATION CLASSIFICATION TESTSET ONLY\\n\")\n",
    "\n",
    "print(\"hit_rate: {:.3f}\".format(hit_rate()))\n",
    "print(\"reciprocal_rank: {:.3f}\".format(reciprocal_rank()))\n",
    "print(\"dcg: {:.3f}\".format(dcg()))\n",
    "print(\"precision: {:.3f}\".format(precision()))\n",
    "print(\"recall: {:.3f}\".format(recall()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notes:** \n",
    "\n",
    "- XGB2 outperform because its leverage rich data from user and item features\n",
    "- Next, we test on unseen data to check whether its over-fitting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Prediction on All Combination Data (excluded training data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assuming all_users is a list of all user IDs and all_items is a list of all item IDs\n",
    "# Create a DataFrame for all user-item pairs\n",
    "all_user_item_pairs = pd.DataFrame([(user, item) for user in all_users for item in all_items], columns=['user_id', 'item_id'])\n",
    "\n",
    "# Remove training data from all_user_item_pairs\n",
    "all_user_item_pairs = all_user_item_pairs[~all_user_item_pairs.isin(user_item_train[['user_id', 'item_id']])].dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add user and item features\n",
    "all_pairs_completed = all_user_item_pairs\n",
    "\n",
    "dpredict = all_pairs_completed\n",
    "\n",
    "xgb2 = exp.get_model(\"XGB2\")\n",
    "\n",
    "# Predict the interaction probabilities\n",
    "all_pairs_completed['predicted_interaction'] = xgb2.predict(dpredict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1.0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2692.0</td>\n",
       "      <td>1207.0</td>\n",
       "      <td>1246.0</td>\n",
       "      <td>1357.0</td>\n",
       "      <td>1213.0</td>\n",
       "      <td>1253.0</td>\n",
       "      <td>902.0</td>\n",
       "      <td>368.0</td>\n",
       "      <td>1259.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2.0</th>\n",
       "      <td>1193.0</td>\n",
       "      <td>914.0</td>\n",
       "      <td>1197.0</td>\n",
       "      <td>1287.0</td>\n",
       "      <td>594.0</td>\n",
       "      <td>919.0</td>\n",
       "      <td>595.0</td>\n",
       "      <td>2398.0</td>\n",
       "      <td>2918.0</td>\n",
       "      <td>1035.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3.0</th>\n",
       "      <td>1193.0</td>\n",
       "      <td>914.0</td>\n",
       "      <td>1197.0</td>\n",
       "      <td>1287.0</td>\n",
       "      <td>594.0</td>\n",
       "      <td>919.0</td>\n",
       "      <td>595.0</td>\n",
       "      <td>2398.0</td>\n",
       "      <td>2918.0</td>\n",
       "      <td>1035.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4.0</th>\n",
       "      <td>1193.0</td>\n",
       "      <td>914.0</td>\n",
       "      <td>1197.0</td>\n",
       "      <td>1287.0</td>\n",
       "      <td>594.0</td>\n",
       "      <td>919.0</td>\n",
       "      <td>595.0</td>\n",
       "      <td>2398.0</td>\n",
       "      <td>2918.0</td>\n",
       "      <td>1035.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5.0</th>\n",
       "      <td>1193.0</td>\n",
       "      <td>914.0</td>\n",
       "      <td>1197.0</td>\n",
       "      <td>1287.0</td>\n",
       "      <td>594.0</td>\n",
       "      <td>919.0</td>\n",
       "      <td>595.0</td>\n",
       "      <td>2398.0</td>\n",
       "      <td>2918.0</td>\n",
       "      <td>1035.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          1       2       3       4       5       6       7       8       9  \\\n",
       "1.0     1.0  2692.0  1207.0  1246.0  1357.0  1213.0  1253.0   902.0   368.0   \n",
       "2.0  1193.0   914.0  1197.0  1287.0   594.0   919.0   595.0  2398.0  2918.0   \n",
       "3.0  1193.0   914.0  1197.0  1287.0   594.0   919.0   595.0  2398.0  2918.0   \n",
       "4.0  1193.0   914.0  1197.0  1287.0   594.0   919.0   595.0  2398.0  2918.0   \n",
       "5.0  1193.0   914.0  1197.0  1287.0   594.0   919.0   595.0  2398.0  2918.0   \n",
       "\n",
       "         10  \n",
       "1.0  1259.0  \n",
       "2.0  1035.0  \n",
       "3.0  1035.0  \n",
       "4.0  1035.0  \n",
       "5.0  1035.0  "
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rank the predictions\n",
    "all_pairs_completed['rank'] = all_pairs_completed.groupby('user_id')['predicted_interaction'].rank(method='first', ascending=False)\n",
    "\n",
    "# Filter to get top 10 predictions for each user\n",
    "top_10_recommendations = all_pairs_completed[all_pairs_completed['rank'] <= 10]\n",
    "\n",
    "# Pivot the data to get a wide format DataFrame with one row per user and top 10 movie recommendations\n",
    "pivot_recommendations = pivot_table_recommendation(top_10_recommendations)\n",
    "pivot_recommendations.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluation Unseen Data Prediction Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVALUATION CLASSIFICATION UNSEEN DATA EXCLUDED TRAINING\n",
      "\n",
      "hit_rate: 0.367\n",
      "reciprocal_rank: 0.139\n",
      "dcg: 0.249\n",
      "precision: 0.053\n",
      "recall: 0.017\n"
     ]
    }
   ],
   "source": [
    "test_users_items = df_test.groupby('user_id')['item_id'].apply(set).to_dict()\n",
    "test_users = list(test_users_items.keys())\n",
    "comm_user = pivot_recommendations.index.values\n",
    "\n",
    "print(\"EVALUATION CLASSIFICATION UNSEEN DATA EXCLUDED TRAINING\\n\")\n",
    "\n",
    "print(\"hit_rate: {:.3f}\".format(hit_rate()))\n",
    "print(\"reciprocal_rank: {:.3f}\".format(reciprocal_rank()))\n",
    "print(\"dcg: {:.3f}\".format(dcg()))\n",
    "print(\"precision: {:.3f}\".format(precision()))\n",
    "print(\"recall: {:.3f}\".format(recall()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notes:** \n",
    "\n",
    "- Its significant lower when predicting over unseen data and back testing into test data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Regression Approach**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = rating\n",
    "\n",
    "user_item = df[['user_id', 'item_id']]\n",
    "\n",
    "# Prepare the features and labels\n",
    "X = df.drop(['rating'], axis=1)\n",
    "y = df['rating']\n",
    "\n",
    "# Perform train-test split\n",
    "train_x, test_x, train_y, test_y, user_item_train, user_item_test = train_test_split(\n",
    "    X, y, user_item, test_size=0.25, random_state=42\n",
    ")\n",
    "\n",
    "# Get the indices for train and test sets\n",
    "train_indices = np.array(train_x.index)\n",
    "test_indices = np.array(test_x.index)\n",
    "\n",
    "exp = Experiment(highcode_only=True)\n",
    "exp.data_loader(data=df, silent=True)\n",
    "exp.data_summary(feature_exclude=['rating'], silent=True)\n",
    "exp.data_prepare(target='rating', task_type='regression', train_idx=train_indices, test_idx=test_indices, silent=True)\n",
    "# exp.feature_select(threshold=0.98, method=\"pfi\", figsize=(6, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>MSE</th>\n",
       "      <th>MAE</th>\n",
       "      <th>R2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Train</th>\n",
       "      <td>0.0723</td>\n",
       "      <td>0.2212</td>\n",
       "      <td>0.0717</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Test</th>\n",
       "      <td>0.0728</td>\n",
       "      <td>0.2220</td>\n",
       "      <td>0.0697</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gap</th>\n",
       "      <td>0.0005</td>\n",
       "      <td>0.0008</td>\n",
       "      <td>-0.0020</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          MSE     MAE       R2\n",
       "                              \n",
       "Train  0.0723  0.2212   0.0717\n",
       "Test   0.0728  0.2220   0.0697\n",
       "Gap    0.0005  0.0008  -0.0020"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "exp.model_train(model=XGB2Regressor(), name=\"XGB2\")\n",
    "exp.model_diagnose(model=\"XGB2\", show=\"accuracy_table\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1193.0</td>\n",
       "      <td>1246.0</td>\n",
       "      <td>595.0</td>\n",
       "      <td>1035.0</td>\n",
       "      <td>608.0</td>\n",
       "      <td>588.0</td>\n",
       "      <td>3105.0</td>\n",
       "      <td>3186.0</td>\n",
       "      <td>2321.0</td>\n",
       "      <td>2340.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1253.0</td>\n",
       "      <td>1196.0</td>\n",
       "      <td>265.0</td>\n",
       "      <td>1084.0</td>\n",
       "      <td>1090.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>1945.0</td>\n",
       "      <td>1957.0</td>\n",
       "      <td>1953.0</td>\n",
       "      <td>3678.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1196.0</td>\n",
       "      <td>1259.0</td>\n",
       "      <td>1270.0</td>\n",
       "      <td>1291.0</td>\n",
       "      <td>1049.0</td>\n",
       "      <td>3671.0</td>\n",
       "      <td>3168.0</td>\n",
       "      <td>2081.0</td>\n",
       "      <td>1394.0</td>\n",
       "      <td>653.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1210.0</td>\n",
       "      <td>1201.0</td>\n",
       "      <td>260.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>913.0</td>\n",
       "      <td>919.0</td>\n",
       "      <td>1279.0</td>\n",
       "      <td>1192.0</td>\n",
       "      <td>1175.0</td>\n",
       "      <td>1191.0</td>\n",
       "      <td>1171.0</td>\n",
       "      <td>321.0</td>\n",
       "      <td>593.0</td>\n",
       "      <td>1089.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        1       2       3       4       5       6       7       8       9  \\\n",
       "1  1193.0  1246.0   595.0  1035.0   608.0   588.0  3105.0  3186.0  2321.0   \n",
       "2  1253.0  1196.0   265.0  1084.0  1090.0   110.0  1945.0  1957.0  1953.0   \n",
       "3  1196.0  1259.0  1270.0  1291.0  1049.0  3671.0  3168.0  2081.0  1394.0   \n",
       "4  1210.0  1201.0   260.0     NaN     NaN     NaN     NaN     NaN     NaN   \n",
       "5   913.0   919.0  1279.0  1192.0  1175.0  1191.0  1171.0   321.0   593.0   \n",
       "\n",
       "       10  \n",
       "1  2340.0  \n",
       "2  3678.0  \n",
       "3   653.0  \n",
       "4     NaN  \n",
       "5  1089.0  "
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test = user_item_test\n",
    "\n",
    "dpredict = df_test\n",
    "\n",
    "xgb2 = exp.get_model(\"XGB2\")\n",
    "\n",
    "# Predict the interaction probabilities\n",
    "df_test['predicted_rating'] = xgb2.predict(dpredict)\n",
    "\n",
    "# Rank the predictions\n",
    "df_test['rank'] = df_test.groupby('user_id')['predicted_rating'].rank(method='first', ascending=False)\n",
    "\n",
    "# Filter to get top 10 predictions for each user\n",
    "top_10_recommendations = df_test[df_test['rank'] <= 10]\n",
    "\n",
    "# Pivot the data to get a wide format DataFrame with one row per user and top 10 movie recommendations\n",
    "pivot_recommendations = pivot_table_recommendation(top_10_recommendations)\n",
    "pivot_recommendations.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test with RankFM Validation Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1246.0</td>\n",
       "      <td>938.0</td>\n",
       "      <td>48.0</td>\n",
       "      <td>608.0</td>\n",
       "      <td>588.0</td>\n",
       "      <td>3114.0</td>\n",
       "      <td>2804.0</td>\n",
       "      <td>1907.0</td>\n",
       "      <td>2692.0</td>\n",
       "      <td>661.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1213.0</td>\n",
       "      <td>1193.0</td>\n",
       "      <td>1196.0</td>\n",
       "      <td>1245.0</td>\n",
       "      <td>920.0</td>\n",
       "      <td>1265.0</td>\n",
       "      <td>1293.0</td>\n",
       "      <td>590.0</td>\n",
       "      <td>1084.0</td>\n",
       "      <td>1953.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1079.0</td>\n",
       "      <td>2871.0</td>\n",
       "      <td>3671.0</td>\n",
       "      <td>3114.0</td>\n",
       "      <td>3534.0</td>\n",
       "      <td>1641.0</td>\n",
       "      <td>3421.0</td>\n",
       "      <td>3552.0</td>\n",
       "      <td>2167.0</td>\n",
       "      <td>653.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1196.0</td>\n",
       "      <td>1198.0</td>\n",
       "      <td>2947.0</td>\n",
       "      <td>3527.0</td>\n",
       "      <td>2366.0</td>\n",
       "      <td>3418.0</td>\n",
       "      <td>480.0</td>\n",
       "      <td>1387.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>908.0</td>\n",
       "      <td>913.0</td>\n",
       "      <td>265.0</td>\n",
       "      <td>1175.0</td>\n",
       "      <td>1191.0</td>\n",
       "      <td>1171.0</td>\n",
       "      <td>860.0</td>\n",
       "      <td>321.0</td>\n",
       "      <td>1089.0</td>\n",
       "      <td>2395.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        1       2       3       4       5       6       7       8       9  \\\n",
       "1  1246.0   938.0    48.0   608.0   588.0  3114.0  2804.0  1907.0  2692.0   \n",
       "2  1213.0  1193.0  1196.0  1245.0   920.0  1265.0  1293.0   590.0  1084.0   \n",
       "3  1079.0  2871.0  3671.0  3114.0  3534.0  1641.0  3421.0  3552.0  2167.0   \n",
       "4  1196.0  1198.0  2947.0  3527.0  2366.0  3418.0   480.0  1387.0     NaN   \n",
       "5   908.0   913.0   265.0  1175.0  1191.0  1171.0   860.0   321.0  1089.0   \n",
       "\n",
       "       10  \n",
       "1   661.0  \n",
       "2  1953.0  \n",
       "3   653.0  \n",
       "4     NaN  \n",
       "5  2395.0  "
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test = interactions_valid.copy()\n",
    "dpredict = df_test\n",
    "\n",
    "xgb2 = exp.get_model(\"XGB2\")\n",
    "\n",
    "# Predict the interaction probabilities\n",
    "df_test['predicted_rating'] = xgb2.predict(dpredict)\n",
    "\n",
    "# Rank the predictions\n",
    "df_test['rank'] = df_test.groupby('user_id')['predicted_rating'].rank(method='first', ascending=False)\n",
    "\n",
    "# Filter to get top 10 predictions for each user\n",
    "top_10_recommendations = df_test[df_test['rank'] <= 10]\n",
    "\n",
    "# Pivot the data to get a wide format DataFrame with one row per user and top 10 movie recommendations\n",
    "pivot_recommendations = pivot_table_recommendation(top_10_recommendations)\n",
    "pivot_recommendations.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVALUATION REGRESSION TEST SET ONLY \n",
      "\n",
      "hit_rate: 1.000\n",
      "reciprocal_rank: 1.000\n",
      "dcg: 4.315\n",
      "precision: 0.928\n",
      "recall: 0.510\n"
     ]
    }
   ],
   "source": [
    "test_users_items = df_test.groupby('user_id')['item_id'].apply(set).to_dict()\n",
    "test_users = list(test_users_items.keys())\n",
    "comm_user = pivot_recommendations.index.values\n",
    "\n",
    "print(\"EVALUATION REGRESSION TEST SET ONLY \\n\")\n",
    "\n",
    "print(\"hit_rate: {:.3f}\".format(hit_rate()))\n",
    "print(\"reciprocal_rank: {:.3f}\".format(reciprocal_rank()))\n",
    "print(\"dcg: {:.3f}\".format(dcg()))\n",
    "print(\"precision: {:.3f}\".format(precision()))\n",
    "print(\"recall: {:.3f}\".format(recall()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assuming all_users is a list of all user IDs and all_items is a list of all item IDs\n",
    "# Create a DataFrame for all user-item pairs\n",
    "all_user_item_pairs = pd.DataFrame([(user, item) for user in rating.user_id.unique() for item in rating.item_id.unique()], columns=['user_id', 'item_id'])\n",
    "\n",
    "# Remove training data from all_user_item_pairs\n",
    "all_user_item_pairs = all_user_item_pairs[~all_user_item_pairs.isin(user_item_train[['user_id', 'item_id']])].dropna()\n",
    "\n",
    "all_pairs_completed = all_user_item_pairs.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "xgb2 = exp.get_model(\"XGB2\")\n",
    "\n",
    "# Predict the interaction probabilities\n",
    "all_user_item_pairs['predicted_rating'] = xgb2.predict(all_pairs_completed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1.0</th>\n",
       "      <td>1193.0</td>\n",
       "      <td>1246.0</td>\n",
       "      <td>1253.0</td>\n",
       "      <td>1225.0</td>\n",
       "      <td>1196.0</td>\n",
       "      <td>1198.0</td>\n",
       "      <td>1244.0</td>\n",
       "      <td>1245.0</td>\n",
       "      <td>1247.0</td>\n",
       "      <td>1214.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2.0</th>\n",
       "      <td>1193.0</td>\n",
       "      <td>1197.0</td>\n",
       "      <td>1207.0</td>\n",
       "      <td>1246.0</td>\n",
       "      <td>1210.0</td>\n",
       "      <td>1213.0</td>\n",
       "      <td>1217.0</td>\n",
       "      <td>1253.0</td>\n",
       "      <td>1225.0</td>\n",
       "      <td>1196.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3.0</th>\n",
       "      <td>1193.0</td>\n",
       "      <td>1197.0</td>\n",
       "      <td>1207.0</td>\n",
       "      <td>1246.0</td>\n",
       "      <td>1210.0</td>\n",
       "      <td>1213.0</td>\n",
       "      <td>1217.0</td>\n",
       "      <td>1253.0</td>\n",
       "      <td>1225.0</td>\n",
       "      <td>1196.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4.0</th>\n",
       "      <td>1193.0</td>\n",
       "      <td>1197.0</td>\n",
       "      <td>1207.0</td>\n",
       "      <td>1246.0</td>\n",
       "      <td>1210.0</td>\n",
       "      <td>1213.0</td>\n",
       "      <td>1217.0</td>\n",
       "      <td>1253.0</td>\n",
       "      <td>1225.0</td>\n",
       "      <td>1196.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5.0</th>\n",
       "      <td>1193.0</td>\n",
       "      <td>1197.0</td>\n",
       "      <td>1207.0</td>\n",
       "      <td>1246.0</td>\n",
       "      <td>1210.0</td>\n",
       "      <td>1213.0</td>\n",
       "      <td>1217.0</td>\n",
       "      <td>1253.0</td>\n",
       "      <td>1225.0</td>\n",
       "      <td>1196.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          1       2       3       4       5       6       7       8       9  \\\n",
       "1.0  1193.0  1246.0  1253.0  1225.0  1196.0  1198.0  1244.0  1245.0  1247.0   \n",
       "2.0  1193.0  1197.0  1207.0  1246.0  1210.0  1213.0  1217.0  1253.0  1225.0   \n",
       "3.0  1193.0  1197.0  1207.0  1246.0  1210.0  1213.0  1217.0  1253.0  1225.0   \n",
       "4.0  1193.0  1197.0  1207.0  1246.0  1210.0  1213.0  1217.0  1253.0  1225.0   \n",
       "5.0  1193.0  1197.0  1207.0  1246.0  1210.0  1213.0  1217.0  1253.0  1225.0   \n",
       "\n",
       "         10  \n",
       "1.0  1214.0  \n",
       "2.0  1196.0  \n",
       "3.0  1196.0  \n",
       "4.0  1196.0  \n",
       "5.0  1196.0  "
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rank the predictions\n",
    "all_user_item_pairs['rank'] = all_user_item_pairs.groupby('user_id')['predicted_rating'].rank(method='first', ascending=False)\n",
    "\n",
    "# Filter to get top 10 predictions for each user\n",
    "top_10_recommendations = all_user_item_pairs[all_user_item_pairs['rank'] <= 10]\n",
    "\n",
    "# Pivot the data to get a wide format DataFrame with one row per user and top 10 movie recommendations\n",
    "pivot_recommendations = pivot_table_recommendation(top_10_recommendations)\n",
    "pivot_recommendations.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVALUATION REGRESSION UNSEEN DATA EXCLUDED TRAINING \n",
      "\n",
      "hit_rate: 0.432\n",
      "reciprocal_rank: 0.163\n",
      "dcg: 0.301\n",
      "precision: 0.065\n",
      "recall: 0.023\n"
     ]
    }
   ],
   "source": [
    "test_users_items = df_test.groupby('user_id')['item_id'].apply(set).to_dict()\n",
    "test_users = list(test_users_items.keys())\n",
    "comm_user = pivot_recommendations.index.values\n",
    "\n",
    "print(\"EVALUATION REGRESSION UNSEEN DATA EXCLUDED TRAINING \\n\")\n",
    "\n",
    "print(\"hit_rate: {:.3f}\".format(hit_rate()))\n",
    "print(\"reciprocal_rank: {:.3f}\".format(reciprocal_rank()))\n",
    "print(\"dcg: {:.3f}\".format(dcg()))\n",
    "print(\"precision: {:.3f}\".format(precision()))\n",
    "print(\"recall: {:.3f}\".format(recall()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **XGBRanker Approach**\n",
    "We are using the classification data that have positive and negative balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = balanced_df.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GroupShuffleSplit\n",
    "\n",
    "gss = GroupShuffleSplit(n_splits=1, test_size=0.25, random_state=42)\n",
    "train_idx, test_indices = next(gss.split(df, groups=df.user_id))\n",
    "\n",
    "train_data = df.iloc[train_idx]\n",
    "test_data = df.iloc[test_indices]\n",
    "\n",
    "X_train = train_data.drop(columns=['interaction'])\n",
    "y_train = train_data['interaction']\n",
    "X_test = test_data.drop(columns=['interaction'])\n",
    "y_test = test_data['interaction']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_groups = X_train.groupby('user_id').size().to_numpy()\n",
    "test_groups = X_test.groupby('user_id').size().to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0]\ttest-ndcg:1.00000\n",
      "[1]\ttest-ndcg:1.00000\n",
      "[2]\ttest-ndcg:1.00000\n",
      "[3]\ttest-ndcg:1.00000\n",
      "[4]\ttest-ndcg:1.00000\n",
      "[5]\ttest-ndcg:1.00000\n",
      "[6]\ttest-ndcg:1.00000\n",
      "[7]\ttest-ndcg:1.00000\n",
      "[8]\ttest-ndcg:1.00000\n",
      "[9]\ttest-ndcg:1.00000\n"
     ]
    }
   ],
   "source": [
    "import xgboost as xgb \n",
    "\n",
    "dtrain = xgb.DMatrix(X_train, label=y_train)\n",
    "dtrain.set_group(train_groups)\n",
    "\n",
    "dtest = xgb.DMatrix(X_test, label=y_test)\n",
    "dtest.set_group(test_groups)\n",
    "\n",
    "params = {\n",
    "    'objective': 'rank:pairwise',\n",
    "    'eval_metric': 'ndcg',\n",
    "    'learning_rate': 0.1,\n",
    "    'max_depth': 6,\n",
    "    'verbose': 0 \n",
    "}\n",
    "\n",
    "bst = xgb.train(params, dtrain, num_boost_round=100, evals=[(dtest, 'test')], early_stopping_rounds=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>2268</td>\n",
       "      <td>1466</td>\n",
       "      <td>1393</td>\n",
       "      <td>861</td>\n",
       "      <td>1682</td>\n",
       "      <td>3717</td>\n",
       "      <td>508</td>\n",
       "      <td>3793</td>\n",
       "      <td>720</td>\n",
       "      <td>367</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>2987</td>\n",
       "      <td>648</td>\n",
       "      <td>2628</td>\n",
       "      <td>2054</td>\n",
       "      <td>1259</td>\n",
       "      <td>589</td>\n",
       "      <td>1690</td>\n",
       "      <td>2</td>\n",
       "      <td>153</td>\n",
       "      <td>1331</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>3421</td>\n",
       "      <td>648</td>\n",
       "      <td>3354</td>\n",
       "      <td>2485</td>\n",
       "      <td>141</td>\n",
       "      <td>2126</td>\n",
       "      <td>2058</td>\n",
       "      <td>3798</td>\n",
       "      <td>2997</td>\n",
       "      <td>653</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>2987</td>\n",
       "      <td>2555</td>\n",
       "      <td>2629</td>\n",
       "      <td>1682</td>\n",
       "      <td>2485</td>\n",
       "      <td>2701</td>\n",
       "      <td>2568</td>\n",
       "      <td>3004</td>\n",
       "      <td>1269</td>\n",
       "      <td>2713</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>2987</td>\n",
       "      <td>2989</td>\n",
       "      <td>2622</td>\n",
       "      <td>648</td>\n",
       "      <td>2628</td>\n",
       "      <td>1682</td>\n",
       "      <td>1683</td>\n",
       "      <td>1688</td>\n",
       "      <td>2123</td>\n",
       "      <td>2052</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       1     2     3     4     5     6     7     8     9    10\n",
       "9   2268  1466  1393   861  1682  3717   508  3793   720   367\n",
       "13  2987   648  2628  2054  1259   589  1690     2   153  1331\n",
       "15  3421   648  3354  2485   141  2126  2058  3798  2997   653\n",
       "16  2987  2555  2629  1682  2485  2701  2568  3004  1269  2713\n",
       "18  2987  2989  2622   648  2628  1682  1683  1688  2123  2052"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_data['predicted_score'] = bst.predict(dtest)\n",
    "test_data['rank'] = test_data.groupby('user_id')['predicted_score'].rank(method='first', ascending=False)\n",
    "\n",
    "top_10_recommendations = test_data[test_data['rank'] <= 10]\n",
    "\n",
    "# Pivot the data to get a wide format DataFrame with one row per user and top 10 movie recommendations\n",
    "pivot_recommendations = pivot_table_recommendation(top_10_recommendations)\n",
    "pivot_recommendations.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVALUATION XGB RANKER ON TESTSET\n",
      "\n",
      "hit_rate: 0.942\n",
      "reciprocal_rank: 0.465\n",
      "dcg: 1.138\n",
      "precision: 0.248\n",
      "recall: 0.157\n"
     ]
    }
   ],
   "source": [
    "test_users_items = df_test.groupby('user_id')['item_id'].apply(set).to_dict()\n",
    "test_users = list(test_users_items.keys())\n",
    "comm_user = pivot_recommendations.index.values\n",
    "\n",
    "print(\"EVALUATION XGB RANKER ON TESTSET\\n\")\n",
    "\n",
    "print(\"hit_rate: {:.3f}\".format(hit_rate()))\n",
    "print(\"reciprocal_rank: {:.3f}\".format(reciprocal_rank()))\n",
    "print(\"dcg: {:.3f}\".format(dcg()))\n",
    "print(\"precision: {:.3f}\".format(precision()))\n",
    "print(\"recall: {:.3f}\".format(recall()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Result Comparison**\n",
    "\n",
    "| Metrics | Classification (all-unseen) | Regressor (all-unseen) | Rank Based | RankFM |\n",
    "| --- | --- | --- | --- | --- | \n",
    "| hit_rate |  0.367 | 0.432 | 0.942 | 0.788 |\n",
    "| reciprocal_rank | 0.139 | 0.163 | 0.465 | 0.334 |\n",
    "| dcg | 0.249 |  0.301 | 1.138 | 0.718 |\n",
    "| precision | 0.053 | 0.065 | 0.248 | 0.156 |\n",
    "| recall | 0.017 | 0.023 | 0.157 | 0.072 |"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "rec",
   "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.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}