From dc7b0bf368a71d69f698c7a29bc021aba10ce027 Mon Sep 17 00:00:00 2001 From: Emiliy Feldman Date: Thu, 29 Aug 2024 12:36:42 +0200 Subject: [PATCH 01/13] added exception for coverage on experimental branches --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index df1a74b3..6f63edb7 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -71,7 +71,7 @@ jobs: run: make test - name: Upload coverage - if: matrix.python-version == '3.9' + if: matrix.python-version == '3.9' && ! startsWith(github.base_ref, 'experimental/') uses: codecov/codecov-action@v4 with: fail_ci_if_error: true From 7ab4546a313d77fb119878af84bab2f1eb051fc7 Mon Sep 17 00:00:00 2001 From: Daria <93913290+blondered@users.noreply.github.com> Date: Fri, 30 Aug 2024 15:32:58 +0300 Subject: [PATCH 02/13] Feature/sasrec (#185) Added SasRecModel --- examples/sasrec_metrics_comp.ipynb | 1175 ++++++++++++++++++++++++++++ rectools/models/sasrec.py | 716 +++++++++++++++++ 2 files changed, 1891 insertions(+) create mode 100644 examples/sasrec_metrics_comp.ipynb create mode 100644 rectools/models/sasrec.py diff --git a/examples/sasrec_metrics_comp.ipynb b/examples/sasrec_metrics_comp.ipynb new file mode 100644 index 00000000..74d4a66f --- /dev/null +++ b/examples/sasrec_metrics_comp.ipynb @@ -0,0 +1,1175 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/data/home/dmtikhono1/git_project/sasrec/RecTools/examples\n" + ] + } + ], + "source": [ + "!pwd" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"/data/home/dmtikhono1/git_project/sasrec/RecTools/\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2024-06-27T14:29:22.494979Z", + "iopub.status.busy": "2024-06-27T14:29:22.494423Z", + "iopub.status.idle": "2024-06-27T14:29:22.812073Z", + "shell.execute_reply": "2024-06-27T14:29:22.811404Z", + "shell.execute_reply.started": "2024-06-27T14:29:22.494879Z" + } + }, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import pandas as pd\n", + "from rectools import Columns\n", + "import numpy as np\n", + "import logging\n", + "import os\n", + "import torch\n", + "from lightning_fabric import seed_everything\n", + "\n", + "from rectools.models import ImplicitALSWrapperModel\n", + "from implicit.als import AlternatingLeastSquares\n", + "from rectools.models.sasrec import SasRecModel\n", + "\n", + "from rectools.metrics import MAP, calc_metrics, MeanInvUserFreq, Serendipity\n", + "from rectools.dataset import Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "os.environ[\"CUBLAS_WORKSPACE_CONFIG\"] = \":4096:8\"\n", + "os.environ[\"OPENBLAS_NUM_THREADS\"] = \"1\"\n", + "\n", + "logging.basicConfig()\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "logger = logging.getLogger()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# %%time\n", + "# !wget -q https://github.com/irsafilo/KION_DATASET/raw/f69775be31fa5779907cf0a92ddedb70037fb5ae/data_original.zip -O data_original.zip\n", + "# !unzip -o data_original.zip\n", + "# !rm data_original.zip" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "DATA_PATH = Path(\"data_original\")\n", + "\n", + "interactions = (\n", + " pd.read_csv(DATA_PATH / 'interactions.csv', parse_dates=[\"last_watch_dt\"])\n", + " .rename(columns={\"last_watch_dt\": \"datetime\"})\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Split dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "interactions[Columns.Weight] = np.where(interactions['watched_pct'] > 10, 3, 1)\n", + "\n", + "# Split to train / test\n", + "max_date = interactions[Columns.Datetime].max()\n", + "train = interactions[interactions[Columns.Datetime] < max_date - pd.Timedelta(days=7)].copy()\n", + "test = interactions[interactions[Columns.Datetime] >= max_date - pd.Timedelta(days=7)].copy()\n", + "train.drop(train.query(\"total_dur < 300\").index, inplace=True)\n", + "\n", + "# drop items with less than 20 interactions in train\n", + "items = train[\"item_id\"].value_counts()\n", + "items = items[items >= 20]\n", + "items = items.index.to_list()\n", + "train = train[train[\"item_id\"].isin(items)]\n", + " \n", + "# drop users with less than 2 interactions in train\n", + "users = train[\"user_id\"].value_counts()\n", + "users = users[users >= 2]\n", + "users = users.index.to_list()\n", + "train = train[(train[\"user_id\"].isin(users))]\n", + "\n", + "# leave item features for items only from train\n", + "# items = train[\"item_id\"].drop_duplicates().to_list()\n", + "users = train[\"user_id\"].drop_duplicates().to_list()\n", + "\n", + "# drop cold users from test\n", + "test_users = test[Columns.User].unique()\n", + "cold_users = set(test[Columns.User]) - set(train[Columns.User])\n", + "test.drop(test[test[Columns.User].isin(cold_users)].index, inplace=True)\n", + "\n", + "catalog=train[Columns.Item].unique()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = Dataset.construct(\n", + " interactions_df=train,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# sasrec" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Seed set to 32\n" + ] + }, + { + "data": { + "text/plain": [ + "32" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "RANDOM_SEED = 32\n", + "torch.use_deterministic_algorithms(True)\n", + "seed_everything(RANDOM_SEED, workers=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "factors=128\n", + "session_maxlen=32\n", + "model = SasRecModel(\n", + " factors=factors, # 50\n", + " n_blocks=2,\n", + " n_heads=1,\n", + " dropout_rate=0.2,\n", + " use_pos_emb=True,\n", + " session_maxlen=session_maxlen,\n", + " lr=1e-3,\n", + " batch_size=128,\n", + " epochs=5,\n", + " device=\"cuda:1\",\n", + " loss=\"softmax\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:rectools.models.sasrec:training epoch 1\n", + "INFO:rectools.models.sasrec:training epoch 2\n", + "INFO:rectools.models.sasrec:training epoch 3\n", + "INFO:rectools.models.sasrec:training epoch 4\n", + "INFO:rectools.models.sasrec:training epoch 5\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 4min 50s, sys: 8.14 s, total: 4min 58s\n", + "Wall time: 4min 53s\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "%%time\n", + "model.fit(dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/dmtikhono1/git_project/sasrec/RecTools/rectools/models/sasrec.py:522: UserWarning: 91202 target users were considered cold\n", + " because of missing known items\n", + " interactions[Columns.User] = dataset.user_id_map.convert_to_external(interactions[Columns.User])\n", + "/data/home/dmtikhono1/git_project/sasrec/RecTools/rectools/models/base.py:403: UserWarning: \n", + " Model `` doesn't support recommendations for cold users,\n", + " but some of given users are cold: they are not in the `dataset.user_id_map`\n", + " \n", + " warnings.warn(explanation)\n", + "100%|██████████| 740/740 [00:02<00:00, 267.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2min 15s, sys: 11min 24s, total: 13min 40s\n", + "Wall time: 22 s\n" + ] + } + ], + "source": [ + "%%time\n", + "recs = model.recommend(\n", + " users = test_users, \n", + " dataset = dataset,\n", + " k = 10,\n", + " filter_viewed = True,\n", + " on_unsupported_targets=\"warn\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "metrics_name = {\n", + " 'MAP': MAP,\n", + " 'MIUF': MeanInvUserFreq,\n", + " 'Serendipity': Serendipity\n", + " \n", + "\n", + "}\n", + "metrics = {}\n", + "for metric_name, metric in metrics_name.items():\n", + " for k in (1, 5, 10):\n", + " metrics[f'{metric_name}@{k}'] = metric(k=k)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "recs[\"item_id\"] = recs[\"item_id\"].apply(str)\n", + "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", + "features_results = []\n", + "metric_values = calc_metrics(metrics, recs[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", + "metric_values[\"model\"] = \"sasrec\"\n", + "features_results.append(metric_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_idscorerank
575550377932.7551871
575551378292.6235832
5755523152972.6182093
575553337842.3957074
5755543148991.9945785
...............
224955109754437342.1089716
2249561097544138652.0898627
2249571097544144312.0583028
224958109754441511.9439509
2249591097544152971.94186410
\n", + "

947050 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " user_id item_id score rank\n", + "575550 3 7793 2.755187 1\n", + "575551 3 7829 2.623583 2\n", + "575552 3 15297 2.618209 3\n", + "575553 3 3784 2.395707 4\n", + "575554 3 14899 1.994578 5\n", + "... ... ... ... ...\n", + "224955 1097544 3734 2.108971 6\n", + "224956 1097544 13865 2.089862 7\n", + "224957 1097544 14431 2.058302 8\n", + "224958 1097544 4151 1.943950 9\n", + "224959 1097544 15297 1.941864 10\n", + "\n", + "[947050 rows x 4 columns]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# major recommend\n", + "recs.sort_values([\"user_id\", \"rank\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'MAP@1': 0.04896729054820606,\n", + " 'MAP@5': 0.08284725776567772,\n", + " 'MAP@10': 0.09202214080523476,\n", + " 'MIUF@1': 18.824620072061013,\n", + " 'MIUF@5': 18.824620072061013,\n", + " 'MIUF@10': 18.824620072061013,\n", + " 'Serendipity@1': 0.10074441687344914,\n", + " 'Serendipity@5': 0.06064590171647837,\n", + " 'Serendipity@10': 0.04443191713787037,\n", + " 'model': 'sasrec'}]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "features_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Item to item" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "target_items = [13865, 4457, 15297]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.76 s, sys: 2.4 s, total: 4.16 s\n", + "Wall time: 1.14 s\n" + ] + } + ], + "source": [ + "%%time\n", + "recs = model.recommend_to_items(\n", + " target_items = target_items, \n", + " dataset = dataset,\n", + " k = 10,\n", + " filter_itself = True,\n", + " items_to_recommend=None, #white_list,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
target_item_iditem_idscorerank
01386597280.7533471
11386541510.7402392
21386537340.7162843
31386568090.6731164
4138651420.6504365
51386518440.6465566
61386575710.6458287
713865152970.6247718
81386586360.6231939
913865104400.58220610
10445797280.6961661
11445737340.6718792
1244571420.6664783
13445786360.6639684
14445768090.6427035
15445741510.6301686
16445718440.6252827
17445775710.6186418
18445744360.6098939
19445726570.58072910
201529737340.7100781
211529797280.6907392
2215297104400.6703693
231529768090.6404654
24152971420.6385145
251529726570.6268806
2615297138650.6247717
271529786360.6097698
281529741510.6017069
291529718440.58179910
\n", + "
" + ], + "text/plain": [ + " target_item_id item_id score rank\n", + "0 13865 9728 0.753347 1\n", + "1 13865 4151 0.740239 2\n", + "2 13865 3734 0.716284 3\n", + "3 13865 6809 0.673116 4\n", + "4 13865 142 0.650436 5\n", + "5 13865 1844 0.646556 6\n", + "6 13865 7571 0.645828 7\n", + "7 13865 15297 0.624771 8\n", + "8 13865 8636 0.623193 9\n", + "9 13865 10440 0.582206 10\n", + "10 4457 9728 0.696166 1\n", + "11 4457 3734 0.671879 2\n", + "12 4457 142 0.666478 3\n", + "13 4457 8636 0.663968 4\n", + "14 4457 6809 0.642703 5\n", + "15 4457 4151 0.630168 6\n", + "16 4457 1844 0.625282 7\n", + "17 4457 7571 0.618641 8\n", + "18 4457 4436 0.609893 9\n", + "19 4457 2657 0.580729 10\n", + "20 15297 3734 0.710078 1\n", + "21 15297 9728 0.690739 2\n", + "22 15297 10440 0.670369 3\n", + "23 15297 6809 0.640465 4\n", + "24 15297 142 0.638514 5\n", + "25 15297 2657 0.626880 6\n", + "26 15297 13865 0.624771 7\n", + "27 15297 8636 0.609769 8\n", + "28 15297 4151 0.601706 9\n", + "29 15297 1844 0.581799 10" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "recs" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[25], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m() \u001b[38;5;66;03m# skip updating cells below\u001b[39;00m\n", + "\u001b[0;31mValueError\u001b[0m: " + ] + } + ], + "source": [ + "raise ValueError() # skip updating cells below" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ALS" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "users = pd.read_csv(DATA_PATH / 'users.csv')\n", + "items = pd.read_csv(DATA_PATH / 'items.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Process user features to the form of a flatten dataframe\n", + "users.fillna('Unknown', inplace=True)\n", + "users = users.loc[users[Columns.User].isin(train[Columns.User])].copy()\n", + "user_features_frames = []\n", + "for feature in [\"sex\", \"age\", \"income\"]:\n", + " feature_frame = users.reindex(columns=[Columns.User, feature])\n", + " feature_frame.columns = [\"id\", \"value\"]\n", + " feature_frame[\"feature\"] = feature\n", + " user_features_frames.append(feature_frame)\n", + "user_features = pd.concat(user_features_frames)\n", + "\n", + "# Process item features to the form of a flatten dataframe\n", + "items = items.loc[items[Columns.Item].isin(train[Columns.Item])].copy()\n", + "items[\"genre\"] = items[\"genres\"].str.lower().str.replace(\", \", \",\", regex=False).str.split(\",\")\n", + "genre_feature = items[[\"item_id\", \"genre\"]].explode(\"genre\")\n", + "genre_feature.columns = [\"id\", \"value\"]\n", + "genre_feature[\"feature\"] = \"genre\"\n", + "content_feature = items.reindex(columns=[Columns.Item, \"content_type\"])\n", + "content_feature.columns = [\"id\", \"value\"]\n", + "content_feature[\"feature\"] = \"content_type\"\n", + "item_features = pd.concat((genre_feature, content_feature))\n", + "\n", + "candidate_items = interactions['item_id'].drop_duplicates().astype(int)\n", + "test[\"user_id\"] = test[\"user_id\"].astype(int)\n", + "test[\"item_id\"] = test[\"item_id\"].astype(int)\n", + "catalog=train[Columns.Item].unique()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dataset_no_features = Dataset.construct(\n", + " interactions_df=train,\n", + ")\n", + "\n", + "dataset_full_features = Dataset.construct(\n", + " interactions_df=train,\n", + " user_features_df=user_features,\n", + " cat_user_features=[\"sex\", \"age\", \"income\"],\n", + " item_features_df=item_features,\n", + " cat_item_features=[\"genre\", \"content_type\"],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "K_RECOS = 10\n", + "NUM_THREADS = 32\n", + "RANDOM_STATE = 32\n", + "ITERATIONS = 10\n", + "\n", + "def make_base_model(factors: int, regularization: float, alpha: float, fit_features_together: bool=False):\n", + " return ImplicitALSWrapperModel(\n", + " AlternatingLeastSquares(\n", + " factors=factors,\n", + " regularization=regularization,\n", + " alpha=alpha,\n", + " random_state=RANDOM_STATE,\n", + " use_gpu=False,\n", + " num_threads = NUM_THREADS,\n", + " iterations=ITERATIONS),\n", + " fit_features_together = fit_features_together,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/maspirina1/Tasks/RecTools/.venv/lib/python3.8/site-packages/implicit/cpu/als.py:95: RuntimeWarning: OpenBLAS is configured to use 64 threads. It is highly recommended to disable its internal threadpool by setting the environment variable 'OPENBLAS_NUM_THREADS=1' or by calling 'threadpoolctl.threadpool_limits(1, \"blas\")'. Having OpenBLAS use a threadpool can lead to severe performance issues here.\n", + " check_blas_config()\n" + ] + } + ], + "source": [ + "n_factors = 128\n", + "regularization = 0.5\n", + "alpha = 10\n", + "\n", + "model = make_base_model(factors=n_factors, regularization=regularization, alpha=alpha)\n", + "model.fit(dataset_no_features)\n", + "recos = model.recommend(\n", + " users=test_users.astype(int),\n", + " dataset=dataset_no_features,\n", + " k=K_RECOS,\n", + " filter_viewed=True,\n", + ")\n", + "metric_values = calc_metrics(metrics, recos, test, train, catalog)\n", + "metric_values[\"model\"] = \"no_features_factors_128_alpha_10_reg_0.5\"\n", + "features_results.append(metric_values)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/maspirina1/Tasks/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", + " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n" + ] + } + ], + "source": [ + "model = make_base_model(factors = n_factors, regularization=regularization, alpha=alpha, fit_features_together=True)\n", + "model.fit(dataset_full_features)\n", + "recos = model.recommend(\n", + " users=test_users.astype(int),\n", + " dataset=dataset_full_features,\n", + " k=K_RECOS,\n", + " filter_viewed=True,\n", + ")\n", + "metric_values = calc_metrics(metrics, recos, test, train, catalog)\n", + "metric_values[\"model\"] = \"full_features_factors_128_fit_together_True\"\n", + "features_results.append(metric_values)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
MAP@1MAP@5MAP@10MIUF@1MIUF@5MIUF@10Serendipity@1Serendipity@5Serendipity@10
model
sasrec0.0475790.0810930.09032218.82462018.82462018.8246200.0981680.0599830.044268
full_features_factors_128_fit_together_True0.0338490.0565330.0624864.3395145.3380826.0441690.0004290.0004600.000459
no_features_factors_128_alpha_10_reg_0.50.0155300.0284660.0328206.6038476.9432177.1465070.0010470.0009040.000815
\n", + "
" + ], + "text/plain": [ + " MAP@1 MAP@5 MAP@10 \\\n", + "model \n", + "sasrec 0.047579 0.081093 0.090322 \n", + "full_features_factors_128_fit_together_True 0.033849 0.056533 0.062486 \n", + "no_features_factors_128_alpha_10_reg_0.5 0.015530 0.028466 0.032820 \n", + "\n", + " MIUF@1 MIUF@5 MIUF@10 \\\n", + "model \n", + "sasrec 18.824620 18.824620 18.824620 \n", + "full_features_factors_128_fit_together_True 4.339514 5.338082 6.044169 \n", + "no_features_factors_128_alpha_10_reg_0.5 6.603847 6.943217 7.146507 \n", + "\n", + " Serendipity@1 Serendipity@5 \\\n", + "model \n", + "sasrec 0.098168 0.059983 \n", + "full_features_factors_128_fit_together_True 0.000429 0.000460 \n", + "no_features_factors_128_alpha_10_reg_0.5 0.001047 0.000904 \n", + "\n", + " Serendipity@10 \n", + "model \n", + "sasrec 0.044268 \n", + "full_features_factors_128_fit_together_True 0.000459 \n", + "no_features_factors_128_alpha_10_reg_0.5 0.000815 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "features_df = (\n", + " pd.DataFrame(features_results)\n", + " .set_index(\"model\")\n", + " .sort_values(by=[\"MAP@10\", \"Serendipity@10\"], ascending=False)\n", + ")\n", + "features_df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/rectools/models/sasrec.py b/rectools/models/sasrec.py new file mode 100644 index 00000000..192d1c29 --- /dev/null +++ b/rectools/models/sasrec.py @@ -0,0 +1,716 @@ +import logging +import typing as tp +import warnings +from copy import deepcopy +from typing import List, Tuple + +import numpy as np +import pandas as pd +import torch +import tqdm +import typing_extensions as tpe +from torch import nn +from torch.utils.data import DataLoader +from torch.utils.data import Dataset as TorchDataset + +from rectools import Columns, ExternalIds +from rectools.dataset import Dataset, Interactions +from rectools.dataset.identifiers import IdMap +from rectools.models.base import ErrorBehaviour, InternalRecoTriplet, ModelBase +from rectools.models.rank import Distance, ImplicitRanker +from rectools.types import InternalIdsArray + +PADDING_VALUE = "PAD" + +logger = logging.getLogger(__name__) # TODO: remove + +# #### -------------- Net blocks -------------- #### # + + +class ItemNetBase(nn.Module): + """Base class ItemNet. Used only for type hinting.""" + + def forward(self, items: torch.Tensor) -> torch.Tensor: + """TODO""" + raise NotImplementedError() + + @classmethod + def from_dataset(cls, dataset: Dataset, *args: tp.Any, **kwargs: tp.Any) -> tpe.Self: + """TODO""" + raise NotImplementedError() + + def get_all_embeddings(self) -> torch.Tensor: + """TODO""" + raise NotImplementedError() + + +class TransformerLayersBase(nn.Module): + """Base class for transformer layers. Used only for type hinting.""" + + def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: torch.Tensor) -> torch.Tensor: + """Forward""" + raise NotImplementedError() + + +class IdEmbeddingsItemNet(ItemNetBase): + """ + Base class for item embeddings. To use more complicated logic then just id embeddings inherit + from this class and pass your custom ItemNet to your model params + """ + + def __init__(self, n_factors: int, n_items: int, dropout_rate: float): + super().__init__() + + self.n_items = n_items + self.item_emb = nn.Embedding( + num_embeddings=n_items, + embedding_dim=n_factors, + padding_idx=0, + ) + self.drop_layer = nn.Dropout(dropout_rate) + + def forward(self, items: torch.Tensor) -> torch.Tensor: + """TODO""" + item_embs = self.item_emb(items) + item_embs = self.drop_layer(item_embs) + return item_embs + + @property + def catalogue(self) -> torch.Tensor: + """TODO""" + return torch.arange(0, self.n_items, device=self.item_emb.weight.device) + + def get_all_embeddings(self) -> torch.Tensor: + """TODO""" + return self.forward(self.catalogue) + + @classmethod + def from_dataset(cls, dataset: Dataset, n_factors: int, dropout_rate: float) -> tpe.Self: + """TODO""" + n_items = dataset.item_id_map.size + return cls(n_factors, n_items, dropout_rate) + + +class PointWiseFeedForward(nn.Module): + """TODO""" + + def __init__(self, n_factors: int, n_factors_ff: int, dropout_rate: float) -> None: + """TODO""" + super().__init__() + self.ff_linear1 = nn.Linear(n_factors, n_factors_ff) + self.ff_dropout1 = torch.nn.Dropout(dropout_rate) + self.ff_relu = torch.nn.ReLU() + self.ff_linear2 = nn.Linear(n_factors_ff, n_factors) + self.ff_dropout2 = torch.nn.Dropout(dropout_rate) + + def forward(self, seqs: torch.Tensor) -> torch.Tensor: + """TODO""" + output = self.ff_relu(self.ff_dropout1(self.ff_linear1(seqs))) + fin = self.ff_dropout2(self.ff_linear2(output)) + return fin + + +class SasRecTransformerLayers(TransformerLayersBase): + """Exactly SASRec authors architecture but with torch MHA realisation""" + + def __init__( + self, + n_blocks: int, + n_factors: int, + n_heads: int, + dropout_rate: float, + ): + super().__init__() + self.n_blocks = n_blocks + self.multi_head_attn = nn.ModuleList( + [torch.nn.MultiheadAttention(n_factors, n_heads, dropout_rate, batch_first=True) for _ in range(n_blocks)] + ) # TODO: original architecture had another version of MHA + self.q_layer_norm = nn.ModuleList([nn.LayerNorm(n_factors) for _ in range(n_blocks)]) + self.ff_layer_norm = nn.ModuleList([nn.LayerNorm(n_factors) for _ in range(n_blocks)]) + self.feed_forward = nn.ModuleList( + [PointWiseFeedForward(n_factors, n_factors, dropout_rate) for _ in range(n_blocks)] + ) + self.last_layernorm = torch.nn.LayerNorm(n_factors, eps=1e-8) + + def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: torch.Tensor) -> torch.Tensor: + """TODO""" + for i in range(self.n_blocks): + q = self.q_layer_norm[i](seqs) + mha_output, _ = self.multi_head_attn[i](q, seqs, seqs, attn_mask=attn_mask, need_weights=False) + seqs = q + mha_output + ff_input = self.ff_layer_norm[i](seqs) + seqs = self.feed_forward[i](ff_input) + seqs += ff_input + seqs *= timeline_mask + + seqs = self.last_layernorm(seqs) + + return seqs + + +class PreLNTransformerLayers(TransformerLayersBase): + """ + Based on https://arxiv.org/pdf/2002.04745 + On Kion open dataset didn't change metrics, even got a bit worse + But let's keep it for now + """ + + def __init__( + self, + n_blocks: int, + n_factors: int, + n_heads: int, + dropout_rate: float, + ): + super().__init__() + self.n_blocks = n_blocks + self.multi_head_attn = nn.ModuleList( + [torch.nn.MultiheadAttention(n_factors, n_heads, dropout_rate, batch_first=True) for _ in range(n_blocks)] + ) + self.mha_layer_norm = nn.ModuleList([nn.LayerNorm(n_factors) for _ in range(n_blocks)]) + self.mha_dropout = nn.Dropout(dropout_rate) + self.ff_layer_norm = nn.ModuleList([nn.LayerNorm(n_factors) for _ in range(n_blocks)]) + self.feed_forward = nn.ModuleList( + [PointWiseFeedForward(n_factors, n_factors, dropout_rate) for _ in range(n_blocks)] + ) + + def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: torch.Tensor) -> torch.Tensor: + """TODO""" + for i in range(self.n_blocks): + mha_input = self.mha_layer_norm[i](seqs) + mha_output, _ = self.multi_head_attn[i]( + mha_input, mha_input, mha_input, attn_mask=attn_mask, need_weights=False + ) + mha_output = self.mha_dropout(mha_output) + seqs = seqs + mha_output + ff_input = self.ff_layer_norm[i](seqs) + ff_output = self.feed_forward[i](ff_input) + seqs = seqs + ff_output + seqs *= timeline_mask + + return seqs + + +class LearnableInversePositionalEncoding(torch.nn.Module): + """TODO""" + + def __init__(self, use_pos_emb: bool, session_maxlen: int, n_factors: int): + super().__init__() + self.pos_emb = torch.nn.Embedding(session_maxlen, n_factors) if use_pos_emb else None + + def forward(self, sessions: torch.Tensor, timeline_mask: torch.Tensor) -> torch.Tensor: + """TODO""" + batch_size, session_maxlen, _ = sessions.shape + + if self.pos_emb is not None: + # Inverse positions are appropriate for variable length sequences across different batches + # They are equal to absolute positions for fixed sequence length across different batches + positions = torch.tile( + torch.arange(session_maxlen - 1, -1, -1), (batch_size, 1) + ) # [batch_size, session_maxlen] + sessions += self.pos_emb(positions.to(sessions.device)) + + # TODO: do we need to fill padding embeds in sessions to all zeros + # or should we use the learnt padding embedding? Should we make it an option for user to decide? + sessions *= timeline_mask # [batch_size, session_maxlen, n_factors] + + return sessions + + +# #### -------------- Session Encoder -------------- #### # + + +class TransformerBasedSessionEncoder(torch.nn.Module): + """TODO""" + + def __init__( + self, + n_blocks: int, + n_factors: int, + n_heads: int, + session_maxlen: int, + dropout_rate: float, + use_pos_emb: bool = True, # TODO: add pos_encoding_type option for user to pass + use_causal_attn: bool = True, + transformer_layers_type: tp.Type[TransformerLayersBase] = SasRecTransformerLayers, + item_net_type: tp.Type[ItemNetBase] = IdEmbeddingsItemNet, + ) -> None: + super().__init__() + + self.item_model: ItemNetBase + self.pos_encoding = LearnableInversePositionalEncoding(use_pos_emb, session_maxlen, n_factors) + self.emb_dropout = torch.nn.Dropout(dropout_rate) + self.transformer_layers = transformer_layers_type( + n_blocks=n_blocks, + n_factors=n_factors, + n_heads=n_heads, + dropout_rate=dropout_rate, + ) + self.use_causal_attn = use_causal_attn + self.item_net_type = item_net_type + self.n_factors = n_factors + self.dropout_rate = dropout_rate + + def costruct_item_net(self, dataset: Dataset) -> None: + """TODO""" + self.item_model = self.item_net_type.from_dataset(dataset, self.n_factors, self.dropout_rate) + + def encode_sessions(self, sessions: torch.Tensor, item_embs: torch.Tensor) -> torch.Tensor: + """ + Pass user history through item embeddings and transformer blocks. + + Returns + ------- + torch.Tensor. [batch_size, session_maxlen, factors] + + """ + session_maxlen = sessions.shape[1] + attn_mask = None + if self.use_causal_attn: + attn_mask = ~torch.tril( + torch.ones((session_maxlen, session_maxlen), dtype=torch.bool, device=sessions.device) + ) + timeline_mask = (sessions != 0).unsqueeze(-1) # [batch_size, session_maxlen, 1] + seqs = item_embs[sessions] # [batch_size, session_maxlen, n_factors] + seqs = self.pos_encoding(seqs, timeline_mask) + seqs = self.emb_dropout(seqs) + seqs = self.transformer_layers(seqs, timeline_mask, attn_mask) + return seqs + + def forward( + self, + sessions: torch.Tensor, # [batch_size, session_maxlen] + ) -> torch.Tensor: + """TODO""" + item_embs = self.item_model.get_all_embeddings() # [n_items + 1, n_factors] + session_embs = self.encode_sessions(sessions, item_embs) # [batch_size, session_maxlen, n_factors] + logits = session_embs @ item_embs.T # [batch_size, session_maxlen, n_items + 1] + return logits + + +# #### -------------- Trainer -------------- #### # + + +class Trainer: + """TODO""" + + def __init__( + self, + lr: float, + epochs: int, + device: torch.device, + loss: str = "softmax", + ): + """TODO""" + self.model: TransformerBasedSessionEncoder + self.optimizer: torch.optim.Adam + self.lr = lr + self.epochs = epochs + self.device = device + self.loss_func = self._init_loss_func(loss) # TODO: move loss func to `SasRec` class + + def fit( + self, + model: TransformerBasedSessionEncoder, + fit_dataloader: DataLoader, + ) -> None: + """TODO""" + self.model = model + self.optimizer = self._init_optimizers() + self.model.to(self.device) + + self.xavier_normal_init(self.model) + self.model.train() # enable model training + + # self.model.item_model.to_device(self.device) + + epoch_start_idx = 1 + + # ce_criterion = torch.nn.CrossEntropyLoss() + # https://github.com/NVIDIA/pix2pixHD/issues/9 how could an old bug appear again... + + for epoch in range(epoch_start_idx, self.epochs + 1): + logger.info("training epoch %s", epoch) + for x, y, w in fit_dataloader: + x = x.to(self.device) # [batch_size, session_maxlen] + y = y.to(self.device) # [batch_size, session_maxlen] + w = w.to(self.device) # [batch_size, session_maxlen] + + self.train_step(x, y, w) + + def train_step(self, x: torch.Tensor, y: torch.Tensor, w: torch.Tensor) -> None: + """TODO""" + self.optimizer.zero_grad() + logits = self.model(x) # [batch_size, session_maxlen, n_items + 1] + # We are using CrossEntropyLoss with a multi-dimensional case + + # Logits must be passed in form of [batch_size, n_items + 1, session_maxlen], + # where n_items + 1 is number of classes + + # Target label indexes must be passed in a form of [batch_size, session_maxlen] + # (`0` index for "PAD" ix excluded from loss) + + # Loss output will have a shape of [batch_size, session_maxlen] + # and will have zeros for every `0` target label + loss = self.loss_func(logits.transpose(1, 2), y) # [batch_size, session_maxlen] + loss = loss * w + n = (loss > 0).to(loss.dtype) + loss = torch.sum(loss) / torch.sum(n) + loss.backward() + self.optimizer.step() + + def _init_optimizers(self) -> torch.optim.Adam: + optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr, betas=(0.9, 0.98)) + return optimizer + + def _init_loss_func(self, loss: str) -> nn.CrossEntropyLoss: + + if loss == "softmax": + return nn.CrossEntropyLoss(ignore_index=0, reduction="none") + raise ValueError(f"loss {loss} is not supported") + + def xavier_normal_init(self, model: nn.Module) -> None: + """TODO""" + for _, param in model.named_parameters(): + try: + torch.nn.init.xavier_normal_(param.data) + except ValueError: + pass + + +# #### -------------- Data Processor -------------- #### # + + +class SequenceDataset(TorchDataset): + """TODO""" + + def __init__(self, sessions: List[List[int]], weights: List[List[float]]): + self.sessions = sessions + self.weights = weights + + def __len__(self) -> int: + return len(self.sessions) + + def __getitem__(self, index: int) -> Tuple[List[int], List[float]]: + session = self.sessions[index] # [session_len] + weights = self.weights[index] # [session_len] + return session, weights + + @classmethod + def from_interactions( + cls, + interactions: pd.DataFrame, + ) -> "SequenceDataset": + """TODO""" + sessions = ( + interactions.sort_values(Columns.Datetime) + .groupby(Columns.User, sort=True)[[Columns.Item, Columns.Weight]] + .agg(list) + ) + sessions, weights = ( + sessions[Columns.Item].to_list(), + sessions[Columns.Weight].to_list(), + ) + + return cls(sessions=sessions, weights=weights) + + +class SasRecDataPreparator: + """TODO""" + + def __init__( + self, + session_maxlen: int, + batch_size: int, + item_extra_tokens: tp.Sequence[tp.Hashable] = (PADDING_VALUE,), + shuffle_train: bool = True, # not shuffling train dataloader hurts performance + train_min_user_interactions: int = 2, + ) -> None: + self.session_maxlen = session_maxlen + self.batch_size = batch_size + self.item_extra_tokens = item_extra_tokens + self.shuffle_train = shuffle_train + self.train_min_user_interactions = train_min_user_interactions + self.item_id_map: IdMap + # TODO: add SequenceDatasetType for fit and recommend + + @property + def n_item_extra_tokens(self) -> int: + """TODO""" + return len(self.item_extra_tokens) + + def get_known_item_ids(self) -> np.ndarray: + """TODO""" + return self.item_id_map.get_external_sorted_by_internal()[self.n_item_extra_tokens :] + + def get_known_items_sorted_internal_ids(self) -> np.ndarray: + """TODO""" + return self.item_id_map.get_sorted_internal()[self.n_item_extra_tokens :] + + def process_dataset_train(self, dataset: Dataset) -> Dataset: + """TODO""" + interactions = dataset.get_raw_interactions() + + # Filter interactions + user_stats = interactions[Columns.User].value_counts() + users = user_stats[user_stats >= self.train_min_user_interactions].index + interactions = interactions[(interactions[Columns.User].isin(users))] + interactions = interactions.sort_values(Columns.Datetime).groupby(Columns.User).tail(self.session_maxlen + 1) + + # Construct dataset + # TODO: user features and item features are dropped for now + user_id_map = IdMap.from_values(interactions[Columns.User].values) + item_id_map = IdMap.from_values(self.item_extra_tokens) + item_id_map = item_id_map.add_ids(interactions[Columns.Item]) + interactions = Interactions.from_raw(interactions, user_id_map, item_id_map) + dataset = Dataset(user_id_map, item_id_map, interactions) + + self.item_id_map = dataset.item_id_map + return dataset + + def _collate_fn_train( + self, + batch: List[Tuple[List[int], List[float]]], + ) -> Tuple[torch.LongTensor, torch.LongTensor, torch.FloatTensor]: + """ + Truncate each session from right to keep (session_maxlen+1) last items. + Do left padding until (session_maxlen+1) is reached. + Split to `x`, `y`, and `yw`. + """ + batch_size = len(batch) + x = np.zeros((batch_size, self.session_maxlen)) + y = np.zeros((batch_size, self.session_maxlen)) + yw = np.zeros((batch_size, self.session_maxlen)) + for i, (ses, ses_weights) in enumerate(batch): + x[i, -len(ses) + 1 :] = ses[:-1] # ses: [session_len] -> x[i]: [session_maxlen] + y[i, -len(ses) + 1 :] = ses[1:] # ses: [session_len] -> y[i]: [session_maxlen] + yw[i, -len(ses) + 1 :] = ses_weights[1:] # ses_weights: [session_len] -> yw[i]: [session_maxlen] + return torch.LongTensor(x), torch.LongTensor(y), torch.FloatTensor(yw) + + def get_dataloader_train(self, processed_dataset: Dataset) -> DataLoader: + """TODO""" + sequence_dataset = SequenceDataset.from_interactions(processed_dataset.interactions.df) + train_dataloader = DataLoader( + sequence_dataset, collate_fn=self._collate_fn_train, batch_size=self.batch_size, shuffle=self.shuffle_train + ) + return train_dataloader + + def transform_dataset_u2i(self, dataset: Dataset, users: ExternalIds) -> Dataset: + """ + Filter out interactions and adapt id maps. + Final dataset will consist only of model known items during fit and only of required + (and supported) target users for recommendations. + All users beyond target users for recommendations are dropped. + All target users that do not have at least one known item in interactions are dropped. + Final user_id_map is an enumerated list of supported (filtered) target users + Final item_id_map is model item_id_map constructed during training + """ + # Filter interactions in dataset internal ids + interactions = dataset.interactions.df + users_internal = dataset.user_id_map.convert_to_internal(users, strict=False) + items_internal = dataset.item_id_map.convert_to_internal(self.get_known_item_ids(), strict=False) + interactions = interactions[interactions[Columns.User].isin(users_internal)] # todo: fast_isin + interactions = interactions[interactions[Columns.Item].isin(items_internal)] + + # Convert to external ids + interactions[Columns.Item] = dataset.item_id_map.convert_to_external(interactions[Columns.Item]) + interactions[Columns.User] = dataset.user_id_map.convert_to_external(interactions[Columns.User]) + + # Prepare new user id mapping + rec_user_id_map = IdMap.from_values(interactions[Columns.User]) + + # Construct dataset + # TODO: For now features are dropped because model doesn't support them + n_filtered = len(users) - rec_user_id_map.size + if n_filtered > 0: + explanation = f"""{n_filtered} target users were considered cold + because of missing known items""" + warnings.warn(explanation) + filtered_interactions = Interactions.from_raw(interactions, rec_user_id_map, self.item_id_map) + filtered_dataset = Dataset(rec_user_id_map, self.item_id_map, filtered_interactions) + return filtered_dataset + + def transform_dataset_i2i(self, dataset: Dataset) -> Dataset: + """ + Filter out interactions and adapt id maps. + Final dataset will consist only of model known items during fit. + Final user_id_map is the same as dataset original + Final item_id_map is model item_id_map constructed during training + """ + # TODO: optimize by filtering in internal ids + # TODO: For now features are dropped because model doesn't support them + interactions = dataset.get_raw_interactions() + interactions = interactions[interactions[Columns.Item].isin(self.get_known_item_ids())] + filtered_interactions = Interactions.from_raw(interactions, dataset.user_id_map, self.item_id_map) + filtered_dataset = Dataset(dataset.user_id_map, self.item_id_map, filtered_interactions) + return filtered_dataset + + def _collate_fn_recommend(self, batch: List[Tuple[List[int], List[float]]]) -> torch.LongTensor: + """Right truncation, left padding to session_maxlen""" + x = np.zeros((len(batch), self.session_maxlen)) + for i, (ses, _) in enumerate(batch): + x[i, -len(ses) :] = ses[-self.session_maxlen :] + return torch.LongTensor(x) + + def get_dataloader_recommend(self, dataset: Dataset) -> DataLoader: + """TODO""" + sequence_dataset = SequenceDataset.from_interactions(dataset.interactions.df) + recommend_dataloader = DataLoader( + sequence_dataset, batch_size=self.batch_size, collate_fn=self._collate_fn_recommend, shuffle=False + ) + return recommend_dataloader + + +# #### -------------- SASRec Model -------------- #### # + + +class SasRecModel(ModelBase): # pylint: disable=too-many-instance-attributes + """TODO""" + + def __init__( + self, + session_maxlen: int, + lr: float, + batch_size: int, + epochs: int, + device: str, + n_blocks: int, + n_factors: int, + n_heads: int, + dropout_rate: float, + use_pos_emb: bool = True, + loss: str = "softmax", + verbose: int = 0, + cpu_n_threads: int = 0, + transformer_layers_type: tp.Type[TransformerLayersBase] = SasRecTransformerLayers, # SASRec authors net + item_net_type: tp.Type[ItemNetBase] = IdEmbeddingsItemNet, # item embeddings on ids + ): + super().__init__(verbose=verbose) + self.device = torch.device(device) + self.n_threads = cpu_n_threads + self.model: TransformerBasedSessionEncoder + self._model = TransformerBasedSessionEncoder( + n_blocks=n_blocks, + n_factors=n_factors, + n_heads=n_heads, + session_maxlen=session_maxlen, + dropout_rate=dropout_rate, + use_pos_emb=use_pos_emb, + use_causal_attn=True, + transformer_layers_type=transformer_layers_type, + item_net_type=item_net_type, + ) + self.trainer = Trainer( # TODO: move to lightning trainer and add option to pass initialized trainer + lr=lr, + epochs=epochs, + device=self.device, + loss=loss, + ) + self.data_preparator = SasRecDataPreparator(session_maxlen, batch_size) # TODO: add data_preparator_type + self.u2i_dist = Distance.DOT + self.i2i_dist = Distance.COSINE + + def _fit( + self, + dataset: Dataset, + ) -> None: + processed_dataset = self.data_preparator.process_dataset_train(dataset) + train_dataloader = self.data_preparator.get_dataloader_train(processed_dataset) + + self.model = deepcopy(self._model) # TODO: check that it works + self.model.costruct_item_net(processed_dataset) + + self.trainer.fit(self.model, train_dataloader) + self.model = self.trainer.model + + def _custom_transform_dataset_u2i( + self, dataset: Dataset, users: ExternalIds, on_unsupported_targets: ErrorBehaviour + ) -> Dataset: + return self.data_preparator.transform_dataset_u2i(dataset, users) + + def _custom_transform_dataset_i2i( + self, dataset: Dataset, target_items: ExternalIds, on_unsupported_targets: ErrorBehaviour + ) -> Dataset: + return self.data_preparator.transform_dataset_i2i(dataset) + + def _recommend_u2i( + self, + user_ids: InternalIdsArray, + dataset: Dataset, # [n_rec_users x n_items + 1] + k: int, + filter_viewed: bool, + sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray], # model_internal + ) -> InternalRecoTriplet: + + if sorted_item_ids_to_recommend is None: # TODO: move to _get_sorted_item_ids_to_recommend + sorted_item_ids_to_recommend = self.data_preparator.get_known_items_sorted_internal_ids() # model internal + + self.model = self.model.eval() + self.model.to(self.device) + + # Dataset has already been filtered and adapted to known item_id_map + recommend_dataloader = self.data_preparator.get_dataloader_recommend(dataset) + + session_embs = [] + item_embs = self.model.item_model.get_all_embeddings() # [n_items + 1, n_factors] + with torch.no_grad(): + for x_batch in tqdm.tqdm(recommend_dataloader): # TODO: from tqdm.auto import tqdm. Also check `verbose`` + x_batch = x_batch.to(self.device) # [batch_size, session_maxlen] + encoded = self.model.encode_sessions(x_batch, item_embs)[:, -1, :] # [batch_size, n_factors] + encoded = encoded.detach().cpu().numpy() + session_embs.append(encoded) + + user_embs = np.concatenate(session_embs, axis=0) + user_embs = user_embs[user_ids] + item_embs_np = item_embs.detach().cpu().numpy() + + ranker = ImplicitRanker( + self.u2i_dist, + user_embs, # [n_rec_users, n_factors] + item_embs_np, # [n_items + 1, n_factors] + ) + if filter_viewed: + user_items = dataset.get_user_item_matrix(include_weights=False) + ui_csr_for_filter = user_items[user_ids] + else: + ui_csr_for_filter = None + + # TODO: When filter_viewed is not needed and user has GPU, torch DOT and topk should be faster + + user_ids_indices, all_reco_ids, all_scores = ranker.rank( + subject_ids=np.arange(user_embs.shape[0]), # n_rec_users + k=k, + filter_pairs_csr=ui_csr_for_filter, # [n_rec_users x n_items + 1] + sorted_object_whitelist=sorted_item_ids_to_recommend, # model_internal + num_threads=self.n_threads, + ) + all_target_ids = user_ids[user_ids_indices] + + return all_target_ids, all_reco_ids, all_scores # n_rec_users, model_internal, scores + + def _recommend_i2i( + self, + target_ids: InternalIdsArray, # model internal + dataset: Dataset, + k: int, + sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray], + ) -> InternalRecoTriplet: + if sorted_item_ids_to_recommend is None: + sorted_item_ids_to_recommend = self.data_preparator.get_known_items_sorted_internal_ids() + item_embs = self.model.item_model.get_all_embeddings().detach().cpu().numpy() # [n_items + 1, n_factors] + + # TODO: i2i reco do not need filtering viewed. And user most of the times has GPU + # Should we use torch dot and topk? Should be faster + + ranker = ImplicitRanker( + self.i2i_dist, + item_embs, # [n_items + 1, n_factors] + item_embs, # [n_items + 1, n_factors] + ) + return ranker.rank( + subject_ids=target_ids, # model internal + k=k, + filter_pairs_csr=None, + sorted_object_whitelist=sorted_item_ids_to_recommend, # model internal + num_threads=0, + ) From afd046379517fb38153d326f74e2c8bc6df59691 Mon Sep 17 00:00:00 2001 From: spirinamayya <90619187+spirinamayya@users.noreply.github.com> Date: Fri, 13 Sep 2024 15:09:55 +0300 Subject: [PATCH 03/13] SasRec tutorial (#186) Added sasrec tutorial --- examples/tutorials/sasrec_tutorial.ipynb | 1203 ++++++++++++++++++++++ 1 file changed, 1203 insertions(+) create mode 100644 examples/tutorials/sasrec_tutorial.ipynb diff --git a/examples/tutorials/sasrec_tutorial.ipynb b/examples/tutorials/sasrec_tutorial.ipynb new file mode 100644 index 00000000..8f8dc929 --- /dev/null +++ b/examples/tutorials/sasrec_tutorial.ipynb @@ -0,0 +1,1203 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SASRec model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Table of Contents**\n", + "\n", + "* Prepare data\n", + "* Model description\n", + "* Recommendations\n", + "* RecTools implementation\n", + " * Additional details\n", + "* Model application\n", + " * Additional details\n", + "* Under the hood: Dataset processing\n", + "* Under the hood: Transformer layers\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import os\n", + "import pandas as pd\n", + "import torch\n", + "\n", + "from lightning_fabric import seed_everything\n", + "from pathlib import Path\n", + "\n", + "from rectools import Columns\n", + "from rectools.dataset import Dataset\n", + "from rectools.models.sasrec import SasRecModel\n", + "\n", + "# Enable deterministic behaviour with CUDA >= 10.2\n", + "os.environ[\"CUBLAS_WORKSPACE_CONFIG\"] = \":4096:8\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Prepare data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are using KION dataset for this tutorial. The data was gathered from the users of MTS KION video streaming platform. To make recommendations only user-item interactions are required, as SASRec implementation does not support user and item features." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Archive: data_en.zip\n", + " inflating: data_en/items_en.csv \n", + " inflating: __MACOSX/data_en/._items_en.csv \n", + " inflating: data_en/interactions.csv \n", + " inflating: __MACOSX/data_en/._interactions.csv \n", + " inflating: data_en/users_en.csv \n", + " inflating: __MACOSX/data_en/._users_en.csv \n", + "CPU times: user 83.8 ms, sys: 44.4 ms, total: 128 ms\n", + "Wall time: 5.51 s\n" + ] + } + ], + "source": [ + "%%time\n", + "!wget -q https://github.com/irsafilo/KION_DATASET/raw/f69775be31fa5779907cf0a92ddedb70037fb5ae/data_en.zip -O data_en.zip\n", + "!unzip -o data_en.zip\n", + "!rm data_en.zip" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5476251, 5)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_iddatetimetotal_durwatched_pct
017654995062021-05-11425072.0
169931716592021-05-298317100.0
\n", + "
" + ], + "text/plain": [ + " user_id item_id datetime total_dur watched_pct\n", + "0 176549 9506 2021-05-11 4250 72.0\n", + "1 699317 1659 2021-05-29 8317 100.0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Download dataset\n", + "DATA_PATH = Path(\"data_en\")\n", + "items = pd.read_csv(DATA_PATH / 'items_en.csv', index_col=0)\n", + "interactions = (\n", + " pd.read_csv(DATA_PATH / 'interactions.csv', parse_dates=[\"last_watch_dt\"])\n", + " .rename(columns={\"last_watch_dt\": Columns.Datetime})\n", + ")\n", + "print(interactions.shape)\n", + "interactions.head(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5476251, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_iddatetimeweight
017654995062021-05-113
169931716592021-05-293
\n", + "
" + ], + "text/plain": [ + " user_id item_id datetime weight\n", + "0 176549 9506 2021-05-11 3\n", + "1 699317 1659 2021-05-29 3" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Process interactions\n", + "interactions[Columns.Weight] = np.where(interactions['watched_pct'] > 10, 3, 1)\n", + "interactions = interactions[[\"user_id\", \"item_id\", \"datetime\", \"weight\"]]\n", + "print(interactions.shape)\n", + "interactions.head(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Create dataset \n", + "dataset = Dataset.construct(\n", + " interactions_df=interactions,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model description" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "SASRec is a transformer-based sequential model with unidirectional attention mechanism and \"Shifted Sequence\" training objective. \n", + "\n", + "As an input SASRec takes user sequences, containig previous user interaction history. Description of how they are created from user-item interactions can be found in \"Under the hood: Dataset processing\" part. Item embeddings from these sequences are fed to multi-head self-attention to acquire user sequence latent represenation. After one or several stacked attention blocks, resulting embeddings are used to predict next item.\n", + "\n", + "In contrust to BERT4Rec, another transformer-based recommender model, SASRec is a causal model. It applies causal mask to enforce model focus solely on past interactions.\n" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Recommendations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After that implicit ranker is applied to make recommendations. Implicit ranker bases on implicit library matrix factorization topk method that:\n", + "* Receives as input:\n", + " * Item embeddings\n", + " * User sequence latent embeddings. Similarly to train stage, user sequence item embeddings are passed through transformer blocks and layer normalization to receive latent representation.\n", + "* Finds relevanace of each item by multiplication of user and item embeddings\n", + "* Returns items within topk with greates relevance\n", + "\n", + "For u2i recommendations DOT distance is applied to find item relevance, for i2i - COSINE" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# RecTools implementation\n", + "Current implementation uses architecture offered by the authors of original article. In contrast to original model, only cross-entropy loss is supported and no negative sampling is provided. However, in the future versions more loss functions are expected." + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Additional details\n", + "1. Xavier normal initialization for model parameters\n", + "2. Adam optimizer with betas=(0.9, 0.98) is used\n", + "3. Masked multi-head attention uses attention and timeline mask\n", + "4. Cross-entropy loss without reduction is applied, ignoring 0 index not to take into account pad element. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model Application" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Seed set to 60\n" + ] + }, + { + "data": { + "text/plain": [ + "60" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "RANDOM_STATE=60\n", + "torch.use_deterministic_algorithms(True)\n", + "seed_everything(RANDOM_STATE, workers=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(82, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_iddatetimeweight
017654995062021-05-113
3815176549154692021-05-253
\n", + "
" + ], + "text/plain": [ + " user_id item_id datetime weight\n", + "0 176549 9506 2021-05-11 3\n", + "3815 176549 15469 2021-05-25 3" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Prepare test user\n", + "test_user = [176549] \n", + "print(interactions[interactions[\"user_id\"] == test_user[0]].shape)\n", + "interactions[interactions[\"user_id\"] == test_user[0]].head(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Specify latent embeddings size with `n_factors`\n", + "* Specify number of self-attention blocks with `n_blocks` \n", + "* Specify number of attention heads with `n_heads`\n", + "* Specify `dropout_rate`\n", + "* Specify whether positional encoding should be used with `use_pos_emb`\n", + "* Specify maximum length of user-item interaction history with `session_maxlen`\n", + "* Specify `lr` for learning rate \n", + "* Specify `batch_size`\n", + "* Specify `epochs` for number of model training epochs" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/data/home/maspirina1/Tasks/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `pytorch_lightning` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n" + ] + } + ], + "source": [ + "factors=128\n", + "session_maxlen=32\n", + "model = SasRecModel(\n", + " n_factors=factors, \n", + " n_blocks=2,\n", + " n_heads=1,\n", + " dropout_rate=0.2,\n", + " use_pos_emb=True,\n", + " session_maxlen=session_maxlen,\n", + " lr=1e-3,\n", + " batch_size=128,\n", + " epochs=5,\n", + " device=\"cuda:1\",\n", + " loss=\"softmax\",\n", + " verbose=1,\n", + " deterministic=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------------------------\n", + "0 | loss_func | CrossEntropyLoss | 0 \n", + "1 | torch_model | TransformerBasedSessionEncoder | 2.1 M \n", + "---------------------------------------------------------------\n", + "2.1 M Trainable params\n", + "0 Non-trainable params\n", + "2.1 M Total params\n", + "8.207 Total estimated model params size (MB)\n", + "/data/home/maspirina1/Tasks/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2f8d8fadf85a48438d76510422437065", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "model.fit(dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1/1 [00:00<00:00, 28.36it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 670 ms, sys: 1.19 s, total: 1.86 s\n", + "Wall time: 342 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_idscoreranktitle_orig
0176549117492.8346251Incredibles 2
117654973102.7687712Despicable Me 2
2176549152662.6864913Monsters University
\n", + "
" + ], + "text/plain": [ + " user_id item_id score rank title_orig\n", + "0 176549 11749 2.834625 1 Incredibles 2\n", + "1 176549 7310 2.768771 2 Despicable Me 2\n", + "2 176549 15266 2.686491 3 Monsters University" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "recos = model.recommend(\n", + " users = test_user, \n", + " dataset = dataset,\n", + " k = 3,\n", + " filter_viewed = True,\n", + " on_unsupported_targets=\"warn\",\n", + ")\n", + "recos.merge(items[[\"item_id\", \"title_orig\"]], on=\"item_id\").sort_values([\"user_id\", \"rank\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Additional details\n", + "It may happen that SASRec filters out users with less than 2 interactions during train stage, as target is a shifted interaction sequence. However, it is still possible to make recommendations for user with one interaction in history if this interaction item was present at training.\n", + "\n", + "As an example consider user 324373, for whom there is only one interaction in the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_iddatetimeweight
2493287324373104402021-06-243
\n", + "
" + ], + "text/plain": [ + " user_id item_id datetime weight\n", + "2493287 324373 10440 2021-06-24 3" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Prepare test user with 1 interaction\n", + "test_user_recs = [324373] \n", + "print(interactions[interactions[\"user_id\"] == test_user_recs[0]].shape)\n", + "interactions[interactions[\"user_id\"] == test_user_recs[0]]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1/1 [00:00<00:00, 232.91it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 580 ms, sys: 690 ms, total: 1.27 s\n", + "Wall time: 97.7 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_idscoreranktitle_orig
0324373152975.8946321Klinika schast'ya
132437397284.0819712Wrath of Man
2324373138654.0801283V2. Escape from Hell
\n", + "
" + ], + "text/plain": [ + " user_id item_id score rank title_orig\n", + "0 324373 15297 5.894632 1 Klinika schast'ya\n", + "1 324373 9728 4.081971 2 Wrath of Man\n", + "2 324373 13865 4.080128 3 V2. Escape from Hell" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "recos = model.recommend(\n", + " users = test_user_recs, \n", + " dataset = dataset,\n", + " k = 3,\n", + " filter_viewed = True,\n", + " on_unsupported_targets=\"warn\",\n", + ")\n", + "recos.merge(items[[\"item_id\", \"title_orig\"]], on=\"item_id\").sort_values([\"user_id\", \"rank\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another case is when user had interactions, but all of the items were not present at the train stage. This may happen due to several reasons:\n", + "* Other users with this item were excluded due to lack of interactions\n", + "* User sequence exceeded `session_maxlen` and was shortened \n", + "\n", + "If user does not have interactions containg items, which model knows, this user will not get recommendations." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_iddatetimeweight
23938771463088712021-03-283
\n", + "
" + ], + "text/plain": [ + " user_id item_id datetime weight\n", + "2393877 14630 8871 2021-03-28 3" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Prepare test user with items unknown by the model\n", + "test_user_no_recs = [14630] \n", + "print(interactions[interactions[\"user_id\"] == test_user_no_recs[0]].shape)\n", + "interactions[interactions[\"user_id\"] == test_user_no_recs[0]].head(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Flag `on_unsupported_target` allows to monitor the number of users without any known items.\n", + "\n", + "Flag options:\n", + "* \"ignore\" - skip such users, show warning with the number of cold users.\n", + "* \"warn\" - skip such users, show warning with the number of cold users and that cold users are not supported.\n", + "* \"raise\" - stop recommendation procedure." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 61.4 ms, sys: 73 µs, total: 61.5 ms\n", + "Wall time: 60.2 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/maspirina1/Tasks/RecTools/rectools/models/sasrec.py:507: UserWarning: 1 target users were considered cold\n", + " because of missing known items\n", + " warnings.warn(explanation)\n", + "/data/home/maspirina1/Tasks/RecTools/rectools/models/base.py:406: UserWarning: \n", + " Model `` doesn't support recommendations for cold users,\n", + " but some of given users are cold: they are not in the `dataset.user_id_map`\n", + " \n", + " warnings.warn(explanation)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_idscorerankitem_idtitle_orig
\n", + "
" + ], + "text/plain": [ + "Empty DataFrame\n", + "Columns: [user_id, score, rank, item_id, title_orig]\n", + "Index: []" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "recos = model.recommend(\n", + " users = test_user_no_recs, \n", + " dataset = dataset,\n", + " k = 3,\n", + " filter_viewed = True,\n", + " on_unsupported_targets=\"warn\",\n", + ")\n", + "recos.merge(items[[\"item_id\", \"title_orig\"]], on=\"item_id\").sort_values([\"user_id\", \"rank\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Links\n", + "1. SASRec original paper: [Self-Attentive Sequential Recommendation](https://arxiv.org/abs/1808.09781)\n", + "2. [Turning Dross Into Gold Loss: is BERT4Rec really better than SASRec?](https://arxiv.org/abs/2309.07602)\n", + "3. [gSASRec: Reducing Overconfidence in Sequential Recommendation Trained with Negative Sampling](https://arxiv.org/pdf/2308.07192)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Under the hood: Dataset processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Preprocessing steps will be shown using toy dataset:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_id item_id weight datetime
u1i10.12021-09-09
u2i10.32021-09-09
u2i30.22021-09-05
u1i20.32021-09-07
u3i20.42021-09-05
u1i30.52021-09-08
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Filter out users with less than 2 interactions in train dataset. The model uses shifted user interactions to make next item prediction, thus at least 2 items should be in the history. \n", + "\n", + "2. Leave `session_maxlen` most recent interactions for each user.\n", + "\n", + "After first 2 steps, some users and/or items may be filtered out from train dataset. However, as it will be shown further, it is still possible to make recommendations for a previously unmet user, if interaction is known.\n", + "\n", + "3. Create user sessions: for each user specify items with which there was an interaction in the order from earliest to most recent. Sessions for example dataset are the following:\n", + "$$S^1 = (i2, i3, i1)$$\n", + "$$S^2 = (i3, i1)$$\n", + "\n", + "4. Before train stage each session is divided into train and target. As the task is to predict next item, shifted sequence is considered as target.\n", + "$$S^1_{train} = (i2, i3), S^1_{target} = (i3, i1)$$\n", + "$$S^2_{train} = (i3), S^2_{target} = (i1)$$\n", + "5. Both train and target sequences are adjusted to have user-defined `session_maxlen`:\n", + " * If session is longer than `session_maxlen`, cut earliest items\n", + " * If session is shorter than `session_maxlen`, pad earliest items with PAD element\n", + "$$S^1_{train} = (PAD, PAD, PAD, i2, i3), S^1_{target} = (PAD, PAD, PAD, i3, i1)$$\n", + "$$S^2_{train} = (PAD, PAD, PAD, PAD, i3), S^2_{target} = (PAD, PAD, PAD, PAD, i1)$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Under the hood: Transformer layers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Multi-head attention layer receives queries after layer normalisarion, keys and values without it. Masked attention is required to forbid model consider future interactions: cannot access element t+2 when predicting element t+1. Following notation from original article: \n", + "$$ \\text{Attention}(Q, K, V) = \\text{softmax} (\\frac {QK^T}{\\sqrt{d}})V $$\n", + "$$S = SA(\\hat{E}) = \\text{Attention} (\\hat{E}W^Q, \\hat{E}W^K, \\hat{E}W^V)$$\n", + "\n", + "where $\\hat{E}$ - input embedding\n", + "* Point-wise feed-forward network has the following structure: $F_i = \\text{FFN}(S_i) = \\text{ReLU}(S_i \\cdot W^{(1)} + b^{(1)}) \\cdot W^{(2)} + b^{(2)}$,\n", + "\n", + "where $S_i, S_j$ - items of user sequence\n", + "\n", + "$W_1, W_2$ - weights\n", + "\n", + "$b_1, b_2$ - biases\n", + "* To avoid overfitting and stabelize training process, 2 residual connections are applied adding data after layer normalization.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.8.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From bec657f16b71f787a81f54322ae2b974948067a3 Mon Sep 17 00:00:00 2001 From: spirinamayya <90619187+spirinamayya@users.noreply.github.com> Date: Fri, 27 Sep 2024 11:45:44 +0300 Subject: [PATCH 04/13] lightning module (#187) Added lightning module --- examples/sasrec_metrics_comp.ipynb | 317 +++++++++++------------ rectools/models/sasrec.py | 395 ++++++++++++++++------------- 2 files changed, 367 insertions(+), 345 deletions(-) diff --git a/examples/sasrec_metrics_comp.ipynb b/examples/sasrec_metrics_comp.ipynb index 74d4a66f..3cba1fa8 100644 --- a/examples/sasrec_metrics_comp.ipynb +++ b/examples/sasrec_metrics_comp.ipynb @@ -2,74 +2,43 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/data/home/dmtikhono1/git_project/sasrec/RecTools/examples\n" - ] - } - ], - "source": [ - "!pwd" - ] - }, - { - "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "import sys\n", - "sys.path.append(\"/data/home/dmtikhono1/git_project/sasrec/RecTools/\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "execution": { - "iopub.execute_input": "2024-06-27T14:29:22.494979Z", - "iopub.status.busy": "2024-06-27T14:29:22.494423Z", - "iopub.status.idle": "2024-06-27T14:29:22.812073Z", - "shell.execute_reply": "2024-06-27T14:29:22.811404Z", - "shell.execute_reply.started": "2024-06-27T14:29:22.494879Z" - } - }, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "import pandas as pd\n", - "from rectools import Columns\n", - "import numpy as np\n", "import logging\n", "import os\n", + "import threadpoolctl\n", "import torch\n", + "from pathlib import Path\n", "from lightning_fabric import seed_everything\n", "\n", - "from rectools.models import ImplicitALSWrapperModel\n", + "import numpy as np\n", + "import pandas as pd\n", + "from rectools import Columns\n", + "\n", "from implicit.als import AlternatingLeastSquares\n", - "from rectools.models.sasrec import SasRecModel\n", "\n", + "from rectools.dataset import Dataset\n", "from rectools.metrics import MAP, calc_metrics, MeanInvUserFreq, Serendipity\n", - "from rectools.dataset import Dataset" + "from rectools.models import ImplicitALSWrapperModel\n", + "from rectools.models.sasrec import SASRecModel" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "os.environ[\"CUBLAS_WORKSPACE_CONFIG\"] = \":4096:8\"\n", + "\n", + "# For implicit ALS\n", "os.environ[\"OPENBLAS_NUM_THREADS\"] = \"1\"\n", + "threadpoolctl.threadpool_limits(1, \"blas\")\n", "\n", "logging.basicConfig()\n", "logging.getLogger().setLevel(logging.INFO)\n", - "\n", "logger = logging.getLogger()" ] }, @@ -82,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -94,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -115,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -139,21 +108,20 @@ "users = users.index.to_list()\n", "train = train[(train[\"user_id\"].isin(users))]\n", "\n", - "# leave item features for items only from train\n", - "# items = train[\"item_id\"].drop_duplicates().to_list()\n", "users = train[\"user_id\"].drop_duplicates().to_list()\n", "\n", "# drop cold users from test\n", - "test_users = test[Columns.User].unique()\n", + "test_users_sasrec = test[Columns.User].unique()\n", "cold_users = set(test[Columns.User]) - set(train[Columns.User])\n", "test.drop(test[test[Columns.User].isin(cold_users)].index, inplace=True)\n", + "test_users = test[Columns.User].unique()\n", "\n", "catalog=train[Columns.Item].unique()\n" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -171,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -187,7 +155,7 @@ "32" ] }, - "execution_count": 9, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -200,101 +168,125 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `pytorch_lightning` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n" + ] + } + ], "source": [ - "factors=128\n", "session_maxlen=32\n", - "model = SasRecModel(\n", - " factors=factors, # 50\n", + "model = SASRecModel(\n", " n_blocks=2,\n", - " n_heads=1,\n", - " dropout_rate=0.2,\n", - " use_pos_emb=True,\n", - " session_maxlen=session_maxlen,\n", + " session_max_len=32,\n", " lr=1e-3,\n", - " batch_size=128,\n", " epochs=5,\n", - " device=\"cuda:1\",\n", - " loss=\"softmax\",\n", + " verbose=1,\n", + " deterministic=True,\n", ")" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "INFO:rectools.models.sasrec:training epoch 1\n", - "INFO:rectools.models.sasrec:training epoch 2\n", - "INFO:rectools.models.sasrec:training epoch 3\n", - "INFO:rectools.models.sasrec:training epoch 4\n", - "INFO:rectools.models.sasrec:training epoch 5\n" + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------------------------\n", + "0 | torch_model | TransformerBasedSessionEncoder | 927 K \n", + "---------------------------------------------------------------\n", + "927 K Trainable params\n", + "0 Non-trainable params\n", + "927 K Total params\n", + "3.709 Total estimated model params size (MB)\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, { - "name": "stdout", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a8549cea538d4078a6beddd33b1e1a2a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" + "" ] }, - "execution_count": 11, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "\n", - "%%time\n", + "#%%time\n", "model.fit(dataset)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/dmtikhono1/git_project/sasrec/RecTools/rectools/models/sasrec.py:522: UserWarning: 91202 target users were considered cold\n", - " because of missing known items\n", - " interactions[Columns.User] = dataset.user_id_map.convert_to_external(interactions[Columns.User])\n", - "/data/home/dmtikhono1/git_project/sasrec/RecTools/rectools/models/base.py:403: UserWarning: \n", - " Model `` doesn't support recommendations for cold users,\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:475: UserWarning: 91202 target users were considered cold because of missing known items\n", + " warnings.warn(explanation)\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:406: UserWarning: \n", + " Model `` doesn't support recommendations for cold users,\n", " but some of given users are cold: they are not in the `dataset.user_id_map`\n", " \n", " warnings.warn(explanation)\n", - "100%|██████████| 740/740 [00:02<00:00, 267.59it/s]\n" + "100%|██████████| 740/740 [00:03<00:00, 237.27it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 2min 15s, sys: 11min 24s, total: 13min 40s\n", - "Wall time: 22 s\n" + "CPU times: user 26.9 s, sys: 5.41 s, total: 32.3 s\n", + "Wall time: 22.5 s\n" ] } ], "source": [ "%%time\n", "recs = model.recommend(\n", - " users = test_users, \n", + " users = test_users_sasrec, \n", " dataset = dataset,\n", " k = 10,\n", " filter_viewed = True,\n", @@ -304,7 +296,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -323,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -337,7 +329,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -467,7 +459,7 @@ "[947050 rows x 4 columns]" ] }, - "execution_count": 20, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -479,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -497,7 +489,7 @@ " 'model': 'sasrec'}]" ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -515,7 +507,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -524,15 +516,15 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.76 s, sys: 2.4 s, total: 4.16 s\n", - "Wall time: 1.14 s\n" + "CPU times: user 1.39 s, sys: 301 ms, total: 1.7 s\n", + "Wall time: 1.19 s\n" ] } ], @@ -549,7 +541,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -828,7 +820,7 @@ "29 15297 1844 0.581799 10" ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -837,27 +829,6 @@ "recs" ] }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[25], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m() \u001b[38;5;66;03m# skip updating cells below\u001b[39;00m\n", - "\u001b[0;31mValueError\u001b[0m: " - ] - } - ], - "source": [ - "raise ValueError() # skip updating cells below" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -867,7 +838,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -877,7 +848,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -911,7 +882,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -930,7 +901,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -955,18 +926,9 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/data/home/maspirina1/Tasks/RecTools/.venv/lib/python3.8/site-packages/implicit/cpu/als.py:95: RuntimeWarning: OpenBLAS is configured to use 64 threads. It is highly recommended to disable its internal threadpool by setting the environment variable 'OPENBLAS_NUM_THREADS=1' or by calling 'threadpoolctl.threadpool_limits(1, \"blas\")'. Having OpenBLAS use a threadpool can lead to severe performance issues here.\n", - " check_blas_config()\n" - ] - } - ], + "outputs": [], "source": [ "n_factors = 128\n", "regularization = 0.5\n", @@ -979,6 +941,7 @@ " dataset=dataset_no_features,\n", " k=K_RECOS,\n", " filter_viewed=True,\n", + " on_unsupported_targets=\"warn\"\n", ")\n", "metric_values = calc_metrics(metrics, recos, test, train, catalog)\n", "metric_values[\"model\"] = \"no_features_factors_128_alpha_10_reg_0.5\"\n", @@ -987,7 +950,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -1007,6 +970,7 @@ " dataset=dataset_full_features,\n", " k=K_RECOS,\n", " filter_viewed=True,\n", + " on_unsupported_targets=\"warn\"\n", ")\n", "metric_values = calc_metrics(metrics, recos, test, train, catalog)\n", "metric_values[\"model\"] = \"full_features_factors_128_fit_together_True\"\n", @@ -1015,7 +979,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -1065,37 +1029,37 @@ " \n", " \n", " sasrec\n", - " 0.047579\n", - " 0.081093\n", - " 0.090322\n", + " 0.048967\n", + " 0.082847\n", + " 0.092022\n", " 18.824620\n", " 18.824620\n", " 18.824620\n", - " 0.098168\n", - " 0.059983\n", - " 0.044268\n", + " 0.100744\n", + " 0.060646\n", + " 0.044432\n", " \n", " \n", " full_features_factors_128_fit_together_True\n", - " 0.033849\n", - " 0.056533\n", - " 0.062486\n", - " 4.339514\n", - " 5.338082\n", - " 6.044169\n", - " 0.000429\n", - " 0.000460\n", - " 0.000459\n", + " 0.033850\n", + " 0.056586\n", + " 0.062547\n", + " 4.340709\n", + " 5.339626\n", + " 6.045144\n", + " 0.000438\n", + " 0.000462\n", + " 0.000461\n", " \n", " \n", " no_features_factors_128_alpha_10_reg_0.5\n", - " 0.015530\n", - " 0.028466\n", - " 0.032820\n", - " 6.603847\n", - " 6.943217\n", - " 7.146507\n", - " 0.001047\n", + " 0.015523\n", + " 0.028465\n", + " 0.032814\n", + " 6.603868\n", + " 6.943141\n", + " 7.146539\n", + " 0.001046\n", " 0.000904\n", " 0.000815\n", " \n", @@ -1106,30 +1070,30 @@ "text/plain": [ " MAP@1 MAP@5 MAP@10 \\\n", "model \n", - "sasrec 0.047579 0.081093 0.090322 \n", - "full_features_factors_128_fit_together_True 0.033849 0.056533 0.062486 \n", - "no_features_factors_128_alpha_10_reg_0.5 0.015530 0.028466 0.032820 \n", + "sasrec 0.048967 0.082847 0.092022 \n", + "full_features_factors_128_fit_together_True 0.033850 0.056586 0.062547 \n", + "no_features_factors_128_alpha_10_reg_0.5 0.015523 0.028465 0.032814 \n", "\n", " MIUF@1 MIUF@5 MIUF@10 \\\n", "model \n", "sasrec 18.824620 18.824620 18.824620 \n", - "full_features_factors_128_fit_together_True 4.339514 5.338082 6.044169 \n", - "no_features_factors_128_alpha_10_reg_0.5 6.603847 6.943217 7.146507 \n", + "full_features_factors_128_fit_together_True 4.340709 5.339626 6.045144 \n", + "no_features_factors_128_alpha_10_reg_0.5 6.603868 6.943141 7.146539 \n", "\n", " Serendipity@1 Serendipity@5 \\\n", "model \n", - "sasrec 0.098168 0.059983 \n", - "full_features_factors_128_fit_together_True 0.000429 0.000460 \n", - "no_features_factors_128_alpha_10_reg_0.5 0.001047 0.000904 \n", + "sasrec 0.100744 0.060646 \n", + "full_features_factors_128_fit_together_True 0.000438 0.000462 \n", + "no_features_factors_128_alpha_10_reg_0.5 0.001046 0.000904 \n", "\n", " Serendipity@10 \n", "model \n", - "sasrec 0.044268 \n", - "full_features_factors_128_fit_together_True 0.000459 \n", + "sasrec 0.044432 \n", + "full_features_factors_128_fit_together_True 0.000461 \n", "no_features_factors_128_alpha_10_reg_0.5 0.000815 " ] }, - "execution_count": 18, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1143,6 +1107,13 @@ "features_df" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, @@ -1167,7 +1138,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/rectools/models/sasrec.py b/rectools/models/sasrec.py index 192d1c29..578471de 100644 --- a/rectools/models/sasrec.py +++ b/rectools/models/sasrec.py @@ -1,4 +1,3 @@ -import logging import typing as tp import warnings from copy import deepcopy @@ -9,6 +8,7 @@ import torch import tqdm import typing_extensions as tpe +from pytorch_lightning import LightningModule, Trainer from torch import nn from torch.utils.data import DataLoader from torch.utils.data import Dataset as TorchDataset @@ -22,13 +22,12 @@ PADDING_VALUE = "PAD" -logger = logging.getLogger(__name__) # TODO: remove # #### -------------- Net blocks -------------- #### # class ItemNetBase(nn.Module): - """Base class ItemNet. Used only for type hinting.""" + """TODO: use Protocol""" def forward(self, items: torch.Tensor) -> torch.Tensor: """TODO""" @@ -45,13 +44,21 @@ def get_all_embeddings(self) -> torch.Tensor: class TransformerLayersBase(nn.Module): - """Base class for transformer layers. Used only for type hinting.""" + """TODO: use Protocol""" def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: torch.Tensor) -> torch.Tensor: """Forward""" raise NotImplementedError() +class PositionalEncodingBase(torch.nn.Module): + """TODO: use Protocol""" + + def forward(self, sessions: torch.Tensor, timeline_mask: torch.Tensor) -> torch.Tensor: + """TODO""" + raise NotImplementedError() + + class IdEmbeddingsItemNet(ItemNetBase): """ Base class for item embeddings. To use more complicated logic then just id embeddings inherit @@ -110,7 +117,7 @@ def forward(self, seqs: torch.Tensor) -> torch.Tensor: return fin -class SasRecTransformerLayers(TransformerLayersBase): +class SASRecTransformerLayers(TransformerLayersBase): """Exactly SASRec authors architecture but with torch MHA realisation""" def __init__( @@ -191,28 +198,28 @@ def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: to return seqs -class LearnableInversePositionalEncoding(torch.nn.Module): +class LearnableInversePositionalEncoding(PositionalEncodingBase): """TODO""" - def __init__(self, use_pos_emb: bool, session_maxlen: int, n_factors: int): + def __init__(self, use_pos_emb: bool, session_max_len: int, n_factors: int): super().__init__() - self.pos_emb = torch.nn.Embedding(session_maxlen, n_factors) if use_pos_emb else None + self.pos_emb = torch.nn.Embedding(session_max_len, n_factors) if use_pos_emb else None def forward(self, sessions: torch.Tensor, timeline_mask: torch.Tensor) -> torch.Tensor: """TODO""" - batch_size, session_maxlen, _ = sessions.shape + batch_size, session_max_len, _ = sessions.shape if self.pos_emb is not None: # Inverse positions are appropriate for variable length sequences across different batches # They are equal to absolute positions for fixed sequence length across different batches positions = torch.tile( - torch.arange(session_maxlen - 1, -1, -1), (batch_size, 1) - ) # [batch_size, session_maxlen] + torch.arange(session_max_len - 1, -1, -1), (batch_size, 1) + ) # [batch_size, session_max_len] sessions += self.pos_emb(positions.to(sessions.device)) # TODO: do we need to fill padding embeds in sessions to all zeros # or should we use the learnt padding embedding? Should we make it an option for user to decide? - sessions *= timeline_mask # [batch_size, session_maxlen, n_factors] + sessions *= timeline_mask # [batch_size, session_max_len, n_factors] return sessions @@ -228,17 +235,18 @@ def __init__( n_blocks: int, n_factors: int, n_heads: int, - session_maxlen: int, + session_max_len: int, dropout_rate: float, - use_pos_emb: bool = True, # TODO: add pos_encoding_type option for user to pass + use_pos_emb: bool = True, use_causal_attn: bool = True, - transformer_layers_type: tp.Type[TransformerLayersBase] = SasRecTransformerLayers, + transformer_layers_type: tp.Type[TransformerLayersBase] = SASRecTransformerLayers, item_net_type: tp.Type[ItemNetBase] = IdEmbeddingsItemNet, + pos_encoding_type: tp.Type[PositionalEncodingBase] = LearnableInversePositionalEncoding, ) -> None: super().__init__() self.item_model: ItemNetBase - self.pos_encoding = LearnableInversePositionalEncoding(use_pos_emb, session_maxlen, n_factors) + self.pos_encoding = pos_encoding_type(use_pos_emb, session_max_len, n_factors) self.emb_dropout = torch.nn.Dropout(dropout_rate) self.transformer_layers = transformer_layers_type( n_blocks=n_blocks, @@ -251,7 +259,7 @@ def __init__( self.n_factors = n_factors self.dropout_rate = dropout_rate - def costruct_item_net(self, dataset: Dataset) -> None: + def construct_item_net(self, dataset: Dataset) -> None: """TODO""" self.item_model = self.item_net_type.from_dataset(dataset, self.n_factors, self.dropout_rate) @@ -261,17 +269,17 @@ def encode_sessions(self, sessions: torch.Tensor, item_embs: torch.Tensor) -> to Returns ------- - torch.Tensor. [batch_size, session_maxlen, factors] + torch.Tensor. [batch_size, session_max_len, n_factors] """ - session_maxlen = sessions.shape[1] + session_max_len = sessions.shape[1] attn_mask = None if self.use_causal_attn: attn_mask = ~torch.tril( - torch.ones((session_maxlen, session_maxlen), dtype=torch.bool, device=sessions.device) + torch.ones((session_max_len, session_max_len), dtype=torch.bool, device=sessions.device) ) - timeline_mask = (sessions != 0).unsqueeze(-1) # [batch_size, session_maxlen, 1] - seqs = item_embs[sessions] # [batch_size, session_maxlen, n_factors] + timeline_mask = (sessions != 0).unsqueeze(-1) # [batch_size, session_max_len, 1] + seqs = item_embs[sessions] # [batch_size, session_max_len, n_factors] seqs = self.pos_encoding(seqs, timeline_mask) seqs = self.emb_dropout(seqs) seqs = self.transformer_layers(seqs, timeline_mask, attn_mask) @@ -279,105 +287,15 @@ def encode_sessions(self, sessions: torch.Tensor, item_embs: torch.Tensor) -> to def forward( self, - sessions: torch.Tensor, # [batch_size, session_maxlen] + sessions: torch.Tensor, # [batch_size, session_max_len] ) -> torch.Tensor: """TODO""" item_embs = self.item_model.get_all_embeddings() # [n_items + 1, n_factors] - session_embs = self.encode_sessions(sessions, item_embs) # [batch_size, session_maxlen, n_factors] - logits = session_embs @ item_embs.T # [batch_size, session_maxlen, n_items + 1] + session_embs = self.encode_sessions(sessions, item_embs) # [batch_size, session_max_len, n_factors] + logits = session_embs @ item_embs.T # [batch_size, session_max_len, n_items + 1] return logits -# #### -------------- Trainer -------------- #### # - - -class Trainer: - """TODO""" - - def __init__( - self, - lr: float, - epochs: int, - device: torch.device, - loss: str = "softmax", - ): - """TODO""" - self.model: TransformerBasedSessionEncoder - self.optimizer: torch.optim.Adam - self.lr = lr - self.epochs = epochs - self.device = device - self.loss_func = self._init_loss_func(loss) # TODO: move loss func to `SasRec` class - - def fit( - self, - model: TransformerBasedSessionEncoder, - fit_dataloader: DataLoader, - ) -> None: - """TODO""" - self.model = model - self.optimizer = self._init_optimizers() - self.model.to(self.device) - - self.xavier_normal_init(self.model) - self.model.train() # enable model training - - # self.model.item_model.to_device(self.device) - - epoch_start_idx = 1 - - # ce_criterion = torch.nn.CrossEntropyLoss() - # https://github.com/NVIDIA/pix2pixHD/issues/9 how could an old bug appear again... - - for epoch in range(epoch_start_idx, self.epochs + 1): - logger.info("training epoch %s", epoch) - for x, y, w in fit_dataloader: - x = x.to(self.device) # [batch_size, session_maxlen] - y = y.to(self.device) # [batch_size, session_maxlen] - w = w.to(self.device) # [batch_size, session_maxlen] - - self.train_step(x, y, w) - - def train_step(self, x: torch.Tensor, y: torch.Tensor, w: torch.Tensor) -> None: - """TODO""" - self.optimizer.zero_grad() - logits = self.model(x) # [batch_size, session_maxlen, n_items + 1] - # We are using CrossEntropyLoss with a multi-dimensional case - - # Logits must be passed in form of [batch_size, n_items + 1, session_maxlen], - # where n_items + 1 is number of classes - - # Target label indexes must be passed in a form of [batch_size, session_maxlen] - # (`0` index for "PAD" ix excluded from loss) - - # Loss output will have a shape of [batch_size, session_maxlen] - # and will have zeros for every `0` target label - loss = self.loss_func(logits.transpose(1, 2), y) # [batch_size, session_maxlen] - loss = loss * w - n = (loss > 0).to(loss.dtype) - loss = torch.sum(loss) / torch.sum(n) - loss.backward() - self.optimizer.step() - - def _init_optimizers(self) -> torch.optim.Adam: - optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr, betas=(0.9, 0.98)) - return optimizer - - def _init_loss_func(self, loss: str) -> nn.CrossEntropyLoss: - - if loss == "softmax": - return nn.CrossEntropyLoss(ignore_index=0, reduction="none") - raise ValueError(f"loss {loss} is not supported") - - def xavier_normal_init(self, model: nn.Module) -> None: - """TODO""" - for _, param in model.named_parameters(): - try: - torch.nn.init.xavier_normal_(param.data) - except ValueError: - pass - - # #### -------------- Data Processor -------------- #### # @@ -415,37 +333,63 @@ def from_interactions( return cls(sessions=sessions, weights=weights) -class SasRecDataPreparator: - """TODO""" +class SessionEncoderDataPreparatorBase: + """Base class for data preparator. Used only for type hinting.""" def __init__( self, - session_maxlen: int, + session_max_len: int, batch_size: int, + dataloader_num_workers: int, item_extra_tokens: tp.Sequence[tp.Hashable] = (PADDING_VALUE,), shuffle_train: bool = True, # not shuffling train dataloader hurts performance train_min_user_interactions: int = 2, ) -> None: - self.session_maxlen = session_maxlen + self.session_max_len = session_max_len self.batch_size = batch_size + self.dataloader_num_workers = dataloader_num_workers self.item_extra_tokens = item_extra_tokens self.shuffle_train = shuffle_train self.train_min_user_interactions = train_min_user_interactions self.item_id_map: IdMap # TODO: add SequenceDatasetType for fit and recommend + def get_known_items_sorted_internal_ids(self) -> np.ndarray: + """TODO""" + return self.item_id_map.get_sorted_internal()[self.n_item_extra_tokens :] + + def get_known_item_ids(self) -> np.ndarray: + """TODO""" + return self.item_id_map.get_external_sorted_by_internal()[self.n_item_extra_tokens :] + @property def n_item_extra_tokens(self) -> int: """TODO""" return len(self.item_extra_tokens) - def get_known_item_ids(self) -> np.ndarray: + def process_dataset_train(self, dataset: Dataset) -> Dataset: """TODO""" - return self.item_id_map.get_external_sorted_by_internal()[self.n_item_extra_tokens :] + raise NotImplementedError() - def get_known_items_sorted_internal_ids(self) -> np.ndarray: + def get_dataloader_train(self, processed_dataset: Dataset) -> DataLoader: """TODO""" - return self.item_id_map.get_sorted_internal()[self.n_item_extra_tokens :] + raise NotImplementedError() + + def get_dataloader_recommend(self, dataset: Dataset) -> DataLoader: + """TODO""" + raise NotImplementedError() + + def transform_dataset_u2i(self, dataset: Dataset, users: ExternalIds) -> Dataset: + """TODO""" + raise NotImplementedError() + + def transform_dataset_i2i(self, dataset: Dataset) -> Dataset: + """TODO""" + raise NotImplementedError() + + +class SASRecDataPreparator(SessionEncoderDataPreparatorBase): + """TODO""" def process_dataset_train(self, dataset: Dataset) -> Dataset: """TODO""" @@ -455,7 +399,7 @@ def process_dataset_train(self, dataset: Dataset) -> Dataset: user_stats = interactions[Columns.User].value_counts() users = user_stats[user_stats >= self.train_min_user_interactions].index interactions = interactions[(interactions[Columns.User].isin(users))] - interactions = interactions.sort_values(Columns.Datetime).groupby(Columns.User).tail(self.session_maxlen + 1) + interactions = interactions.sort_values(Columns.Datetime).groupby(Columns.User).tail(self.session_max_len + 1) # Construct dataset # TODO: user features and item features are dropped for now @@ -473,25 +417,29 @@ def _collate_fn_train( batch: List[Tuple[List[int], List[float]]], ) -> Tuple[torch.LongTensor, torch.LongTensor, torch.FloatTensor]: """ - Truncate each session from right to keep (session_maxlen+1) last items. - Do left padding until (session_maxlen+1) is reached. + Truncate each session from right to keep (session_max_len+1) last items. + Do left padding until (session_max_len+1) is reached. Split to `x`, `y`, and `yw`. """ batch_size = len(batch) - x = np.zeros((batch_size, self.session_maxlen)) - y = np.zeros((batch_size, self.session_maxlen)) - yw = np.zeros((batch_size, self.session_maxlen)) + x = np.zeros((batch_size, self.session_max_len)) + y = np.zeros((batch_size, self.session_max_len)) + yw = np.zeros((batch_size, self.session_max_len)) for i, (ses, ses_weights) in enumerate(batch): - x[i, -len(ses) + 1 :] = ses[:-1] # ses: [session_len] -> x[i]: [session_maxlen] - y[i, -len(ses) + 1 :] = ses[1:] # ses: [session_len] -> y[i]: [session_maxlen] - yw[i, -len(ses) + 1 :] = ses_weights[1:] # ses_weights: [session_len] -> yw[i]: [session_maxlen] + x[i, -len(ses) + 1 :] = ses[:-1] # ses: [session_len] -> x[i]: [session_max_len] + y[i, -len(ses) + 1 :] = ses[1:] # ses: [session_len] -> y[i]: [session_max_len] + yw[i, -len(ses) + 1 :] = ses_weights[1:] # ses_weights: [session_len] -> yw[i]: [session_max_len] return torch.LongTensor(x), torch.LongTensor(y), torch.FloatTensor(yw) def get_dataloader_train(self, processed_dataset: Dataset) -> DataLoader: """TODO""" sequence_dataset = SequenceDataset.from_interactions(processed_dataset.interactions.df) train_dataloader = DataLoader( - sequence_dataset, collate_fn=self._collate_fn_train, batch_size=self.batch_size, shuffle=self.shuffle_train + sequence_dataset, + collate_fn=self._collate_fn_train, + batch_size=self.batch_size, + num_workers=self.dataloader_num_workers, + shuffle=self.shuffle_train, ) return train_dataloader @@ -523,8 +471,7 @@ def transform_dataset_u2i(self, dataset: Dataset, users: ExternalIds) -> Dataset # TODO: For now features are dropped because model doesn't support them n_filtered = len(users) - rec_user_id_map.size if n_filtered > 0: - explanation = f"""{n_filtered} target users were considered cold - because of missing known items""" + explanation = f"""{n_filtered} target users were considered cold because of missing known items""" warnings.warn(explanation) filtered_interactions = Interactions.from_raw(interactions, rec_user_id_map, self.item_id_map) filtered_dataset = Dataset(rec_user_id_map, self.item_id_map, filtered_interactions) @@ -546,69 +493,166 @@ def transform_dataset_i2i(self, dataset: Dataset) -> Dataset: return filtered_dataset def _collate_fn_recommend(self, batch: List[Tuple[List[int], List[float]]]) -> torch.LongTensor: - """Right truncation, left padding to session_maxlen""" - x = np.zeros((len(batch), self.session_maxlen)) + """Right truncation, left padding to session_max_len""" + x = np.zeros((len(batch), self.session_max_len)) for i, (ses, _) in enumerate(batch): - x[i, -len(ses) :] = ses[-self.session_maxlen :] + x[i, -len(ses) :] = ses[-self.session_max_len :] return torch.LongTensor(x) def get_dataloader_recommend(self, dataset: Dataset) -> DataLoader: """TODO""" sequence_dataset = SequenceDataset.from_interactions(dataset.interactions.df) recommend_dataloader = DataLoader( - sequence_dataset, batch_size=self.batch_size, collate_fn=self._collate_fn_recommend, shuffle=False + sequence_dataset, + batch_size=self.batch_size, + collate_fn=self._collate_fn_recommend, + num_workers=self.dataloader_num_workers, + shuffle=False, ) return recommend_dataloader -# #### -------------- SASRec Model -------------- #### # +# #### -------------- Lightning Model -------------- #### # -class SasRecModel(ModelBase): # pylint: disable=too-many-instance-attributes - """TODO""" +class SessionEncoderLightningModuleBase(LightningModule): + """Base class for lightning module. Used only for type hinting.""" def __init__( self, - session_maxlen: int, + torch_model: TransformerBasedSessionEncoder, lr: float, - batch_size: int, - epochs: int, - device: str, - n_blocks: int, - n_factors: int, - n_heads: int, - dropout_rate: float, + loss: str = "softmax", + adam_betas: Tuple[float, float] = (0.9, 0.98), + ): + super().__init__() + self.lr = lr + self.loss = loss + self.torch_model = torch_model + self.adam_betas = adam_betas + + def configure_optimizers(self) -> torch.optim.Adam: + """TODO""" + optimizer = torch.optim.Adam(self.torch_model.parameters(), lr=self.lr, betas=self.adam_betas) + return optimizer + + def forward( + self, + batch: torch.Tensor, + ) -> torch.Tensor: + """TODO""" + return self.torch_model(batch) + + def training_step(self, batch: torch.Tensor, batch_idx: int) -> torch.Tensor: + """TODO""" + raise NotImplementedError() + + +class SessionEncoderLightningModule(SessionEncoderLightningModuleBase): + """TODO""" + + def on_train_start(self) -> None: + """TODO""" + self._xavier_normal_init() + + def training_step(self, batch: torch.Tensor, batch_idx: int) -> torch.Tensor: + """TODO""" + x, y, w = batch + logits = self.forward(x) # [batch_size, session_max_len, n_items + 1] + if self.loss == "softmax": + # We are using CrossEntropyLoss with a multi-dimensional case + + # Logits must be passed in form of [batch_size, n_items + 1, session_max_len], + # where n_items + 1 is number of classes + + # Target label indexes must be passed in a form of [batch_size, session_max_len] + # (`0` index for "PAD" ix excluded from loss) + + # Loss output will have a shape of [batch_size, session_max_len] + # and will have zeros for every `0` target label + + loss = torch.nn.functional.cross_entropy( + logits.transpose(1, 2), y, ignore_index=0, reduction="none" + ) # [batch_size, session_max_len] + loss = loss * w + n = (loss > 0).to(loss.dtype) + loss = torch.sum(loss) / torch.sum(n) + return loss + raise ValueError(f"loss {loss} is not supported") + + def _xavier_normal_init(self) -> None: + """TODO""" + for _, param in self.torch_model.named_parameters(): + try: + torch.nn.init.xavier_normal_(param.data) + except ValueError: + pass + + +# #### -------------- SASRec Model -------------- #### # + + +class SASRecModel(ModelBase): + """TODO""" + + def __init__( # pylint: disable=too-many-arguments + self, + n_blocks: int = 1, + n_heads: int = 1, + n_factors: int = 128, use_pos_emb: bool = True, + dropout_rate: float = 0.2, + session_max_len: int = 32, + dataloader_num_workers: int = 0, + batch_size: int = 128, loss: str = "softmax", + lr: float = 0.01, + epochs: int = 3, verbose: int = 0, + deterministic: bool = False, + device: str = "cuda:1", cpu_n_threads: int = 0, - transformer_layers_type: tp.Type[TransformerLayersBase] = SasRecTransformerLayers, # SASRec authors net + trainer: tp.Optional[Trainer] = None, item_net_type: tp.Type[ItemNetBase] = IdEmbeddingsItemNet, # item embeddings on ids + pos_encoding_type: tp.Type[PositionalEncodingBase] = LearnableInversePositionalEncoding, + transformer_layers_type: tp.Type[TransformerLayersBase] = SASRecTransformerLayers, # SASRec authors net + data_preparator_type: tp.Type[SessionEncoderDataPreparatorBase] = SASRecDataPreparator, + lightning_module_type: tp.Type[SessionEncoderLightningModuleBase] = SessionEncoderLightningModule, ): super().__init__(verbose=verbose) self.device = torch.device(device) self.n_threads = cpu_n_threads - self.model: TransformerBasedSessionEncoder - self._model = TransformerBasedSessionEncoder( + self.torch_model: TransformerBasedSessionEncoder + self._torch_model = TransformerBasedSessionEncoder( n_blocks=n_blocks, n_factors=n_factors, n_heads=n_heads, - session_maxlen=session_maxlen, + session_max_len=session_max_len, dropout_rate=dropout_rate, use_pos_emb=use_pos_emb, use_causal_attn=True, transformer_layers_type=transformer_layers_type, item_net_type=item_net_type, + pos_encoding_type=pos_encoding_type, ) - self.trainer = Trainer( # TODO: move to lightning trainer and add option to pass initialized trainer - lr=lr, - epochs=epochs, - device=self.device, - loss=loss, - ) - self.data_preparator = SasRecDataPreparator(session_maxlen, batch_size) # TODO: add data_preparator_type + self.lightning_module_type = lightning_module_type + self.trainer: Trainer + if trainer is None: + self._trainer = Trainer( + max_epochs=epochs, + min_epochs=epochs, + deterministic=deterministic, + enable_progress_bar=verbose > 0, + enable_model_summary=verbose > 0, + logger=verbose > 0, + ) + else: + self._trainer = trainer + self.data_preparator = data_preparator_type(session_max_len, batch_size, dataloader_num_workers) self.u2i_dist = Distance.DOT self.i2i_dist = Distance.COSINE + self.lr = lr + self.loss = loss def _fit( self, @@ -617,11 +661,12 @@ def _fit( processed_dataset = self.data_preparator.process_dataset_train(dataset) train_dataloader = self.data_preparator.get_dataloader_train(processed_dataset) - self.model = deepcopy(self._model) # TODO: check that it works - self.model.costruct_item_net(processed_dataset) + self.torch_model = deepcopy(self._torch_model) # TODO: check that it works + self.torch_model.construct_item_net(processed_dataset) - self.trainer.fit(self.model, train_dataloader) - self.model = self.trainer.model + lightning_model = self.lightning_module_type(self.torch_model, self.lr, self.loss) + self.trainer = deepcopy(self._trainer) + self.trainer.fit(lightning_model, train_dataloader) def _custom_transform_dataset_u2i( self, dataset: Dataset, users: ExternalIds, on_unsupported_targets: ErrorBehaviour @@ -641,22 +686,21 @@ def _recommend_u2i( filter_viewed: bool, sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray], # model_internal ) -> InternalRecoTriplet: - if sorted_item_ids_to_recommend is None: # TODO: move to _get_sorted_item_ids_to_recommend sorted_item_ids_to_recommend = self.data_preparator.get_known_items_sorted_internal_ids() # model internal - self.model = self.model.eval() - self.model.to(self.device) + self.torch_model = self.torch_model.eval() + self.torch_model.to(self.device) # Dataset has already been filtered and adapted to known item_id_map recommend_dataloader = self.data_preparator.get_dataloader_recommend(dataset) session_embs = [] - item_embs = self.model.item_model.get_all_embeddings() # [n_items + 1, n_factors] + item_embs = self.torch_model.item_model.get_all_embeddings() # [n_items + 1, n_factors] with torch.no_grad(): for x_batch in tqdm.tqdm(recommend_dataloader): # TODO: from tqdm.auto import tqdm. Also check `verbose`` - x_batch = x_batch.to(self.device) # [batch_size, session_maxlen] - encoded = self.model.encode_sessions(x_batch, item_embs)[:, -1, :] # [batch_size, n_factors] + x_batch = x_batch.to(self.device) # [batch_size, session_max_len] + encoded = self.torch_model.encode_sessions(x_batch, item_embs)[:, -1, :] # [batch_size, n_factors] encoded = encoded.detach().cpu().numpy() session_embs.append(encoded) @@ -697,7 +741,9 @@ def _recommend_i2i( ) -> InternalRecoTriplet: if sorted_item_ids_to_recommend is None: sorted_item_ids_to_recommend = self.data_preparator.get_known_items_sorted_internal_ids() - item_embs = self.model.item_model.get_all_embeddings().detach().cpu().numpy() # [n_items + 1, n_factors] + + self.torch_model = self.torch_model.eval() + item_embs = self.torch_model.item_model.get_all_embeddings().detach().cpu().numpy() # [n_items + 1, n_factors] # TODO: i2i reco do not need filtering viewed. And user most of the times has GPU # Should we use torch dot and topk? Should be faster @@ -714,3 +760,8 @@ def _recommend_i2i( sorted_object_whitelist=sorted_item_ids_to_recommend, # model internal num_threads=0, ) + + @property + def lightning_model(self) -> SessionEncoderLightningModule: + """TODO""" + return self.trainer.lightning_module From 1700391284eaab4fb172b9ccf997626022885183 Mon Sep 17 00:00:00 2001 From: Andrey Semenov <43339130+In48semenov@users.noreply.github.com> Date: Tue, 1 Oct 2024 13:25:29 +0300 Subject: [PATCH 05/13] Feature/categories in item net (#191) --- examples/sasrec_metrics_comp.ipynb | 873 +++++++++++++++------ examples/tutorials/sasrec_tutorial.ipynb | 936 ++++++++++++++++++++--- rectools/dataset/features.py | 12 + rectools/models/sasrec.py | 188 ++++- 4 files changed, 1657 insertions(+), 352 deletions(-) diff --git a/examples/sasrec_metrics_comp.ipynb b/examples/sasrec_metrics_comp.ipynb index 3cba1fa8..9ed4963d 100644 --- a/examples/sasrec_metrics_comp.ipynb +++ b/examples/sasrec_metrics_comp.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -22,12 +22,12 @@ "from rectools.dataset import Dataset\n", "from rectools.metrics import MAP, calc_metrics, MeanInvUserFreq, Serendipity\n", "from rectools.models import ImplicitALSWrapperModel\n", - "from rectools.models.sasrec import SASRecModel" + "from rectools.models.sasrec import CatFeaturesItemNet, IdEmbeddingsItemNet, SASRecModel" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -114,22 +114,81 @@ "test_users_sasrec = test[Columns.User].unique()\n", "cold_users = set(test[Columns.User]) - set(train[Columns.User])\n", "test.drop(test[test[Columns.User].isin(cold_users)].index, inplace=True)\n", - "test_users = test[Columns.User].unique()\n", + "test_users = test[Columns.User].unique()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "items = pd.read_csv(DATA_PATH / 'items.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Process item features to the form of a flatten dataframe\n", + "items = items.loc[items[Columns.Item].isin(train[Columns.Item])].copy()\n", + "items[\"genre\"] = items[\"genres\"].str.lower().str.replace(\", \", \",\", regex=False).str.split(\",\")\n", + "genre_feature = items[[\"item_id\", \"genre\"]].explode(\"genre\")\n", + "genre_feature.columns = [\"id\", \"value\"]\n", + "genre_feature[\"feature\"] = \"genre\"\n", + "content_feature = items.reindex(columns=[Columns.Item, \"content_type\"])\n", + "content_feature.columns = [\"id\", \"value\"]\n", + "content_feature[\"feature\"] = \"content_type\"\n", + "item_features = pd.concat((genre_feature, content_feature))\n", "\n", - "catalog=train[Columns.Item].unique()\n" + "candidate_items = interactions['item_id'].drop_duplicates().astype(int)\n", + "test[\"user_id\"] = test[\"user_id\"].astype(int)\n", + "test[\"item_id\"] = test[\"item_id\"].astype(int)\n", + "\n", + "catalog=train[Columns.Item].unique()" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "dataset = Dataset.construct(\n", + "dataset_no_features = Dataset.construct(\n", + " interactions_df=train,\n", + ")\n", + "\n", + "dataset_item_features = Dataset.construct(\n", " interactions_df=train,\n", + " item_features_df=item_features,\n", + " cat_item_features=[\"genre\", \"content_type\"],\n", ")" ] }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "metrics_name = {\n", + " 'MAP': MAP,\n", + " 'MIUF': MeanInvUserFreq,\n", + " 'Serendipity': Serendipity\n", + " \n", + "\n", + "}\n", + "metrics = {}\n", + "for metric_name, metric in metrics_name.items():\n", + " for k in (1, 5, 10):\n", + " metrics[f'{metric_name}@{k}'] = metric(k=k)\n", + "\n", + "# list with metrics results of all models\n", + "features_results = []\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -139,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -155,7 +214,7 @@ "32" ] }, - "execution_count": 15, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -168,7 +227,23 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "session_maxlen=32" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### sasrec with item ids embeddings in ItemNetBlock" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -180,12 +255,11 @@ "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", - "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `pytorch_lightning` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n" + "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `pytorch_lightning` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n" ] } ], "source": [ - "session_maxlen=32\n", "model = SASRecModel(\n", " n_blocks=2,\n", " session_max_len=32,\n", @@ -193,12 +267,13 @@ " epochs=5,\n", " verbose=1,\n", " deterministic=True,\n", + " item_net_block_types=(IdEmbeddingsItemNet, ) # Use only item ids in ItemNetBlock\n", ")" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -215,13 +290,13 @@ "0 Non-trainable params\n", "927 K Total params\n", "3.709 Total estimated model params size (MB)\n", - "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a8549cea538d4078a6beddd33b1e1a2a", + "model_id": "00f2ec3343d24c3296e3b6e217689b84", "version_major": 2, "version_minor": 0 }, @@ -242,94 +317,74 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#%%time\n", - "model.fit(dataset)" + "model.fit(dataset_no_features)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:475: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/sasrec.py:635: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", - "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:406: UserWarning: \n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/base.py:406: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", " but some of given users are cold: they are not in the `dataset.user_id_map`\n", " \n", " warnings.warn(explanation)\n", - "100%|██████████| 740/740 [00:03<00:00, 237.27it/s]\n" + "100%|██████████| 740/740 [00:02<00:00, 251.43it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 26.9 s, sys: 5.41 s, total: 32.3 s\n", - "Wall time: 22.5 s\n" + "CPU times: user 23.3 s, sys: 3.2 s, total: 26.5 s\n", + "Wall time: 19.3 s\n" ] } ], "source": [ "%%time\n", - "recs = model.recommend(\n", - " users = test_users_sasrec, \n", - " dataset = dataset,\n", - " k = 10,\n", - " filter_viewed = True,\n", + "recos = model.recommend(\n", + " users=test_users_sasrec, \n", + " dataset=dataset_no_features,\n", + " k=10,\n", + " filter_viewed=True,\n", " on_unsupported_targets=\"warn\"\n", ")" ] }, { "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "metrics_name = {\n", - " 'MAP': MAP,\n", - " 'MIUF': MeanInvUserFreq,\n", - " 'Serendipity': Serendipity\n", - " \n", - "\n", - "}\n", - "metrics = {}\n", - "for metric_name, metric in metrics_name.items():\n", - " for k in (1, 5, 10):\n", - " metrics[f'{metric_name}@{k}'] = metric(k=k)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "recs[\"item_id\"] = recs[\"item_id\"].apply(str)\n", + "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", - "features_results = []\n", - "metric_values = calc_metrics(metrics, recs[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", - "metric_values[\"model\"] = \"sasrec\"\n", + "metric_values = calc_metrics(metrics, recos[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", + "metric_values[\"model\"] = \"sasrec_ids\"\n", "features_results.append(metric_values)" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -459,20 +514,328 @@ "[947050 rows x 4 columns]" ] }, - "execution_count": 21, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# major recommend\n", - "recs.sort_values([\"user_id\", \"rank\"])" + "recos.sort_values([\"user_id\", \"rank\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### sasrec with item ids and category features embeddings in ItemNetBlock" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "model = SASRecModel(\n", + " n_blocks=2,\n", + " session_max_len=32,\n", + " lr=1e-3,\n", + " epochs=5,\n", + " verbose=1,\n", + " deterministic=True,\n", + " item_net_block_types=(IdEmbeddingsItemNet, CatFeaturesItemNet) # Use item ids and cat features in ItemNetBlock\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------------------------\n", + "0 | torch_model | TransformerBasedSessionEncoder | 935 K \n", + "---------------------------------------------------------------\n", + "935 K Trainable params\n", + "0 Non-trainable params\n", + "935 K Total params\n", + "3.742 Total estimated model params size (MB)\n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e2c708eb62314805b5c49e8b20e9b0ef", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#%%time\n", + "model.fit(dataset_item_features)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/sasrec.py:635: UserWarning: 91202 target users were considered cold because of missing known items\n", + " warnings.warn(explanation)\n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/base.py:406: UserWarning: \n", + " Model `` doesn't support recommendations for cold users,\n", + " but some of given users are cold: they are not in the `dataset.user_id_map`\n", + " \n", + " warnings.warn(explanation)\n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", + " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", + "100%|██████████| 740/740 [00:05<00:00, 147.19it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 27 s, sys: 3.07 s, total: 30.1 s\n", + "Wall time: 25.4 s\n" + ] + } + ], + "source": [ + "%%time\n", + "recos = model.recommend(\n", + " users=test_users_sasrec, \n", + " dataset=dataset_item_features,\n", + " k=10,\n", + " filter_viewed=True,\n", + " on_unsupported_targets=\"warn\"\n", + ")" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, + "outputs": [], + "source": [ + "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", + "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", + "metric_values = calc_metrics(metrics, recos[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", + "metric_values[\"model\"] = \"sasrec_ids_cat\"\n", + "features_results.append(metric_values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### sasrec with category item features embeddings in ItemNetBlock" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "model = SASRecModel(\n", + " n_blocks=2,\n", + " session_max_len=32,\n", + " lr=1e-3,\n", + " epochs=5,\n", + " verbose=1,\n", + " deterministic=True,\n", + " item_net_block_types=(CatFeaturesItemNet, ) # Use only cat item features in ItemNetBlock\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------------------------\n", + "0 | torch_model | TransformerBasedSessionEncoder | 211 K \n", + "---------------------------------------------------------------\n", + "211 K Trainable params\n", + "0 Non-trainable params\n", + "211 K Total params\n", + "0.847 Total estimated model params size (MB)\n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2b530ea90b93478e998efd1001127679", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#%%time\n", + "model.fit(dataset_item_features)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/sasrec.py:635: UserWarning: 91202 target users were considered cold because of missing known items\n", + " warnings.warn(explanation)\n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/base.py:406: UserWarning: \n", + " Model `` doesn't support recommendations for cold users,\n", + " but some of given users are cold: they are not in the `dataset.user_id_map`\n", + " \n", + " warnings.warn(explanation)\n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", + " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", + "100%|██████████| 740/740 [00:03<00:00, 190.30it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 27.4 s, sys: 3.19 s, total: 30.6 s\n", + "Wall time: 25.3 s\n" + ] + } + ], + "source": [ + "%%time\n", + "recos = model.recommend(\n", + " users=test_users_sasrec, \n", + " dataset=dataset_item_features,\n", + " k=10,\n", + " filter_viewed=True,\n", + " on_unsupported_targets=\"warn\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", + "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", + "metric_values = calc_metrics(metrics, recos[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", + "metric_values[\"model\"] = \"sasrec_cat\"\n", + "features_results.append(metric_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, "outputs": [ { "data": { @@ -486,10 +849,30 @@ " 'Serendipity@1': 0.10074441687344914,\n", " 'Serendipity@5': 0.06064590171647837,\n", " 'Serendipity@10': 0.04443191713787037,\n", - " 'model': 'sasrec'}]" + " 'model': 'sasrec_ids'},\n", + " {'MAP@1': 0.048234298055477735,\n", + " 'MAP@5': 0.08192462506032493,\n", + " 'MAP@10': 0.09101495299417822,\n", + " 'MIUF@1': 18.824620072061013,\n", + " 'MIUF@5': 18.824620072061013,\n", + " 'MIUF@10': 18.824620072061013,\n", + " 'Serendipity@1': 0.0989599281980888,\n", + " 'Serendipity@5': 0.06013060657890493,\n", + " 'Serendipity@10': 0.044194283863380424,\n", + " 'model': 'sasrec_ids_cat'},\n", + " {'MAP@1': 0.0017264182022730505,\n", + " 'MAP@5': 0.006089300504524266,\n", + " 'MAP@10': 0.007153018046864342,\n", + " 'MIUF@1': 18.824620072061013,\n", + " 'MIUF@5': 18.824620072061013,\n", + " 'MIUF@10': 18.824620072061013,\n", + " 'Serendipity@1': 0.005543529908663745,\n", + " 'Serendipity@5': 0.006284975924895983,\n", + " 'Serendipity@10': 0.005200095825788708,\n", + " 'model': 'sasrec_cat'}]" ] }, - "execution_count": 22, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -507,7 +890,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -516,32 +899,40 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.39 s, sys: 301 ms, total: 1.7 s\n", - "Wall time: 1.19 s\n" + "CPU times: user 1.58 s, sys: 307 ms, total: 1.88 s\n", + "Wall time: 1.37 s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", + " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n" ] } ], "source": [ "%%time\n", - "recs = model.recommend_to_items(\n", - " target_items = target_items, \n", - " dataset = dataset,\n", - " k = 10,\n", - " filter_itself = True,\n", + "recos = model.recommend_to_items(\n", + " target_items=target_items, \n", + " dataset=dataset,\n", + " k=10,\n", + " filter_itself=True,\n", " items_to_recommend=None, #white_list,\n", ")" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -575,211 +966,211 @@ " \n", " 0\n", " 13865\n", - " 9728\n", - " 0.753347\n", + " 15648\n", + " 1.000000\n", " 1\n", " \n", " \n", " 1\n", " 13865\n", - " 4151\n", - " 0.740239\n", + " 3386\n", + " 1.000000\n", " 2\n", " \n", " \n", " 2\n", " 13865\n", - " 3734\n", - " 0.716284\n", + " 147\n", + " 0.898218\n", " 3\n", " \n", " \n", " 3\n", " 13865\n", - " 6809\n", - " 0.673116\n", + " 16194\n", + " 0.898218\n", " 4\n", " \n", " \n", " 4\n", " 13865\n", - " 142\n", - " 0.650436\n", + " 12309\n", + " 0.898218\n", " 5\n", " \n", " \n", " 5\n", " 13865\n", - " 1844\n", - " 0.646556\n", + " 12586\n", + " 0.898218\n", " 6\n", " \n", " \n", " 6\n", " 13865\n", - " 7571\n", - " 0.645828\n", + " 6661\n", + " 0.898218\n", " 7\n", " \n", " \n", " 7\n", " 13865\n", - " 15297\n", - " 0.624771\n", + " 2255\n", + " 0.898218\n", " 8\n", " \n", " \n", " 8\n", " 13865\n", - " 8636\n", - " 0.623193\n", + " 3792\n", + " 0.898218\n", " 9\n", " \n", " \n", " 9\n", " 13865\n", - " 10440\n", - " 0.582206\n", + " 4130\n", + " 0.898218\n", " 10\n", " \n", " \n", " 10\n", " 4457\n", - " 9728\n", - " 0.696166\n", + " 5109\n", + " 1.000000\n", " 1\n", " \n", " \n", " 11\n", " 4457\n", - " 3734\n", - " 0.671879\n", + " 8851\n", + " 1.000000\n", " 2\n", " \n", " \n", " 12\n", " 4457\n", - " 142\n", - " 0.666478\n", + " 8486\n", + " 1.000000\n", " 3\n", " \n", " \n", " 13\n", " 4457\n", - " 8636\n", - " 0.663968\n", + " 12087\n", + " 1.000000\n", " 4\n", " \n", " \n", " 14\n", " 4457\n", - " 6809\n", - " 0.642703\n", + " 2313\n", + " 1.000000\n", " 5\n", " \n", " \n", " 15\n", " 4457\n", - " 4151\n", - " 0.630168\n", + " 11977\n", + " 1.000000\n", " 6\n", " \n", " \n", " 16\n", " 4457\n", - " 1844\n", - " 0.625282\n", + " 7928\n", + " 1.000000\n", " 7\n", " \n", " \n", " 17\n", " 4457\n", - " 7571\n", - " 0.618641\n", + " 3384\n", + " 1.000000\n", " 8\n", " \n", " \n", " 18\n", " 4457\n", - " 4436\n", - " 0.609893\n", + " 11513\n", + " 1.000000\n", " 9\n", " \n", " \n", " 19\n", " 4457\n", - " 2657\n", - " 0.580729\n", + " 6285\n", + " 1.000000\n", " 10\n", " \n", " \n", " 20\n", " 15297\n", - " 3734\n", - " 0.710078\n", + " 8723\n", + " 1.000000\n", " 1\n", " \n", " \n", " 21\n", " 15297\n", - " 9728\n", - " 0.690739\n", + " 5926\n", + " 1.000000\n", " 2\n", " \n", " \n", " 22\n", " 15297\n", - " 10440\n", - " 0.670369\n", + " 4131\n", + " 1.000000\n", " 3\n", " \n", " \n", " 23\n", " 15297\n", - " 6809\n", - " 0.640465\n", + " 4229\n", + " 1.000000\n", " 4\n", " \n", " \n", " 24\n", " 15297\n", - " 142\n", - " 0.638514\n", + " 7005\n", + " 1.000000\n", " 5\n", " \n", " \n", " 25\n", " 15297\n", - " 2657\n", - " 0.626880\n", + " 10797\n", + " 1.000000\n", " 6\n", " \n", " \n", " 26\n", " 15297\n", - " 13865\n", - " 0.624771\n", + " 10535\n", + " 1.000000\n", " 7\n", " \n", " \n", " 27\n", " 15297\n", - " 8636\n", - " 0.609769\n", + " 5400\n", + " 1.000000\n", " 8\n", " \n", " \n", " 28\n", " 15297\n", - " 4151\n", - " 0.601706\n", + " 4716\n", + " 1.000000\n", " 9\n", " \n", " \n", " 29\n", " 15297\n", - " 1844\n", - " 0.581799\n", + " 13103\n", + " 1.000000\n", " 10\n", " \n", " \n", @@ -788,45 +1179,45 @@ ], "text/plain": [ " target_item_id item_id score rank\n", - "0 13865 9728 0.753347 1\n", - "1 13865 4151 0.740239 2\n", - "2 13865 3734 0.716284 3\n", - "3 13865 6809 0.673116 4\n", - "4 13865 142 0.650436 5\n", - "5 13865 1844 0.646556 6\n", - "6 13865 7571 0.645828 7\n", - "7 13865 15297 0.624771 8\n", - "8 13865 8636 0.623193 9\n", - "9 13865 10440 0.582206 10\n", - "10 4457 9728 0.696166 1\n", - "11 4457 3734 0.671879 2\n", - "12 4457 142 0.666478 3\n", - "13 4457 8636 0.663968 4\n", - "14 4457 6809 0.642703 5\n", - "15 4457 4151 0.630168 6\n", - "16 4457 1844 0.625282 7\n", - "17 4457 7571 0.618641 8\n", - "18 4457 4436 0.609893 9\n", - "19 4457 2657 0.580729 10\n", - "20 15297 3734 0.710078 1\n", - "21 15297 9728 0.690739 2\n", - "22 15297 10440 0.670369 3\n", - "23 15297 6809 0.640465 4\n", - "24 15297 142 0.638514 5\n", - "25 15297 2657 0.626880 6\n", - "26 15297 13865 0.624771 7\n", - "27 15297 8636 0.609769 8\n", - "28 15297 4151 0.601706 9\n", - "29 15297 1844 0.581799 10" + "0 13865 15648 1.000000 1\n", + "1 13865 3386 1.000000 2\n", + "2 13865 147 0.898218 3\n", + "3 13865 16194 0.898218 4\n", + "4 13865 12309 0.898218 5\n", + "5 13865 12586 0.898218 6\n", + "6 13865 6661 0.898218 7\n", + "7 13865 2255 0.898218 8\n", + "8 13865 3792 0.898218 9\n", + "9 13865 4130 0.898218 10\n", + "10 4457 5109 1.000000 1\n", + "11 4457 8851 1.000000 2\n", + "12 4457 8486 1.000000 3\n", + "13 4457 12087 1.000000 4\n", + "14 4457 2313 1.000000 5\n", + "15 4457 11977 1.000000 6\n", + "16 4457 7928 1.000000 7\n", + "17 4457 3384 1.000000 8\n", + "18 4457 11513 1.000000 9\n", + "19 4457 6285 1.000000 10\n", + "20 15297 8723 1.000000 1\n", + "21 15297 5926 1.000000 2\n", + "22 15297 4131 1.000000 3\n", + "23 15297 4229 1.000000 4\n", + "24 15297 7005 1.000000 5\n", + "25 15297 10797 1.000000 6\n", + "26 15297 10535 1.000000 7\n", + "27 15297 5400 1.000000 8\n", + "28 15297 4716 1.000000 9\n", + "29 15297 13103 1.000000 10" ] }, - "execution_count": 25, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "recs" + "recos" ] }, { @@ -838,17 +1229,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ - "users = pd.read_csv(DATA_PATH / 'users.csv')\n", - "items = pd.read_csv(DATA_PATH / 'items.csv')" + "users = pd.read_csv(DATA_PATH / 'users.csv')" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -861,35 +1251,15 @@ " feature_frame.columns = [\"id\", \"value\"]\n", " feature_frame[\"feature\"] = feature\n", " user_features_frames.append(feature_frame)\n", - "user_features = pd.concat(user_features_frames)\n", - "\n", - "# Process item features to the form of a flatten dataframe\n", - "items = items.loc[items[Columns.Item].isin(train[Columns.Item])].copy()\n", - "items[\"genre\"] = items[\"genres\"].str.lower().str.replace(\", \", \",\", regex=False).str.split(\",\")\n", - "genre_feature = items[[\"item_id\", \"genre\"]].explode(\"genre\")\n", - "genre_feature.columns = [\"id\", \"value\"]\n", - "genre_feature[\"feature\"] = \"genre\"\n", - "content_feature = items.reindex(columns=[Columns.Item, \"content_type\"])\n", - "content_feature.columns = [\"id\", \"value\"]\n", - "content_feature[\"feature\"] = \"content_type\"\n", - "item_features = pd.concat((genre_feature, content_feature))\n", - "\n", - "candidate_items = interactions['item_id'].drop_duplicates().astype(int)\n", - "test[\"user_id\"] = test[\"user_id\"].astype(int)\n", - "test[\"item_id\"] = test[\"item_id\"].astype(int)\n", - "catalog=train[Columns.Item].unique()" + "user_features = pd.concat(user_features_frames)" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ - "dataset_no_features = Dataset.construct(\n", - " interactions_df=train,\n", - ")\n", - "\n", "dataset_full_features = Dataset.construct(\n", " interactions_df=train,\n", " user_features_df=user_features,\n", @@ -901,7 +1271,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -910,7 +1280,7 @@ "RANDOM_STATE = 32\n", "ITERATIONS = 10\n", "\n", - "def make_base_model(factors: int, regularization: float, alpha: float, fit_features_together: bool=False):\n", + "def make_base_model(factors: int, regularization: float, alpha: float, fit_features_together: bool = False):\n", " return ImplicitALSWrapperModel(\n", " AlternatingLeastSquares(\n", " factors=factors,\n", @@ -918,15 +1288,15 @@ " alpha=alpha,\n", " random_state=RANDOM_STATE,\n", " use_gpu=False,\n", - " num_threads = NUM_THREADS,\n", + " num_threads=NUM_THREADS,\n", " iterations=ITERATIONS),\n", - " fit_features_together = fit_features_together,\n", + " fit_features_together=fit_features_together,\n", " )" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -943,6 +1313,8 @@ " filter_viewed=True,\n", " on_unsupported_targets=\"warn\"\n", ")\n", + "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", + "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", "metric_values = calc_metrics(metrics, recos, test, train, catalog)\n", "metric_values[\"model\"] = \"no_features_factors_128_alpha_10_reg_0.5\"\n", "features_results.append(metric_values)" @@ -950,20 +1322,20 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/Tasks/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n" ] } ], "source": [ - "model = make_base_model(factors = n_factors, regularization=regularization, alpha=alpha, fit_features_together=True)\n", + "model = make_base_model(factors=n_factors, regularization=regularization, alpha=alpha, fit_features_together=True)\n", "model.fit(dataset_full_features)\n", "recos = model.recommend(\n", " users=test_users.astype(int),\n", @@ -972,6 +1344,8 @@ " filter_viewed=True,\n", " on_unsupported_targets=\"warn\"\n", ")\n", + "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", + "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", "metric_values = calc_metrics(metrics, recos, test, train, catalog)\n", "metric_values[\"model\"] = \"full_features_factors_128_fit_together_True\"\n", "features_results.append(metric_values)" @@ -979,7 +1353,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 48, "metadata": {}, "outputs": [ { @@ -1028,40 +1402,64 @@ " \n", " \n", " \n", - " sasrec\n", + " sasrec_ids\n", " 0.048967\n", " 0.082847\n", " 0.092022\n", - " 18.824620\n", - " 18.824620\n", - " 18.824620\n", + " 18.82462\n", + " 18.82462\n", + " 18.82462\n", " 0.100744\n", " 0.060646\n", " 0.044432\n", " \n", " \n", + " sasrec_ids_cat\n", + " 0.048234\n", + " 0.081925\n", + " 0.091015\n", + " 18.82462\n", + " 18.82462\n", + " 18.82462\n", + " 0.098960\n", + " 0.060131\n", + " 0.044194\n", + " \n", + " \n", " full_features_factors_128_fit_together_True\n", " 0.033850\n", " 0.056586\n", " 0.062547\n", - " 4.340709\n", - " 5.339626\n", - " 6.045144\n", - " 0.000438\n", - " 0.000462\n", - " 0.000461\n", + " 18.82462\n", + " 18.82462\n", + " 18.82462\n", + " 0.070039\n", + " 0.042134\n", + " 0.030772\n", " \n", " \n", " no_features_factors_128_alpha_10_reg_0.5\n", " 0.015523\n", " 0.028465\n", " 0.032814\n", - " 6.603868\n", - " 6.943141\n", - " 7.146539\n", - " 0.001046\n", - " 0.000904\n", - " 0.000815\n", + " 18.82462\n", + " 18.82462\n", + " 18.82462\n", + " 0.036070\n", + " 0.025459\n", + " 0.020493\n", + " \n", + " \n", + " sasrec_cat\n", + " 0.001726\n", + " 0.006089\n", + " 0.007153\n", + " 18.82462\n", + " 18.82462\n", + " 18.82462\n", + " 0.005544\n", + " 0.006285\n", + " 0.005200\n", " \n", " \n", "\n", @@ -1070,30 +1468,38 @@ "text/plain": [ " MAP@1 MAP@5 MAP@10 \\\n", "model \n", - "sasrec 0.048967 0.082847 0.092022 \n", + "sasrec_ids 0.048967 0.082847 0.092022 \n", + "sasrec_ids_cat 0.048234 0.081925 0.091015 \n", "full_features_factors_128_fit_together_True 0.033850 0.056586 0.062547 \n", "no_features_factors_128_alpha_10_reg_0.5 0.015523 0.028465 0.032814 \n", + "sasrec_cat 0.001726 0.006089 0.007153 \n", "\n", - " MIUF@1 MIUF@5 MIUF@10 \\\n", - "model \n", - "sasrec 18.824620 18.824620 18.824620 \n", - "full_features_factors_128_fit_together_True 4.340709 5.339626 6.045144 \n", - "no_features_factors_128_alpha_10_reg_0.5 6.603868 6.943141 7.146539 \n", + " MIUF@1 MIUF@5 MIUF@10 \\\n", + "model \n", + "sasrec_ids 18.82462 18.82462 18.82462 \n", + "sasrec_ids_cat 18.82462 18.82462 18.82462 \n", + "full_features_factors_128_fit_together_True 18.82462 18.82462 18.82462 \n", + "no_features_factors_128_alpha_10_reg_0.5 18.82462 18.82462 18.82462 \n", + "sasrec_cat 18.82462 18.82462 18.82462 \n", "\n", " Serendipity@1 Serendipity@5 \\\n", "model \n", - "sasrec 0.100744 0.060646 \n", - "full_features_factors_128_fit_together_True 0.000438 0.000462 \n", - "no_features_factors_128_alpha_10_reg_0.5 0.001046 0.000904 \n", + "sasrec_ids 0.100744 0.060646 \n", + "sasrec_ids_cat 0.098960 0.060131 \n", + "full_features_factors_128_fit_together_True 0.070039 0.042134 \n", + "no_features_factors_128_alpha_10_reg_0.5 0.036070 0.025459 \n", + "sasrec_cat 0.005544 0.006285 \n", "\n", " Serendipity@10 \n", "model \n", - "sasrec 0.044432 \n", - "full_features_factors_128_fit_together_True 0.000461 \n", - "no_features_factors_128_alpha_10_reg_0.5 0.000815 " + "sasrec_ids 0.044432 \n", + "sasrec_ids_cat 0.044194 \n", + "full_features_factors_128_fit_together_True 0.030772 \n", + "no_features_factors_128_alpha_10_reg_0.5 0.020493 \n", + "sasrec_cat 0.005200 " ] }, - "execution_count": 24, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } @@ -1107,13 +1513,6 @@ "features_df" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": null, @@ -1124,9 +1523,9 @@ ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "rectools_origin", "language": "python", - "name": "python3" + "name": "rectools_origin" }, "language_info": { "codemirror_mode": { @@ -1138,7 +1537,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.9.12" } }, "nbformat": 4, diff --git a/examples/tutorials/sasrec_tutorial.ipynb b/examples/tutorials/sasrec_tutorial.ipynb index 8f8dc929..c49a9d72 100644 --- a/examples/tutorials/sasrec_tutorial.ipynb +++ b/examples/tutorials/sasrec_tutorial.ipynb @@ -19,6 +19,9 @@ "* RecTools implementation\n", " * Additional details\n", "* Model application\n", + " * SASRec with item ids embeddings in ItemNetBlock\n", + " * SASRec with item ids and category features embeddings in ItemNetBlock\n", + " * SASRec with category item features embeddings in ItemNetBlock\n", " * Additional details\n", "* Under the hood: Dataset processing\n", "* Under the hood: Transformer layers\n", @@ -28,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -36,13 +39,14 @@ "import os\n", "import pandas as pd\n", "import torch\n", + "import typing as tp\n", "\n", "from lightning_fabric import seed_everything\n", "from pathlib import Path\n", "\n", "from rectools import Columns\n", "from rectools.dataset import Dataset\n", - "from rectools.models.sasrec import SasRecModel\n", + "from rectools.models.sasrec import CatFeaturesItemNet, IdEmbeddingsItemNet, SASRecModel\n", "\n", "# Enable deterministic behaviour with CUDA >= 10.2\n", "os.environ[\"CUBLAS_WORKSPACE_CONFIG\"] = \":4096:8\"" @@ -64,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -78,8 +82,8 @@ " inflating: __MACOSX/data_en/._interactions.csv \n", " inflating: data_en/users_en.csv \n", " inflating: __MACOSX/data_en/._users_en.csv \n", - "CPU times: user 83.8 ms, sys: 44.4 ms, total: 128 ms\n", - "Wall time: 5.51 s\n" + "CPU times: user 73.6 ms, sys: 46.7 ms, total: 120 ms\n", + "Wall time: 4.07 s\n" ] } ], @@ -92,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -157,7 +161,7 @@ "1 699317 1659 2021-05-29 8317 100.0" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -176,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -238,7 +242,7 @@ "1 699317 1659 2021-05-29 3" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -253,13 +257,256 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(15963, 16)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
item_idcontent_typetitletitle_origrelease_yeargenrescountriesfor_kidsage_ratingstudiosdescriptionkeywordsactors_translatedactors_transliterateddirectors_translatedtransliterated
010711filmTalk to herHable con ella2002.0drama, foreign, detective, melodramaSpainNaN16.0NaNMarco, a journalist, interviews the famous Tor...Talk, her, 2002, Spain, friends, love, strong,...Adolfo Fernández, Ana Fernández, Dario Grandin...Adol'fo Fernandes, Ana Fernandes, Dario Grandi...Pedro AlmodovarPedro Al'modovar
12508filmNaked PeppersSearch Party2014.0foreign, adventure, comedyUSANaN16.0NaNThe main character has learned not to invite h...Naked, Peppers, 2014, USA, friends, weddings, ...Adam Palley, Brian Huskey, JB Smoove, Jason Ma...Adam Palli, Brajan Haski, Dzh.B. Smuv, Dzhejso...Scott ArmstrongSkot Armstrong
\n", + "
" + ], + "text/plain": [ + " item_id content_type title title_orig release_year \\\n", + "0 10711 film Talk to her Hable con ella 2002.0 \n", + "1 2508 film Naked Peppers Search Party 2014.0 \n", + "\n", + " genres countries for_kids age_rating \\\n", + "0 drama, foreign, detective, melodrama Spain NaN 16.0 \n", + "1 foreign, adventure, comedy USA NaN 16.0 \n", + "\n", + " studios description \\\n", + "0 NaN Marco, a journalist, interviews the famous Tor... \n", + "1 NaN The main character has learned not to invite h... \n", + "\n", + " keywords \\\n", + "0 Talk, her, 2002, Spain, friends, love, strong,... \n", + "1 Naked, Peppers, 2014, USA, friends, weddings, ... \n", + "\n", + " actors_translated \\\n", + "0 Adolfo Fernández, Ana Fernández, Dario Grandin... \n", + "1 Adam Palley, Brian Huskey, JB Smoove, Jason Ma... \n", + "\n", + " actors_transliterated directors_translated \\\n", + "0 Adol'fo Fernandes, Ana Fernandes, Dario Grandi... Pedro Almodovar \n", + "1 Adam Palli, Brajan Haski, Dzh.B. Smuv, Dzhejso... Scott Armstrong \n", + "\n", + " transliterated \n", + "0 Pedro Al'modovar \n", + "1 Skot Armstrong " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(items.shape)\n", + "items.head(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Process item features\n", + "items = items.loc[items[Columns.Item].isin(interactions[Columns.Item])].copy()\n", + "# items = items.loc[items[Columns.Item].isin(interactions[~interactions.isin(test_user)][Columns.Item])].copy()\n", + "items[\"genre\"] = items[\"genres\"].str.lower().str.replace(\", \", \",\", regex=False).str.split(\",\")\n", + "genre_feature = items[[\"item_id\", \"genre\"]].explode(\"genre\")\n", + "genre_feature.columns = [\"id\", \"value\"]\n", + "genre_feature[\"feature\"] = \"genre\"\n", + "content_feature = items.reindex(columns=[Columns.Item, \"content_type\"])\n", + "content_feature.columns = [\"id\", \"value\"]\n", + "content_feature[\"feature\"] = \"content_type\"\n", + "item_features = pd.concat((genre_feature, content_feature))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idvaluefeature
010711dramagenre
010711foreigngenre
010711detectivegenre
010711melodramagenre
12508foreigngenre
\n", + "
" + ], + "text/plain": [ + " id value feature\n", + "0 10711 drama genre\n", + "0 10711 foreign genre\n", + "0 10711 detective genre\n", + "0 10711 melodrama genre\n", + "1 2508 foreign genre" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "item_features.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "# Create dataset \n", - "dataset = Dataset.construct(\n", + "# Create datasets\n", + "dataset_no_features = Dataset.construct(\n", + " interactions_df=interactions,\n", + ")\n", + "\n", + "dataset_item_features = Dataset.construct(\n", " interactions_df=interactions,\n", + " item_features_df=item_features,\n", + " cat_item_features=[\"genre\", \"content_type\"],\n", ")" ] }, @@ -322,6 +569,13 @@ "Current implementation uses architecture offered by the authors of original article. In contrast to original model, only cross-entropy loss is supported and no negative sampling is provided. However, in the future versions more loss functions are expected." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**TODO: Add category item features emebeddings**" + ] + }, { "attachments": { "image.png": { @@ -354,7 +608,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -370,7 +624,7 @@ "60" ] }, - "execution_count": 6, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -383,7 +637,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -445,7 +699,7 @@ "3815 176549 15469 2021-05-25 3" ] }, - "execution_count": 7, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -466,15 +720,50 @@ "* Specify number of attention heads with `n_heads`\n", "* Specify `dropout_rate`\n", "* Specify whether positional encoding should be used with `use_pos_emb`\n", - "* Specify maximum length of user-item interaction history with `session_maxlen`\n", + "* Specify maximum length of user-item interaction history with `session_max_len`\n", "* Specify `lr` for learning rate \n", "* Specify `batch_size`\n", - "* Specify `epochs` for number of model training epochs" + "* Specify `epochs` for number of model training epochs\n", + "* Specify `item_net_block_types` for Item Net blocks" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "n_factors=128\n", + "session_max_len=32" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def recommend(model: SASRecModel, test_user: tp.List[int], dataset: Dataset, k: int, filter_view: bool, on_unsupported_targets: str) -> pd.DataFrame:\n", + " recos = model.recommend(\n", + " users=test_user, \n", + " dataset=dataset,\n", + " k=k,\n", + " filter_viewed=filter_view,\n", + " on_unsupported_targets=on_unsupported_targets,\n", + " )\n", + " return recos.merge(items[[\"item_id\", \"title_orig\"]], on=\"item_id\").sort_values([\"user_id\", \"rank\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SASRec with item ids embeddings in ItemNetBlock" + ] + }, + { + "cell_type": "code", + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -486,20 +775,18 @@ "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", - "/data/home/maspirina1/Tasks/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `pytorch_lightning` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n" + "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `pytorch_lightning` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n" ] } ], "source": [ - "factors=128\n", - "session_maxlen=32\n", - "model = SasRecModel(\n", - " n_factors=factors, \n", + "model = SASRecModel(\n", + " n_factors=n_factors, \n", " n_blocks=2,\n", " n_heads=1,\n", " dropout_rate=0.2,\n", " use_pos_emb=True,\n", - " session_maxlen=session_maxlen,\n", + " session_max_len=session_max_len,\n", " lr=1e-3,\n", " batch_size=128,\n", " epochs=5,\n", @@ -507,12 +794,13 @@ " loss=\"softmax\",\n", " verbose=1,\n", " deterministic=True,\n", + " item_net_block_types=(IdEmbeddingsItemNet, ) # Use only item ids in ItemNetBlock\n", ")" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -523,20 +811,19 @@ "\n", " | Name | Type | Params\n", "---------------------------------------------------------------\n", - "0 | loss_func | CrossEntropyLoss | 0 \n", - "1 | torch_model | TransformerBasedSessionEncoder | 2.1 M \n", + "0 | torch_model | TransformerBasedSessionEncoder | 2.1 M \n", "---------------------------------------------------------------\n", "2.1 M Trainable params\n", "0 Non-trainable params\n", "2.1 M Total params\n", "8.207 Total estimated model params size (MB)\n", - "/data/home/maspirina1/Tasks/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2f8d8fadf85a48438d76510422437065", + "model_id": "7ef9f4c7e8db4cf099d29151db02acc4", "version_major": 2, "version_minor": 0 }, @@ -558,44 +845,44 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 10min 11s, sys: 15 s, total: 10min 26s\n", - "Wall time: 10min 13s\n" + "CPU times: user 12min 11s, sys: 20 s, total: 12min 31s\n", + "Wall time: 12min 23s\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%%time\n", - "model.fit(dataset)" + "model.fit(dataset_no_features)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1/1 [00:00<00:00, 28.36it/s]" + "100%|██████████| 1/1 [00:00<00:00, 22.21it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 670 ms, sys: 1.19 s, total: 1.86 s\n", - "Wall time: 342 ms\n" + "CPU times: user 818 ms, sys: 1.54 s, total: 2.36 s\n", + "Wall time: 489 ms\n" ] }, { @@ -669,48 +956,492 @@ "2 176549 15266 2.686491 3 Monsters University" ] }, - "execution_count": 10, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%%time\n", - "recos = model.recommend(\n", - " users = test_user, \n", - " dataset = dataset,\n", - " k = 3,\n", - " filter_viewed = True,\n", + "recommend(\n", + " model=model,\n", + " test_user=test_user,\n", + " dataset=dataset_no_features,\n", + " k=3,\n", + " filter_view=True,\n", " on_unsupported_targets=\"warn\",\n", - ")\n", - "recos.merge(items[[\"item_id\", \"title_orig\"]], on=\"item_id\").sort_values([\"user_id\", \"rank\"])" + ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Additional details\n", - "It may happen that SASRec filters out users with less than 2 interactions during train stage, as target is a shifted interaction sequence. However, it is still possible to make recommendations for user with one interaction in history if this interaction item was present at training.\n", - "\n", - "As an example consider user 324373, for whom there is only one interaction in the dataset." + "### SASRec with item ids and category features embeddings in ItemNetBlock" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "model = SASRecModel(\n", + " n_factors=n_factors, \n", + " n_blocks=2,\n", + " n_heads=1,\n", + " dropout_rate=0.2,\n", + " use_pos_emb=True,\n", + " session_max_len=session_max_len,\n", + " lr=1e-3,\n", + " batch_size=128,\n", + " epochs=5,\n", + " device=\"cuda:1\",\n", + " loss=\"softmax\",\n", + " verbose=1,\n", + " deterministic=True,\n", + " item_net_block_types=(IdEmbeddingsItemNet, CatFeaturesItemNet) # Use item ids and cat features in ItemNetBlock\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------------------------\n", + "0 | torch_model | TransformerBasedSessionEncoder | 2.1 M \n", + "---------------------------------------------------------------\n", + "2.1 M Trainable params\n", + "0 Non-trainable params\n", + "2.1 M Total params\n", + "8.288 Total estimated model params size (MB)\n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5202a77c2a004c3ca9b01c37e90e946a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "model.fit(dataset_item_features)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", + " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", + "100%|██████████| 1/1 [00:00<00:00, 217.36it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 528 ms, sys: 561 ms, total: 1.09 s\n", + "Wall time: 209 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_idscoreranktitle_orig
0176549129653.7080241Cars 3
1176549117493.3445212Incredibles 2
217654967743.3214123Cars 2
\n", + "
" + ], + "text/plain": [ + " user_id item_id score rank title_orig\n", + "0 176549 12965 3.708024 1 Cars 3\n", + "1 176549 11749 3.344521 2 Incredibles 2\n", + "2 176549 6774 3.321412 3 Cars 2" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "recommend(\n", + " model=model,\n", + " test_user=test_user,\n", + " dataset=dataset_item_features,\n", + " k=3,\n", + " filter_view=True,\n", + " on_unsupported_targets=\"warn\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SASRec with category item features embeddings in ItemNetBlock" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "model = SASRecModel(\n", + " n_factors=n_factors, \n", + " n_blocks=2,\n", + " n_heads=1,\n", + " dropout_rate=0.2,\n", + " use_pos_emb=True,\n", + " session_max_len=session_max_len,\n", + " lr=1e-3,\n", + " batch_size=128,\n", + " epochs=5,\n", + " device=\"cuda:1\",\n", + " loss=\"softmax\",\n", + " verbose=1,\n", + " deterministic=True,\n", + " item_net_block_types=(CatFeaturesItemNet, ) # Use only cat item features in ItemNetBlock\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------------------------\n", + "0 | torch_model | TransformerBasedSessionEncoder | 223 K \n", + "---------------------------------------------------------------\n", + "223 K Trainable params\n", + "0 Non-trainable params\n", + "223 K Total params\n", + "0.895 Total estimated model params size (MB)\n", + "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2de8ecaef7134980b3507d37236e0a18", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "model.fit(dataset_item_features)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", + " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", + "100%|██████████| 1/1 [00:00<00:00, 222.04it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 531 ms, sys: 512 ms, total: 1.04 s\n", + "Wall time: 128 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_idscoreranktitle_orig
0176549854.6132781Turbo
1176549128734.3739792Spies in Disguise
217654962144.0657713Early Man
\n", + "
" + ], + "text/plain": [ + " user_id item_id score rank title_orig\n", + "0 176549 85 4.613278 1 Turbo\n", + "1 176549 12873 4.373979 2 Spies in Disguise\n", + "2 176549 6214 4.065771 3 Early Man" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "recommend(\n", + " model=model,\n", + " test_user=test_user,\n", + " dataset=dataset_item_features,\n", + " k=3,\n", + " filter_view=True,\n", + " on_unsupported_targets=\"warn\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Additional details\n", + "It may happen that SASRec filters out users with less than 2 interactions during train stage, as target is a shifted interaction sequence. However, it is still possible to make recommendations for user with one interaction in history if this interaction item was present at training.\n", + "\n", + "As an example consider user 324373, for whom there is only one interaction in the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 4)\n" + ] + }, + { + "data": { + "text/html": [ "
\n", "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_idscorerank
07344677930.9713501
17344678290.9338672
27344637840.6187423
37344697280.6087454
473446121920.2983885
...............
94704585716237341.4075016
94704685716241511.2583127
94704785716286361.2272388
94704885716218441.1099769
94704985716244360.99829510
\n", + "

947050 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " user_id item_id score rank\n", + "0 73446 7793 0.971350 1\n", + "1 73446 7829 0.933867 2\n", + "2 73446 3784 0.618742 3\n", + "3 73446 9728 0.608745 4\n", + "4 73446 12192 0.298388 5\n", + "... ... ... ... ...\n", + "947045 857162 3734 1.407501 6\n", + "947046 857162 4151 1.258312 7\n", + "947047 857162 8636 1.227238 8\n", + "947048 857162 1844 1.109976 9\n", + "947049 857162 4436 0.998295 10\n", + "\n", + "[947050 rows x 4 columns]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "recos" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'MAP@1': 0.0457901198911608,\n", + " 'MAP@5': 0.07710723775026486,\n", + " 'MAP@10': 0.08559323634049909,\n", + " 'MIUF@1': 18.824620072061013,\n", + " 'MIUF@5': 18.824620072061013,\n", + " 'MIUF@10': 18.824620072061013,\n", + " 'Serendipity@1': 0.09274061559579748,\n", + " 'Serendipity@5': 0.056047439499790956,\n", + " 'Serendipity@10': 0.04129842262611581,\n", + " 'model': 'bert4rec_ids'}]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "features_results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/sasrec_metrics_comp.ipynb b/examples/sasrec_metrics_comp.ipynb index 9ed4963d..b3053f8f 100644 --- a/examples/sasrec_metrics_comp.ipynb +++ b/examples/sasrec_metrics_comp.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -128,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -152,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -169,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -198,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -214,7 +214,7 @@ "32" ] }, - "execution_count": 11, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -227,7 +227,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -243,7 +243,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -254,8 +254,7 @@ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `pytorch_lightning` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n" + "HPU available: False, using: 0 HPUs\n" ] } ], @@ -273,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -290,13 +289,13 @@ "0 Non-trainable params\n", "927 K Total params\n", "3.709 Total estimated model params size (MB)\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "00f2ec3343d24c3296e3b6e217689b84", + "model_id": "872b6e4e393b469db004bdd889a89533", "version_major": 2, "version_minor": 0 }, @@ -317,10 +316,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 14, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -332,29 +331,44 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/sasrec.py:635: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:786: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/base.py:406: UserWarning: \n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", " but some of given users are cold: they are not in the `dataset.user_id_map`\n", " \n", " warnings.warn(explanation)\n", - "100%|██████████| 740/740 [00:02<00:00, 251.43it/s]\n" + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ddd4a5fc9400481f98f0f0c0c086b96f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Predicting: | | 0/? [00:00" + "" ] }, - "execution_count": 19, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } @@ -629,31 +637,44 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/sasrec.py:635: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:786: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/base.py:406: UserWarning: \n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", " but some of given users are cold: they are not in the `dataset.user_id_map`\n", " \n", " warnings.warn(explanation)\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", - " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", - "100%|██████████| 740/740 [00:05<00:00, 147.19it/s]\n" + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "612e92b761d741348fd7ec531d2a1964", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Predicting: | | 0/? [00:00" + "" ] }, - "execution_count": 28, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } @@ -780,31 +801,44 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 53, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/sasrec.py:635: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:786: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/base.py:406: UserWarning: \n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", " but some of given users are cold: they are not in the `dataset.user_id_map`\n", " \n", " warnings.warn(explanation)\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", - " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", - "100%|██████████| 740/740 [00:03<00:00, 190.30it/s]\n" + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "59de5ff7662c493f8e96359a7c3b2190", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Predicting: | | 0/? [00:00" ], "text/plain": [ - " target_item_id item_id score rank\n", - "0 13865 15648 1.000000 1\n", - "1 13865 3386 1.000000 2\n", - "2 13865 147 0.898218 3\n", - "3 13865 16194 0.898218 4\n", - "4 13865 12309 0.898218 5\n", - "5 13865 12586 0.898218 6\n", - "6 13865 6661 0.898218 7\n", - "7 13865 2255 0.898218 8\n", - "8 13865 3792 0.898218 9\n", - "9 13865 4130 0.898218 10\n", - "10 4457 5109 1.000000 1\n", - "11 4457 8851 1.000000 2\n", - "12 4457 8486 1.000000 3\n", - "13 4457 12087 1.000000 4\n", - "14 4457 2313 1.000000 5\n", - "15 4457 11977 1.000000 6\n", - "16 4457 7928 1.000000 7\n", - "17 4457 3384 1.000000 8\n", - "18 4457 11513 1.000000 9\n", - "19 4457 6285 1.000000 10\n", - "20 15297 8723 1.000000 1\n", - "21 15297 5926 1.000000 2\n", - "22 15297 4131 1.000000 3\n", - "23 15297 4229 1.000000 4\n", - "24 15297 7005 1.000000 5\n", - "25 15297 10797 1.000000 6\n", - "26 15297 10535 1.000000 7\n", - "27 15297 5400 1.000000 8\n", - "28 15297 4716 1.000000 9\n", - "29 15297 13103 1.000000 10" + " target_item_id item_id score rank\n", + "0 13865 15648 1.000000 1\n", + "1 13865 3386 1.000000 2\n", + "2 13865 147 0.898218 3\n", + "3 13865 16194 0.898218 4\n", + "4 13865 12309 0.898218 5\n", + "5 13865 12586 0.898218 6\n", + "6 13865 6661 0.898218 7\n", + "7 13865 2255 0.898218 8\n", + "8 13865 3792 0.898218 9\n", + "9 13865 4130 0.898218 10\n", + "10 4457 5109 1.000000 1\n", + "11 4457 8851 1.000000 2\n", + "12 4457 8486 1.000000 3\n", + "13 4457 12087 1.000000 4\n", + "14 4457 2313 1.000000 5\n", + "15 4457 11977 1.000000 6\n", + "16 4457 7928 1.000000 7\n", + "17 4457 3384 1.000000 8\n", + "18 4457 11513 1.000000 9\n", + "19 4457 6285 1.000000 10\n", + "20 15297 8723 1.000000 1\n", + "21 15297 5926 1.000000 2\n", + "22 15297 4131 1.000000 3\n", + "23 15297 4229 1.000000 4\n", + "24 15297 7005 1.000000 5\n", + "25 15297 10797 1.000000 6\n", + "26 15297 10535 1.000000 7\n", + "27 15297 5400 1.000000 8\n", + "28 15297 4716 1.000000 9\n", + "29 15297 13103 1.000000 10" ] }, - "execution_count": 34, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } @@ -1229,7 +1206,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 68, "metadata": {}, "outputs": [], "source": [ @@ -1238,7 +1215,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 69, "metadata": {}, "outputs": [], "source": [ @@ -1256,7 +1233,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 70, "metadata": {}, "outputs": [], "source": [ @@ -1271,7 +1248,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 71, "metadata": {}, "outputs": [], "source": [ @@ -1296,7 +1273,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 72, "metadata": {}, "outputs": [], "source": [ @@ -1322,14 +1299,14 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 73, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n" ] } @@ -1353,7 +1330,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 74, "metadata": {}, "outputs": [ { @@ -1499,7 +1476,7 @@ "sasrec_cat 0.005200 " ] }, - "execution_count": 48, + "execution_count": 74, "metadata": {}, "output_type": "execute_result" } @@ -1523,9 +1500,9 @@ ], "metadata": { "kernelspec": { - "display_name": "rectools_origin", + "display_name": ".venv", "language": "python", - "name": "rectools_origin" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1537,7 +1514,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.8.2" } }, "nbformat": 4, diff --git a/rectools/models/bert4rec.py b/rectools/models/bert4rec.py new file mode 100644 index 00000000..1a054864 --- /dev/null +++ b/rectools/models/bert4rec.py @@ -0,0 +1,199 @@ +import typing as tp +from typing import List, Tuple + +import numpy as np +import torch +from pytorch_lightning import Trainer +from torch import nn + +from rectools.models.sasrec import ( + CatFeaturesItemNet, + IdEmbeddingsItemNet, + ItemNetBase, + LearnableInversePositionalEncoding, + PointWiseFeedForward, + PositionalEncodingBase, + SessionEncoderDataPreparatorBase, + SessionEncoderLightningModule, + SessionEncoderLightningModuleBase, + TransformerLayersBase, + TransformerModelBase, +) + +PADDING_VALUE = "PAD" +MASKING_VALUE = "MASK" + + +class BERT4RecDataPreparator(SessionEncoderDataPreparatorBase): + """TODO""" + + def __init__( + self, + session_max_len: int, + batch_size: int, + dataloader_num_workers: int, + train_min_user_interactions: int, + mask_prob: float, + item_extra_tokens: tp.Sequence[tp.Hashable], + shuffle_train: bool = True, + ) -> None: + super().__init__( + session_max_len=session_max_len, + batch_size=batch_size, + dataloader_num_workers=dataloader_num_workers, + train_min_user_interactions=train_min_user_interactions, + item_extra_tokens=item_extra_tokens, + shuffle_train=shuffle_train, + ) + self.mask_prob = mask_prob + + def _mask_session(self, ses: List[int]) -> Tuple[List[int], List[int]]: + masked_session = ses.copy() + target = ses.copy() + random_probs = np.random.rand(len(ses)) + for j in range(len(ses)): + if random_probs[j] < self.mask_prob: + random_probs[j] /= self.mask_prob + if random_probs[j] < 0.8: + masked_session[j] = self.extra_token_ids[MASKING_VALUE] + elif random_probs[j] < 0.9: + masked_session[j] = np.random.randint(low=self.n_item_extra_tokens, high=self.item_id_map.size) + else: + target[j] = 0 + return masked_session, target + + def _collate_fn_train( + self, + batch: List[Tuple[List[int], List[float]]], + ) -> Tuple[torch.LongTensor, torch.LongTensor, torch.FloatTensor]: + """TODO""" + batch_size = len(batch) + x = np.zeros((batch_size, self.session_max_len + 1)) + y = np.zeros((batch_size, self.session_max_len + 1)) + yw = np.zeros((batch_size, self.session_max_len + 1)) + for i, (ses, ses_weights) in enumerate(batch): + masked_session, target = self._mask_session(ses) + x[i, -len(ses) :] = masked_session # ses: [session_len] -> x[i]: [session_max_len + 1] + y[i, -len(ses) :] = target # ses: [session_len] -> y[i]: [session_max_len + 1] + yw[i, -len(ses) :] = ses_weights # ses_weights: [session_len] -> yw[i]: [session_max_len + 1] + + return torch.LongTensor(x), torch.LongTensor(y), torch.FloatTensor(yw) + + def _collate_fn_recommend(self, batch: List[Tuple[List[int], List[float]]]) -> torch.LongTensor: + """Right truncation, left padding to session_max_len""" + x = np.zeros((len(batch), self.session_max_len + 1)) + for i, (ses, _) in enumerate(batch): + session = ses.copy() + session = session + [self.extra_token_ids[MASKING_VALUE]] + x[i, -len(ses) - 1 :] = session[-self.session_max_len - 1 :] + return torch.LongTensor(x) + + +class BERT4RecTransformerLayers(TransformerLayersBase): + """TODO""" + + def __init__( + self, + n_blocks: int, + n_factors: int, + n_heads: int, + dropout_rate: float, + ): + super().__init__() + self.n_blocks = n_blocks + self.multi_head_attn = nn.ModuleList( + [nn.MultiheadAttention(n_factors, n_heads, dropout_rate, batch_first=True) for _ in range(n_blocks)] + ) + self.layer_norm1 = nn.ModuleList([nn.LayerNorm(n_factors) for _ in range(n_blocks)]) + self.dropout1 = nn.ModuleList([nn.Dropout(dropout_rate) for _ in range(n_blocks)]) + self.layer_norm2 = nn.ModuleList([nn.LayerNorm(n_factors) for _ in range(n_blocks)]) + self.feed_forward = nn.ModuleList( + [PointWiseFeedForward(n_factors, n_factors * 4, dropout_rate, torch.nn.GELU()) for _ in range(n_blocks)] + ) + self.dropout2 = nn.ModuleList([nn.Dropout(dropout_rate) for _ in range(n_blocks)]) + self.dropout3 = nn.ModuleList([nn.Dropout(dropout_rate) for _ in range(n_blocks)]) + + def forward( + self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: torch.Tensor, key_padding_mask: torch.Tensor + ) -> torch.Tensor: + """TODO""" + for i in range(self.n_blocks): + mha_input = self.layer_norm1[i](seqs) + mha_output, _ = self.multi_head_attn[i]( + mha_input, + mha_input, + mha_input, + attn_mask=attn_mask, + key_padding_mask=key_padding_mask, + need_weights=False, + ) + seqs = seqs + self.dropout1[i](mha_output) + ff_input = self.layer_norm2[i](seqs) + ff_output = self.feed_forward[i](ff_input) + seqs = seqs + self.dropout2[i](ff_output) + seqs = self.dropout3[i](seqs) + # TODO: test with torch.nn.Linear and cross-entropy loss as in + # https://github.com/jaywonchung/BERT4Rec-VAE-Pytorch/blob/f66f2534ebfd937778c7174b5f9f216efdebe5de/models/bert.py#L11C1-L11C67 + return seqs + + +class BERT4RecModel(TransformerModelBase): + """TODO""" + + def __init__( # pylint: disable=too-many-arguments, too-many-locals + self, + n_blocks: int = 1, + n_heads: int = 1, + n_factors: int = 128, + use_pos_emb: bool = True, + use_causal_attn: bool = False, + use_key_padding_mask: bool = True, + dropout_rate: float = 0.2, + epochs: int = 3, + verbose: int = 0, + deterministic: bool = False, + cpu_n_threads: int = 0, + session_max_len: int = 32, + batch_size: int = 128, + loss: str = "softmax", + lr: float = 0.01, + dataloader_num_workers: int = 0, + train_min_user_interaction: int = 2, + mask_prob: float = 0.15, + trainer: tp.Optional[Trainer] = None, + item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]] = (IdEmbeddingsItemNet, CatFeaturesItemNet), + pos_encoding_type: tp.Type[PositionalEncodingBase] = LearnableInversePositionalEncoding, + transformer_layers_type: tp.Type[TransformerLayersBase] = BERT4RecTransformerLayers, + data_preparator_type: tp.Type[BERT4RecDataPreparator] = BERT4RecDataPreparator, + lightning_module_type: tp.Type[SessionEncoderLightningModuleBase] = SessionEncoderLightningModule, + ): + super().__init__( + transformer_layers_type=transformer_layers_type, + data_preparator_type=data_preparator_type, + n_blocks=n_blocks, + n_heads=n_heads, + n_factors=n_factors, + use_pos_emb=use_pos_emb, + use_causal_attn=use_causal_attn, + use_key_padding_mask=use_key_padding_mask, + dropout_rate=dropout_rate, + epochs=epochs, + verbose=verbose, + deterministic=deterministic, + cpu_n_threads=cpu_n_threads, + loss=loss, + lr=lr, + session_max_len=session_max_len + 1, + trainer=trainer, + item_net_block_types=item_net_block_types, + pos_encoding_type=pos_encoding_type, + lightning_module_type=lightning_module_type, + ) + self.data_preparator = data_preparator_type( + session_max_len=session_max_len, + batch_size=batch_size, + dataloader_num_workers=dataloader_num_workers, + train_min_user_interactions=train_min_user_interaction, + item_extra_tokens=(PADDING_VALUE, MASKING_VALUE), + mask_prob=mask_prob, + ) diff --git a/rectools/models/sasrec.py b/rectools/models/sasrec.py index eb7d8d11..a260275c 100644 --- a/rectools/models/sasrec.py +++ b/rectools/models/sasrec.py @@ -52,7 +52,9 @@ def device(self) -> torch.device: class TransformerLayersBase(nn.Module): """TODO: use Protocol""" - def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: torch.Tensor) -> torch.Tensor: + def forward( + self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: torch.Tensor, key_padding_mask: torch.Tensor + ) -> torch.Tensor: """Forward pass.""" raise NotImplementedError() @@ -60,7 +62,7 @@ def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: to class PositionalEncodingBase(torch.nn.Module): """TODO: use Protocol""" - def forward(self, sessions: torch.Tensor, timeline_mask: torch.Tensor) -> torch.Tensor: + def forward(self, sessions: torch.Tensor) -> torch.Tensor: """Forward pass.""" raise NotImplementedError() @@ -264,13 +266,12 @@ class PointWiseFeedForward(nn.Module): Probability of a hidden unit to be zeroed. """ - def __init__(self, n_factors: int, n_factors_ff: int, dropout_rate: float) -> None: + def __init__(self, n_factors: int, n_factors_ff: int, dropout_rate: float, activation: torch.nn.Module) -> None: super().__init__() self.ff_linear1 = nn.Linear(n_factors, n_factors_ff) self.ff_dropout1 = torch.nn.Dropout(dropout_rate) - self.ff_relu = torch.nn.ReLU() + self.ff_activation = activation self.ff_linear2 = nn.Linear(n_factors_ff, n_factors) - self.ff_dropout2 = torch.nn.Dropout(dropout_rate) def forward(self, seqs: torch.Tensor) -> torch.Tensor: """ @@ -286,8 +287,8 @@ def forward(self, seqs: torch.Tensor) -> torch.Tensor: torch.Tensor User sequence that passed through all layers. """ - output = self.ff_relu(self.ff_dropout1(self.ff_linear1(seqs))) - fin = self.ff_dropout2(self.ff_linear2(output)) + output = self.ff_activation(self.ff_linear1(seqs)) + fin = self.ff_linear2(self.ff_dropout1(output)) return fin @@ -322,11 +323,14 @@ def __init__( self.q_layer_norm = nn.ModuleList([nn.LayerNorm(n_factors) for _ in range(n_blocks)]) self.ff_layer_norm = nn.ModuleList([nn.LayerNorm(n_factors) for _ in range(n_blocks)]) self.feed_forward = nn.ModuleList( - [PointWiseFeedForward(n_factors, n_factors, dropout_rate) for _ in range(n_blocks)] + [PointWiseFeedForward(n_factors, n_factors, dropout_rate, torch.nn.ReLU()) for _ in range(n_blocks)] ) + self.dropout = nn.ModuleList([torch.nn.Dropout(dropout_rate) for _ in range(n_blocks)]) self.last_layernorm = torch.nn.LayerNorm(n_factors, eps=1e-8) - def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: torch.Tensor) -> torch.Tensor: + def forward( + self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: torch.Tensor, key_padding_mask: torch.Tensor + ) -> torch.Tensor: """ Forward pass through transformer blocks. @@ -344,12 +348,18 @@ def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: to torch.Tensor User sequences passed through transformer layers. """ + # TODO: do we need to fill padding embeds in sessions to all zeros + # or should we use the learnt padding embedding? Should we make it an option for user to decide? + seqs *= timeline_mask # [batch_size, session_max_len, n_factors] for i in range(self.n_blocks): q = self.q_layer_norm[i](seqs) - mha_output, _ = self.multi_head_attn[i](q, seqs, seqs, attn_mask=attn_mask, need_weights=False) + mha_output, _ = self.multi_head_attn[i]( + q, seqs, seqs, attn_mask=attn_mask, key_padding_mask=key_padding_mask, need_weights=False + ) seqs = q + mha_output ff_input = self.ff_layer_norm[i](seqs) seqs = self.feed_forward[i](ff_input) + seqs = self.dropout[i](seqs) seqs += ff_input seqs *= timeline_mask @@ -358,75 +368,6 @@ def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: to return seqs -class PreLNTransformerLayers(TransformerLayersBase): - """ - Architecture of transformer blocks based on https://arxiv.org/pdf/2002.04745 - On Kion open dataset didn't change metrics, even got a bit worse. - - Parameters - ---------- - n_blocks: int - Number of transformer blocks. - n_factors: int - Latent embeddings size. - n_heads: int - Number of attention heads. - dropout_rate: float - Probability of a hidden unit to be zeroed. - """ - - def __init__( - self, - n_blocks: int, - n_factors: int, - n_heads: int, - dropout_rate: float, - ): - super().__init__() - self.n_blocks = n_blocks - self.multi_head_attn = nn.ModuleList( - [torch.nn.MultiheadAttention(n_factors, n_heads, dropout_rate, batch_first=True) for _ in range(n_blocks)] - ) - self.mha_layer_norm = nn.ModuleList([nn.LayerNorm(n_factors) for _ in range(n_blocks)]) - self.mha_dropout = nn.Dropout(dropout_rate) - self.ff_layer_norm = nn.ModuleList([nn.LayerNorm(n_factors) for _ in range(n_blocks)]) - self.feed_forward = nn.ModuleList( - [PointWiseFeedForward(n_factors, n_factors, dropout_rate) for _ in range(n_blocks)] - ) - - def forward(self, seqs: torch.Tensor, timeline_mask: torch.Tensor, attn_mask: torch.Tensor) -> torch.Tensor: - """ - Forward pass through transformer blocks. - - Parameters - ---------- - seqs: torch.Tensor - User sequences of item embeddings. - timeline_mask: torch.Tensor - Mask to zero out padding elements. - attn_mask: torch.Tensor - Forbid model to use future interactions. - - Returns - ------- - torch.Tensor - User sequences passed through transformer layers. - """ - for i in range(self.n_blocks): - mha_input = self.mha_layer_norm[i](seqs) - mha_output, _ = self.multi_head_attn[i]( - mha_input, mha_input, mha_input, attn_mask=attn_mask, need_weights=False - ) - mha_output = self.mha_dropout(mha_output) - seqs = seqs + mha_output - ff_input = self.ff_layer_norm[i](seqs) - ff_output = self.feed_forward[i](ff_input) - seqs = seqs + ff_output - seqs *= timeline_mask - - return seqs - - class LearnableInversePositionalEncoding(PositionalEncodingBase): """ Class to introduce learnable positional embeddings. @@ -445,7 +386,7 @@ def __init__(self, use_pos_emb: bool, session_max_len: int, n_factors: int): super().__init__() self.pos_emb = torch.nn.Embedding(session_max_len, n_factors) if use_pos_emb else None - def forward(self, sessions: torch.Tensor, timeline_mask: torch.Tensor) -> torch.Tensor: + def forward(self, sessions: torch.Tensor) -> torch.Tensor: """ Forward pass to add learnable positional encoding to sessions and mask padding elements. @@ -471,10 +412,6 @@ def forward(self, sessions: torch.Tensor, timeline_mask: torch.Tensor) -> torch. ) # [batch_size, session_max_len] sessions += self.pos_emb(positions.to(sessions.device)) - # TODO: do we need to fill padding embeds in sessions to all zeros - # or should we use the learnt padding embedding? Should we make it an option for user to decide? - sessions *= timeline_mask # [batch_size, session_max_len, n_factors] - return sessions @@ -518,6 +455,7 @@ def __init__( dropout_rate: float, use_pos_emb: bool = True, use_causal_attn: bool = True, + use_key_padding_mask: bool = False, transformer_layers_type: tp.Type[TransformerLayersBase] = SASRecTransformerLayers, item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]] = (IdEmbeddingsItemNet, CatFeaturesItemNet), pos_encoding_type: tp.Type[PositionalEncodingBase] = LearnableInversePositionalEncoding, @@ -534,8 +472,10 @@ def __init__( dropout_rate=dropout_rate, ) self.use_causal_attn = use_causal_attn + self.use_key_padding_mask = use_key_padding_mask self.n_factors = n_factors self.dropout_rate = dropout_rate + self.n_heads = n_heads self.item_net_block_types = item_net_block_types @@ -572,15 +512,20 @@ def encode_sessions(self, sessions: torch.Tensor, item_embs: torch.Tensor) -> to """ session_max_len = sessions.shape[1] attn_mask = None + key_padding_mask = None + # TODO: att_mask and key_padding_mask together result into NaN scores if self.use_causal_attn: attn_mask = ~torch.tril( torch.ones((session_max_len, session_max_len), dtype=torch.bool, device=sessions.device) ) + if self.use_key_padding_mask: + key_padding_mask = sessions == 0 timeline_mask = (sessions != 0).unsqueeze(-1) # [batch_size, session_max_len, 1] seqs = item_embs[sessions] # [batch_size, session_max_len, n_factors] - seqs = self.pos_encoding(seqs, timeline_mask) + seqs = self.pos_encoding(seqs) seqs = self.emb_dropout(seqs) - seqs = self.transformer_layers(seqs, timeline_mask, attn_mask) + # TODO: stop passing timeline_mask together with key_padding_mask because they have same information + seqs = self.transformer_layers(seqs, timeline_mask, attn_mask, key_padding_mask) return seqs def forward( @@ -603,9 +548,9 @@ def forward( torch.Tensor Logits. """ - item_embs = self.item_model.get_all_embeddings() # [n_items + 1, n_factors] + item_embs = self.item_model.get_all_embeddings() # [n_items + n_special_tokens, n_factors] session_embs = self.encode_sessions(sessions, item_embs) # [batch_size, session_max_len, n_factors] - logits = session_embs @ item_embs.T # [batch_size, session_max_len, n_items + 1] + logits = session_embs @ item_embs.T # [batch_size, session_max_len, n_items + n_special_tokens] return logits @@ -689,18 +634,19 @@ def __init__( session_max_len: int, batch_size: int, dataloader_num_workers: int, + shuffle_train: bool = True, item_extra_tokens: tp.Sequence[tp.Hashable] = (PADDING_VALUE,), - shuffle_train: bool = True, # not shuffling train dataloader hurts performance train_min_user_interactions: int = 2, ) -> None: + """TODO""" + self.item_id_map: IdMap + self.extra_token_ids: tp.Dict self.session_max_len = session_max_len self.batch_size = batch_size self.dataloader_num_workers = dataloader_num_workers + self.train_min_user_interactions = train_min_user_interactions self.item_extra_tokens = item_extra_tokens self.shuffle_train = shuffle_train - self.train_min_user_interactions = train_min_user_interactions - self.item_id_map: IdMap - # TODO: add SequenceDatasetType for fit and recommend def get_known_items_sorted_internal_ids(self) -> np.ndarray: """Return internal item ids from processed dataset in sorted order.""" @@ -716,45 +662,7 @@ def n_item_extra_tokens(self) -> int: return len(self.item_extra_tokens) def process_dataset_train(self, dataset: Dataset) -> Dataset: - """Process train dataset.""" - raise NotImplementedError() - - def get_dataloader_train(self, processed_dataset: Dataset) -> DataLoader: - """Return train dataloader.""" - raise NotImplementedError() - - def get_dataloader_recommend(self, dataset: Dataset) -> DataLoader: - """Return recommend dataloader.""" - raise NotImplementedError() - - def transform_dataset_u2i(self, dataset: Dataset, users: ExternalIds) -> Dataset: - """Process dataset for u2i recommendations.""" - raise NotImplementedError() - - def transform_dataset_i2i(self, dataset: Dataset) -> Dataset: - """Process dataset for i2i recommendations.""" - raise NotImplementedError() - - -class SASRecDataPreparator(SessionEncoderDataPreparatorBase): - """Class to process train/recommend datasets and prepare train/recommend dataloaders.""" - - def process_dataset_train(self, dataset: Dataset) -> Dataset: - """ - Remove sequences shorter than ``train_min_user_interactions``. - Leave ``session_max_len`` + 1 most recent interactions. - Create new RecTools dataset with processed interactions. - - Parameters - ---------- - dataset: Dataset - RecTools dataset with train interactions. - - Returns - ------- - Dataset - RecTools dataset with processed interactions. - """ + """TODO""" interactions = dataset.get_raw_interactions() # Filter interactions @@ -797,26 +705,10 @@ def process_dataset_train(self, dataset: Dataset) -> Dataset: dataset = Dataset(user_id_map, item_id_map, interactions, item_features=item_features) self.item_id_map = dataset.item_id_map - return dataset - def _collate_fn_train( - self, - batch: List[Tuple[List[int], List[float]]], - ) -> Tuple[torch.LongTensor, torch.LongTensor, torch.FloatTensor]: - """ - Truncate each session from right to keep (``session_max_len`` + 1) last items. - Do left padding until (``session_max_len`` + 1) is reached. - Split to `x`, `y`, and `yw`. - """ - batch_size = len(batch) - x = np.zeros((batch_size, self.session_max_len)) - y = np.zeros((batch_size, self.session_max_len)) - yw = np.zeros((batch_size, self.session_max_len)) - for i, (ses, ses_weights) in enumerate(batch): - x[i, -len(ses) + 1 :] = ses[:-1] # ses: [session_len] -> x[i]: [session_max_len] - y[i, -len(ses) + 1 :] = ses[1:] # ses: [session_len] -> y[i]: [session_max_len] - yw[i, -len(ses) + 1 :] = ses_weights[1:] # ses_weights: [session_len] -> yw[i]: [session_max_len] - return torch.LongTensor(x), torch.LongTensor(y), torch.FloatTensor(yw) + extra_token_ids = self.item_id_map.convert_to_internal(self.item_extra_tokens) + self.extra_token_ids = dict(zip(self.item_extra_tokens, extra_token_ids)) + return dataset def get_dataloader_train(self, processed_dataset: Dataset) -> DataLoader: """ @@ -842,6 +734,18 @@ def get_dataloader_train(self, processed_dataset: Dataset) -> DataLoader: ) return train_dataloader + def get_dataloader_recommend(self, dataset: Dataset) -> DataLoader: + """TODO""" + sequence_dataset = SequenceDataset.from_interactions(dataset.interactions.df) + recommend_dataloader = DataLoader( + sequence_dataset, + batch_size=self.batch_size, + collate_fn=self._collate_fn_recommend, + num_workers=self.dataloader_num_workers, + shuffle=False, + ) + return recommend_dataloader + def transform_dataset_u2i(self, dataset: Dataset, users: ExternalIds) -> Dataset: """ Process dataset for u2i recommendations. @@ -908,13 +812,49 @@ def transform_dataset_i2i(self, dataset: Dataset) -> Dataset: Final item_id_map is model item_id_map constructed during training. """ # TODO: optimize by filtering in internal ids - # TODO: For now features are dropped because model doesn't support them interactions = dataset.get_raw_interactions() interactions = interactions[interactions[Columns.Item].isin(self.get_known_item_ids())] filtered_interactions = Interactions.from_raw(interactions, dataset.user_id_map, self.item_id_map) filtered_dataset = Dataset(dataset.user_id_map, self.item_id_map, filtered_interactions) return filtered_dataset + def _collate_fn_train( + self, + batch: List[Tuple[List[int], List[float]]], + ) -> Tuple[torch.LongTensor, torch.LongTensor, torch.FloatTensor]: + """TODO""" + raise NotImplementedError() + + def _collate_fn_recommend( + self, + batch: List[Tuple[List[int], List[float]]], + ) -> torch.LongTensor: + """TODO""" + raise NotImplementedError() + + +class SASRecDataPreparator(SessionEncoderDataPreparatorBase): + """TODO""" + + def _collate_fn_train( + self, + batch: List[Tuple[List[int], List[float]]], + ) -> Tuple[torch.LongTensor, torch.LongTensor, torch.FloatTensor]: + """ + Truncate each session from right to keep (session_max_len+1) last items. + Do left padding until (session_max_len+1) is reached. + Split to `x`, `y`, and `yw`. + """ + batch_size = len(batch) + x = np.zeros((batch_size, self.session_max_len)) + y = np.zeros((batch_size, self.session_max_len)) + yw = np.zeros((batch_size, self.session_max_len)) + for i, (ses, ses_weights) in enumerate(batch): + x[i, -len(ses) + 1 :] = ses[:-1] # ses: [session_len] -> x[i]: [session_max_len] + y[i, -len(ses) + 1 :] = ses[1:] # ses: [session_len] -> y[i]: [session_max_len] + yw[i, -len(ses) + 1 :] = ses_weights[1:] # ses_weights: [session_len] -> yw[i]: [session_max_len] + return torch.LongTensor(x), torch.LongTensor(y), torch.FloatTensor(yw) + def _collate_fn_recommend(self, batch: List[Tuple[List[int], List[float]]]) -> torch.LongTensor: """Right truncation, left padding to session_max_len""" x = np.zeros((len(batch), self.session_max_len)) @@ -922,30 +862,6 @@ def _collate_fn_recommend(self, batch: List[Tuple[List[int], List[float]]]) -> t x[i, -len(ses) :] = ses[-self.session_max_len :] return torch.LongTensor(x) - def get_dataloader_recommend(self, dataset: Dataset) -> DataLoader: - """ - Construct recommend dataloader from processed dataset. - - Parameters - ---------- - processed_dataset: Dataset - RecTools dataset. - - Returns - ------- - DataLoader - Recommend dataloader. - """ - sequence_dataset = SequenceDataset.from_interactions(dataset.interactions.df) - recommend_dataloader = DataLoader( - sequence_dataset, - batch_size=self.batch_size, - collate_fn=self._collate_fn_recommend, - num_workers=self.dataloader_num_workers, - shuffle=False, - ) - return recommend_dataloader - # #### -------------- Lightning Model -------------- #### # @@ -1003,6 +919,7 @@ class SessionEncoderLightningModule(SessionEncoderLightningModuleBase): def on_train_start(self) -> None: """Initialize parameters with values from Xavier normal distribution.""" + # TODO: init padding embedding with zeros self._xavier_normal_init() def training_step(self, batch: torch.Tensor, batch_idx: int) -> torch.Tensor: @@ -1023,12 +940,12 @@ def training_step(self, batch: torch.Tensor, batch_idx: int) -> torch.Tensor: Loss. """ x, y, w = batch - logits = self.forward(x) # [batch_size, session_max_len, n_items + 1] + logits = self.forward(x) # [batch_size, session_max_len, n_items + n_special_tokens] if self.loss == "softmax": # We are using CrossEntropyLoss with a multi-dimensional case - # Logits must be passed in form of [batch_size, n_items + 1, session_max_len], - # where n_items + 1 is number of classes + # Logits must be passed in form of [batch_size, n_items + n_special_tokens, session_max_len], + # where n_items + n_special_tokens is number of classes # Target label indexes must be passed in a form of [batch_size, session_max_len] # (`0` index for "PAD" ix excluded from loss) @@ -1066,67 +983,25 @@ def _xavier_normal_init(self) -> None: pass -# #### -------------- SASRec Model -------------- #### # - - -class SASRecModel(ModelBase): +class TransformerModelBase(ModelBase): """ - SASRec model for i2i and u2i recommendations. - - n_blocks: int, default 1 - Number of transformer blocks. - n_heads: int, default 1 - Number of attention heads. - n_factors: int, default 128 - Latent embeddings size. - use_pos_emb: bool, default ``True`` - If ``True``, adds learnable positional encoding to session item embeddings. - dropout_rate: float, default 0.2 - Probability of a hidden unit to be zeroed. - session_max_len: int, default 32 - Maximum length of user sequence. - dataloader_num_workers: int, default 0 - Number of loader worker processes. - batch_size: int, default 128 - How many samples per batch to load. - loss: str, default "softmax" - Loss function. - lr: float, default 0.01 - Learning rate. - epochs: int, default 3 - Number of training epochs. - verbose: int, default 0 - Verbosity level. - deterministic: bool, default ``False`` - If ``True``, sets deterministic algorithms for PyTorch operations. - Use `pytorch_lightning.seed_everything` together with this parameter to fix the random state. - cpu_n_threads: int, default 0 - Number of threads to use in ranker. - trainer: Optional(Trainer), default None - Which trainer to use for training. - If trainer is None, default pytorch_lightning Trainer is created. - item_net_type: Type(ItemNetBase), default `IdEmbeddingsItemNet` - Type of network returning item enbeddings. - pos_encoding_type: Type(PositionalEncodingBase), default `LearnableInversePositionalEncoding` - Type of positional encoding. - transformer_layers_type: Type(TransformerLayersBase), default `SasRecTransformerLayers` - Type of transformer layers architecture. - data_preparator_type: Type(SessionEncoderDataPreparatorBase), default `SasRecDataPreparator` - Type of data preparator used for dataset processing and dataloader creation. - lightning_module_type: Type(SessionEncoderLightningModuleBase), default `SessionEncoderLightningModule` - Type of lightning module defining training procedure. + Base model for all recommender algorithms that work on transformer architecture (e.g. SASRec, Bert4Rec). + To create a custom transformer model it is necessary to inherit from this class + and write self.data_preparator initialization logic. """ def __init__( # pylint: disable=too-many-arguments self, + transformer_layers_type: tp.Type[TransformerLayersBase], + data_preparator_type: tp.Type[SessionEncoderDataPreparatorBase], n_blocks: int = 1, n_heads: int = 1, n_factors: int = 128, use_pos_emb: bool = True, + use_causal_attn: bool = True, + use_key_padding_mask: bool = False, dropout_rate: float = 0.2, session_max_len: int = 32, - dataloader_num_workers: int = 0, - batch_size: int = 128, loss: str = "softmax", lr: float = 0.01, epochs: int = 3, @@ -1136,11 +1011,9 @@ def __init__( # pylint: disable=too-many-arguments trainer: tp.Optional[Trainer] = None, item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]] = (IdEmbeddingsItemNet, CatFeaturesItemNet), pos_encoding_type: tp.Type[PositionalEncodingBase] = LearnableInversePositionalEncoding, - transformer_layers_type: tp.Type[TransformerLayersBase] = SASRecTransformerLayers, # SASRec authors net - data_preparator_type: tp.Type[SessionEncoderDataPreparatorBase] = SASRecDataPreparator, lightning_module_type: tp.Type[SessionEncoderLightningModuleBase] = SessionEncoderLightningModule, - ): - super().__init__(verbose=verbose) + ) -> None: + super().__init__(verbose) self.n_threads = cpu_n_threads self._torch_model = TransformerBasedSessionEncoder( n_blocks=n_blocks, @@ -1149,7 +1022,8 @@ def __init__( # pylint: disable=too-many-arguments session_max_len=session_max_len, dropout_rate=dropout_rate, use_pos_emb=use_pos_emb, - use_causal_attn=True, + use_causal_attn=use_causal_attn, + use_key_padding_mask=use_key_padding_mask, transformer_layers_type=transformer_layers_type, item_net_block_types=item_net_block_types, pos_encoding_type=pos_encoding_type, @@ -1168,7 +1042,7 @@ def __init__( # pylint: disable=too-many-arguments ) else: self._trainer = trainer - self.data_preparator = data_preparator_type(session_max_len, batch_size, dataloader_num_workers) + self.data_preparator: SessionEncoderDataPreparatorBase self.u2i_dist = Distance.DOT self.i2i_dist = Distance.COSINE self.lr = lr @@ -1202,7 +1076,7 @@ def _custom_transform_dataset_i2i( def _recommend_u2i( self, user_ids: InternalIdsArray, - dataset: Dataset, # [n_rec_users x n_items + 1] + dataset: Dataset, # [n_rec_users x n_items + n_special_tokens] k: int, filter_viewed: bool, sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray], # model_internal @@ -1221,7 +1095,7 @@ def _recommend_u2i( ranker = ImplicitRanker( self.u2i_dist, user_embs, # [n_rec_users, n_factors] - item_embs_np, # [n_items + 1, n_factors] + item_embs_np, # [n_items + n_special_tokens, n_factors] ) if filter_viewed: user_items = dataset.get_user_item_matrix(include_weights=False) @@ -1260,8 +1134,8 @@ def _recommend_i2i( ranker = ImplicitRanker( self.i2i_dist, - item_embs, # [n_items + 1, n_factors] - item_embs, # [n_items + 1, n_factors] + item_embs, # [n_items + n_special_tokens, n_factors] + item_embs, # [n_items + n_special_tokens, n_factors] ) return ranker.rank( subject_ids=target_ids, # model internal @@ -1273,5 +1147,67 @@ def _recommend_i2i( @property def torch_model(self) -> TransformerBasedSessionEncoder: - """Return torch model.""" + """TODO""" return self.lightning_model.torch_model + + +# #### -------------- SASRec Model -------------- #### # + + +class SASRecModel(TransformerModelBase): + """TODO""" + + def __init__( # pylint: disable=too-many-arguments, too-many-locals + self, + n_blocks: int = 1, + n_heads: int = 1, + n_factors: int = 128, + use_pos_emb: bool = True, + use_causal_attn: bool = True, + use_key_padding_mask: bool = False, + dropout_rate: float = 0.2, + session_max_len: int = 32, + dataloader_num_workers: int = 0, + batch_size: int = 128, + loss: str = "softmax", + lr: float = 0.01, + epochs: int = 3, + verbose: int = 0, + deterministic: bool = False, + cpu_n_threads: int = 0, + train_min_user_interaction: int = 2, + trainer: tp.Optional[Trainer] = None, + item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]] = (IdEmbeddingsItemNet, CatFeaturesItemNet), + pos_encoding_type: tp.Type[PositionalEncodingBase] = LearnableInversePositionalEncoding, + transformer_layers_type: tp.Type[TransformerLayersBase] = SASRecTransformerLayers, # SASRec authors net + data_preparator_type: tp.Type[SessionEncoderDataPreparatorBase] = SASRecDataPreparator, + lightning_module_type: tp.Type[SessionEncoderLightningModuleBase] = SessionEncoderLightningModule, + ): + super().__init__( + transformer_layers_type, + data_preparator_type, + n_blocks, + n_heads, + n_factors, + use_pos_emb, + use_causal_attn, + use_key_padding_mask, + dropout_rate, + session_max_len, + loss, + lr, + epochs, + verbose, + deterministic, + cpu_n_threads, + trainer, + item_net_block_types, + pos_encoding_type, + lightning_module_type, + ) + self.data_preparator = data_preparator_type( + session_max_len=session_max_len, + batch_size=batch_size, + dataloader_num_workers=dataloader_num_workers, + train_min_user_interactions=train_min_user_interaction, + ) From fae5634b6f81fbf301ce3f36e2ed4663c92e8830 Mon Sep 17 00:00:00 2001 From: Andrey Semenov <43339130+In48semenov@users.noreply.github.com> Date: Fri, 22 Nov 2024 18:09:17 +0300 Subject: [PATCH 08/13] ItemNet tests and docs (#202) Added tests and docs for ItemNet --- rectools/models/sasrec.py | 156 +++++++++---- tests/dataset/test_features.py | 34 +++ tests/models/test_sasrec.py | 398 ++++++++++++++++++++++++++++++++- 3 files changed, 542 insertions(+), 46 deletions(-) diff --git a/rectools/models/sasrec.py b/rectools/models/sasrec.py index a260275c..6d6ea26e 100644 --- a/rectools/models/sasrec.py +++ b/rectools/models/sasrec.py @@ -35,7 +35,7 @@ def forward(self, items: torch.Tensor) -> torch.Tensor: raise NotImplementedError() @classmethod - def from_dataset(cls, dataset: Dataset, *args: tp.Any, **kwargs: tp.Any) -> tpe.Self: + def from_dataset(cls, dataset: Dataset, *args: tp.Any, **kwargs: tp.Any) -> tp.Optional[tpe.Self]: """Construct ItemNet.""" raise NotImplementedError() @@ -43,11 +43,6 @@ def get_all_embeddings(self) -> torch.Tensor: """Return item embeddings.""" raise NotImplementedError() - @property - def device(self) -> torch.device: - """TODO""" - raise NotImplementedError() - class TransformerLayersBase(nn.Module): """TODO: use Protocol""" @@ -69,8 +64,16 @@ def forward(self, sessions: torch.Tensor) -> torch.Tensor: class CatFeaturesItemNet(ItemNetBase): """ - Base class for all category item features embeddings. To use more complicated logic then just id embeddings inherit - from this class and pass your custom ItemNet to your model params. + Network for item embeddings based only on categorical item features. + + Parameters + ---------- + item_features: SparseFeatures + Storage for sparse features. + n_factors: int + Latent embedding size of item embeddings. + dropout_rate: float + Probability of a hidden unit to be zeroed. """ def __init__( @@ -89,45 +92,90 @@ def __init__( self.drop_layer = nn.Dropout(dropout_rate) def forward(self, items: torch.Tensor) -> torch.Tensor: - """TODO""" - # TODO: Should we use torch.nn.EmbeddingBag.html? + """ + Forward pass to get item embeddings from categorical item features. + + Parameters + ---------- + items: torch.Tensor + Internal item ids. + + Returns + ------- + torch.Tensor + Item embeddings. + """ + # TODO: Should we use torch.nn.EmbeddingBag? feature_dense = self.get_dense_item_features(items) + feature_dense.to(items.device) - feature_embs = self.category_embeddings(self.feature_catalogue) + feature_embs = self.category_embeddings(self.feature_catalogue.to(items.device)) feature_embs = self.drop_layer(feature_embs) feature_embeddings_per_items = feature_dense @ feature_embs return feature_embeddings_per_items - @property - def device(self) -> torch.device: - """TODO""" - return self.category_embeddings.weight.device - @property def feature_catalogue(self) -> torch.Tensor: - """TODO""" - return torch.arange(0, self.n_cat_features, device=self.device) + """Return tensor with elements in range [0, n_cat_features).""" + return torch.arange(0, self.n_cat_features) def get_dense_item_features(self, items: torch.Tensor) -> torch.Tensor: - """TODO""" + """ + Get categorical item values by certain item ids in dense format. + + Parameters + ---------- + items: torch.Tensor + Internal item ids. + + Returns + ------- + torch.Tensor + categorical item values in dense format. + """ # TODO: Add the whole `feature_dense` to the right gpu device at once? feature_dense = self.item_features.take(items.detach().cpu().numpy()).get_dense() - return torch.from_numpy(feature_dense).to(self.device) + return torch.from_numpy(feature_dense) @classmethod - def from_dataset(cls, dataset: Dataset, n_factors: int, dropout_rate: float) -> tpe.Self: - """TODO""" + def from_dataset(cls, dataset: Dataset, n_factors: int, dropout_rate: float) -> tp.Optional[tpe.Self]: + """ + Create CatFeaturesItemNet from RecTools dataset. + + Parameters + ---------- + dataset: Dataset + RecTools dataset. + n_factors: int + Latent embedding size of item embeddings. + dropout_rate: float + Probability of a hidden unit of item embedding to be zeroed. + """ item_features = dataset.item_features if item_features is None: - explanation = """When `use_cat_features_embs` is True, the dataset must have item features.""" - raise ValueError(explanation) + explanation = """Ignoring `CatFeaturesItemNet` block because dataset doesn't contain item features.""" + warnings.warn(explanation) + return None if not isinstance(item_features, SparseFeatures): - raise ValueError("`item_features` in `dataset` must be `SparseFeatures` instance.") + explanation = """ + Ignoring `CatFeaturesItemNet` block because + dataset item features are dense and unable to contain categorical features. + """ + warnings.warn(explanation) + return None item_cat_features = item_features.get_cat_features() + + if item_cat_features.values.size == 0: + explanation = """ + Ignoring `CatFeaturesItemNet` block because dataset item features do not contain categorical features. + """ + warnings.warn(explanation) + return None + return cls(item_cat_features, n_factors, dropout_rate) @@ -174,11 +222,6 @@ def forward(self, items: torch.Tensor) -> torch.Tensor: item_embs = self.drop_layer(item_embs) return item_embs - @property - def device(self) -> torch.device: - """TODO""" - return self.ids_emb.weight.device - @classmethod def from_dataset(cls, dataset: Dataset, n_factors: int, dropout_rate: float) -> tpe.Self: """TODO""" @@ -188,9 +231,14 @@ def from_dataset(cls, dataset: Dataset, n_factors: int, dropout_rate: float) -> class ItemNetConstructor(ItemNetBase): """ - Base class constructor for ItemNet, taking as input a sequence of ItemNetBase nets, - including custom ItemNetBase nets. - Constructs item's embedding based on aggregation of its embeddings from the passed networks. + Constructed network for item embeddings based on aggregation of embeddings from transferred item network types. + + Parameters + ---------- + n_items: int + Number of items in the dataset. + item_net_blocks: Sequence(ItemNetBase) + Latent embedding size of item embeddings. """ def __init__( @@ -209,7 +257,19 @@ def __init__( self.item_net_blocks = nn.ModuleList(item_net_blocks) def forward(self, items: torch.Tensor) -> torch.Tensor: - """TODO""" + """ + Forward pass to get item embeddings from item network blocks. + + Parameters + ---------- + items: torch.Tensor + Internal item ids. + + Returns + ------- + torch.Tensor + Item embeddings. + """ item_embs = [] # TODO: Add functionality for parallel computing. for idx_block in range(self.n_item_blocks): @@ -217,16 +277,10 @@ def forward(self, items: torch.Tensor) -> torch.Tensor: item_embs.append(item_emb) return torch.sum(torch.stack(item_embs, dim=0), dim=0) - @property - def device(self) -> torch.device: - """TODO""" - device = self.item_net_blocks[0].device - return device - @property def catalogue(self) -> torch.Tensor: """Return tensor with elements in range [0, n_items).""" - return torch.arange(0, self.n_items, device=self.device) + return torch.arange(0, self.n_items) def get_all_embeddings(self) -> torch.Tensor: """Return item embeddings.""" @@ -240,13 +294,27 @@ def from_dataset( dropout_rate: float, item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]], ) -> tpe.Self: - """TODO""" + """ + Construct ItemNet from RecTools dataset and from various blocks of item networks. + + Parameters + ---------- + dataset: Dataset + RecTools dataset. + n_factors: int + Latent embedding size of item embeddings. + dropout_rate: float + Probability of a hidden unit of item embedding to be zeroed. + item_net_block_types: Sequence(Type(ItemNetBase)) + Sequence item network block types. + """ n_items = dataset.item_id_map.size - item_net_blocks = [] + item_net_blocks: tp.List[ItemNetBase] = [] for item_net in item_net_block_types: item_net_block = item_net.from_dataset(dataset, n_factors, dropout_rate) - item_net_blocks.append(item_net_block) + if item_net_block is not None: + item_net_blocks.append(item_net_block) return cls(n_items, item_net_blocks) diff --git a/tests/dataset/test_features.py b/tests/dataset/test_features.py index 97d742b6..919c13f9 100644 --- a/tests/dataset/test_features.py +++ b/tests/dataset/test_features.py @@ -290,3 +290,37 @@ def test_take_with_nonexistent_ids(self) -> None: def test_len(self) -> None: features = SparseFeatures(self.values, self.names) assert len(features) == 4 + + @pytest.mark.parametrize( + "cat_features,expected_names,expected_values", + ( + ( + ["f3", "f4"], + (("f3", 0), ("f4", 100), ("f4", 200)), + sparse.csr_matrix([[1, 0, 1], [0, 2, 1], [0, 0, 0]], dtype=float), + ), + ([], (), sparse.csr_matrix([[] for _ in range(3)], dtype=float)), + ), + ) + def test_get_cat_features( + self, cat_features: tp.List, expected_names: tp.Tuple, expected_values: sparse.csr_matrix + ) -> None: + df = pd.DataFrame( + [ + [10, "f3", 0], + [20, "f4", 100], + [10, "f4", 200], + [20, "f4", 100], + [20, "f4", 200], + [20, "f1", 200], + [20, "f0", 200], + ], + columns=["id", "feature", "value"], + ) + id_map = IdMap.from_values([10, 20, 30]) + features = SparseFeatures.from_flatten(df, id_map=id_map, cat_features=cat_features) + + category_features = features.get_cat_features() + + assert expected_names == category_features.names + assert_sparse_matrix_equal(category_features.values, expected_values) diff --git a/tests/models/test_sasrec.py b/tests/models/test_sasrec.py index a7af7644..124e8844 100644 --- a/tests/models/test_sasrec.py +++ b/tests/models/test_sasrec.py @@ -9,9 +9,20 @@ from rectools.columns import Columns from rectools.dataset import Dataset, IdMap, Interactions -from rectools.models.sasrec import IdEmbeddingsItemNet, SASRecDataPreparator, SASRecModel, SequenceDataset +from rectools.dataset.features import SparseFeatures +from rectools.models.sasrec import ( + CatFeaturesItemNet, + IdEmbeddingsItemNet, + ItemNetBase, + ItemNetConstructor, + SASRecDataPreparator, + SASRecModel, + SequenceDataset, +) from tests.models.utils import assert_second_fit_refits_model -from tests.testing_utils import assert_id_map_equal, assert_interactions_set_equal +from tests.testing_utils import assert_feature_set_equal, assert_id_map_equal, assert_interactions_set_equal + +from .data import DATASET, INTERACTIONS class TestSASRecModel: @@ -582,3 +593,386 @@ def test_get_dataloader_recommend( dataloader = data_preparator.get_dataloader_recommend(dataset) actual = next(iter(dataloader)) assert torch.equal(actual, recommend_batch) + + +class TestIdEmbeddingsItemNet: + def setup_method(self) -> None: + self._seed_everything() + + def _seed_everything(self) -> None: + torch.use_deterministic_algorithms(True) + seed_everything(32, workers=True) + + @pytest.mark.parametrize("n_factors", (10, 100)) + def test_create_from_dataset(self, n_factors: int) -> None: + item_id_embeddings = IdEmbeddingsItemNet.from_dataset(DATASET, n_factors=n_factors, dropout_rate=0.5) + + actual_n_items = item_id_embeddings.n_items + actual_embedding_dim = item_id_embeddings.ids_emb.embedding_dim + + assert actual_n_items == DATASET.item_id_map.size + assert actual_embedding_dim == n_factors + + @pytest.mark.parametrize("n_items,n_factors", ((2, 10), (4, 100))) + def test_embedding_shape_after_model_pass(self, n_items: int, n_factors: int) -> None: + items = torch.from_numpy(np.random.choice(DATASET.item_id_map.internal_ids, size=n_items, replace=False)) + item_id_embeddings = IdEmbeddingsItemNet.from_dataset(DATASET, n_factors=n_factors, dropout_rate=0.5) + + expected_item_ids = item_id_embeddings(items) + assert expected_item_ids.shape == (n_items, n_factors) + + +@pytest.mark.filterwarnings("ignore::DeprecationWarning") +class TestCatFeaturesItemNet: + def setup_method(self) -> None: + self._seed_everything() + + def _seed_everything(self) -> None: + torch.use_deterministic_algorithms(True) + seed_everything(32, workers=True) + + @pytest.fixture + def dataset_item_features(self) -> Dataset: + item_features = pd.DataFrame( + [ + [11, "f1", "f1val1"], + [11, "f2", "f2val1"], + [12, "f1", "f1val1"], + [12, "f2", "f2val2"], + [13, "f1", "f1val1"], + [13, "f2", "f2val3"], + [14, "f1", "f1val2"], + [14, "f2", "f2val1"], + [15, "f1", "f1val2"], + [15, "f2", "f2val2"], + [17, "f1", "f1val2"], + [17, "f2", "f2val3"], + [16, "f1", "f1val2"], + [16, "f2", "f2val3"], + [11, "f3", 0], + [12, "f3", 1], + [13, "f3", 2], + [14, "f3", 3], + [15, "f3", 4], + [17, "f3", 5], + [16, "f3", 6], + ], + columns=["id", "feature", "value"], + ) + ds = Dataset.construct( + INTERACTIONS, + item_features_df=item_features, + cat_item_features=["f1", "f2"], + ) + return ds + + def test_feature_catalogue(self, dataset_item_features: Dataset) -> None: + cat_item_embeddings = CatFeaturesItemNet.from_dataset(dataset_item_features, n_factors=5, dropout_rate=0.5) + assert isinstance(cat_item_embeddings, CatFeaturesItemNet) + expected_feature_catalogue = torch.arange(0, cat_item_embeddings.n_cat_features) + assert torch.equal(cat_item_embeddings.feature_catalogue, expected_feature_catalogue) + + def test_get_dense_item_features(self, dataset_item_features: Dataset) -> None: + items = torch.from_numpy( + dataset_item_features.item_id_map.convert_to_internal(INTERACTIONS[Columns.Item].unique()) + ) + cat_item_embeddings = CatFeaturesItemNet.from_dataset(dataset_item_features, n_factors=5, dropout_rate=0.5) + + assert isinstance(cat_item_embeddings, CatFeaturesItemNet) + + actual_feature_dense = cat_item_embeddings.get_dense_item_features(items) + expected_feature_dense = torch.tensor( + [ + [1.0, 0.0, 1.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 1.0, 1.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 0.0, 1.0], + [0.0, 1.0, 0.0, 1.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 1.0], + ] + ) + + assert torch.equal(actual_feature_dense, expected_feature_dense) + + @pytest.mark.parametrize("n_factors", (10, 100)) + def test_create_from_dataset(self, n_factors: int, dataset_item_features: Dataset) -> None: + cat_item_embeddings = CatFeaturesItemNet.from_dataset( + dataset_item_features, n_factors=n_factors, dropout_rate=0.5 + ) + + assert isinstance(cat_item_embeddings, CatFeaturesItemNet) + + actual_item_features = cat_item_embeddings.item_features + actual_n_items = cat_item_embeddings.n_items + actual_n_cat_features = cat_item_embeddings.n_cat_features + actual_embedding_dim = cat_item_embeddings.category_embeddings.embedding_dim + + expected_item_features = dataset_item_features.item_features + + assert isinstance(expected_item_features, SparseFeatures) + expected_cat_item_features = expected_item_features.get_cat_features() + + assert_feature_set_equal(actual_item_features, expected_cat_item_features) + assert actual_n_items == dataset_item_features.item_id_map.size + assert actual_n_cat_features == len(expected_cat_item_features.names) + assert actual_embedding_dim == n_factors + + @pytest.mark.parametrize( + "n_items,n_factors", + ((2, 10), (4, 100)), + ) + def test_embedding_shape_after_model_pass( + self, dataset_item_features: Dataset, n_items: int, n_factors: int + ) -> None: + items = torch.from_numpy( + np.random.choice(dataset_item_features.item_id_map.internal_ids, size=n_items, replace=False) + ) + cat_item_embeddings = IdEmbeddingsItemNet.from_dataset( + dataset_item_features, n_factors=n_factors, dropout_rate=0.5 + ) + + expected_item_ids = cat_item_embeddings(items) + assert expected_item_ids.shape == (n_items, n_factors) + + @pytest.mark.parametrize( + "item_features,cat_item_features,make_dense_item_features", + ( + (None, (), False), + ( + pd.DataFrame( + [ + [11, "f3", 0], + [12, "f3", 1], + [13, "f3", 2], + [14, "f3", 3], + [15, "f3", 4], + [17, "f3", 5], + [16, "f3", 6], + ], + columns=["id", "feature", "value"], + ), + (), + False, + ), + ( + pd.DataFrame( + [ + [11, 1, 1], + [12, 1, 2], + [13, 1, 3], + [14, 2, 1], + [15, 2, 2], + [17, 2, 3], + ], + columns=[Columns.Item, "f1", "f2"], + ), + ["f1", "f2"], + True, + ), + ), + ) + def test_when_cat_item_features_is_none( + self, + item_features: tp.Optional[pd.DataFrame], + cat_item_features: tp.Iterable[str], + make_dense_item_features: bool, + ) -> None: + ds = Dataset.construct( + INTERACTIONS, + item_features_df=item_features, + cat_item_features=cat_item_features, + make_dense_item_features=make_dense_item_features, + ) + cat_features_item_net = CatFeaturesItemNet.from_dataset(ds, n_factors=10, dropout_rate=0.5) + assert cat_features_item_net is None + + +@pytest.mark.filterwarnings("ignore::DeprecationWarning") +class TestItemNetConstructor: + def setup_method(self) -> None: + self._seed_everything() + + def _seed_everything(self) -> None: + torch.use_deterministic_algorithms(True) + seed_everything(32, workers=True) + + @pytest.fixture + def dataset_item_features(self) -> Dataset: + item_features = pd.DataFrame( + [ + [11, "f1", "f1val1"], + [11, "f2", "f2val1"], + [12, "f1", "f1val1"], + [12, "f2", "f2val2"], + [13, "f1", "f1val1"], + [13, "f2", "f2val3"], + [14, "f1", "f1val2"], + [14, "f2", "f2val1"], + [15, "f1", "f1val2"], + [15, "f2", "f2val2"], + [16, "f1", "f1val2"], + [16, "f2", "f2val3"], + [11, "f3", 0], + [12, "f3", 1], + [13, "f3", 2], + [14, "f3", 3], + [15, "f3", 4], + [16, "f3", 6], + ], + columns=["id", "feature", "value"], + ) + ds = Dataset.construct( + INTERACTIONS, + item_features_df=item_features, + cat_item_features=["f1", "f2"], + ) + return ds + + def test_catalogue(self) -> None: + item_net = ItemNetConstructor.from_dataset( + DATASET, n_factors=10, dropout_rate=0.5, item_net_block_types=(IdEmbeddingsItemNet,) + ) + expected_feature_catalogue = torch.arange(0, DATASET.item_id_map.size) + assert torch.equal(item_net.catalogue, expected_feature_catalogue) + + @pytest.mark.parametrize( + "item_net_block_types,n_factors", + ( + ((IdEmbeddingsItemNet,), 8), + ((IdEmbeddingsItemNet, CatFeaturesItemNet), 16), + ((CatFeaturesItemNet,), 16), + ), + ) + def test_get_all_embeddings( + self, dataset_item_features: Dataset, item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]], n_factors: int + ) -> None: + item_net = ItemNetConstructor.from_dataset( + dataset_item_features, n_factors=n_factors, dropout_rate=0.5, item_net_block_types=item_net_block_types + ) + assert item_net.get_all_embeddings().shape == (item_net.n_items, n_factors) + + @pytest.mark.parametrize( + "item_net_block_types,make_dense_item_features,expected_n_item_net_blocks", + ( + ((IdEmbeddingsItemNet,), False, 1), + ((IdEmbeddingsItemNet, CatFeaturesItemNet), False, 2), + ((IdEmbeddingsItemNet,), True, 1), + ((IdEmbeddingsItemNet, CatFeaturesItemNet), True, 1), + ), + ) + def test_correct_number_of_item_net_blocks( + self, + dataset_item_features: Dataset, + item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]], + make_dense_item_features: bool, + expected_n_item_net_blocks: int, + ) -> None: + if make_dense_item_features: + item_features = pd.DataFrame( + [ + [11, "f3", 0], + [12, "f3", 1], + [13, "f3", 2], + [14, "f3", 3], + [15, "f3", 4], + [17, "f3", 5], + [16, "f3", 6], + ], + columns=["id", "feature", "value"], + ) + ds = Dataset.construct( + INTERACTIONS, + item_features_df=item_features, + make_dense_user_features=make_dense_item_features, + ) + else: + ds = dataset_item_features + + item_net: ItemNetConstructor = ItemNetConstructor.from_dataset( + ds, n_factors=10, dropout_rate=0.5, item_net_block_types=item_net_block_types + ) + + actual_n_items = item_net.n_items + actual_n_item_net_blocks = len(item_net.item_net_blocks) + + assert actual_n_items == dataset_item_features.item_id_map.size + assert actual_n_item_net_blocks == expected_n_item_net_blocks + + @pytest.mark.parametrize( + "item_net_block_types,n_items,n_factors", + ( + ((IdEmbeddingsItemNet,), 2, 16), + ((IdEmbeddingsItemNet, CatFeaturesItemNet), 4, 8), + ), + ) + def test_embedding_shape_after_model_pass( + self, + dataset_item_features: Dataset, + item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]], + n_items: int, + n_factors: int, + ) -> None: + items = torch.from_numpy( + np.random.choice(dataset_item_features.item_id_map.internal_ids, size=n_items, replace=False) + ) + item_net: ItemNetConstructor = ItemNetConstructor.from_dataset( + dataset_item_features, n_factors=n_factors, dropout_rate=0.5, item_net_block_types=item_net_block_types + ) + + expected_embeddings = item_net(items) + + assert expected_embeddings.shape == (n_items, n_factors) + + @pytest.mark.parametrize( + "item_net_block_types,item_features,make_dense_item_features", + ( + ([], None, False), + ((CatFeaturesItemNet,), None, False), + ( + (CatFeaturesItemNet,), + pd.DataFrame( + [ + [11, 1, 1], + [12, 1, 2], + [13, 1, 3], + [14, 2, 1], + [15, 2, 2], + [17, 2, 3], + ], + columns=[Columns.Item, "f1", "f2"], + ), + True, + ), + ( + (CatFeaturesItemNet,), + pd.DataFrame( + [ + [11, "f3", 0], + [12, "f3", 1], + [13, "f3", 2], + [14, "f3", 3], + [15, "f3", 4], + [17, "f3", 5], + [16, "f3", 6], + ], + columns=[Columns.Item, "feature", "value"], + ), + False, + ), + ), + ) + def test_raise_when_no_item_net_blocks( + self, + item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]], + item_features: tp.Optional[pd.DataFrame], + make_dense_item_features: bool, + ) -> None: + ds = Dataset.construct( + INTERACTIONS, + item_features_df=item_features, + make_dense_item_features=make_dense_item_features, + ) + with pytest.raises(ValueError): + ItemNetConstructor.from_dataset( + ds, n_factors=10, dropout_rate=0.5, item_net_block_types=item_net_block_types + ) From a94dc2924f796d3241060924c017b33462751855 Mon Sep 17 00:00:00 2001 From: spirinamayya <90619187+spirinamayya@users.noreply.github.com> Date: Mon, 25 Nov 2024 15:06:46 +0300 Subject: [PATCH 09/13] Sasrec loss (#198) Added bce and gbce losses --- examples/sasrec_metrics_comp.ipynb | 1476 +++++++++++++++------------- rectools/models/bert4rec.py | 27 +- rectools/models/sasrec.py | 258 +++-- tests/models/test_sasrec.py | 31 +- 4 files changed, 984 insertions(+), 808 deletions(-) diff --git a/examples/sasrec_metrics_comp.ipynb b/examples/sasrec_metrics_comp.ipynb index b3053f8f..693760c4 100644 --- a/examples/sasrec_metrics_comp.ipynb +++ b/examples/sasrec_metrics_comp.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -128,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -152,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -169,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -186,19 +186,19 @@ " metrics[f'{metric_name}@{k}'] = metric(k=k)\n", "\n", "# list with metrics results of all models\n", - "features_results = []\n" + "features_results = []" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# sasrec" + "# SASRec" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -214,7 +214,7 @@ "32" ] }, - "execution_count": 39, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -225,25 +225,16 @@ "seed_everything(RANDOM_SEED, workers=True)" ] }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "session_maxlen=32" - ] - }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### sasrec with item ids embeddings in ItemNetBlock" + "## Softmax loss" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -267,12 +258,12 @@ " verbose=1,\n", " deterministic=True,\n", " item_net_block_types=(IdEmbeddingsItemNet, ) # Use only item ids in ItemNetBlock\n", - ")" + ")\n" ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -295,7 +286,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "872b6e4e393b469db004bdd889a89533", + "model_id": "4ae70ba676fa4f41b5153c137e3364cb", "version_major": 2, "version_minor": 0 }, @@ -313,32 +304,40 @@ "`Trainer.fit` stopped: `max_epochs=5` reached.\n" ] }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 6min 36s, sys: 9.8 s, total: 6min 46s\n", + "Wall time: 6min 25s\n" + ] + }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 42, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "#%%time\n", + "%%time\n", "model.fit(dataset_no_features)" ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:786: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:790: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", @@ -352,7 +351,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ddd4a5fc9400481f98f0f0c0c086b96f", + "model_id": "12e7dd5ca3cb464ebb9d8baa4dd8e061", "version_major": 2, "version_minor": 0 }, @@ -367,8 +366,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 29.8 s, sys: 6.86 s, total: 36.6 s\n", - "Wall time: 25.1 s\n" + "CPU times: user 30.3 s, sys: 3.45 s, total: 33.8 s\n", + "Wall time: 24.3 s\n" ] } ], @@ -385,169 +384,56 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", "metric_values = calc_metrics(metrics, recos[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", - "metric_values[\"model\"] = \"sasrec_ids\"\n", - "features_results.append(metric_values)" + "metric_values[\"model\"] = \"softmax\"\n", + "features_results.append(metric_values)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## BCE loss" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 40, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Seed set to 32\n" + ] + }, { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_iditem_idscorerank
575550377932.7551871
575551378292.6235832
5755523152972.6182093
575553337842.3957074
5755543148991.9945785
...............
224955109754437342.1089716
2249561097544138652.0898627
2249571097544144312.0583028
224958109754441511.9439509
2249591097544152971.94186410
\n", - "

947050 rows × 4 columns

\n", - "
" - ], "text/plain": [ - " user_id item_id score rank\n", - "575550 3 7793 2.755187 1\n", - "575551 3 7829 2.623583 2\n", - "575552 3 15297 2.618209 3\n", - "575553 3 3784 2.395707 4\n", - "575554 3 14899 1.994578 5\n", - "... ... ... ... ...\n", - "224955 1097544 3734 2.108971 6\n", - "224956 1097544 13865 2.089862 7\n", - "224957 1097544 14431 2.058302 8\n", - "224958 1097544 4151 1.943950 9\n", - "224959 1097544 15297 1.941864 10\n", - "\n", - "[947050 rows x 4 columns]" + "32" ] }, - "execution_count": 45, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# major recommend\n", - "recos.sort_values([\"user_id\", \"rank\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### sasrec with item ids and category features embeddings in ItemNetBlock" + "RANDOM_SEED = 32\n", + "torch.use_deterministic_algorithms(True)\n", + "seed_everything(RANDOM_SEED, workers=True)" ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -570,13 +456,14 @@ " epochs=5,\n", " verbose=1,\n", " deterministic=True,\n", - " item_net_block_types=(IdEmbeddingsItemNet, CatFeaturesItemNet) # Use item ids and cat features in ItemNetBlock\n", - ")" + " loss=\"BCE\",\n", + " item_net_block_types=(IdEmbeddingsItemNet, ) # Use only item ids in ItemNetBlock\n", + ")\n" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -587,19 +474,19 @@ "\n", " | Name | Type | Params\n", "---------------------------------------------------------------\n", - "0 | torch_model | TransformerBasedSessionEncoder | 935 K \n", + "0 | torch_model | TransformerBasedSessionEncoder | 927 K \n", "---------------------------------------------------------------\n", - "935 K Trainable params\n", + "927 K Trainable params\n", "0 Non-trainable params\n", - "935 K Total params\n", - "3.742 Total estimated model params size (MB)\n", + "927 K Total params\n", + "3.709 Total estimated model params size (MB)\n", "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8ebf5302f89a4a208fd1cc380897d01e", + "model_id": "026eb575d3ff4b61b3d6d141c72ae13d", "version_major": 2, "version_minor": 0 }, @@ -614,37 +501,43 @@ "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/tasks/repo/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", - " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", "`Trainer.fit` stopped: `max_epochs=5` reached.\n" ] }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 6min 39s, sys: 11.4 s, total: 6min 50s\n", + "Wall time: 6min 36s\n" + ] + }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 48, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "#%%time\n", - "model.fit(dataset_item_features)" + "%%time\n", + "model.fit(dataset_no_features)" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:786: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:790: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", @@ -658,7 +551,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "612e92b761d741348fd7ec531d2a1964", + "model_id": "6489bb7e2f4c498f8fb72f295cf835cf", "version_major": 2, "version_minor": 0 }, @@ -673,8 +566,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 26.8 s, sys: 5.79 s, total: 32.6 s\n", - "Wall time: 21.7 s\n" + "CPU times: user 28.7 s, sys: 3.63 s, total: 32.3 s\n", + "Wall time: 22 s\n" ] } ], @@ -682,7 +575,7 @@ "%%time\n", "recos = model.recommend(\n", " users=test_users_sasrec, \n", - " dataset=dataset_item_features,\n", + " dataset=dataset_no_features,\n", " k=10,\n", " filter_viewed=True,\n", " on_unsupported_targets=\"warn\"\n", @@ -691,14 +584,14 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", "metric_values = calc_metrics(metrics, recos[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", - "metric_values[\"model\"] = \"sasrec_ids_cat\"\n", + "metric_values[\"model\"] = \"bce\"\n", "features_results.append(metric_values)" ] }, @@ -706,12 +599,41 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### sasrec with category item features embeddings in ItemNetBlock" + "## gBCE loss" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Seed set to 32\n" + ] + }, + { + "data": { + "text/plain": [ + "32" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "RANDOM_SEED = 32\n", + "torch.use_deterministic_algorithms(True)\n", + "seed_everything(RANDOM_SEED, workers=True)" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -734,13 +656,16 @@ " epochs=5,\n", " verbose=1,\n", " deterministic=True,\n", - " item_net_block_types=(CatFeaturesItemNet, ) # Use only cat item features in ItemNetBlock\n", + " loss=\"gBCE\",\n", + " n_negatives=256,\n", + " gbce_t=0.75,\n", + " item_net_block_types=(IdEmbeddingsItemNet, ) # Use only item ids in ItemNetBlock\n", ")" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -751,19 +676,19 @@ "\n", " | Name | Type | Params\n", "---------------------------------------------------------------\n", - "0 | torch_model | TransformerBasedSessionEncoder | 211 K \n", + "0 | torch_model | TransformerBasedSessionEncoder | 927 K \n", "---------------------------------------------------------------\n", - "211 K Trainable params\n", + "927 K Trainable params\n", "0 Non-trainable params\n", - "211 K Total params\n", - "0.847 Total estimated model params size (MB)\n", + "927 K Total params\n", + "3.709 Total estimated model params size (MB)\n", "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5c099fbd68504c60893ca8beabe1e9ac", + "model_id": "1ff49bfd02a740b4abf2b43eab16915f", "version_major": 2, "version_minor": 0 }, @@ -778,37 +703,43 @@ "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/tasks/repo/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", - " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", "`Trainer.fit` stopped: `max_epochs=5` reached.\n" ] }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2h 26min 4s, sys: 39.6 s, total: 2h 26min 43s\n", + "Wall time: 10min 49s\n" + ] + }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 52, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "#%%time\n", - "model.fit(dataset_item_features)" + "%%time\n", + "model.fit(dataset_no_features)" ] }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:786: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:790: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", @@ -822,7 +753,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "59de5ff7662c493f8e96359a7c3b2190", + "model_id": "723345dda1cd4b9997ba226476a6dce3", "version_major": 2, "version_minor": 0 }, @@ -837,8 +768,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 27.1 s, sys: 6.15 s, total: 33.2 s\n", - "Wall time: 22.2 s\n" + "CPU times: user 31.5 s, sys: 3.95 s, total: 35.5 s\n", + "Wall time: 26 s\n" ] } ], @@ -846,70 +777,58 @@ "%%time\n", "recos = model.recommend(\n", " users=test_users_sasrec, \n", - " dataset=dataset_item_features,\n", + " dataset=dataset_no_features,\n", " k=10,\n", " filter_viewed=True,\n", " on_unsupported_targets=\"warn\"\n", - ")" + ")\n" ] }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", "metric_values = calc_metrics(metrics, recos[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", - "metric_values[\"model\"] = \"sasrec_cat\"\n", + "metric_values[\"model\"] = \"gBCE\"\n", "features_results.append(metric_values)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Item to item" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [], - "source": [ - "target_items = [13865, 4457, 15297]" - ] - }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 30, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 1.38 s, sys: 132 ms, total: 1.51 s\n", - "Wall time: 1.04 s\n" - ] + "data": { + "text/plain": [ + "[{'MAP@1': 0.047545855054294456,\n", + " 'MAP@5': 0.0811899212734244,\n", + " 'MAP@10': 0.08998959207113556,\n", + " 'MIUF@1': 18.824620072061013,\n", + " 'MIUF@5': 18.824620072061013,\n", + " 'MIUF@10': 18.824620072061013,\n", + " 'Serendipity@1': 0.09685866638509054,\n", + " 'Serendipity@5': 0.05965352221273331,\n", + " 'Serendipity@10': 0.04342951535717909,\n", + " 'model': 'gBCE'}]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "%%time\n", - "recos = model.recommend_to_items(\n", - " target_items=target_items, \n", - " dataset=dataset_no_features,\n", - " k=10,\n", - " filter_itself=True,\n", - " items_to_recommend=None, #white_list,\n", - ")" + "features_results" ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -933,561 +852,696 @@ " \n", " \n", " \n", - " target_item_id\n", - " item_id\n", - " score\n", - " rank\n", - " \n", - " \n", - " \n", - " \n", - " 0\n", - " 13865\n", - " 15648\n", - " 1.000000\n", - " 1\n", - " \n", - " \n", - " 1\n", - " 13865\n", - " 3386\n", - " 1.000000\n", - " 2\n", - " \n", - " \n", - " 2\n", - " 13865\n", - " 147\n", - " 0.898218\n", - " 3\n", + " MAP@1\n", + " MAP@5\n", + " MAP@10\n", + " MIUF@1\n", + " MIUF@5\n", + " MIUF@10\n", + " Serendipity@1\n", + " Serendipity@5\n", + " Serendipity@10\n", " \n", " \n", - " 3\n", - " 13865\n", - " 16194\n", - " 0.898218\n", - " 4\n", - " \n", - " \n", - " 4\n", - " 13865\n", - " 12309\n", - " 0.898218\n", - " 5\n", - " \n", - " \n", - " 5\n", - " 13865\n", - " 12586\n", - " 0.898218\n", - " 6\n", + " model\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", " \n", - " 6\n", - " 13865\n", - " 6661\n", - " 0.898218\n", - " 7\n", + " softmax\n", + " 0.048967\n", + " 0.082847\n", + " 0.092022\n", + " 18.82462\n", + " 18.82462\n", + " 18.82462\n", + " 0.100744\n", + " 0.060646\n", + " 0.044432\n", " \n", " \n", - " 7\n", - " 13865\n", - " 2255\n", - " 0.898218\n", - " 8\n", + " gBCE\n", + " 0.047546\n", + " 0.081190\n", + " 0.089990\n", + " 18.82462\n", + " 18.82462\n", + " 18.82462\n", + " 0.096859\n", + " 0.059654\n", + " 0.043430\n", " \n", " \n", - " 8\n", - " 13865\n", - " 3792\n", - " 0.898218\n", - " 9\n", + " bce\n", + " 0.043528\n", + " 0.074286\n", + " 0.083131\n", + " 18.82462\n", + " 18.82462\n", + " 18.82462\n", + " 0.088359\n", + " 0.055013\n", + " 0.041208\n", " \n", - " \n", - " 9\n", - " 13865\n", - " 4130\n", - " 0.898218\n", - " 10\n", + " \n", + "\n", + "" + ], + "text/plain": [ + " MAP@1 MAP@5 MAP@10 MIUF@1 MIUF@5 MIUF@10 \\\n", + "model \n", + "softmax 0.048967 0.082847 0.092022 18.82462 18.82462 18.82462 \n", + "gBCE 0.047546 0.081190 0.089990 18.82462 18.82462 18.82462 \n", + "bce 0.043528 0.074286 0.083131 18.82462 18.82462 18.82462 \n", + "\n", + " Serendipity@1 Serendipity@5 Serendipity@10 \n", + "model \n", + "softmax 0.100744 0.060646 0.044432 \n", + "gBCE 0.096859 0.059654 0.043430 \n", + "bce 0.088359 0.055013 0.041208 " + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "features_df = (\n", + " pd.DataFrame(features_results)\n", + " .set_index(\"model\")\n", + " .sort_values(by=[\"MAP@10\", \"Serendipity@10\"], ascending=False)\n", + ")\n", + "features_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### sasrec with item ids embeddings in ItemNetBlock" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], + "source": [ + "model = SASRecModel(\n", + " n_blocks=2,\n", + " session_max_len=32,\n", + " lr=1e-3,\n", + " epochs=5,\n", + " verbose=1,\n", + " deterministic=True,\n", + " item_net_block_types=(IdEmbeddingsItemNet, ) # Use only item ids in ItemNetBlock\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------------------------\n", + "0 | torch_model | TransformerBasedSessionEncoder | 289 K \n", + "---------------------------------------------------------------\n", + "289 K Trainable params\n", + "0 Non-trainable params\n", + "289 K Total params\n", + "1.157 Total estimated model params size (MB)\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/loops/fit_loop.py:298: The number of training batches (29) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb03532e057c480b82f280cb35f969e8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "model.fit(dataset_no_features)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:777: UserWarning: 8407 target users were considered cold because of missing known items\n", + " warnings.warn(explanation)\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", + " Model `` doesn't support recommendations for cold users,\n", + " but some of given users are cold: they are not in the `dataset.user_id_map`\n", + " \n", + " warnings.warn(explanation)\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d691db0e941b4a2b92b3448b098bba09", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Predicting: | | 0/? [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", + " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", "
user_iditem_idscorerank
10445751091.0000009901398152973.2938921
11445788511.0000009911398138652.5455972
12445784861.000000992139837342.5081513
134457120871.0000009931398104402.4806594
14445723131.000000994139871021.7911825
154457119771.0000006
16445779281.0000007
17445733841.0000008
184457115131.0000009...............
1912151097060445762851.00000010
201529787231.0000001
211529759261.0000002
221529741311.0000003
231529742291.0000004
241529770051.0000005
2515297107971.0000001.5744686
2615297105351.0000001216109706026571.4815997
271529754001.0000001217109706071021.4584678
281529747161.0000001218109706041511.4464329
2915297131031.000000121910970601421.32679410
\n", + "

1500 rows × 4 columns

\n", "" ], "text/plain": [ - " target_item_id item_id score rank\n", - "0 13865 15648 1.000000 1\n", - "1 13865 3386 1.000000 2\n", - "2 13865 147 0.898218 3\n", - "3 13865 16194 0.898218 4\n", - "4 13865 12309 0.898218 5\n", - "5 13865 12586 0.898218 6\n", - "6 13865 6661 0.898218 7\n", - "7 13865 2255 0.898218 8\n", - "8 13865 3792 0.898218 9\n", - "9 13865 4130 0.898218 10\n", - "10 4457 5109 1.000000 1\n", - "11 4457 8851 1.000000 2\n", - "12 4457 8486 1.000000 3\n", - "13 4457 12087 1.000000 4\n", - "14 4457 2313 1.000000 5\n", - "15 4457 11977 1.000000 6\n", - "16 4457 7928 1.000000 7\n", - "17 4457 3384 1.000000 8\n", - "18 4457 11513 1.000000 9\n", - "19 4457 6285 1.000000 10\n", - "20 15297 8723 1.000000 1\n", - "21 15297 5926 1.000000 2\n", - "22 15297 4131 1.000000 3\n", - "23 15297 4229 1.000000 4\n", - "24 15297 7005 1.000000 5\n", - "25 15297 10797 1.000000 6\n", - "26 15297 10535 1.000000 7\n", - "27 15297 5400 1.000000 8\n", - "28 15297 4716 1.000000 9\n", - "29 15297 13103 1.000000 10" + " user_id item_id score rank\n", + "990 1398 15297 3.293892 1\n", + "991 1398 13865 2.545597 2\n", + "992 1398 3734 2.508151 3\n", + "993 1398 10440 2.480659 4\n", + "994 1398 7102 1.791182 5\n", + "... ... ... ... ...\n", + "1215 1097060 4457 1.574468 6\n", + "1216 1097060 2657 1.481599 7\n", + "1217 1097060 7102 1.458467 8\n", + "1218 1097060 4151 1.446432 9\n", + "1219 1097060 142 1.326794 10\n", + "\n", + "[1500 rows x 4 columns]" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# major recommend\n", + "recos.sort_values([\"user_id\", \"rank\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'MAP@1': 0.006666666666666667,\n", + " 'MAP@5': 0.008,\n", + " 'MAP@10': 0.010952380952380951,\n", + " 'MIUF@1': 11.847448903982434,\n", + " 'MIUF@5': 11.847448903982434,\n", + " 'MIUF@10': 11.847448903982434,\n", + " 'Serendipity@1': 0.006666666666666667,\n", + " 'Serendipity@5': 0.002658682634730539,\n", + " 'Serendipity@10': 0.003963073852295409,\n", + " 'model': 'softmax'},\n", + " {'MAP@1': 0.0,\n", + " 'MAP@5': 0.00611111111111111,\n", + " 'MAP@10': 0.008888888888888889,\n", + " 'MIUF@1': 11.847448903982434,\n", + " 'MIUF@5': 11.847448903982434,\n", + " 'MIUF@10': 11.847448903982434,\n", + " 'Serendipity@1': 0.0,\n", + " 'Serendipity@5': 0.003986027944111776,\n", + " 'Serendipity@10': 0.004627744510978044,\n", + " 'model': 'bce'},\n", + " {'MAP@1': 0.0,\n", + " 'MAP@5': 0.0016666666666666668,\n", + " 'MAP@10': 0.004944444444444445,\n", + " 'MIUF@1': 11.847448903982434,\n", + " 'MIUF@5': 11.847448903982434,\n", + " 'MIUF@10': 11.847448903982434,\n", + " 'Serendipity@1': 0.0,\n", + " 'Serendipity@5': 0.0013273453093812376,\n", + " 'Serendipity@10': 0.0033003992015968064,\n", + " 'model': 'gBCE'},\n", + " {'MAP@1': 0.0,\n", + " 'MAP@5': 0.0013333333333333335,\n", + " 'MAP@10': 0.005851851851851852,\n", + " 'MIUF@1': 11.847448903982434,\n", + " 'MIUF@5': 11.847448903982434,\n", + " 'MIUF@10': 11.847448903982434,\n", + " 'Serendipity@1': 0.0,\n", + " 'Serendipity@5': 0.0013253493013972056,\n", + " 'Serendipity@10': 0.0046177644710578844,\n", + " 'model': 'sasrec_ids'}]" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "features_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### sasrec with item ids and category features embeddings in ItemNetBlock" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "model = SASRecModel(\n", + " n_blocks=2,\n", + " session_max_len=32,\n", + " lr=1e-3,\n", + " epochs=5,\n", + " verbose=1,\n", + " deterministic=True,\n", + " item_net_block_types=(IdEmbeddingsItemNet, CatFeaturesItemNet) # Use item ids and cat features in ItemNetBlock\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------------------------\n", + "0 | torch_model | TransformerBasedSessionEncoder | 289 K \n", + "---------------------------------------------------------------\n", + "289 K Trainable params\n", + "0 Non-trainable params\n", + "289 K Total params\n", + "1.157 Total estimated model params size (MB)\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/loops/fit_loop.py:298: The number of training batches (29) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cc0dda9903ee43eeb1571294a780f231", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" ] }, - "execution_count": 58, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "recos" + "#%%time\n", + "model.fit(dataset_item_features)" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 44, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:777: UserWarning: 8407 target users were considered cold because of missing known items\n", + " warnings.warn(explanation)\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", + " Model `` doesn't support recommendations for cold users,\n", + " but some of given users are cold: they are not in the `dataset.user_id_map`\n", + " \n", + " warnings.warn(explanation)\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "15b86d1de5064bc1ab3e6593e2dab70f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Predicting: | | 0/? [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
MAP@1MAP@5MAP@10MIUF@1MIUF@5MIUF@10Serendipity@1Serendipity@5Serendipity@10
model
sasrec_ids0.0489670.0828470.09202218.8246218.8246218.824620.1007440.0606460.044432
sasrec_ids_cat0.0482340.0819250.09101518.8246218.8246218.824620.0989600.0601310.044194
full_features_factors_128_fit_together_True0.0338500.0565860.06254718.8246218.8246218.824620.0700390.0421340.030772
no_features_factors_128_alpha_10_reg_0.50.0155230.0284650.03281418.8246218.8246218.824620.0360700.0254590.020493
sasrec_cat0.0017260.0060890.00715318.8246218.8246218.824620.0055440.0062850.005200
\n", - "" - ], - "text/plain": [ - " MAP@1 MAP@5 MAP@10 \\\n", - "model \n", - "sasrec_ids 0.048967 0.082847 0.092022 \n", - "sasrec_ids_cat 0.048234 0.081925 0.091015 \n", - "full_features_factors_128_fit_together_True 0.033850 0.056586 0.062547 \n", - "no_features_factors_128_alpha_10_reg_0.5 0.015523 0.028465 0.032814 \n", - "sasrec_cat 0.001726 0.006089 0.007153 \n", - "\n", - " MIUF@1 MIUF@5 MIUF@10 \\\n", - "model \n", - "sasrec_ids 18.82462 18.82462 18.82462 \n", - "sasrec_ids_cat 18.82462 18.82462 18.82462 \n", - "full_features_factors_128_fit_together_True 18.82462 18.82462 18.82462 \n", - "no_features_factors_128_alpha_10_reg_0.5 18.82462 18.82462 18.82462 \n", - "sasrec_cat 18.82462 18.82462 18.82462 \n", - "\n", - " Serendipity@1 Serendipity@5 \\\n", - "model \n", - "sasrec_ids 0.100744 0.060646 \n", - "sasrec_ids_cat 0.098960 0.060131 \n", - "full_features_factors_128_fit_together_True 0.070039 0.042134 \n", - "no_features_factors_128_alpha_10_reg_0.5 0.036070 0.025459 \n", - "sasrec_cat 0.005544 0.006285 \n", - "\n", - " Serendipity@10 \n", - "model \n", - "sasrec_ids 0.044432 \n", - "sasrec_ids_cat 0.044194 \n", - "full_features_factors_128_fit_together_True 0.030772 \n", - "no_features_factors_128_alpha_10_reg_0.5 0.020493 \n", - "sasrec_cat 0.005200 " - ] - }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "features_df = (\n", - " pd.DataFrame(features_results)\n", - " .set_index(\"model\")\n", - " .sort_values(by=[\"MAP@10\", \"Serendipity@10\"], ascending=False)\n", - ")\n", - "features_df" + "target_items = [13865, 4457, 15297]" ] }, { @@ -1495,7 +1549,39 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "%%time\n", + "recos = model.recommend_to_items(\n", + " target_items=target_items, \n", + " dataset=dataset,\n", + " k=10,\n", + " filter_itself=True,\n", + " items_to_recommend=None, #white_list,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "recos" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "features_df = (\n", + " pd.DataFrame(features_results)\n", + " .set_index(\"model\")\n", + " .sort_values(by=[\"MAP@10\", \"Serendipity@10\"], ascending=False)\n", + ")\n", + "features_df" + ] } ], "metadata": { @@ -1518,5 +1604,5 @@ } }, "nbformat": 4, - "nbformat_minor": 4 + "nbformat_minor": 2 } diff --git a/rectools/models/bert4rec.py b/rectools/models/bert4rec.py index 1a054864..6d9285a2 100644 --- a/rectools/models/bert4rec.py +++ b/rectools/models/bert4rec.py @@ -1,5 +1,5 @@ import typing as tp -from typing import List, Tuple +from typing import Dict, List, Tuple import numpy as np import torch @@ -30,6 +30,7 @@ class BERT4RecDataPreparator(SessionEncoderDataPreparatorBase): def __init__( self, session_max_len: int, + n_negatives: tp.Optional[int], batch_size: int, dataloader_num_workers: int, train_min_user_interactions: int, @@ -39,6 +40,7 @@ def __init__( ) -> None: super().__init__( session_max_len=session_max_len, + n_negatives=n_negatives, batch_size=batch_size, dataloader_num_workers=dataloader_num_workers, train_min_user_interactions=train_min_user_interactions, @@ -65,7 +67,7 @@ def _mask_session(self, ses: List[int]) -> Tuple[List[int], List[int]]: def _collate_fn_train( self, batch: List[Tuple[List[int], List[float]]], - ) -> Tuple[torch.LongTensor, torch.LongTensor, torch.FloatTensor]: + ) -> Dict[str, torch.Tensor]: """TODO""" batch_size = len(batch) x = np.zeros((batch_size, self.session_max_len + 1)) @@ -77,16 +79,25 @@ def _collate_fn_train( y[i, -len(ses) :] = target # ses: [session_len] -> y[i]: [session_max_len + 1] yw[i, -len(ses) :] = ses_weights # ses_weights: [session_len] -> yw[i]: [session_max_len + 1] - return torch.LongTensor(x), torch.LongTensor(y), torch.FloatTensor(yw) - - def _collate_fn_recommend(self, batch: List[Tuple[List[int], List[float]]]) -> torch.LongTensor: + batch_dict = {"x": torch.LongTensor(x), "y": torch.LongTensor(y), "yw": torch.FloatTensor(yw)} + # TODO: we are sampling negatives for paddings + if self.n_negatives is not None: + negatives = torch.randint( + low=self.n_item_extra_tokens, + high=self.item_id_map.size, + size=(batch_size, self.session_max_len, self.n_negatives), + ) # [batch_size, session_max_len, n_negatives] + batch_dict["negatives"] = negatives + return batch_dict + + def _collate_fn_recommend(self, batch: List[Tuple[List[int], List[float]]]) -> Dict[str, torch.Tensor]: """Right truncation, left padding to session_max_len""" x = np.zeros((len(batch), self.session_max_len + 1)) for i, (ses, _) in enumerate(batch): session = ses.copy() session = session + [self.extra_token_ids[MASKING_VALUE]] x[i, -len(ses) - 1 :] = session[-self.session_max_len - 1 :] - return torch.LongTensor(x) + return {"x": torch.LongTensor(x)} class BERT4RecTransformerLayers(TransformerLayersBase): @@ -154,8 +165,10 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals deterministic: bool = False, cpu_n_threads: int = 0, session_max_len: int = 32, + n_negatives: int = 1, batch_size: int = 128, loss: str = "softmax", + gbce_t: float = 0.2, lr: float = 0.01, dataloader_num_workers: int = 0, train_min_user_interaction: int = 2, @@ -182,6 +195,7 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals deterministic=deterministic, cpu_n_threads=cpu_n_threads, loss=loss, + gbce_t=gbce_t, lr=lr, session_max_len=session_max_len + 1, trainer=trainer, @@ -191,6 +205,7 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals ) self.data_preparator = data_preparator_type( session_max_len=session_max_len, + n_negatives=n_negatives if loss != "softmax" else None, batch_size=batch_size, dataloader_num_workers=dataloader_num_workers, train_min_user_interactions=train_min_user_interaction, diff --git a/rectools/models/sasrec.py b/rectools/models/sasrec.py index 6d6ea26e..4903ef57 100644 --- a/rectools/models/sasrec.py +++ b/rectools/models/sasrec.py @@ -1,7 +1,7 @@ import typing as tp import warnings from copy import deepcopy -from typing import List, Tuple +from typing import Dict, List, Tuple import numpy as np import pandas as pd @@ -105,18 +105,18 @@ def forward(self, items: torch.Tensor) -> torch.Tensor: torch.Tensor Item embeddings. """ + device = self.category_embeddings.weight.device # TODO: Should we use torch.nn.EmbeddingBag? feature_dense = self.get_dense_item_features(items) - feature_dense.to(items.device) - feature_embs = self.category_embeddings(self.feature_catalogue.to(items.device)) + feature_embs = self.category_embeddings(self.feature_catalog.to(device)) feature_embs = self.drop_layer(feature_embs) - feature_embeddings_per_items = feature_dense @ feature_embs + feature_embeddings_per_items = feature_dense.to(device) @ feature_embs return feature_embeddings_per_items @property - def feature_catalogue(self) -> torch.Tensor: + def feature_catalog(self) -> torch.Tensor: """Return tensor with elements in range [0, n_cat_features).""" return torch.arange(0, self.n_cat_features) @@ -218,7 +218,7 @@ def forward(self, items: torch.Tensor) -> torch.Tensor: torch.Tensor Item embeddings. """ - item_embs = self.ids_emb(items) + item_embs = self.ids_emb(items.to(self.ids_emb.weight.device)) item_embs = self.drop_layer(item_embs) return item_embs @@ -278,13 +278,13 @@ def forward(self, items: torch.Tensor) -> torch.Tensor: return torch.sum(torch.stack(item_embs, dim=0), dim=0) @property - def catalogue(self) -> torch.Tensor: + def catalog(self) -> torch.Tensor: """Return tensor with elements in range [0, n_items).""" return torch.arange(0, self.n_items) def get_all_embeddings(self) -> torch.Tensor: """Return item embeddings.""" - return self.forward(self.catalogue) + return self.forward(self.catalog) @classmethod def from_dataset( @@ -599,12 +599,11 @@ def encode_sessions(self, sessions: torch.Tensor, item_embs: torch.Tensor) -> to def forward( self, sessions: torch.Tensor, # [batch_size, session_max_len] - ) -> torch.Tensor: + ) -> Tuple[torch.Tensor, torch.Tensor]: """ - Forward pass to get logits. + Forward pass to get item and session embeddings. Get item embeddings. Pass user sessions through transformer blocks. - Calculate logits. Parameters ---------- @@ -613,13 +612,11 @@ def forward( Returns ------- - torch.Tensor - Logits. + (torch.Tensor, torch.Tensor) """ - item_embs = self.item_model.get_all_embeddings() # [n_items + n_special_tokens, n_factors] + item_embs = self.item_model.get_all_embeddings() # [n_items + n_item_extra_tokens, n_factors] session_embs = self.encode_sessions(sessions, item_embs) # [batch_size, session_max_len, n_factors] - logits = session_embs @ item_embs.T # [batch_size, session_max_len, n_items + n_special_tokens] - return logits + return item_embs, session_embs # #### -------------- Data Processor -------------- #### # @@ -705,11 +702,13 @@ def __init__( shuffle_train: bool = True, item_extra_tokens: tp.Sequence[tp.Hashable] = (PADDING_VALUE,), train_min_user_interactions: int = 2, + n_negatives: tp.Optional[int] = None, ) -> None: """TODO""" self.item_id_map: IdMap self.extra_token_ids: tp.Dict self.session_max_len = session_max_len + self.n_negatives = n_negatives self.batch_size = batch_size self.dataloader_num_workers = dataloader_num_workers self.train_min_user_interactions = train_min_user_interactions @@ -889,14 +888,14 @@ def transform_dataset_i2i(self, dataset: Dataset) -> Dataset: def _collate_fn_train( self, batch: List[Tuple[List[int], List[float]]], - ) -> Tuple[torch.LongTensor, torch.LongTensor, torch.FloatTensor]: + ) -> Dict[str, torch.Tensor]: """TODO""" raise NotImplementedError() def _collate_fn_recommend( self, batch: List[Tuple[List[int], List[float]]], - ) -> torch.LongTensor: + ) -> Dict[str, torch.Tensor]: """TODO""" raise NotImplementedError() @@ -907,7 +906,7 @@ class SASRecDataPreparator(SessionEncoderDataPreparatorBase): def _collate_fn_train( self, batch: List[Tuple[List[int], List[float]]], - ) -> Tuple[torch.LongTensor, torch.LongTensor, torch.FloatTensor]: + ) -> Dict[str, torch.Tensor]: """ Truncate each session from right to keep (session_max_len+1) last items. Do left padding until (session_max_len+1) is reached. @@ -921,14 +920,24 @@ def _collate_fn_train( x[i, -len(ses) + 1 :] = ses[:-1] # ses: [session_len] -> x[i]: [session_max_len] y[i, -len(ses) + 1 :] = ses[1:] # ses: [session_len] -> y[i]: [session_max_len] yw[i, -len(ses) + 1 :] = ses_weights[1:] # ses_weights: [session_len] -> yw[i]: [session_max_len] - return torch.LongTensor(x), torch.LongTensor(y), torch.FloatTensor(yw) - def _collate_fn_recommend(self, batch: List[Tuple[List[int], List[float]]]) -> torch.LongTensor: + batch_dict = {"x": torch.LongTensor(x), "y": torch.LongTensor(y), "yw": torch.FloatTensor(yw)} + # TODO: we are sampling negatives for paddings + if self.n_negatives is not None: + negatives = torch.randint( + low=self.n_item_extra_tokens, + high=self.item_id_map.size, + size=(batch_size, self.session_max_len, self.n_negatives), + ) # [batch_size, session_max_len, n_negatives] + batch_dict["negatives"] = negatives + return batch_dict + + def _collate_fn_recommend(self, batch: List[Tuple[List[int], List[float]]]) -> Dict[str, torch.Tensor]: """Right truncation, left padding to session_max_len""" x = np.zeros((len(batch), self.session_max_len)) for i, (ses, _) in enumerate(batch): x[i, -len(ses) :] = ses[-self.session_max_len :] - return torch.LongTensor(x) + return {"x": torch.LongTensor(x)} # #### -------------- Lightning Model -------------- #### # @@ -955,6 +964,8 @@ def __init__( self, torch_model: TransformerBasedSessionEncoder, lr: float, + gbce_t: float, + n_item_extra_tokens: int, loss: str = "softmax", adam_betas: Tuple[float, float] = (0.9, 0.98), ): @@ -963,6 +974,8 @@ def __init__( self.loss = loss self.torch_model = torch_model self.adam_betas = adam_betas + self.gbce_t = gbce_t + self.n_item_extra_tokens = n_item_extra_tokens self.item_embs: torch.Tensor def configure_optimizers(self) -> torch.optim.Adam: @@ -970,17 +983,14 @@ def configure_optimizers(self) -> torch.optim.Adam: optimizer = torch.optim.Adam(self.torch_model.parameters(), lr=self.lr, betas=self.adam_betas) return optimizer - def forward( - self, - batch: torch.Tensor, - ) -> torch.Tensor: - """Forward pass. Propagate the batch through torch_model.""" - return self.torch_model(batch) - - def training_step(self, batch: torch.Tensor, batch_idx: int) -> torch.Tensor: + def training_step(self, batch: Dict[str, torch.Tensor], batch_idx: int) -> torch.Tensor: """Training step.""" raise NotImplementedError() + def predict_step(self, batch: Dict[str, torch.Tensor], batch_idx: int) -> torch.Tensor: + """Prediction step.""" + raise NotImplementedError() + class SessionEncoderLightningModule(SessionEncoderLightningModuleBase): """Lightning module to train SASRec model.""" @@ -990,57 +1000,108 @@ def on_train_start(self) -> None: # TODO: init padding embedding with zeros self._xavier_normal_init() - def training_step(self, batch: torch.Tensor, batch_idx: int) -> torch.Tensor: - """ - Training step. - Compute logits by propagating torch network. - Compute loss. + def training_step(self, batch: Dict[str, torch.Tensor], batch_idx: int) -> torch.Tensor: + """TODO""" + x, y, w = batch["x"], batch["y"], batch["yw"] + if self.loss == "softmax": + logits = self._get_full_catalog_logits(x) + return self._calc_softmax_loss(logits, y, w) + if self.loss == "BCE": + negatives = batch["negatives"] + logits = self._get_pos_neg_logits(x, y, negatives) + return self._calc_bce_loss(logits, y, w) + if self.loss == "gBCE": + negatives = batch["negatives"] + logits = self._get_pos_neg_logits(x, y, negatives) + return self._calc_gbce_loss(logits, y, w, negatives) + + raise ValueError(f"loss {self.loss} is not supported") + + def _get_full_catalog_logits(self, x: torch.Tensor) -> torch.Tensor: + item_embs, session_embs = self.torch_model(x) + logits = session_embs @ item_embs.T + return logits - Parameters - ---------- - batch: torch.Tensor - Batch containing user interaction sequences, target interactions, interaction weights. - batch_idx: int - Index of a batch. + def _get_pos_neg_logits(self, x: torch.Tensor, y: torch.Tensor, negatives: torch.Tensor) -> torch.Tensor: + # [n_items + n_item_extra_tokens, n_factors], [batch_size, session_max_len, n_factors] + item_embs, session_embs = self.torch_model(x) + pos_neg = torch.cat([y.unsqueeze(-1), negatives], dim=-1) # [batch_size, session_max_len, n_negatives + 1] + pos_neg_embs = item_embs[pos_neg] # [batch_size, session_max_len, n_negatives + 1, n_factors] + # [batch_size, session_max_len, n_negatives + 1] + logits = (pos_neg_embs @ session_embs.unsqueeze(-1)).squeeze(-1) + return logits - Returns - ------- - Loss. - """ - x, y, w = batch - logits = self.forward(x) # [batch_size, session_max_len, n_items + n_special_tokens] - if self.loss == "softmax": - # We are using CrossEntropyLoss with a multi-dimensional case + def _get_reduced_overconfidence_logits(self, logits: torch.Tensor, n_items: int, n_negatives: int) -> torch.Tensor: + # https://arxiv.org/pdf/2308.07192.pdf + alpha = n_negatives / (n_items - 1) # sampling rate + beta = alpha * (self.gbce_t * (1 - 1 / alpha) + 1 / alpha) + + pos_logits = logits[:, :, 0:1].to(torch.float64) + neg_logits = logits[:, :, 1:].to(torch.float64) - # Logits must be passed in form of [batch_size, n_items + n_special_tokens, session_max_len], - # where n_items + n_special_tokens is number of classes + epsilon = 1e-10 + pos_probs = torch.clamp(torch.sigmoid(pos_logits), epsilon, 1 - epsilon) + pos_probs_adjusted = torch.clamp(pos_probs.pow(-beta), 1 + epsilon, torch.finfo(torch.float64).max) + pos_probs_adjusted = torch.clamp( + torch.div(1, (pos_probs_adjusted - 1)), epsilon, torch.finfo(torch.float64).max + ) + pos_logits_transformed = torch.log(pos_probs_adjusted) + logits = torch.cat([pos_logits_transformed, neg_logits], dim=-1) + return logits + + @classmethod + def _calc_softmax_loss(cls, logits: torch.Tensor, y: torch.Tensor, w: torch.Tensor) -> torch.Tensor: + # We are using CrossEntropyLoss with a multi-dimensional case - # Target label indexes must be passed in a form of [batch_size, session_max_len] - # (`0` index for "PAD" ix excluded from loss) + # Logits must be passed in form of [batch_size, n_items + n_item_extra_tokens, session_max_len], + # where n_items + n_item_extra_tokens is number of classes - # Loss output will have a shape of [batch_size, session_max_len] - # and will have zeros for every `0` target label + # Target label indexes must be passed in a form of [batch_size, session_max_len] + # (`0` index for "PAD" ix excluded from loss) - loss = torch.nn.functional.cross_entropy( - logits.transpose(1, 2), y, ignore_index=0, reduction="none" - ) # [batch_size, session_max_len] - loss = loss * w - n = (loss > 0).to(loss.dtype) - loss = torch.sum(loss) / torch.sum(n) - return loss - raise ValueError(f"loss {loss} is not supported") + # Loss output will have a shape of [batch_size, session_max_len] + # and will have zeros for every `0` target label + loss = torch.nn.functional.cross_entropy( + logits.transpose(1, 2), y, ignore_index=0, reduction="none" + ) # [batch_size, session_max_len] + loss = loss * w + n = (loss > 0).to(loss.dtype) + loss = torch.sum(loss) / torch.sum(n) + return loss + + @classmethod + def _calc_bce_loss(cls, logits: torch.Tensor, y: torch.Tensor, w: torch.Tensor) -> torch.Tensor: + mask = y != 0 + target = torch.zeros_like(logits) + target[:, :, 0] = 1 + + loss = torch.nn.functional.binary_cross_entropy_with_logits( + logits, target, reduction="none" + ) # [batch_size, session_max_len, n_negatives + 1] + loss = loss.mean(-1) * mask * w # [batch_size, session_max_len] + loss = torch.sum(loss) / torch.sum(mask) + return loss + + def _calc_gbce_loss( + self, logits: torch.Tensor, y: torch.Tensor, w: torch.Tensor, negatives: torch.Tensor + ) -> torch.Tensor: + n_actual_items = self.torch_model.item_model.n_items - self.n_item_extra_tokens + n_negatives = negatives.shape[2] + logits = self._get_reduced_overconfidence_logits(logits, n_actual_items, n_negatives) + loss = self._calc_bce_loss(logits, y, w) + return loss def on_train_end(self) -> None: """Save item embeddings""" self.eval() self.item_embs = self.torch_model.item_model.get_all_embeddings() - def predict_step(self, batch: torch.Tensor, batch_idx: int) -> torch.Tensor: + def predict_step(self, batch: Dict[str, torch.Tensor], batch_idx: int) -> torch.Tensor: """ Prediction step. Encode user sessions. """ - encoded_sessions = self.torch_model.encode_sessions(batch, self.item_embs)[:, -1, :] + encoded_sessions = self.torch_model.encode_sessions(batch["x"], self.item_embs)[:, -1, :] return encoded_sessions def _xavier_normal_init(self) -> None: @@ -1058,7 +1119,7 @@ class TransformerModelBase(ModelBase): and write self.data_preparator initialization logic. """ - def __init__( # pylint: disable=too-many-arguments + def __init__( # pylint: disable=too-many-arguments, too-many-locals self, transformer_layers_type: tp.Type[TransformerLayersBase], data_preparator_type: tp.Type[SessionEncoderDataPreparatorBase], @@ -1071,6 +1132,7 @@ def __init__( # pylint: disable=too-many-arguments dropout_rate: float = 0.2, session_max_len: int = 32, loss: str = "softmax", + gbce_t: float = 0.5, lr: float = 0.01, epochs: int = 3, verbose: int = 0, @@ -1115,6 +1177,7 @@ def __init__( # pylint: disable=too-many-arguments self.i2i_dist = Distance.COSINE self.lr = lr self.loss = loss + self.gbce_t = gbce_t def _fit( self, @@ -1126,7 +1189,14 @@ def _fit( torch_model = deepcopy(self._torch_model) # TODO: check that it works torch_model.construct_item_net(processed_dataset) - self.lightning_model = self.lightning_module_type(torch_model, self.lr, self.loss) + n_item_extra_tokens = self.data_preparator.n_item_extra_tokens + self.lightning_model = self.lightning_module_type( + torch_model=torch_model, + lr=self.lr, + loss=self.loss, + gbce_t=self.gbce_t, + n_item_extra_tokens=n_item_extra_tokens, + ) self.trainer = deepcopy(self._trainer) self.trainer.fit(self.lightning_model, train_dataloader) @@ -1144,7 +1214,7 @@ def _custom_transform_dataset_i2i( def _recommend_u2i( self, user_ids: InternalIdsArray, - dataset: Dataset, # [n_rec_users x n_items + n_special_tokens] + dataset: Dataset, # [n_rec_users x n_items + n_item_extra_tokens] k: int, filter_viewed: bool, sorted_item_ids_to_recommend: tp.Optional[InternalIdsArray], # model_internal @@ -1163,7 +1233,7 @@ def _recommend_u2i( ranker = ImplicitRanker( self.u2i_dist, user_embs, # [n_rec_users, n_factors] - item_embs_np, # [n_items + n_special_tokens, n_factors] + item_embs_np, # [n_items + n_item_extra_tokens, n_factors] ) if filter_viewed: user_items = dataset.get_user_item_matrix(include_weights=False) @@ -1176,7 +1246,7 @@ def _recommend_u2i( user_ids_indices, all_reco_ids, all_scores = ranker.rank( subject_ids=np.arange(user_embs.shape[0]), # n_rec_users k=k, - filter_pairs_csr=ui_csr_for_filter, # [n_rec_users x n_items + 1] + filter_pairs_csr=ui_csr_for_filter, # [n_rec_users x n_items + n_item_extra_tokens] sorted_object_whitelist=sorted_item_ids_to_recommend, # model_internal num_threads=self.n_threads, ) @@ -1202,8 +1272,8 @@ def _recommend_i2i( ranker = ImplicitRanker( self.i2i_dist, - item_embs, # [n_items + n_special_tokens, n_factors] - item_embs, # [n_items + n_special_tokens, n_factors] + item_embs, # [n_items + n_item_extra_tokens, n_factors] + item_embs, # [n_items + n_item_extra_tokens, n_factors] ) return ranker.rank( subject_ids=target_ids, # model internal @@ -1238,6 +1308,8 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals dataloader_num_workers: int = 0, batch_size: int = 128, loss: str = "softmax", + n_negatives: int = 1, + gbce_t: float = 0.2, lr: float = 0.01, epochs: int = 3, verbose: int = 0, @@ -1252,29 +1324,31 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals lightning_module_type: tp.Type[SessionEncoderLightningModuleBase] = SessionEncoderLightningModule, ): super().__init__( - transformer_layers_type, - data_preparator_type, - n_blocks, - n_heads, - n_factors, - use_pos_emb, - use_causal_attn, - use_key_padding_mask, - dropout_rate, - session_max_len, - loss, - lr, - epochs, - verbose, - deterministic, - cpu_n_threads, - trainer, - item_net_block_types, - pos_encoding_type, - lightning_module_type, + transformer_layers_type=transformer_layers_type, + data_preparator_type=data_preparator_type, + n_blocks=n_blocks, + n_heads=n_heads, + n_factors=n_factors, + use_pos_emb=use_pos_emb, + use_causal_attn=use_causal_attn, + use_key_padding_mask=use_key_padding_mask, + dropout_rate=dropout_rate, + session_max_len=session_max_len, + loss=loss, + gbce_t=gbce_t, + lr=lr, + epochs=epochs, + verbose=verbose, + deterministic=deterministic, + cpu_n_threads=cpu_n_threads, + trainer=trainer, + item_net_block_types=item_net_block_types, + pos_encoding_type=pos_encoding_type, + lightning_module_type=lightning_module_type, ) self.data_preparator = data_preparator_type( session_max_len=session_max_len, + n_negatives=n_negatives if loss != "softmax" else None, batch_size=batch_size, dataloader_num_workers=dataloader_num_workers, train_min_user_interactions=train_min_user_interaction, diff --git a/tests/models/test_sasrec.py b/tests/models/test_sasrec.py index 124e8844..613af430 100644 --- a/tests/models/test_sasrec.py +++ b/tests/models/test_sasrec.py @@ -564,11 +564,11 @@ def test_tranform_dataset_i2i( "train_batch", ( ( - [ - torch.tensor([[5, 2, 3], [0, 1, 3], [0, 0, 2]]), - torch.tensor([[2, 3, 6], [0, 3, 2], [0, 0, 4]]), - torch.tensor([[1.0, 1.0, 1.0], [0.0, 2.0, 1.0], [0.0, 0.0, 1.0]]), - ] + { + "x": torch.tensor([[5, 2, 3], [0, 1, 3], [0, 0, 2]]), + "y": torch.tensor([[2, 3, 6], [0, 3, 2], [0, 0, 4]]), + "yw": torch.tensor([[1.0, 1.0, 1.0], [0.0, 2.0, 1.0], [0.0, 0.0, 1.0]]), + } ), ), ) @@ -578,12 +578,12 @@ def test_get_dataloader_train( dataset = data_preparator.process_dataset_train(dataset) dataloader = data_preparator.get_dataloader_train(dataset) actual = next(iter(dataloader)) - for i, value in enumerate(actual): - assert torch.equal(value, train_batch[i]) + for key, value in actual.items(): + assert torch.equal(value, train_batch[key]) @pytest.mark.parametrize( "recommend_batch", - ((torch.tensor([[2, 3, 6], [1, 3, 2], [0, 2, 4], [0, 0, 6]])),), + (({"x": torch.tensor([[2, 3, 6], [1, 3, 2], [0, 2, 4], [0, 0, 6]])}),), ) def test_get_dataloader_recommend( self, dataset: Dataset, data_preparator: SASRecDataPreparator, recommend_batch: torch.Tensor @@ -592,7 +592,8 @@ def test_get_dataloader_recommend( dataset = data_preparator.transform_dataset_i2i(dataset) dataloader = data_preparator.get_dataloader_recommend(dataset) actual = next(iter(dataloader)) - assert torch.equal(actual, recommend_batch) + for key, value in actual.items(): + assert torch.equal(value, recommend_batch[key]) class TestIdEmbeddingsItemNet: @@ -666,11 +667,11 @@ def dataset_item_features(self) -> Dataset: ) return ds - def test_feature_catalogue(self, dataset_item_features: Dataset) -> None: + def test_feature_catalog(self, dataset_item_features: Dataset) -> None: cat_item_embeddings = CatFeaturesItemNet.from_dataset(dataset_item_features, n_factors=5, dropout_rate=0.5) assert isinstance(cat_item_embeddings, CatFeaturesItemNet) - expected_feature_catalogue = torch.arange(0, cat_item_embeddings.n_cat_features) - assert torch.equal(cat_item_embeddings.feature_catalogue, expected_feature_catalogue) + expected_feature_catalog = torch.arange(0, cat_item_embeddings.n_cat_features) + assert torch.equal(cat_item_embeddings.feature_catalog, expected_feature_catalog) def test_get_dense_item_features(self, dataset_item_features: Dataset) -> None: items = torch.from_numpy( @@ -828,12 +829,12 @@ def dataset_item_features(self) -> Dataset: ) return ds - def test_catalogue(self) -> None: + def test_catalog(self) -> None: item_net = ItemNetConstructor.from_dataset( DATASET, n_factors=10, dropout_rate=0.5, item_net_block_types=(IdEmbeddingsItemNet,) ) - expected_feature_catalogue = torch.arange(0, DATASET.item_id_map.size) - assert torch.equal(item_net.catalogue, expected_feature_catalogue) + expected_feature_catalog = torch.arange(0, DATASET.item_id_map.size) + assert torch.equal(item_net.catalog, expected_feature_catalog) @pytest.mark.parametrize( "item_net_block_types,n_factors", From 6baba6330715255a29261436614ae918c00996b6 Mon Sep 17 00:00:00 2001 From: spirinamayya <90619187+spirinamayya@users.noreply.github.com> Date: Wed, 4 Dec 2024 14:56:50 +0300 Subject: [PATCH 10/13] Merge experimental/sasrec and main (#217) Merge experimental/sasrec and main --------- Co-authored-by: Daria <93913290+blondered@users.noreply.github.com> Co-authored-by: Emiliy Feldman Co-authored-by: Daria Tikhonovich Co-authored-by: Vadim Vetrov --- CHANGELOG.md | 13 + README.md | 27 +- examples/9_model_configs_and_params.ipynb | 656 +++++++++++++++++++ poetry.lock | 166 ++++- pyproject.toml | 6 +- rectools/dataset/dataset.py | 18 +- rectools/dataset/interactions.py | 35 +- rectools/models/__init__.py | 2 + rectools/models/base.py | 240 ++++++- rectools/models/ease.py | 21 +- rectools/models/implicit_als.py | 297 +++++++-- rectools/models/implicit_knn.py | 89 ++- rectools/models/lightfm.py | 105 ++- rectools/models/popular.py | 147 ++++- rectools/models/popular_in_category.py | 89 ++- rectools/models/pure_svd.py | 34 +- rectools/models/random.py | 19 +- rectools/models/rank.py | 87 ++- rectools/models/serialization.py | 23 + rectools/models/vector.py | 4 +- rectools/utils/config.py | 5 + rectools/utils/misc.py | 63 ++ rectools/utils/serialization.py | 33 + tests/dataset/test_dataset.py | 34 +- tests/dataset/test_interactions.py | 45 +- tests/model_selection/test_cross_validate.py | 2 +- tests/models/test_base.py | 159 ++++- tests/models/test_dssm.py | 7 +- tests/models/test_ease.py | 53 +- tests/models/test_implicit_als.py | 236 ++++++- tests/models/test_implicit_knn.py | 132 +++- tests/models/test_lightfm.py | 118 +++- tests/models/test_popular.py | 144 +++- tests/models/test_popular_in_category.py | 293 +++++++-- tests/models/test_pure_svd.py | 66 +- tests/models/test_random.py | 50 +- tests/models/test_rank.py | 63 +- tests/models/test_serialization.py | 51 ++ tests/models/utils.py | 61 ++ 39 files changed, 3368 insertions(+), 325 deletions(-) create mode 100644 examples/9_model_configs_and_params.ipynb create mode 100644 rectools/models/serialization.py create mode 100644 rectools/utils/config.py create mode 100644 rectools/utils/serialization.py create mode 100644 tests/models/test_serialization.py diff --git a/CHANGELOG.md b/CHANGELOG.md index caaceb5c..9a1d0480 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## Unreleased + +### Added +- `from_config`, `get_config` and `get_params` methods to all models except neural-net-based ([#170](https://github.com/MobileTeleSystems/RecTools/pull/170)) +- `fit_partial` implementation for `ImplicitALSWrapperModel` that allows to fit model for a specific number of epochs and continue training from the previous point ([#203](https://github.com/MobileTeleSystems/RecTools/pull/203), [#210](https://github.com/MobileTeleSystems/RecTools/pull/210)) +- `save` and `load` methods to all of the models ([#206](https://github.com/MobileTeleSystems/RecTools/pull/206)) +- Model configs example ([#207](https://github.com/MobileTeleSystems/RecTools/pull/207)) +- `use_gpu` argument to `ImplicitRanker.rank` method ([#201](https://github.com/MobileTeleSystems/RecTools/pull/201)) +- `keep_extra_cols` argument to `Dataset.construct` and `Interactions.from_raw` methods. `include_extra_cols` argument to `Dataset.get_raw_interactions` and `Interactions.to_external` methods ([#208](https://github.com/MobileTeleSystems/RecTools/pull/208)) +- dtype adjustment to `recommend`, `recommend_to_items` methods of `ModelBase` ([#211](https://github.com/MobileTeleSystems/RecTools/pull/211)) +- `load_model` function ([#213](https://github.com/MobileTeleSystems/RecTools/pull/213)) + + ## [0.8.0] - 28.08.2024 ### Added diff --git a/README.md b/README.md index 980d0d36..3a319c5c 100644 --- a/README.md +++ b/README.md @@ -121,11 +121,36 @@ See [recommender baselines extended tutorial](https://github.com/MobileTeleSyste - For feeding user/item features to model just specify dataframes when constructing `Dataset`. [Check our tutorial](examples/4_dataset_with_features.ipynb) - For warm / cold inference just provide all required ids in `users` or `target_items` parameters of `recommend` or `recommend_to_items` methods and make sure you have features in the dataset for warm users/items. **Nothing else is needed, everything works out of the box.** + +## Extended validation tools + +### `DebiasConfig` for debiased metrics calculation + +[User guide](https://github.com/MobileTeleSystems/RecTools/blob/main/examples/8_debiased_metrics.ipynb) | [Documentation](https://rectools.readthedocs.io/en/stable/api/rectools.metrics.debias.DebiasConfig.html) + +### `VisualApp` for model recommendations comparison + + + + +[Example](https://github.com/MobileTeleSystems/RecTools/blob/main/examples/7_visualization.ipynb) | [Demo](https://recsysart.ru/voila/) | [Documentation](https://rectools.readthedocs.io/en/stable/api/rectools.visuals.visual_app.VisualApp.html) + + + +### `MetricsApp` for metrics trade-off analysis + + + + +[Example](https://github.com/MobileTeleSystems/RecTools/blob/main/examples/2_cross_validation.ipynb) | +[Documentation](https://rectools.readthedocs.io/en/stable/api/rectools.visuals.metrics_app.MetricsApp.html) + + ## Contribution [Contributing guide](CONTRIBUTING.rst) To install all requirements -- you must have `python>=3.8` and `poetry>=1.5.0` installed +- you must have `python3` and `poetry` installed - make sure you have no active virtual environments (deactivate conda `base` if applicable) - run ``` diff --git a/examples/9_model_configs_and_params.ipynb b/examples/9_model_configs_and_params.ipynb new file mode 100644 index 00000000..59e2a85b --- /dev/null +++ b/examples/9_model_configs_and_params.ipynb @@ -0,0 +1,656 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model configs and params examples\n", + "\n", + "There are some common methods for RecTools models that simplify framework integration with experiment trackers (e.g. MlFlow) and allow running experiments from configs.\n", + "They include:\n", + "\n", + "* `from_config`\n", + "* `get_config`\n", + "* `get_params`\n", + "\n", + "We also allow saving and loading models with methods:\n", + "\n", + "* `save`\n", + "* `load`\n", + "\n", + "In this example we will show basic usage for all of these methods as well as config examples for our models." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import timedelta\n", + "\n", + "from rectools.models import (\n", + " ImplicitItemKNNWrapperModel, \n", + " ImplicitALSWrapperModel, \n", + " EASEModel, \n", + " PopularInCategoryModel, \n", + " PopularModel, \n", + " RandomModel, \n", + " LightFMWrapperModel,\n", + " PureSVDModel,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic usage" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`from_config` methods allows model initialization from a dictionary of model hyper-params." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "config = {\n", + " \"popularity\": \"n_interactions\",\n", + " \"period\": timedelta(weeks=2),\n", + "}\n", + "model = PopularModel.from_config(config)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`get_config` method returns a dictionary of model hyper-params. In contrast to the previous method, here you will get a full list of model parameters, even the ones that were not specified during model initialization but instead were set to their default values." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 0,\n", + " 'popularity': ,\n", + " 'period': {'days': 14},\n", + " 'begin_from': None,\n", + " 'add_cold': False,\n", + " 'inverse': False}" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_config()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can directly use output of `get_config` method to create new model instances using `from_config` method. New instances will have exactly the same hyper-params as the source model." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "source_config = model.get_config()\n", + "new_model = PopularModel.from_config(source_config)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get model config in json-compatible format pass `simple_types=True`. See how `popularity` parameter changes for the Popular model in the example below:" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 0,\n", + " 'popularity': 'n_interactions',\n", + " 'period': {'days': 14},\n", + " 'begin_from': None,\n", + " 'add_cold': False,\n", + " 'inverse': False}" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_config(simple_types=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`get_params` method allows to get model hyper-parameters as a flat dictionary which is often more convenient for experiment trackers. \n", + "\n", + "\n", + "Don't forget to pass `simple_types=True` to make the format json-compatible. Note that you can't initialize a new model from the output of this method." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 0,\n", + " 'popularity': 'n_interactions',\n", + " 'period.days': 14,\n", + " 'begin_from': None,\n", + " 'add_cold': False,\n", + " 'inverse': False}" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_params(simple_types=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`save` and `load` model methods do exactly what you would expect from their naming :)\n", + "Fit model to dataset before saving. Weights will be loaded during `load` method." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "220" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.save(\"pop_model.pkl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "loaded = PopularModel.load(\"pop_model.pkl\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configs examples for all models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ItemKNN\n", + "`ImplicitItemKNNWrapperModel` is a wrapper. \n", + "Use \"model\" key in config to specify wrapped model class and params:\n", + "\n", + "Specify which model you want to wrap under the \"model.cls\" key. Options are:\n", + "- \"TFIDFRecommender\"\n", + "- \"CosineRecommender\"\n", + "- \"BM25Recommender\"\n", + "- \"ItemItemRecommender\"\n", + "- A path to a class (including any custom class) that can be imported. Like \"implicit.nearest_neighbours.TFIDFRecommender\"\n", + "\n", + "Specify wrapped model hyper-params under the \"model.params\" key" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "model = ImplicitItemKNNWrapperModel.from_config({\n", + " \"model\": {\n", + " \"cls\": \"TFIDFRecommender\", # or \"implicit.nearest_neighbours.TFIDFRecommender\"\n", + " \"params\": {\"K\": 50, \"num_threads\": 1}\n", + " }\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 0,\n", + " 'model.cls': 'TFIDFRecommender',\n", + " 'model.params.K': 50,\n", + " 'model.params.num_threads': 1}" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_params(simple_types=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### iALS\n", + "`ImplicitALSWrapperModel` is a wrapper. \n", + "Use \"model\" key in config to specify wrapped model class and params: \n", + "\n", + "Specify which model you want to wrap under the \"model.cls\" key. Since there is only one default model, you can skip this step. \"implicit.als.AlternatingLeastSquares\" will be used by default. Also you can pass a path to a class (including any custom class) that can be imported.\n", + "\n", + "Specify wrapped model hyper-params under the \"model.params\" key. \n", + "\n", + "Specify wrapper hyper-params under relevant keys." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "config = {\n", + " \"model\": {\n", + " # \"cls\": \"AlternatingLeastSquares\", # will work too\n", + " # \"cls\": \"implicit.als.AlternatingLeastSquares\", # will work too\n", + " \"params\": {\n", + " \"factors\": 16,\n", + " \"num_threads\": 2,\n", + " \"iterations\": 2,\n", + " \"random_state\": 32\n", + " },\n", + " },\n", + " \"fit_features_together\": True,\n", + "}\n", + "model = ImplicitALSWrapperModel.from_config(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 0,\n", + " 'model.cls': 'AlternatingLeastSquares',\n", + " 'model.params.factors': 16,\n", + " 'model.params.regularization': 0.01,\n", + " 'model.params.alpha': 1.0,\n", + " 'model.params.dtype': 'float32',\n", + " 'model.params.use_native': True,\n", + " 'model.params.use_cg': True,\n", + " 'model.params.use_gpu': False,\n", + " 'model.params.iterations': 2,\n", + " 'model.params.calculate_training_loss': False,\n", + " 'model.params.num_threads': 2,\n", + " 'model.params.random_state': 32,\n", + " 'fit_features_together': True}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_params(simple_types=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### EASE" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "config = {\n", + " \"regularization\": 100,\n", + " \"verbose\": 1,\n", + "}\n", + "model = EASEModel.from_config(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 1, 'regularization': 100.0, 'num_threads': 1}" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_params(simple_types=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### PureSVD" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "config = {\n", + " \"factors\": 32,\n", + "}\n", + "model = PureSVDModel.from_config(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 0,\n", + " 'factors': 32,\n", + " 'tol': 0.0,\n", + " 'maxiter': None,\n", + " 'random_state': None}" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_params(simple_types=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### LightFM\n", + "\n", + "`LightFMWrapperModel` is a wrapper. \n", + "Use \"model\" key in config to specify wrapped model class and params: \n", + "\n", + "Specify which model you want to wrap under the \"model.cls\" key. Since there is only one default model, you can skip this step. \"LightFM\" will be used by default. Also you can pass a path to a class (including any custom class) that can be imported. Like \"lightfm.lightfm.LightFM\"\n", + "\n", + "Specify wrapped model hyper-params under the \"model.params\" key. \n", + "\n", + "Specify wrapper hyper-params under relevant keys." + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "config = {\n", + " \"model\": {\n", + " # \"cls\": \"lightfm.lightfm.LightFM\", # will work too \n", + " # \"cls\": \"LightFM\", # will work too \n", + " \"params\": {\n", + " \"no_components\": 16,\n", + " \"learning_rate\": 0.03,\n", + " \"random_state\": 32,\n", + " \"loss\": \"warp\"\n", + " },\n", + " },\n", + " \"epochs\": 2,\n", + "}\n", + "model = LightFMWrapperModel.from_config(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 0,\n", + " 'model.cls': 'LightFM',\n", + " 'model.params.no_components': 16,\n", + " 'model.params.k': 5,\n", + " 'model.params.n': 10,\n", + " 'model.params.learning_schedule': 'adagrad',\n", + " 'model.params.loss': 'warp',\n", + " 'model.params.learning_rate': 0.03,\n", + " 'model.params.rho': 0.95,\n", + " 'model.params.epsilon': 1e-06,\n", + " 'model.params.item_alpha': 0.0,\n", + " 'model.params.user_alpha': 0.0,\n", + " 'model.params.max_sampled': 10,\n", + " 'model.params.random_state': 32,\n", + " 'epochs': 2,\n", + " 'num_threads': 1}" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_params(simple_types=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Popular" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import timedelta\n", + "config = {\n", + " \"popularity\": \"n_interactions\",\n", + " \"period\": timedelta(weeks=2),\n", + "}\n", + "model = PopularModel.from_config(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 0,\n", + " 'popularity': 'n_interactions',\n", + " 'period.days': 14,\n", + " 'begin_from': None,\n", + " 'add_cold': False,\n", + " 'inverse': False}" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_params(simple_types=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Popular in category" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "config = {\n", + " \"popularity\": \"n_interactions\",\n", + " \"period\": timedelta(days=1),\n", + " \"category_feature\": \"genres\",\n", + " \"mixing_strategy\": \"group\"\n", + "}\n", + "model = PopularInCategoryModel.from_config(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 0,\n", + " 'popularity': 'n_interactions',\n", + " 'period.days': 1,\n", + " 'begin_from': None,\n", + " 'add_cold': False,\n", + " 'inverse': False,\n", + " 'category_feature': 'genres',\n", + " 'n_categories': None,\n", + " 'mixing_strategy': 'group',\n", + " 'ratio_strategy': 'proportional'}" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_params(simple_types=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Radom" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "config = {\n", + " \"random_state\": 32,\n", + "}\n", + "model = RandomModel.from_config(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'verbose': 0, 'random_state': 32}" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.get_params(simple_types=True)" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/poetry.lock b/poetry.lock index 57bb12ef..d82973f6 100644 --- a/poetry.lock +++ b/poetry.lock @@ -110,6 +110,20 @@ files = [ [package.dependencies] frozenlist = ">=1.1.0" +[[package]] +name = "annotated-types" +version = "0.7.0" +description = "Reusable constraint types to use with typing.Annotated" +optional = false +python-versions = ">=3.8" +files = [ + {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"}, + {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.9\""} + [[package]] name = "appnope" version = "0.1.4" @@ -1797,7 +1811,6 @@ description = "Nvidia JIT LTO Library" optional = true python-versions = ">=3" files = [ - {file = "nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_aarch64.whl", hash = "sha256:4abe7fef64914ccfa909bc2ba39739670ecc9e820c83ccc7a6ed414122599b83"}, {file = "nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:06b3b9b25bf3f8af351d664978ca26a16d2c5127dbd53c0497e28d1fb9611d57"}, {file = "nvidia_nvjitlink_cu12-12.4.127-py3-none-win_amd64.whl", hash = "sha256:fd9020c501d27d135f983c6d3e244b197a7ccad769e34df53a42e276b0e25fa1"}, ] @@ -2116,6 +2129,126 @@ files = [ {file = "pycodestyle-2.11.1.tar.gz", hash = "sha256:41ba0e7afc9752dfb53ced5489e89f8186be00e599e712660695b7a75ff2663f"}, ] +[[package]] +name = "pydantic" +version = "2.8.2" +description = "Data validation using Python type hints" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pydantic-2.8.2-py3-none-any.whl", hash = "sha256:73ee9fddd406dc318b885c7a2eab8a6472b68b8fb5ba8150949fc3db939f23c8"}, + {file = "pydantic-2.8.2.tar.gz", hash = "sha256:6f62c13d067b0755ad1c21a34bdd06c0c12625a22b0fc09c6b149816604f7c2a"}, +] + +[package.dependencies] +annotated-types = ">=0.4.0" +pydantic-core = "2.20.1" +typing-extensions = {version = ">=4.6.1", markers = "python_version < \"3.13\""} + +[package.extras] +email = ["email-validator (>=2.0.0)"] + +[[package]] +name = "pydantic-core" +version = "2.20.1" +description = "Core functionality for Pydantic validation and serialization" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pydantic_core-2.20.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:3acae97ffd19bf091c72df4d726d552c473f3576409b2a7ca36b2f535ffff4a3"}, + {file = "pydantic_core-2.20.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:41f4c96227a67a013e7de5ff8f20fb496ce573893b7f4f2707d065907bffdbd6"}, + {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f239eb799a2081495ea659d8d4a43a8f42cd1fe9ff2e7e436295c38a10c286a"}, + {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:53e431da3fc53360db73eedf6f7124d1076e1b4ee4276b36fb25514544ceb4a3"}, + {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f1f62b2413c3a0e846c3b838b2ecd6c7a19ec6793b2a522745b0869e37ab5bc1"}, + {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d41e6daee2813ecceea8eda38062d69e280b39df793f5a942fa515b8ed67953"}, + {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d482efec8b7dc6bfaedc0f166b2ce349df0011f5d2f1f25537ced4cfc34fd98"}, + {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e93e1a4b4b33daed65d781a57a522ff153dcf748dee70b40c7258c5861e1768a"}, + {file = "pydantic_core-2.20.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e7c4ea22b6739b162c9ecaaa41d718dfad48a244909fe7ef4b54c0b530effc5a"}, + {file = "pydantic_core-2.20.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4f2790949cf385d985a31984907fecb3896999329103df4e4983a4a41e13e840"}, + {file = "pydantic_core-2.20.1-cp310-none-win32.whl", hash = "sha256:5e999ba8dd90e93d57410c5e67ebb67ffcaadcea0ad973240fdfd3a135506250"}, + {file = "pydantic_core-2.20.1-cp310-none-win_amd64.whl", hash = "sha256:512ecfbefef6dac7bc5eaaf46177b2de58cdf7acac8793fe033b24ece0b9566c"}, + {file = "pydantic_core-2.20.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d2a8fa9d6d6f891f3deec72f5cc668e6f66b188ab14bb1ab52422fe8e644f312"}, + {file = "pydantic_core-2.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:175873691124f3d0da55aeea1d90660a6ea7a3cfea137c38afa0a5ffabe37b88"}, + {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37eee5b638f0e0dcd18d21f59b679686bbd18917b87db0193ae36f9c23c355fc"}, + {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25e9185e2d06c16ee438ed39bf62935ec436474a6ac4f9358524220f1b236e43"}, + {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:150906b40ff188a3260cbee25380e7494ee85048584998c1e66df0c7a11c17a6"}, + {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ad4aeb3e9a97286573c03df758fc7627aecdd02f1da04516a86dc159bf70121"}, + {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3f3ed29cd9f978c604708511a1f9c2fdcb6c38b9aae36a51905b8811ee5cbf1"}, + {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b0dae11d8f5ded51699c74d9548dcc5938e0804cc8298ec0aa0da95c21fff57b"}, + {file = "pydantic_core-2.20.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:faa6b09ee09433b87992fb5a2859efd1c264ddc37280d2dd5db502126d0e7f27"}, + {file = "pydantic_core-2.20.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9dc1b507c12eb0481d071f3c1808f0529ad41dc415d0ca11f7ebfc666e66a18b"}, + {file = "pydantic_core-2.20.1-cp311-none-win32.whl", hash = "sha256:fa2fddcb7107e0d1808086ca306dcade7df60a13a6c347a7acf1ec139aa6789a"}, + {file = "pydantic_core-2.20.1-cp311-none-win_amd64.whl", hash = "sha256:40a783fb7ee353c50bd3853e626f15677ea527ae556429453685ae32280c19c2"}, + {file = "pydantic_core-2.20.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:595ba5be69b35777474fa07f80fc260ea71255656191adb22a8c53aba4479231"}, + {file = "pydantic_core-2.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a4f55095ad087474999ee28d3398bae183a66be4823f753cd7d67dd0153427c9"}, + {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f9aa05d09ecf4c75157197f27cdc9cfaeb7c5f15021c6373932bf3e124af029f"}, + {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e97fdf088d4b31ff4ba35db26d9cc472ac7ef4a2ff2badeabf8d727b3377fc52"}, + {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bc633a9fe1eb87e250b5c57d389cf28998e4292336926b0b6cdaee353f89a237"}, + {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d573faf8eb7e6b1cbbcb4f5b247c60ca8be39fe2c674495df0eb4318303137fe"}, + {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26dc97754b57d2fd00ac2b24dfa341abffc380b823211994c4efac7f13b9e90e"}, + {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:33499e85e739a4b60c9dac710c20a08dc73cb3240c9a0e22325e671b27b70d24"}, + {file = "pydantic_core-2.20.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:bebb4d6715c814597f85297c332297c6ce81e29436125ca59d1159b07f423eb1"}, + {file = "pydantic_core-2.20.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:516d9227919612425c8ef1c9b869bbbee249bc91912c8aaffb66116c0b447ebd"}, + {file = "pydantic_core-2.20.1-cp312-none-win32.whl", hash = "sha256:469f29f9093c9d834432034d33f5fe45699e664f12a13bf38c04967ce233d688"}, + {file = "pydantic_core-2.20.1-cp312-none-win_amd64.whl", hash = "sha256:035ede2e16da7281041f0e626459bcae33ed998cca6a0a007a5ebb73414ac72d"}, + {file = "pydantic_core-2.20.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:0827505a5c87e8aa285dc31e9ec7f4a17c81a813d45f70b1d9164e03a813a686"}, + {file = "pydantic_core-2.20.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19c0fa39fa154e7e0b7f82f88ef85faa2a4c23cc65aae2f5aea625e3c13c735a"}, + {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa223cd1e36b642092c326d694d8bf59b71ddddc94cdb752bbbb1c5c91d833b"}, + {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c336a6d235522a62fef872c6295a42ecb0c4e1d0f1a3e500fe949415761b8a19"}, + {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7eb6a0587eded33aeefea9f916899d42b1799b7b14b8f8ff2753c0ac1741edac"}, + {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:70c8daf4faca8da5a6d655f9af86faf6ec2e1768f4b8b9d0226c02f3d6209703"}, + {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e9fa4c9bf273ca41f940bceb86922a7667cd5bf90e95dbb157cbb8441008482c"}, + {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:11b71d67b4725e7e2a9f6e9c0ac1239bbc0c48cce3dc59f98635efc57d6dac83"}, + {file = "pydantic_core-2.20.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:270755f15174fb983890c49881e93f8f1b80f0b5e3a3cc1394a255706cabd203"}, + {file = "pydantic_core-2.20.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:c81131869240e3e568916ef4c307f8b99583efaa60a8112ef27a366eefba8ef0"}, + {file = "pydantic_core-2.20.1-cp313-none-win32.whl", hash = "sha256:b91ced227c41aa29c672814f50dbb05ec93536abf8f43cd14ec9521ea09afe4e"}, + {file = "pydantic_core-2.20.1-cp313-none-win_amd64.whl", hash = "sha256:65db0f2eefcaad1a3950f498aabb4875c8890438bc80b19362cf633b87a8ab20"}, + {file = "pydantic_core-2.20.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:4745f4ac52cc6686390c40eaa01d48b18997cb130833154801a442323cc78f91"}, + {file = "pydantic_core-2.20.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a8ad4c766d3f33ba8fd692f9aa297c9058970530a32c728a2c4bfd2616d3358b"}, + {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41e81317dd6a0127cabce83c0c9c3fbecceae981c8391e6f1dec88a77c8a569a"}, + {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:04024d270cf63f586ad41fff13fde4311c4fc13ea74676962c876d9577bcc78f"}, + {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eaad4ff2de1c3823fddf82f41121bdf453d922e9a238642b1dedb33c4e4f98ad"}, + {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:26ab812fa0c845df815e506be30337e2df27e88399b985d0bb4e3ecfe72df31c"}, + {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c5ebac750d9d5f2706654c638c041635c385596caf68f81342011ddfa1e5598"}, + {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2aafc5a503855ea5885559eae883978c9b6d8c8993d67766ee73d82e841300dd"}, + {file = "pydantic_core-2.20.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:4868f6bd7c9d98904b748a2653031fc9c2f85b6237009d475b1008bfaeb0a5aa"}, + {file = "pydantic_core-2.20.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:aa2f457b4af386254372dfa78a2eda2563680d982422641a85f271c859df1987"}, + {file = "pydantic_core-2.20.1-cp38-none-win32.whl", hash = "sha256:225b67a1f6d602de0ce7f6c1c3ae89a4aa25d3de9be857999e9124f15dab486a"}, + {file = "pydantic_core-2.20.1-cp38-none-win_amd64.whl", hash = "sha256:6b507132dcfc0dea440cce23ee2182c0ce7aba7054576efc65634f080dbe9434"}, + {file = "pydantic_core-2.20.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:b03f7941783b4c4a26051846dea594628b38f6940a2fdc0df00b221aed39314c"}, + {file = "pydantic_core-2.20.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1eedfeb6089ed3fad42e81a67755846ad4dcc14d73698c120a82e4ccf0f1f9f6"}, + {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:635fee4e041ab9c479e31edda27fcf966ea9614fff1317e280d99eb3e5ab6fe2"}, + {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:77bf3ac639c1ff567ae3b47f8d4cc3dc20f9966a2a6dd2311dcc055d3d04fb8a"}, + {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ed1b0132f24beeec5a78b67d9388656d03e6a7c837394f99257e2d55b461611"}, + {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6514f963b023aeee506678a1cf821fe31159b925c4b76fe2afa94cc70b3222b"}, + {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10d4204d8ca33146e761c79f83cc861df20e7ae9f6487ca290a97702daf56006"}, + {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2d036c7187b9422ae5b262badb87a20a49eb6c5238b2004e96d4da1231badef1"}, + {file = "pydantic_core-2.20.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9ebfef07dbe1d93efb94b4700f2d278494e9162565a54f124c404a5656d7ff09"}, + {file = "pydantic_core-2.20.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6b9d9bb600328a1ce523ab4f454859e9d439150abb0906c5a1983c146580ebab"}, + {file = "pydantic_core-2.20.1-cp39-none-win32.whl", hash = "sha256:784c1214cb6dd1e3b15dd8b91b9a53852aed16671cc3fbe4786f4f1db07089e2"}, + {file = "pydantic_core-2.20.1-cp39-none-win_amd64.whl", hash = "sha256:d2fe69c5434391727efa54b47a1e7986bb0186e72a41b203df8f5b0a19a4f669"}, + {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:a45f84b09ac9c3d35dfcf6a27fd0634d30d183205230a0ebe8373a0e8cfa0906"}, + {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d02a72df14dfdbaf228424573a07af10637bd490f0901cee872c4f434a735b94"}, + {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d2b27e6af28f07e2f195552b37d7d66b150adbaa39a6d327766ffd695799780f"}, + {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:084659fac3c83fd674596612aeff6041a18402f1e1bc19ca39e417d554468482"}, + {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:242b8feb3c493ab78be289c034a1f659e8826e2233786e36f2893a950a719bb6"}, + {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:38cf1c40a921d05c5edc61a785c0ddb4bed67827069f535d794ce6bcded919fc"}, + {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e0bbdd76ce9aa5d4209d65f2b27fc6e5ef1312ae6c5333c26db3f5ade53a1e99"}, + {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:254ec27fdb5b1ee60684f91683be95e5133c994cc54e86a0b0963afa25c8f8a6"}, + {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:407653af5617f0757261ae249d3fba09504d7a71ab36ac057c938572d1bc9331"}, + {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:c693e916709c2465b02ca0ad7b387c4f8423d1db7b4649c551f27a529181c5ad"}, + {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b5ff4911aea936a47d9376fd3ab17e970cc543d1b68921886e7f64bd28308d1"}, + {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:177f55a886d74f1808763976ac4efd29b7ed15c69f4d838bbd74d9d09cf6fa86"}, + {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:964faa8a861d2664f0c7ab0c181af0bea66098b1919439815ca8803ef136fc4e"}, + {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:4dd484681c15e6b9a977c785a345d3e378d72678fd5f1f3c0509608da24f2ac0"}, + {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f6d6cff3538391e8486a431569b77921adfcdef14eb18fbf19b7c0a5294d4e6a"}, + {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a6d511cc297ff0883bc3708b465ff82d7560193169a8b93260f74ecb0a5e08a7"}, + {file = "pydantic_core-2.20.1.tar.gz", hash = "sha256:26ca695eeee5f9f1aeeb211ffc12f10bcb6f71e2989988fda61dabd65db878d4"}, +] + +[package.dependencies] +typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0" + [[package]] name = "pydocstyle" version = "6.3.0" @@ -2364,7 +2497,6 @@ files = [ {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"}, {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"}, {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"}, - {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08c6f0fe150303c1c6b71ebcd7213c2858041a7e01975da3a99aed1e7a378ef"}, {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"}, {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"}, {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"}, @@ -2419,13 +2551,13 @@ toml = ["tomli (>=2.0.1)"] [[package]] name = "rectools-lightfm" -version = "1.17.1" +version = "1.17.2" description = "LightFM recommendation model" optional = true python-versions = "*" files = [ - {file = "rectools_lightfm-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f3fb52f893a642bc6220785c4654c25e971372d45fbdc3a689c635ada675e1cf"}, - {file = "rectools_lightfm-1.17.1.tar.gz", hash = "sha256:d0b1bb777feb41d8bf45c09c4f9d3dabbaf543f40d32dd5c90d42fa6a9ca5530"}, + {file = "rectools-lightfm-1.17.2.tar.gz", hash = "sha256:9a73502ebfe89609004c33a426d475a0bd18837926e85be53d099b38c02aaa88"}, + {file = "rectools_lightfm-1.17.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a05f70900ff4698888ff44b37272c5d2c5490c9ff92f18fcf3f44d9c9b8b5c83"}, ] [package.dependencies] @@ -2730,19 +2862,23 @@ test = ["asv", "gmpy2", "hypothesis", "mpmath", "pooch", "pytest", "pytest-cov", [[package]] name = "setuptools" -version = "69.5.1" +version = "75.3.0" description = "Easily download, build, install, upgrade, and uninstall Python packages" optional = true python-versions = ">=3.8" files = [ - {file = "setuptools-69.5.1-py3-none-any.whl", hash = "sha256:c636ac361bc47580504644275c9ad802c50415c7522212252c033bd15f301f32"}, - {file = "setuptools-69.5.1.tar.gz", hash = "sha256:6c1fccdac05a97e598fb0ae3bbed5904ccb317337a51139dcd51453611bbb987"}, + {file = "setuptools-75.3.0-py3-none-any.whl", hash = "sha256:f2504966861356aa38616760c0f66568e535562374995367b4e69c7143cf6bcd"}, + {file = "setuptools-75.3.0.tar.gz", hash = "sha256:fba5dd4d766e97be1b1681d98712680ae8f2f26d7881245f2ce9e40714f1a686"}, ] [package.extras] -docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"] -testing = ["build[virtualenv]", "filelock (>=3.4.0)", "importlib-metadata", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "mypy (==1.9)", "packaging (>=23.2)", "pip (>=19.1)", "pytest (>=6,!=8.1.1)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy", "pytest-perf", "pytest-ruff (>=0.2.1)", "pytest-timeout", "pytest-xdist (>=3)", "tomli", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] -testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] +check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)", "ruff (>=0.5.2)"] +core = ["importlib-metadata (>=6)", "importlib-resources (>=5.10.2)", "jaraco.collections", "jaraco.functools", "jaraco.text (>=3.7)", "more-itertools", "more-itertools (>=8.8)", "packaging", "packaging (>=24)", "platformdirs (>=4.2.2)", "tomli (>=2.0.1)", "wheel (>=0.43.0)"] +cover = ["pytest-cov"] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier", "towncrier (<24.7)"] +enabler = ["pytest-enabler (>=2.2)"] +test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "jaraco.test (>=5.5)", "packaging (>=23.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-home (>=0.5)", "pytest-perf", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel (>=0.44.0)"] +type = ["importlib-metadata (>=7.0.2)", "jaraco.develop (>=7.21)", "mypy (==1.12.*)", "pytest-mypy"] [[package]] name = "six" @@ -3129,13 +3265,13 @@ test = ["coverage[toml] (>=7)", "mypy (>=1.2.0)", "pytest (>=7)"] [[package]] name = "typing-extensions" -version = "4.11.0" +version = "4.12.2" description = "Backported and Experimental Type Hints for Python 3.8+" optional = false python-versions = ">=3.8" files = [ - {file = "typing_extensions-4.11.0-py3-none-any.whl", hash = "sha256:c1f94d72897edaf4ce775bb7558d5b79d8126906a14ea5ed1635921406c0387a"}, - {file = "typing_extensions-4.11.0.tar.gz", hash = "sha256:83f085bd5ca59c80295fc2a82ab5dac679cbe02b9f33f7d83af68e241bea51b0"}, + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, ] [[package]] @@ -3316,4 +3452,4 @@ visuals = ["ipywidgets", "nbformat", "plotly"] [metadata] lock-version = "2.0" python-versions = ">=3.8.1, <3.13" -content-hash = "d13962f958b8a425c50426728eba26c1fefeffb01fe8a4918d78a054d2df0b73" +content-hash = "b438e4df96baa0eba69afba0bbdc725f7a860c9ccb96c6c139057d31dd704381" diff --git a/pyproject.toml b/pyproject.toml index f5a3191d..58ebf912 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -68,10 +68,12 @@ tqdm = "^4.27.0" implicit = "^0.7.1" attrs = ">=19.1.0,<24.0.0" typeguard = "^4.1.0" - +pydantic = "^2.8.2" +pydantic-core = "^2.20.1" +typing-extensions = "^4.12.2" # The latest released version of lightfm is 1.17 and it's not compatible with PEP-517 installers (like latest poetry versions). -rectools-lightfm = {version="1.17.1", python = "<3.12", optional = true} +rectools-lightfm = {version="1.17.2", python = "<3.12", optional = true} nmslib = {version = "^2.0.4", python = "<3.11", optional = true} # nmslib officialy doens't support Python 3.11 and 3.12. Use https://github.com/metabrainz/nmslib-metabrainz instead diff --git a/rectools/dataset/dataset.py b/rectools/dataset/dataset.py index cd68433b..0936656c 100644 --- a/rectools/dataset/dataset.py +++ b/rectools/dataset/dataset.py @@ -102,6 +102,7 @@ def construct( item_features_df: tp.Optional[pd.DataFrame] = None, cat_item_features: tp.Iterable[str] = (), make_dense_item_features: bool = False, + keep_extra_cols: bool = False, ) -> "Dataset": """Class method for convenient `Dataset` creation. @@ -133,6 +134,8 @@ def construct( Used only if `user_features_df` (`item_features_df`) is not ``None``. - if ``False``, `SparseFeatures.from_flatten` method will be used; - if ``True``, `DenseFeatures.from_dataframe` method will be used. + keep_extra_cols: bool, default ``False`` + Flag to keep all columns from interactions besides the default ones. Returns ------- @@ -144,7 +147,7 @@ def construct( raise KeyError(f"Column '{col}' must be present in `interactions_df`") user_id_map = IdMap.from_values(interactions_df[Columns.User].values) item_id_map = IdMap.from_values(interactions_df[Columns.Item].values) - interactions = Interactions.from_raw(interactions_df, user_id_map, item_id_map) + interactions = Interactions.from_raw(interactions_df, user_id_map, item_id_map, keep_extra_cols) user_features, user_id_map = cls._make_features( user_features_df, @@ -200,6 +203,7 @@ def get_user_item_matrix( include_weights: bool = True, include_warm_users: bool = False, include_warm_items: bool = False, + dtype: tp.Type = np.float32, ) -> sparse.csr_matrix: """ Construct user-item CSR matrix based on `interactions` attribute. @@ -224,13 +228,15 @@ def get_user_item_matrix( csr_matrix Resized user-item CSR matrix """ - matrix = self.interactions.get_user_item_matrix(include_weights) + matrix = self.interactions.get_user_item_matrix(include_weights, dtype) n_rows = self.user_id_map.size if include_warm_users else matrix.shape[0] n_columns = self.item_id_map.size if include_warm_items else matrix.shape[1] matrix.resize(n_rows, n_columns) return matrix - def get_raw_interactions(self, include_weight: bool = True, include_datetime: bool = True) -> pd.DataFrame: + def get_raw_interactions( + self, include_weight: bool = True, include_datetime: bool = True, include_extra_cols: bool = True + ) -> pd.DataFrame: """ Return interactions as a `pd.DataFrame` object with replacing internal user and item ids to external ones. @@ -240,12 +246,16 @@ def get_raw_interactions(self, include_weight: bool = True, include_datetime: bo Whether to include weight column into resulting table or not. include_datetime : bool, default ``True`` Whether to include datetime column into resulting table or not. + include_extra_cols: bool, default ``True`` + Whether to include extra columns into resulting table or not. Returns ------- pd.DataFrame """ - return self.interactions.to_external(self.user_id_map, self.item_id_map, include_weight, include_datetime) + return self.interactions.to_external( + self.user_id_map, self.item_id_map, include_weight, include_datetime, include_extra_cols + ) def filter_interactions( self, diff --git a/rectools/dataset/interactions.py b/rectools/dataset/interactions.py index ef614eeb..3f06ba70 100644 --- a/rectools/dataset/interactions.py +++ b/rectools/dataset/interactions.py @@ -14,6 +14,8 @@ """Structure for saving user-item interactions.""" +import typing as tp + import attr import numpy as np import pandas as pd @@ -40,6 +42,7 @@ class Interactions: - `Columns.Weight` - weight of interaction, float, use ``1`` if interactions have no weight; - `Columns.Datetime` - timestamp of interactions, assign random value if you're not going to use it later. + Extra columns can also be present. """ df: pd.DataFrame = attr.ib() @@ -79,12 +82,15 @@ def __attrs_post_init__(self) -> None: """Convert datetime and weight columns to the right data types.""" self._convert_weight_and_datetime_types(self.df) + @staticmethod + def _add_extra_cols(df: pd.DataFrame, interactions: pd.DataFrame) -> None: + extra_cols = [col for col in interactions.columns if col not in df.columns] + for extra_col in extra_cols: + df[extra_col] = interactions[extra_col].values + @classmethod def from_raw( - cls, - interactions: pd.DataFrame, - user_id_map: IdMap, - item_id_map: IdMap, + cls, interactions: pd.DataFrame, user_id_map: IdMap, item_id_map: IdMap, keep_extra_cols: bool = False ) -> "Interactions": """ Create `Interactions` from dataset with external ids and id mappings. @@ -102,6 +108,8 @@ def from_raw( User identifiers mapping. item_id_map : IdMap Item identifiers mapping. + keep_extra_cols: bool, default ``False`` + Flag to keep all columns from interactions besides the default ones. Returns ------- @@ -118,10 +126,12 @@ def from_raw( df[Columns.Weight] = interactions[Columns.Weight].values df[Columns.Datetime] = interactions[Columns.Datetime].values cls._convert_weight_and_datetime_types(df) + if keep_extra_cols: + cls._add_extra_cols(df, interactions) return cls(df) - def get_user_item_matrix(self, include_weights: bool = True) -> sparse.csr_matrix: + def get_user_item_matrix(self, include_weights: bool = True, dtype: tp.Type = np.float32) -> sparse.csr_matrix: """ Form a user-item CSR matrix based on interactions data. @@ -142,7 +152,7 @@ def get_user_item_matrix(self, include_weights: bool = True) -> sparse.csr_matri csr = sparse.csr_matrix( ( - values.astype(np.float32), + values.astype(dtype), ( self.df[Columns.User].values, self.df[Columns.Item].values, @@ -157,6 +167,7 @@ def to_external( item_id_map: IdMap, include_weight: bool = True, include_datetime: bool = True, + include_extra_cols: bool = True, ) -> pd.DataFrame: """ Convert itself to `pd.DataFrame` with replacing internal user and item ids to external ones. @@ -171,6 +182,8 @@ def to_external( Whether to include weight column into resulting table or not include_datetime : bool, default ``True`` Whether to include datetime column into resulting table or not. + include_extra_cols: bool, default ``True`` + Whether to include extra columns into resulting table or not. Returns ------- @@ -182,10 +195,16 @@ def to_external( Columns.Item: item_id_map.convert_to_external(self.df[Columns.Item].values), } ) + cols_to_add = [] if include_weight: - res[Columns.Weight] = self.df[Columns.Weight] + cols_to_add.append(Columns.Weight) if include_datetime: - res[Columns.Datetime] = self.df[Columns.Datetime] + cols_to_add.append(Columns.Datetime) + if include_extra_cols: + extra_cols = [col for col in self.df if col not in Columns.Interactions] + cols_to_add.extend(extra_cols) + for col in cols_to_add: + res[col] = self.df[col] return res diff --git a/rectools/models/__init__.py b/rectools/models/__init__.py index 53e25817..c511e755 100644 --- a/rectools/models/__init__.py +++ b/rectools/models/__init__.py @@ -43,6 +43,7 @@ from .popular_in_category import PopularInCategoryModel from .pure_svd import PureSVDModel from .random import RandomModel +from .serialization import load_model try: from .lightfm import LightFMWrapperModel @@ -65,4 +66,5 @@ "PureSVDModel", "RandomModel", "DSSMModel", + "load_model", ) diff --git a/rectools/models/base.py b/rectools/models/base.py index a742ef41..23563715 100644 --- a/rectools/models/base.py +++ b/rectools/models/base.py @@ -14,17 +14,24 @@ """Base model.""" +import pickle import typing as tp import warnings +from pathlib import Path import numpy as np import pandas as pd +import typing_extensions as tpe +from pydantic_core import PydanticSerializationError from rectools import Columns, ExternalIds, InternalIds from rectools.dataset import Dataset from rectools.dataset.identifiers import IdMap from rectools.exceptions import NotFittedError from rectools.types import ExternalIdsArray, InternalIdsArray +from rectools.utils.config import BaseConfig +from rectools.utils.misc import make_dict_flat +from rectools.utils.serialization import PICKLE_PROTOCOL, FileLike, read_bytes T = tp.TypeVar("T", bound="ModelBase") ScoresArray = np.ndarray @@ -38,7 +45,16 @@ RecoTriplet_T = tp.TypeVar("RecoTriplet_T", InternalRecoTriplet, SemiInternalRecoTriplet, ExternalRecoTriplet) -class ModelBase: +class ModelConfig(BaseConfig): + """Base model config.""" + + verbose: int = 0 + + +ModelConfig_T = tp.TypeVar("ModelConfig_T", bound=ModelConfig) + + +class ModelBase(tp.Generic[ModelConfig_T]): """ Base model class. @@ -49,10 +65,196 @@ class ModelBase: recommends_for_warm: bool = False recommends_for_cold: bool = False + config_class: tp.Type[ModelConfig_T] + def __init__(self, *args: tp.Any, verbose: int = 0, **kwargs: tp.Any) -> None: self.is_fitted = False self.verbose = verbose + @tp.overload + def get_config( # noqa: D102 + self, mode: tp.Literal["pydantic"], simple_types: bool = False + ) -> ModelConfig_T: # pragma: no cover + ... + + @tp.overload + def get_config( # noqa: D102 + self, mode: tp.Literal["dict"] = "dict", simple_types: bool = False + ) -> tp.Dict[str, tp.Any]: # pragma: no cover + ... + + def get_config( + self, mode: tp.Literal["pydantic", "dict"] = "dict", simple_types: bool = False + ) -> tp.Union[ModelConfig_T, tp.Dict[str, tp.Any]]: + """ + Return model config. + + Parameters + ---------- + mode : {'pydantic', 'dict'}, default 'dict' + Format of returning config. + simple_types : bool, default False + If True, return config with JSON serializable types. + Only works for `mode='dict'`. + + Returns + ------- + Pydantic model or dict + Model config. + + Raises + ------ + ValueError + If `mode` is not 'object' or 'dict', or if `simple_types` is ``True`` and format is not 'dict'. + """ + config = self._get_config() + if mode == "pydantic": + if simple_types: + raise ValueError("`simple_types` is not compatible with `mode='pydantic'`") + return config + + pydantic_mode = "json" if simple_types else "python" + try: + config_dict = config.model_dump(mode=pydantic_mode) + except PydanticSerializationError as e: + if e.__cause__ is not None: + raise e.__cause__ + raise e + + if mode == "dict": + return config_dict + + raise ValueError(f"Unknown mode: {mode}") + + def _get_config(self) -> ModelConfig_T: + raise NotImplementedError(f"`get_config` method is not implemented for `{self.__class__.__name__}` model") + + def get_params(self, simple_types: bool = False, sep: str = ".") -> tp.Dict[str, tp.Any]: + """ + Return model parameters. + Same as `get_config` but returns flat dict. + + Parameters + ---------- + simple_types : bool, default False + If True, return config with JSON serializable types. + sep : str, default "." + Separator for nested keys. + + Returns + ------- + dict + Model parameters. + """ + config_dict = self.get_config(mode="dict", simple_types=simple_types) + config_flat = make_dict_flat(config_dict, sep=sep) # NOBUG: We're not handling lists for now + return config_flat + + @classmethod + def from_config(cls, config: tp.Union[dict, ModelConfig_T]) -> tpe.Self: + """ + Create model from config. + + Parameters + ---------- + config : dict or ModelConfig + Model config. + + Returns + ------- + Model instance. + """ + try: + config_cls = cls.config_class + except AttributeError: + raise NotImplementedError(f"`from_config` method is not implemented for `{cls.__name__}` model.") from None + + if not isinstance(config, config_cls): + config_obj = cls.config_class.model_validate(config) + else: + config_obj = config + return cls._from_config(config_obj) + + @classmethod + def _from_config(cls, config: ModelConfig_T) -> tpe.Self: + raise NotImplementedError() + + def save(self, f: FileLike) -> int: + """ + Save model to file. + + Parameters + ---------- + f : str or Path or file-like object + Path to file or file-like object. + + Returns + ------- + int + Number of bytes written. + """ + data = self.dumps() + + if isinstance(f, (str, Path)): + return Path(f).write_bytes(data) + + return f.write(data) + + def dumps(self) -> bytes: + """ + Serialize model to bytes. + + Returns + ------- + bytes + Serialized model. + """ + return pickle.dumps(self, protocol=PICKLE_PROTOCOL) + + @classmethod + def load(cls, f: FileLike) -> tpe.Self: + """ + Load model from file. + + Parameters + ---------- + f : str or Path or file-like object + Path to file or file-like object. + + Returns + ------- + model + Model instance. + """ + data = read_bytes(f) + + return cls.loads(data) + + @classmethod + def loads(cls, data: bytes) -> tpe.Self: + """ + Load model from bytes. + + Parameters + ---------- + data : bytes + Serialized model. + + Returns + ------- + model + Model instance. + + Raises + ------ + TypeError + If loaded object is not a direct instance of model class. + """ + loaded = pickle.loads(data) + if loaded.__class__ is not cls: + raise TypeError(f"Loaded object is not a direct instance of `{cls.__name__}`") + return loaded + def fit(self: T, dataset: Dataset, *args: tp.Any, **kwargs: tp.Any) -> T: """ Fit model. @@ -73,6 +275,27 @@ def fit(self: T, dataset: Dataset, *args: tp.Any, **kwargs: tp.Any) -> T: def _fit(self, dataset: Dataset, *args: tp.Any, **kwargs: tp.Any) -> None: raise NotImplementedError() + def fit_partial(self, dataset: Dataset, *args: tp.Any, **kwargs: tp.Any) -> tpe.Self: + """ + Fit model. Unlike `fit`, repeated calls to this method will cause training to resume from + the current model state. + + Parameters + ---------- + dataset : Dataset + Dataset with input data. + + Returns + ------- + self + """ + self._fit_partial(dataset, *args, **kwargs) + self.is_fitted = True + return self + + def _fit_partial(self, dataset: Dataset, *args: tp.Any, **kwargs: tp.Any) -> None: + raise NotImplementedError("Partial fitting is not supported in {self.__class__.__name__}") + def _custom_transform_dataset_u2i( self, dataset: Dataset, users: ExternalIds, on_unsupported_targets: ErrorBehaviour ) -> Dataset: @@ -154,7 +377,8 @@ def recommend( """ self._check_is_fitted() self._check_k(k) - # `dataset.item_id_map.external_dtype` can change + # We are going to lose original dataset object. Save dtype for later + original_user_type = dataset.user_id_map.external_dtype original_item_type = dataset.item_id_map.external_dtype dataset = self._custom_transform_dataset_u2i(dataset, users, on_unsupported_targets) @@ -195,13 +419,9 @@ def recommend( reco_warm_final = self._reco_to_external(reco_warm, dataset.user_id_map, dataset.item_id_map) reco_cold_final = self._reco_items_to_external(reco_cold, dataset.item_id_map) - reco_hot_final = self._adjust_reco_types(reco_hot_final, dataset.user_id_map.external_dtype, original_item_type) - reco_warm_final = self._adjust_reco_types( - reco_warm_final, dataset.user_id_map.external_dtype, original_item_type - ) - reco_cold_final = self._adjust_reco_types( - reco_cold_final, dataset.user_id_map.external_dtype, original_item_type - ) + reco_hot_final = self._adjust_reco_types(reco_hot_final, original_user_type, original_item_type) + reco_warm_final = self._adjust_reco_types(reco_warm_final, original_user_type, original_item_type) + reco_cold_final = self._adjust_reco_types(reco_cold_final, original_user_type, original_item_type) del reco_hot, reco_warm, reco_cold @@ -276,7 +496,7 @@ def recommend_to_items( # pylint: disable=too-many-branches """ self._check_is_fitted() self._check_k(k) - # `dataset.item_id_map.external_dtype` can change + # We are going to lose original dataset object. Save dtype for later original_item_type = dataset.item_id_map.external_dtype dataset = self._custom_transform_dataset_i2i(dataset, target_items, on_unsupported_targets) diff --git a/rectools/models/ease.py b/rectools/models/ease.py index 36e90135..3139a72e 100644 --- a/rectools/models/ease.py +++ b/rectools/models/ease.py @@ -17,17 +17,26 @@ import typing as tp import numpy as np +import typing_extensions as tpe from scipy import sparse from rectools import InternalIds from rectools.dataset import Dataset +from rectools.models.base import ModelConfig from rectools.types import InternalIdsArray from .base import ModelBase, Scores from .rank import Distance, ImplicitRanker -class EASEModel(ModelBase): +class EASEModelConfig(ModelConfig): + """Config for `EASE` model.""" + + regularization: float = 500.0 + num_threads: int = 1 + + +class EASEModel(ModelBase[EASEModelConfig]): """ Embarrassingly Shallow Autoencoders for Sparse Data model. @@ -51,17 +60,27 @@ class EASEModel(ModelBase): recommends_for_warm = False recommends_for_cold = False + config_class = EASEModelConfig + def __init__( self, regularization: float = 500.0, num_threads: int = 1, verbose: int = 0, ): + super().__init__(verbose=verbose) self.weight: np.ndarray self.regularization = regularization self.num_threads = num_threads + def _get_config(self) -> EASEModelConfig: + return EASEModelConfig(regularization=self.regularization, num_threads=self.num_threads, verbose=self.verbose) + + @classmethod + def _from_config(cls, config: EASEModelConfig) -> tpe.Self: + return cls(regularization=config.regularization, num_threads=config.num_threads, verbose=config.verbose) + def _fit(self, dataset: Dataset) -> None: # type: ignore ui_csr = dataset.get_user_item_matrix(include_weights=True) diff --git a/rectools/models/implicit_als.py b/rectools/models/implicit_als.py index 8c9459df..737ea202 100644 --- a/rectools/models/implicit_als.py +++ b/rectools/models/implicit_als.py @@ -17,23 +17,96 @@ import implicit.gpu import numpy as np +import typing_extensions as tpe +from implicit.als import AlternatingLeastSquares from implicit.cpu.als import AlternatingLeastSquares as CPUAlternatingLeastSquares from implicit.gpu.als import AlternatingLeastSquares as GPUAlternatingLeastSquares from implicit.utils import check_random_state +from pydantic import BeforeValidator, ConfigDict, PlainSerializer, SerializationInfo, WrapSerializer from scipy import sparse from tqdm.auto import tqdm from rectools.dataset import Dataset, Features from rectools.exceptions import NotFittedError +from rectools.models.base import ModelConfig +from rectools.utils.config import BaseConfig +from rectools.utils.misc import get_class_or_function_full_path, import_object +from rectools.utils.serialization import RandomState from .rank import Distance from .vector import Factors, VectorModel -AVAILABLE_RECOMMEND_METHODS = ("loop",) +ALS_STRING = "AlternatingLeastSquares" + AnyAlternatingLeastSquares = tp.Union[CPUAlternatingLeastSquares, GPUAlternatingLeastSquares] +AlternatingLeastSquaresType = tp.Union[tp.Type[AnyAlternatingLeastSquares], tp.Literal["AlternatingLeastSquares"]] + + +def _get_alternating_least_squares_class(spec: tp.Any) -> tp.Any: + if spec in (ALS_STRING, get_class_or_function_full_path(AlternatingLeastSquares)): + return "AlternatingLeastSquares" + if isinstance(spec, str): + return import_object(spec) + return spec + + +def _serialize_alternating_least_squares_class( + cls: AlternatingLeastSquaresType, handler: tp.Callable, info: SerializationInfo +) -> tp.Union[None, str, AnyAlternatingLeastSquares]: + if cls in (CPUAlternatingLeastSquares, GPUAlternatingLeastSquares) or cls == "AlternatingLeastSquares": + return ALS_STRING + if info.mode == "json": + return get_class_or_function_full_path(cls) + return cls + + +AlternatingLeastSquaresClass = tpe.Annotated[ + AlternatingLeastSquaresType, + BeforeValidator(_get_alternating_least_squares_class), + WrapSerializer( + func=_serialize_alternating_least_squares_class, + when_used="always", + ), +] + +DType = tpe.Annotated[ + np.dtype, BeforeValidator(func=np.dtype), PlainSerializer(func=lambda dtp: dtp.name, when_used="json") +] + + +class AlternatingLeastSquaresParams(tpe.TypedDict): + """Params for implicit `AlternatingLeastSquares` model.""" + + factors: tpe.NotRequired[int] + regularization: tpe.NotRequired[float] + alpha: tpe.NotRequired[float] + dtype: tpe.NotRequired[DType] + use_native: tpe.NotRequired[bool] + use_cg: tpe.NotRequired[bool] + use_gpu: tpe.NotRequired[bool] + iterations: tpe.NotRequired[int] + calculate_training_loss: tpe.NotRequired[bool] + num_threads: tpe.NotRequired[int] + random_state: tpe.NotRequired[RandomState] + + +class AlternatingLeastSquaresConfig(BaseConfig): + """Config for implicit `AlternatingLeastSquares` model.""" + + model_config = ConfigDict(arbitrary_types_allowed=True) + + cls: AlternatingLeastSquaresClass = "AlternatingLeastSquares" + params: AlternatingLeastSquaresParams = {} -class ImplicitALSWrapperModel(VectorModel): +class ImplicitALSWrapperModelConfig(ModelConfig): + """Config for `ImplicitALSWrapperModel`.""" + + model: AlternatingLeastSquaresConfig + fit_features_together: bool = False + + +class ImplicitALSWrapperModel(VectorModel[ImplicitALSWrapperModelConfig]): """ Wrapper for `implicit.als.AlternatingLeastSquares` with possibility to use explicit features and GPU support. @@ -58,19 +131,87 @@ class ImplicitALSWrapperModel(VectorModel): u2i_dist = Distance.DOT i2i_dist = Distance.COSINE + config_class = ImplicitALSWrapperModelConfig + def __init__(self, model: AnyAlternatingLeastSquares, verbose: int = 0, fit_features_together: bool = False): + self._config = self._make_config(model, verbose, fit_features_together) + super().__init__(verbose=verbose) self.model: AnyAlternatingLeastSquares - self._model = model # for refit; TODO: try to do it better + self._model = model # for refit self.fit_features_together = fit_features_together self.use_gpu = isinstance(model, GPUAlternatingLeastSquares) if not self.use_gpu: self.n_threads = model.num_threads - def _fit(self, dataset: Dataset) -> None: # type: ignore + @classmethod + def _make_config( + cls, model: AnyAlternatingLeastSquares, verbose: int, fit_features_together: bool + ) -> ImplicitALSWrapperModelConfig: + params = { + "factors": model.factors, + "regularization": model.regularization, + "alpha": model.alpha, + "dtype": model.dtype, + "iterations": model.iterations, + "calculate_training_loss": model.calculate_training_loss, + "random_state": model.random_state, + } + if isinstance(model, GPUAlternatingLeastSquares): + params.update({"use_gpu": True}) + else: + params.update( + { + "use_gpu": False, + "use_native": model.use_native, + "use_cg": model.use_cg, + "num_threads": model.num_threads, + } + ) + + model_cls = model.__class__ + return ImplicitALSWrapperModelConfig( + model=AlternatingLeastSquaresConfig( + cls=( + model_cls + if model_cls not in (CPUAlternatingLeastSquares, GPUAlternatingLeastSquares) + else "AlternatingLeastSquares" + ), + params=tp.cast(AlternatingLeastSquaresParams, params), # https://github.com/python/mypy/issues/8890 + ), + verbose=verbose, + fit_features_together=fit_features_together, + ) + + def _get_config(self) -> ImplicitALSWrapperModelConfig: + return self._config + + @classmethod + def _from_config(cls, config: ImplicitALSWrapperModelConfig) -> tpe.Self: + if config.model.cls == ALS_STRING: + model_cls = AlternatingLeastSquares # Not actually a class, but it's ok + else: + model_cls = config.model.cls + model = model_cls(**config.model.params) + return cls(model=model, verbose=config.verbose, fit_features_together=config.fit_features_together) + + def _fit(self, dataset: Dataset) -> None: self.model = deepcopy(self._model) + self._fit_model_for_epochs(dataset, self.model.iterations) + + def _fit_partial(self, dataset: Dataset, epochs: int) -> None: + if not self.is_fitted: + self.model = deepcopy(self._model) + prev_epochs = 0 + else: + prev_epochs = self.model.iterations + + self._fit_model_for_epochs(dataset, epochs) + self.model.iterations = epochs + prev_epochs + + def _fit_model_for_epochs(self, dataset: Dataset, epochs: int) -> None: ui_csr = dataset.get_user_item_matrix(include_weights=True).astype(np.float32) if self.fit_features_together: @@ -79,6 +220,7 @@ def _fit(self, dataset: Dataset) -> None: # type: ignore ui_csr, dataset.get_hot_user_features(), dataset.get_hot_item_features(), + epochs, self.verbose, ) else: @@ -87,6 +229,7 @@ def _fit(self, dataset: Dataset) -> None: # type: ignore ui_csr, dataset.get_hot_user_features(), dataset.get_hot_item_features(), + epochs, self.verbose, ) @@ -154,6 +297,7 @@ def fit_als_with_features_separately_inplace( ui_csr: sparse.csr_matrix, user_features: tp.Optional[Features], item_features: tp.Optional[Features], + iterations: int, verbose: int = 0, ) -> None: """ @@ -172,7 +316,15 @@ def fit_als_with_features_separately_inplace( verbose : int Whether to print output. """ + # If model was fitted we should drop any learnt embeddings except actual latent factors + if model.user_factors is not None and model.item_factors is not None: + # Without .copy() gpu.Matrix will break correct slicing + user_factors = get_users_vectors(model)[:, : model.factors].copy() + item_factors = get_items_vectors(model)[:, : model.factors].copy() + _set_factors(model, user_factors, item_factors) + iu_csr = ui_csr.T.tocsr(copy=False) + model.iterations = iterations model.fit(ui_csr, show_progress=verbose > 0) user_factors_chunks = [get_users_vectors(model)] @@ -193,10 +345,13 @@ def fit_als_with_features_separately_inplace( user_factors = np.hstack(user_factors_chunks) item_factors = np.hstack(item_factors_chunks) + _set_factors(model, user_factors, item_factors) + + +def _set_factors(model: AnyAlternatingLeastSquares, user_factors: np.ndarray, item_factors: np.ndarray) -> None: if isinstance(model, GPUAlternatingLeastSquares): # pragma: no cover user_factors = implicit.gpu.Matrix(user_factors) item_factors = implicit.gpu.Matrix(item_factors) - model.user_factors = user_factors model.item_factors = item_factors @@ -235,36 +390,30 @@ def _fit_paired_factors( def _init_latent_factors_cpu( model: CPUAlternatingLeastSquares, n_users: int, n_items: int ) -> tp.Tuple[np.ndarray, np.ndarray]: - """Logic is copied and pasted from original implicit library code""" + """ + Logic is copied and pasted from original implicit library code. + This method is used only for model that hasn't been fitted yet. + """ random_state = check_random_state(model.random_state) - if model.user_factors is None: - user_latent_factors = random_state.random((n_users, model.factors)) * 0.01 - else: - user_latent_factors = model.user_factors - if model.item_factors is None: - item_latent_factors = random_state.random((n_items, model.factors)) * 0.01 - else: - item_latent_factors = model.item_factors + user_latent_factors = random_state.random((n_users, model.factors)) * 0.01 + item_latent_factors = random_state.random((n_items, model.factors)) * 0.01 return user_latent_factors, item_latent_factors def _init_latent_factors_gpu( model: GPUAlternatingLeastSquares, n_users: int, n_items: int ) -> tp.Tuple[np.ndarray, np.ndarray]: # pragma: no cover - """Logic is copied and pasted from original implicit library code""" + """ + Logic is copied and pasted from original implicit library code. + This method is used only for model that hasn't been fitted yet. + """ random_state = check_random_state(model.random_state) - if model.user_factors is None: - user_latent_factors = random_state.uniform( - low=-0.5 / model.factors, high=0.5 / model.factors, size=(n_users, model.factors) - ) - else: - user_latent_factors = model.user_factors.to_numpy() - if model.item_factors is None: - item_latent_factors = random_state.uniform( - low=-0.5 / model.factors, high=0.5 / model.factors, size=(n_items, model.factors) - ) - else: - item_latent_factors = model.item_factors.to_numpy() + user_latent_factors = random_state.uniform( + low=-0.5 / model.factors, high=0.5 / model.factors, size=(n_users, model.factors) + ) + item_latent_factors = random_state.uniform( + low=-0.5 / model.factors, high=0.5 / model.factors, size=(n_items, model.factors) + ) return user_latent_factors, item_latent_factors @@ -273,6 +422,7 @@ def fit_als_with_features_together_inplace( ui_csr: sparse.csr_matrix, user_features: tp.Optional[Features], item_features: tp.Optional[Features], + iterations: int, verbose: int = 0, ) -> None: """ @@ -293,6 +443,65 @@ def fit_als_with_features_together_inplace( """ n_users, n_items = ui_csr.shape + if model.user_factors is None or model.item_factors is None: + user_factors, item_factors, n_user_explicit_factors, n_item_explicit_factors = ( + _init_user_item_factors_for_combined_training_with_features( + model, n_users, n_items, user_features, item_features + ) + ) + else: + user_factors = get_users_vectors(model) + item_factors = get_items_vectors(model) + n_user_explicit_factors = user_features.values.shape[1] if user_features is not None else 0 + n_item_explicit_factors = item_features.values.shape[1] if item_features is not None else 0 + + # Fix number of factors + n_latent_factors = model.factors + model.factors = n_latent_factors + n_user_explicit_factors + n_item_explicit_factors + + # Give the positive examples more weight if asked for (implicit library logic copy) + ui_csr = model.alpha * ui_csr + + if isinstance(model, GPUAlternatingLeastSquares): # pragma: no cover + _fit_combined_factors_on_gpu_inplace( + model, + ui_csr, + user_factors, + item_factors, + n_user_explicit_factors, + n_item_explicit_factors, + verbose, + iterations, + ) + else: + _fit_combined_factors_on_cpu_inplace( + model, + ui_csr, + user_factors, + item_factors, + n_user_explicit_factors, + n_item_explicit_factors, + verbose, + iterations, + ) + + # Fix back model factors + model.factors = n_latent_factors + + +def _init_user_item_factors_for_combined_training_with_features( + model: AnyAlternatingLeastSquares, + n_users: int, + n_items: int, + user_features: tp.Optional[Features], + item_features: tp.Optional[Features], +) -> tp.Tuple[np.ndarray, np.ndarray, int, int]: + """ + Init user and item factors for model that hasn't been initialized yet. + Final factors will include latent factors, explicit factors from + user/item features and their paired item/user factors. + This method is only used when `fit_features_together` is set to ``True`` + """ # Prepare explicit factors user_explicit_factors: np.ndarray if user_features is None: @@ -314,10 +523,6 @@ def fit_als_with_features_together_inplace( else: user_latent_factors, item_latent_factors = _init_latent_factors_cpu(model, n_users, n_items) - # Fix number of factors - n_latent_factors = model.factors - model.factors = n_latent_factors + n_user_explicit_factors + n_item_explicit_factors - # Prepare paired factors user_factors_paired_to_items = np.zeros((n_users, n_item_explicit_factors)) item_factors_paired_to_users = np.zeros((n_items, n_user_explicit_factors)) @@ -338,29 +543,7 @@ def fit_als_with_features_together_inplace( ) ).astype(model.dtype) - # Give the positive examples more weight if asked for (implicit library logic copy) - ui_csr = model.alpha * ui_csr - - if isinstance(model, GPUAlternatingLeastSquares): # pragma: no cover - _fit_combined_factors_on_gpu_inplace( - model, - ui_csr, - user_factors, - item_factors, - n_user_explicit_factors, - n_item_explicit_factors, - verbose, - ) - else: - _fit_combined_factors_on_cpu_inplace( - model, - ui_csr, - user_factors, - item_factors, - n_user_explicit_factors, - n_item_explicit_factors, - verbose, - ) + return user_factors, item_factors, n_user_explicit_factors, n_item_explicit_factors def _fit_combined_factors_on_cpu_inplace( @@ -371,6 +554,7 @@ def _fit_combined_factors_on_cpu_inplace( n_user_explicit_factors: int, n_item_explicit_factors: int, verbose: int, + iterations: int, ) -> None: n_factors = user_factors.shape[1] user_explicit_factors = user_factors[:, :n_user_explicit_factors].copy() @@ -384,7 +568,7 @@ def _fit_combined_factors_on_cpu_inplace( solver = model.solver - for _ in tqdm(range(model.iterations), disable=verbose == 0): + for _ in tqdm(range(iterations), disable=verbose == 0): solver( ui_csr, @@ -416,6 +600,7 @@ def _fit_combined_factors_on_gpu_inplace( n_user_explicit_factors: int, n_item_explicit_factors: int, verbose: int, + iterations: int, ) -> None: # pragma: no cover n_factors = user_factors.shape[1] user_explicit_factors = user_factors[:, :n_user_explicit_factors].copy() @@ -435,7 +620,7 @@ def _fit_combined_factors_on_gpu_inplace( _YtY = implicit.gpu.Matrix.zeros(model.factors, model.factors) _XtX = implicit.gpu.Matrix.zeros(model.factors, model.factors) - for _ in tqdm(range(model.iterations), disable=verbose == 0): + for _ in tqdm(range(iterations), disable=verbose == 0): model.solver.calculate_yty(Y, _YtY, model.regularization) model.solver.least_squares(ui_csr_cuda, X, _YtY, Y, model.cg_steps) diff --git a/rectools/models/implicit_knn.py b/rectools/models/implicit_knn.py index cc7ab8cd..3989146f 100644 --- a/rectools/models/implicit_knn.py +++ b/rectools/models/implicit_knn.py @@ -16,9 +16,12 @@ import warnings from copy import deepcopy +import implicit.nearest_neighbours import numpy as np -from implicit.nearest_neighbours import ItemItemRecommender +import typing_extensions as tpe +from implicit.nearest_neighbours import BM25Recommender, CosineRecommender, ItemItemRecommender, TFIDFRecommender from implicit.utils import ParameterWarning +from pydantic import BeforeValidator, ConfigDict, PlainSerializer from scipy import sparse from tqdm.auto import tqdm @@ -26,12 +29,64 @@ from rectools.dataset import Dataset from rectools.types import InternalId, InternalIdsArray from rectools.utils import fast_isin_for_sorted_test_elements +from rectools.utils.config import BaseConfig +from rectools.utils.misc import get_class_or_function_full_path, import_object -from .base import ModelBase, Scores +from .base import ModelBase, ModelConfig, Scores from .utils import get_viewed_item_ids, recommend_from_scores +_base_item_item_recommender_classes = ( + ItemItemRecommender, + CosineRecommender, + TFIDFRecommender, + BM25Recommender, +) -class ImplicitItemKNNWrapperModel(ModelBase): + +def _get_item_item_recommender_class(spec: tp.Any) -> tp.Any: + if not isinstance(spec, str): + return spec + + base_class_names = {cls.__name__ for cls in _base_item_item_recommender_classes} + if spec in base_class_names: + return getattr(implicit.nearest_neighbours, spec) + + return import_object(spec) + + +def _serialize_item_item_recommender_class(cls: tp.Type[ItemItemRecommender]) -> str: + if cls in _base_item_item_recommender_classes: + return cls.__name__ + return get_class_or_function_full_path(cls) + + +ItemItemRecommenderClass = tpe.Annotated[ + tp.Type[ItemItemRecommender], + BeforeValidator(_get_item_item_recommender_class), + PlainSerializer( + func=_serialize_item_item_recommender_class, + return_type=str, + when_used="json", + ), +] + + +class ItemItemRecommenderConfig(BaseConfig): + """Config for `implicit` `ItemItemRecommender` model and its successors.""" + + model_config = ConfigDict(arbitrary_types_allowed=True) + + cls: ItemItemRecommenderClass + params: tp.Dict[str, tp.Any] = {} + + +class ImplicitItemKNNWrapperModelConfig(ModelConfig): + """Config for `ImplicitItemKNNWrapperModel`.""" + + model: ItemItemRecommenderConfig + + +class ImplicitItemKNNWrapperModel(ModelBase[ImplicitItemKNNWrapperModelConfig]): """ Wrapper for `implicit.nearest_neighbours.ItemItemRecommender` and its successors. @@ -47,15 +102,41 @@ class ImplicitItemKNNWrapperModel(ModelBase): recommends_for_warm = False recommends_for_cold = False + config_class = ImplicitItemKNNWrapperModelConfig def __init__(self, model: ItemItemRecommender, verbose: int = 0): super().__init__(verbose=verbose) self.model: ItemItemRecommender self._model = model + def _get_config(self) -> ImplicitItemKNNWrapperModelConfig: + inner_model = self._model + params = {"K": inner_model.K, "num_threads": inner_model.num_threads} + if isinstance(inner_model, BM25Recommender): + # NOBUG: If it's a custom class, we don't know its params + params.update({"K1": inner_model.K1, "B": inner_model.B}) + return ImplicitItemKNNWrapperModelConfig( + model=ItemItemRecommenderConfig( + cls=inner_model.__class__, + params=params, + ), + verbose=self.verbose, + ) + + @classmethod + def _from_config(cls, config: ImplicitItemKNNWrapperModelConfig) -> tpe.Self: + model = config.model.cls(**config.model.params) + return cls(model=model, verbose=config.verbose) + def _fit(self, dataset: Dataset) -> None: # type: ignore self.model = deepcopy(self._model) - ui_csr = dataset.get_user_item_matrix(include_weights=True) + + # There is implicit conversion from float32 to float 64 in implicit library + # in `normalize` function on the line `X.data = X.data / sqrt(bincount(X.row, X.data**2))[X.row]`. + # But this function is not used in the base `ItemItemRecommender` class. + # So we convert it here to make every class including the base on work. + ui_csr = dataset.get_user_item_matrix(include_weights=True, dtype=np.float64) + # implicit library processes weights in coo_matrix format and then warns about converting it to csr with warnings.catch_warnings(): warnings.filterwarnings(action="ignore", category=ParameterWarning, message="Method expects CSR input") diff --git a/rectools/models/lightfm.py b/rectools/models/lightfm.py index 32dad456..40b93189 100644 --- a/rectools/models/lightfm.py +++ b/rectools/models/lightfm.py @@ -16,20 +16,86 @@ from copy import deepcopy import numpy as np +import typing_extensions as tpe from lightfm import LightFM +from pydantic import BeforeValidator, ConfigDict, PlainSerializer from scipy import sparse from rectools.dataset import Dataset, Features from rectools.exceptions import NotFittedError from rectools.models.utils import recommend_from_scores from rectools.types import InternalIds, InternalIdsArray +from rectools.utils.config import BaseConfig +from rectools.utils.misc import get_class_or_function_full_path, import_object +from rectools.utils.serialization import RandomState -from .base import FixedColdRecoModelMixin, InternalRecoTriplet, Scores +from .base import FixedColdRecoModelMixin, InternalRecoTriplet, ModelConfig, Scores from .rank import Distance from .vector import Factors, VectorModel +LIGHT_FM_CLS_STRING = "LightFM" -class LightFMWrapperModel(FixedColdRecoModelMixin, VectorModel): + +def _get_light_fm_class(spec: tp.Any) -> tp.Any: + if not isinstance(spec, str): + return spec + if spec == LIGHT_FM_CLS_STRING: + return LightFM + return import_object(spec) + + +def _serialize_light_fm_class(cls: tp.Type[LightFM]) -> str: + if cls is LightFM: + return LIGHT_FM_CLS_STRING + return get_class_or_function_full_path(cls) + + +LightFMClass = tpe.Annotated[ + tp.Type[LightFM], + BeforeValidator(_get_light_fm_class), + PlainSerializer( + func=_serialize_light_fm_class, + return_type=str, + when_used="json", + ), +] + + +class LightFMParams(tpe.TypedDict): + """Params for `LightFM` model.""" + + no_components: tpe.NotRequired[int] + k: tpe.NotRequired[int] + n: tpe.NotRequired[int] + learning_schedule: tpe.NotRequired[str] + loss: tpe.NotRequired[str] + learning_rate: tpe.NotRequired[float] + rho: tpe.NotRequired[float] + epsilon: tpe.NotRequired[float] + item_alpha: tpe.NotRequired[float] + user_alpha: tpe.NotRequired[float] + max_sampled: tpe.NotRequired[int] + random_state: tpe.NotRequired[RandomState] + + +class LightFMConfig(BaseConfig): + """Config for `LightFM` model.""" + + model_config = ConfigDict(arbitrary_types_allowed=True) + + cls: LightFMClass = LightFM + params: LightFMParams = {} + + +class LightFMWrapperModelConfig(ModelConfig): + """Config for `LightFMWrapperModel`.""" + + model: LightFMConfig + epochs: int = 1 + num_threads: int = 1 + + +class LightFMWrapperModel(FixedColdRecoModelMixin, VectorModel[LightFMWrapperModelConfig]): """ Wrapper for `lightfm.LightFM`. @@ -57,6 +123,8 @@ class LightFMWrapperModel(FixedColdRecoModelMixin, VectorModel): u2i_dist = Distance.DOT i2i_dist = Distance.COSINE + config_class = LightFMWrapperModelConfig + def __init__( self, model: LightFM, @@ -71,6 +139,39 @@ def __init__( self.n_epochs = epochs self.n_threads = num_threads + def _get_config(self) -> LightFMWrapperModelConfig: + inner_model = self._model + params = { + "no_components": inner_model.no_components, + "k": inner_model.k, + "n": inner_model.n, + "learning_schedule": inner_model.learning_schedule, + "loss": inner_model.loss, + "learning_rate": inner_model.learning_rate, + "rho": inner_model.rho, + "epsilon": inner_model.epsilon, + "item_alpha": inner_model.item_alpha, + "user_alpha": inner_model.user_alpha, + "max_sampled": inner_model.max_sampled, + "random_state": inner_model.initial_random_state, # random_state is an object and can't be serialized + } + inner_model_cls = inner_model.__class__ + return LightFMWrapperModelConfig( + model=LightFMConfig( + cls=inner_model_cls, + params=tp.cast(LightFMParams, params), # https://github.com/python/mypy/issues/8890 + ), + epochs=self.n_epochs, + num_threads=self.n_threads, + verbose=self.verbose, + ) + + @classmethod + def _from_config(cls, config: LightFMWrapperModelConfig) -> tpe.Self: + model_cls = config.model.cls + model = model_cls(**config.model.params) + return cls(model=model, epochs=config.epochs, num_threads=config.num_threads, verbose=config.verbose) + def _fit(self, dataset: Dataset) -> None: # type: ignore self.model = deepcopy(self._model) diff --git a/rectools/models/popular.py b/rectools/models/popular.py index c0c3b24f..29708b10 100644 --- a/rectools/models/popular.py +++ b/rectools/models/popular.py @@ -20,10 +20,13 @@ import numpy as np import pandas as pd +import typing_extensions as tpe +from pydantic import PlainSerializer, PlainValidator from tqdm.auto import tqdm from rectools import Columns, InternalIds from rectools.dataset import Dataset +from rectools.models.base import ModelConfig from rectools.types import InternalIdsArray from rectools.utils import fast_isin_for_sorted_test_elements @@ -40,7 +43,89 @@ class Popularity(Enum): SUM_WEIGHT = "sum_weight" -class PopularModel(FixedColdRecoModelMixin, ModelBase): +def _deserialize_timedelta(td: tp.Union[dict, timedelta]) -> timedelta: + if isinstance(td, dict): + return timedelta(**td) + return td + + +def _serialize_timedelta(td: timedelta) -> dict: + serialized_td = { + key: value + for key, value in {"days": td.days, "seconds": td.seconds, "microseconds": td.microseconds}.items() + if value != 0 + } + return serialized_td + + +TimeDelta = tpe.Annotated[ + timedelta, + PlainValidator(func=_deserialize_timedelta), + PlainSerializer(func=_serialize_timedelta), +] + + +class PopularModelConfig(ModelConfig): + """Config for `PopularModel`.""" + + popularity: Popularity = Popularity.N_USERS + period: tp.Optional[TimeDelta] = None + begin_from: tp.Optional[datetime] = None + add_cold: bool = False + inverse: bool = False + + +PopularityOptions = tp.Literal["n_users", "n_interactions", "mean_weight", "sum_weight"] + + +class PopularModelMixin: + """Mixin for models based on popularity.""" + + @classmethod + def _validate_popularity( + cls, + popularity: PopularityOptions, + ) -> Popularity: + try: + return Popularity(popularity) + except ValueError: + possible_values = {item.value for item in Popularity.__members__.values()} + raise ValueError(f"`popularity` must be one of the {possible_values}. Got {popularity}.") + + @classmethod + def _validate_time_attributes( + cls, + period: tp.Optional[TimeDelta], + begin_from: tp.Optional[datetime], + ) -> None: + if period is not None and begin_from is not None: + raise ValueError("Only one of `period` and `begin_from` can be set") + + @classmethod + def _filter_interactions( + cls, interactions: pd.DataFrame, period: tp.Optional[TimeDelta], begin_from: tp.Optional[datetime] + ) -> pd.DataFrame: + if begin_from is not None: + interactions = interactions.loc[interactions[Columns.Datetime] >= begin_from] + elif period is not None: + begin_from = interactions[Columns.Datetime].max() - period + interactions = interactions.loc[interactions[Columns.Datetime] >= begin_from] + return interactions + + @classmethod + def _get_groupby_col_and_agg_func(cls, popularity: Popularity) -> tp.Tuple[str, str]: + if popularity == Popularity.N_USERS: + return Columns.User, "nunique" + if popularity == Popularity.N_INTERACTIONS: + return Columns.User, "count" + if popularity == Popularity.MEAN_WEIGHT: + return Columns.Weight, "mean" + if popularity == Popularity.SUM_WEIGHT: + return Columns.Weight, "sum" + raise ValueError(f"Unexpected popularity {popularity}") + + +class PopularModel(FixedColdRecoModelMixin, PopularModelMixin, ModelBase[PopularModelConfig]): """ Model generating recommendations based on popularity of items. @@ -76,25 +161,22 @@ class PopularModel(FixedColdRecoModelMixin, ModelBase): recommends_for_warm = False recommends_for_cold = True + config_class = PopularModelConfig + def __init__( self, - popularity: str = "n_users", + popularity: PopularityOptions = "n_users", period: tp.Optional[timedelta] = None, begin_from: tp.Optional[datetime] = None, add_cold: bool = False, inverse: bool = False, verbose: int = 0, ): - super().__init__(verbose=verbose) - - try: - self.popularity = Popularity(popularity) - except ValueError: - possible_values = {item.value for item in Popularity.__members__.values()} - raise ValueError(f"`popularity` must be one of the {possible_values}. Got {popularity}.") - - if period is not None and begin_from is not None: - raise ValueError("Only one of `period` and `begin_from` can be set") + super().__init__( + verbose=verbose, + ) + self.popularity = self._validate_popularity(popularity) + self._validate_time_attributes(period, begin_from) self.period = period self.begin_from = begin_from @@ -103,16 +185,29 @@ def __init__( self.popularity_list: tp.Tuple[InternalIdsArray, ScoresArray] - def _filter_interactions(self, interactions: pd.DataFrame) -> pd.DataFrame: - if self.begin_from is not None: - interactions = interactions.loc[interactions[Columns.Datetime] >= self.begin_from] - elif self.period is not None: - begin_from = interactions[Columns.Datetime].max() - self.period - interactions = interactions.loc[interactions[Columns.Datetime] >= begin_from] - return interactions + def _get_config(self) -> PopularModelConfig: + return PopularModelConfig( + popularity=self.popularity, + period=self.period, + begin_from=self.begin_from, + add_cold=self.add_cold, + inverse=self.inverse, + verbose=self.verbose, + ) + + @classmethod + def _from_config(cls, config: PopularModelConfig) -> tpe.Self: + return cls( + popularity=config.popularity.value, + period=config.period, + begin_from=config.begin_from, + add_cold=config.add_cold, + inverse=config.inverse, + verbose=config.verbose, + ) def _fit(self, dataset: Dataset) -> None: # type: ignore - interactions = self._filter_interactions(dataset.interactions.df) + interactions = self._filter_interactions(dataset.interactions.df, self.period, self.begin_from) col, func = self._get_groupby_col_and_agg_func(self.popularity) items_scores = interactions.groupby(Columns.Item)[col].agg(func).sort_values(ascending=False) @@ -130,18 +225,6 @@ def _fit(self, dataset: Dataset) -> None: # type: ignore self.popularity_list = (items, scores) - @classmethod - def _get_groupby_col_and_agg_func(cls, popularity: Popularity) -> tp.Tuple[str, str]: - if popularity == Popularity.N_USERS: - return Columns.User, "nunique" - if popularity == Popularity.N_INTERACTIONS: - return Columns.User, "count" - if popularity == Popularity.MEAN_WEIGHT: - return Columns.Weight, "mean" - if popularity == Popularity.SUM_WEIGHT: - return Columns.Weight, "sum" - raise ValueError(f"Unexpected popularity {popularity}") - def _recommend_u2i( self, user_ids: InternalIdsArray, diff --git a/rectools/models/popular_in_category.py b/rectools/models/popular_in_category.py index f24f5ee3..4f6416c4 100644 --- a/rectools/models/popular_in_category.py +++ b/rectools/models/popular_in_category.py @@ -21,13 +21,14 @@ import numpy as np import pandas as pd +import typing_extensions as tpe from rectools import Columns, InternalIds from rectools.dataset import Dataset, Interactions, features from rectools.types import InternalIdsArray -from .base import Scores -from .popular import PopularModel +from .base import ModelBase, Scores +from .popular import FixedColdRecoModelMixin, PopularModel, PopularModelConfig, PopularModelMixin, PopularityOptions class MixingStrategy(Enum): @@ -44,7 +45,18 @@ class RatioStrategy(Enum): PROPORTIONAL = "proportional" -class PopularInCategoryModel(PopularModel): +class PopularInCategoryModelConfig(PopularModelConfig): + """Config for `PopularInCategoryModel`.""" + + category_feature: str + n_categories: tp.Optional[int] = None + mixing_strategy: MixingStrategy = MixingStrategy.ROTATE + ratio_strategy: RatioStrategy = RatioStrategy.PROPORTIONAL + + +class PopularInCategoryModel( + FixedColdRecoModelMixin, PopularModelMixin, ModelBase[PopularInCategoryModelConfig] +): # pylint: disable=too-many-instance-attributes """ Model generating recommendations based on popularity of items. @@ -98,13 +110,15 @@ class PopularInCategoryModel(PopularModel): recommends_for_warm = False recommends_for_cold = True + config_class = PopularInCategoryModelConfig + def __init__( self, category_feature: str, n_categories: tp.Optional[int] = None, - mixing_strategy: tp.Optional[str] = "rotate", - ratio_strategy: tp.Optional[str] = "proportional", - popularity: str = "n_users", + mixing_strategy: tp.Literal["rotate", "group"] = "rotate", + ratio_strategy: tp.Literal["proportional", "equal"] = "proportional", + popularity: PopularityOptions = "n_users", period: tp.Optional[timedelta] = None, begin_from: tp.Optional[datetime] = None, add_cold: bool = False, @@ -112,26 +126,18 @@ def __init__( verbose: int = 0, ): super().__init__( - popularity=popularity, - period=period, - begin_from=begin_from, - add_cold=add_cold, - inverse=inverse, verbose=verbose, ) - self.category_feature = category_feature - self.category_columns: tp.List[int] = [] - self.category_interactions: tp.Dict[int, pd.DataFrame] = {} - self.category_scores: pd.Series - self.models: tp.Dict[int, PopularModel] = {} - self.n_effective_categories: int + self.popularity = self._validate_popularity(popularity) + self._validate_time_attributes(period, begin_from) + self.period = period + self.begin_from = begin_from - if n_categories is None or n_categories > 0: - self.n_categories = n_categories - else: - raise ValueError(f"`n_categories` must be a positive number. Got {n_categories}") + self.add_cold = add_cold + self.inverse = inverse + self.category_feature = category_feature try: self.mixing_strategy = MixingStrategy(mixing_strategy) except ValueError: @@ -143,6 +149,45 @@ def __init__( except ValueError: possible_values = {item.value for item in RatioStrategy.__members__.values()} raise ValueError(f"`ratio_strategy` must be one of the {possible_values}. Got {ratio_strategy}.") + self.category_columns: tp.List[int] = [] + self.category_interactions: tp.Dict[int, pd.DataFrame] = {} + self.category_scores: pd.Series + self.models: tp.Dict[int, PopularModel] = {} + self.n_effective_categories: int + + if n_categories is None or n_categories > 0: + self.n_categories = n_categories + else: + raise ValueError(f"`n_categories` must be a positive number. Got {n_categories}") + + def _get_config(self) -> PopularInCategoryModelConfig: + return PopularInCategoryModelConfig( + category_feature=self.category_feature, + n_categories=self.n_categories, + mixing_strategy=self.mixing_strategy, + ratio_strategy=self.ratio_strategy, + popularity=self.popularity, + period=self.period, + begin_from=self.begin_from, + add_cold=self.add_cold, + inverse=self.inverse, + verbose=self.verbose, + ) + + @classmethod + def _from_config(cls, config: PopularInCategoryModelConfig) -> tpe.Self: + return cls( + category_feature=config.category_feature, + n_categories=config.n_categories, + mixing_strategy=config.mixing_strategy.value, + ratio_strategy=config.ratio_strategy.value, + popularity=config.popularity.value, + period=config.period, + begin_from=config.begin_from, + add_cold=config.add_cold, + inverse=config.inverse, + verbose=config.verbose, + ) def _check_category_feature(self, dataset: Dataset) -> None: if not dataset.item_features: @@ -200,7 +245,7 @@ def _fit(self, dataset: Dataset) -> None: # type: ignore self.n_effective_categories = 0 self._check_category_feature(dataset) - interactions = self._filter_interactions(dataset.interactions.df) + interactions = self._filter_interactions(dataset.interactions.df, self.period, self.begin_from) self._calc_category_scores(dataset, interactions) self._define_categories_for_analysis() diff --git a/rectools/models/pure_svd.py b/rectools/models/pure_svd.py index 9ef9f874..9984bcff 100644 --- a/rectools/models/pure_svd.py +++ b/rectools/models/pure_svd.py @@ -17,15 +17,26 @@ import typing as tp import numpy as np +import typing_extensions as tpe from scipy.sparse.linalg import svds from rectools.dataset import Dataset from rectools.exceptions import NotFittedError +from rectools.models.base import ModelConfig from rectools.models.rank import Distance from rectools.models.vector import Factors, VectorModel -class PureSVDModel(VectorModel): +class PureSVDModelConfig(ModelConfig): + """Config for `PureSVD` model.""" + + factors: int = 10 + tol: float = 0 + maxiter: tp.Optional[int] = None + random_state: tp.Optional[int] = None + + +class PureSVDModel(VectorModel[PureSVDModelConfig]): """ PureSVD matrix factorization model. @@ -51,6 +62,8 @@ class PureSVDModel(VectorModel): u2i_dist = Distance.DOT i2i_dist = Distance.COSINE + config_class = PureSVDModelConfig + def __init__( self, factors: int = 10, @@ -69,6 +82,25 @@ def __init__( self.user_factors: np.ndarray self.item_factors: np.ndarray + def _get_config(self) -> PureSVDModelConfig: + return PureSVDModelConfig( + factors=self.factors, + tol=self.tol, + maxiter=self.maxiter, + random_state=self.random_state, + verbose=self.verbose, + ) + + @classmethod + def _from_config(cls, config: PureSVDModelConfig) -> tpe.Self: + return cls( + factors=config.factors, + tol=config.tol, + maxiter=config.maxiter, + random_state=config.random_state, + verbose=config.verbose, + ) + def _fit(self, dataset: Dataset) -> None: # type: ignore ui_csr = dataset.get_user_item_matrix(include_weights=True) diff --git a/rectools/models/random.py b/rectools/models/random.py index df84f2b6..3b3ed4e9 100644 --- a/rectools/models/random.py +++ b/rectools/models/random.py @@ -18,10 +18,12 @@ import typing as tp import numpy as np +import typing_extensions as tpe from tqdm.auto import tqdm from rectools import InternalIds from rectools.dataset import Dataset +from rectools.models.base import ModelConfig from rectools.types import AnyIdsArray, InternalId, InternalIdsArray from rectools.utils import fast_isin_for_sorted_test_elements @@ -50,7 +52,13 @@ def sample(self, n: int) -> np.ndarray: return sampled -class RandomModel(ModelBase): +class RandomModelConfig(ModelConfig): + """Config for `Random` model.""" + + random_state: tp.Optional[int] = None + + +class RandomModel(ModelBase[RandomModelConfig]): """ Model generating random recommendations. @@ -70,6 +78,8 @@ class RandomModel(ModelBase): recommends_for_warm = False recommends_for_cold = True + config_class = RandomModelConfig + def __init__(self, random_state: tp.Optional[int] = None, verbose: int = 0): super().__init__(verbose=verbose) self.random_state = random_state @@ -77,6 +87,13 @@ def __init__(self, random_state: tp.Optional[int] = None, verbose: int = 0): self.all_item_ids: np.ndarray + def _get_config(self) -> RandomModelConfig: + return RandomModelConfig(random_state=self.random_state, verbose=self.verbose) + + @classmethod + def _from_config(cls, config: RandomModelConfig) -> tpe.Self: + return cls(random_state=config.random_state, verbose=config.verbose) + def _fit(self, dataset: Dataset) -> None: # type: ignore self.all_item_ids = dataset.item_id_map.internal_ids diff --git a/rectools/models/rank.py b/rectools/models/rank.py index a8ce6549..fabc389d 100644 --- a/rectools/models/rank.py +++ b/rectools/models/rank.py @@ -15,11 +15,14 @@ """Implicit ranker model.""" import typing as tp +import warnings from enum import Enum import implicit.cpu +import implicit.gpu import numpy as np from implicit.cpu.matrix_factorization_base import _filter_items_from_sparse_matrix as filter_items_from_sparse_matrix +from implicit.gpu import HAS_CUDA from scipy import sparse from rectools import InternalIds @@ -74,8 +77,14 @@ def __init__( self.subjects_dots = self._calc_dots(self.subjects_factors) def _get_neginf_score(self) -> float: - # Adding 1 to avoid float calculation errors (we're comparing `scores <= neginf_score`) - return float(-np.finfo(np.float32).max + 1) + # neginf_score computed according to implicit gpu FLT_FILTER_DISTANCE + # https://github.com/benfred/implicit/blob/main/implicit/gpu/knn.cu#L36 + # we're comparing `scores <= neginf_score` + return float( + np.asarray( + np.asarray(-np.finfo(np.float32).max, dtype=np.float32).view(np.uint32) - 1, dtype=np.uint32 + ).view(np.float32) + ) @staticmethod def _calc_dots(factors: np.ndarray) -> np.ndarray: @@ -132,13 +141,50 @@ def _process_implicit_scores( return all_target_ids, np.concatenate(all_reco_ids), np.concatenate(all_scores) - def rank( + def _rank_on_gpu( + self, + object_factors: np.ndarray, + subject_factors: tp.Union[np.ndarray, sparse.csr_matrix], + k: int, + object_norms: tp.Optional[np.ndarray], + filter_query_items: tp.Optional[tp.Union[sparse.csr_matrix, sparse.csr_array]], + ) -> tp.Tuple[np.ndarray, np.ndarray]: # pragma: no cover + object_factors = implicit.gpu.Matrix(object_factors.astype(np.float32)) + + if isinstance(subject_factors, sparse.spmatrix): + warnings.warn("Sparse subject factors converted to Dense matrix") + subject_factors = subject_factors.todense() + + subject_factors = implicit.gpu.Matrix(subject_factors.astype(np.float32)) + + if object_norms is not None: + if len(np.shape(object_norms)) == 1: + object_norms = np.expand_dims(object_norms, axis=0) + object_norms = implicit.gpu.Matrix(object_norms) + + if filter_query_items is not None: + filter_query_items = implicit.gpu.COOMatrix(filter_query_items.tocoo()) + + ids, scores = implicit.gpu.KnnQuery().topk( # pylint: disable=c-extension-no-member + items=object_factors, + m=subject_factors, + k=k, + item_norms=object_norms, + query_filter=filter_query_items, + item_filter=None, + ) + + scores = scores.astype(np.float64) + return ids, scores + + def rank( # pylint: disable=too-many-branches self, subject_ids: InternalIds, k: int, filter_pairs_csr: tp.Optional[sparse.csr_matrix] = None, sorted_object_whitelist: tp.Optional[InternalIdsArray] = None, num_threads: int = 0, + use_gpu: bool = False, ) -> tp.Tuple[InternalIds, InternalIds, Scores]: """Rank objects to proceed inference using implicit library topk cpu method. @@ -156,7 +202,9 @@ def rank( If given, only these items will be used for recommendations. Otherwise all items from dataset will be used. num_threads : int, default 0 - Will be used as `num_threads` parameter for `implicit.cpu.topk.topk`. + Will be used as `num_threads` parameter for `implicit.cpu.topk.topk`. Omitted if use_gpu is True + use_gpu : bool, default False + If True `implicit.gpu.KnnQuery().topk` will be used instead of classic cpu version. Returns ------- @@ -191,15 +239,28 @@ def rank( real_k = min(k, object_factors.shape[0]) - ids, scores = implicit.cpu.topk.topk( # pylint: disable=c-extension-no-member - items=object_factors, - query=subject_factors, - k=real_k, - item_norms=object_norms, # query norms for COSINE distance are applied afterwards - filter_query_items=filter_query_items, # queries x objects csr matrix for getting neginf scores - filter_items=None, # rectools doesn't support blacklist for now - num_threads=num_threads, - ) + if use_gpu and not HAS_CUDA: + warnings.warn("Forced rank() on CPU") + use_gpu = False + + if use_gpu: # pragma: no cover + ids, scores = self._rank_on_gpu( + object_factors=object_factors, + subject_factors=subject_factors, + k=real_k, + object_norms=object_norms, + filter_query_items=filter_query_items, + ) + else: + ids, scores = implicit.cpu.topk.topk( # pylint: disable=c-extension-no-member + items=object_factors, + query=subject_factors, + k=real_k, + item_norms=object_norms, # query norms for COSINE distance are applied afterwards + filter_query_items=filter_query_items, # queries x objects csr matrix for getting neginf scores + filter_items=None, # rectools doesn't support blacklist for now + num_threads=num_threads, + ) if sorted_object_whitelist is not None: ids = sorted_object_whitelist[ids] diff --git a/rectools/models/serialization.py b/rectools/models/serialization.py new file mode 100644 index 00000000..5341bb75 --- /dev/null +++ b/rectools/models/serialization.py @@ -0,0 +1,23 @@ +import pickle + +from rectools.models.base import ModelBase +from rectools.utils.serialization import FileLike, read_bytes + + +def load_model(f: FileLike) -> ModelBase: + """ + Load model from file. + + Parameters + ---------- + f : str or Path or file-like object + Path to file or file-like object. + + Returns + ------- + model + Model instance. + """ + data = read_bytes(f) + loaded = pickle.loads(data) + return loaded diff --git a/rectools/models/vector.py b/rectools/models/vector.py index 237be355..2af68fe5 100644 --- a/rectools/models/vector.py +++ b/rectools/models/vector.py @@ -21,9 +21,9 @@ from rectools import InternalIds from rectools.dataset import Dataset -from rectools.models.base import ModelBase, Scores from rectools.types import InternalIdsArray +from .base import ModelBase, ModelConfig_T, Scores from .rank import Distance, ImplicitRanker @@ -35,7 +35,7 @@ class Factors: biases: tp.Optional[np.ndarray] = None -class VectorModel(ModelBase): +class VectorModel(ModelBase[ModelConfig_T]): """Base class for models that represents users and items as vectors""" u2i_dist: Distance = NotImplemented diff --git a/rectools/utils/config.py b/rectools/utils/config.py new file mode 100644 index 00000000..b3344a2b --- /dev/null +++ b/rectools/utils/config.py @@ -0,0 +1,5 @@ +from pydantic import BaseModel + + +class BaseConfig(BaseModel, extra="forbid"): + """Base config class for rectools.""" diff --git a/rectools/utils/misc.py b/rectools/utils/misc.py index 03aa6dd9..3e6ba433 100644 --- a/rectools/utils/misc.py +++ b/rectools/utils/misc.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +import importlib import typing as tp from itertools import tee @@ -165,3 +166,65 @@ def select_by_type( """ selected = {k: obj for k, obj in objects.items() if is_instance(obj, types)} return selected + + +def import_object(path: str) -> tp.Any: + """ + Import object by its path. + Only module level objects are supported. + + Examples + -------- + >>> import_object("scipy.sparse.csr_matrix") + + """ + module_path, object_name = path.rsplit(".", maxsplit=1) + module = importlib.import_module(module_path) + return getattr(module, object_name) + + +def get_class_or_function_full_path(obj: tp.Union[tp.Type, tp.Callable]) -> str: + """ + Get full path of class or function. + + Examples + -------- + >>> from scipy.sparse import csr_matrix + >>> get_class_or_function_full_path(csr_matrix) + 'scipy.sparse._csr.csr_matrix' + """ + return f"{obj.__module__}.{obj.__qualname__}" + + +def make_dict_flat(d: tp.Dict[str, tp.Any], sep: str = ".", parent_key: str = "") -> tp.Dict[str, tp.Any]: + """ + Flatten nested dictionary. + Other types are left as is. + + Parameters + ---------- + d : dict + Nested dictionary. + sep : str, default "." + Separator. + parent_key : str, default "" + Parent key. + + Returns + ------- + dict + Flattened dictionary. + + Examples + -------- + >>> make_dict_flat({"a": {"b": 1, "c": 2}, "d": 3}) + {'a.b': 1, 'a.c': 2, 'd': 3} + """ + items: tp.List[tp.Tuple[str, tp.Any]] = [] + for k, v in d.items(): + new_key = f"{parent_key}{sep}{k}" if parent_key else k + if isinstance(v, dict): + items.extend(make_dict_flat(v, sep=sep, parent_key=new_key).items()) + else: + items.append((new_key, v)) + return dict(items) diff --git a/rectools/utils/serialization.py b/rectools/utils/serialization.py new file mode 100644 index 00000000..577047fa --- /dev/null +++ b/rectools/utils/serialization.py @@ -0,0 +1,33 @@ +import typing as tp +from pathlib import Path + +import numpy as np +import typing_extensions as tpe +from pydantic import PlainSerializer + +FileLike = tp.Union[str, Path, tp.IO[bytes]] + +PICKLE_PROTOCOL = 5 + + +def _serialize_random_state(rs: tp.Optional[tp.Union[None, int, np.random.RandomState]]) -> tp.Union[None, int]: + if rs is None or isinstance(rs, int): + return rs + + # NOBUG: We can add serialization using get/set_state, but it's not human readable + raise TypeError("`random_state` must be ``None`` or have ``int`` type to convert it to simple type") + + +RandomState = tpe.Annotated[ + tp.Union[None, int, np.random.RandomState], + PlainSerializer(func=_serialize_random_state, when_used="json"), +] + + +def read_bytes(f: FileLike) -> bytes: + """Read bytes from a file.""" + if isinstance(f, (str, Path)): + data = Path(f).read_bytes() + else: + data = f.read() + return data diff --git a/tests/dataset/test_dataset.py b/tests/dataset/test_dataset.py index e9c9dc48..7d1f9dea 100644 --- a/tests/dataset/test_dataset.py +++ b/tests/dataset/test_dataset.py @@ -36,14 +36,14 @@ class TestDataset: def setup_method(self) -> None: self.interactions_df = pd.DataFrame( [ - ["u1", "i1", 2, "2021-09-09"], - ["u1", "i2", 2, "2021-09-05"], - ["u1", "i1", 6, "2021-08-09"], - ["u2", "i1", 7, "2020-09-09"], - ["u2", "i5", 9, "2021-09-03"], - ["u3", "i1", 2, "2021-09-09"], + ["u1", "i1", 2, "2021-09-09", 5], + ["u1", "i2", 2, "2021-09-05", 6], + ["u1", "i1", 6, "2021-08-09", 7], + ["u2", "i1", 7, "2020-09-09", 8], + ["u2", "i5", 9, "2021-09-03", 9], + ["u3", "i1", 2, "2021-09-09", 10], ], - columns=[Columns.User, Columns.Item, Columns.Weight, Columns.Datetime], + columns=[Columns.User, Columns.Item, Columns.Weight, Columns.Datetime, "extra_col"], ) self.expected_user_id_map = IdMap.from_values(["u1", "u2", "u3"]) self.expected_item_id_map = IdMap.from_values(["i1", "i2", "i5"]) @@ -78,6 +78,14 @@ def assert_dataset_equal_to_expected( assert_feature_set_equal(actual.user_features, expected_user_features) assert_feature_set_equal(actual.item_features, expected_item_features) + def test_construct_with_extra_cols(self) -> None: + + dataset = Dataset.construct(self.interactions_df, keep_extra_cols=True) + actual = dataset.interactions + expected = self.expected_interactions + expected.df["extra_col"] = self.interactions_df["extra_col"] + assert_interactions_set_equal(actual, expected) + def test_construct_without_features(self) -> None: dataset = Dataset.construct(self.interactions_df) self.assert_dataset_equal_to_expected(dataset, None, None) @@ -276,14 +284,20 @@ def test_raises_when_in_dense_features_absent_some_ids_that_present_in_interacti @pytest.mark.parametrize("include_weight", (True, False)) @pytest.mark.parametrize("include_datetime", (True, False)) - def test_get_raw_interactions(self, include_weight: bool, include_datetime: bool) -> None: - dataset = Dataset.construct(self.interactions_df) - actual = dataset.get_raw_interactions(include_weight, include_datetime) + @pytest.mark.parametrize("keep_extra_cols", (True, False)) + @pytest.mark.parametrize("include_extra_cols", (True, False)) + def test_get_raw_interactions( + self, include_weight: bool, include_datetime: bool, keep_extra_cols: bool, include_extra_cols: bool + ) -> None: + dataset = Dataset.construct(self.interactions_df, keep_extra_cols=keep_extra_cols) + actual = dataset.get_raw_interactions(include_weight, include_datetime, include_extra_cols) expected = self.interactions_df.astype({Columns.Weight: "float64", Columns.Datetime: "datetime64[ns]"}) if not include_weight: expected.drop(columns=Columns.Weight, inplace=True) if not include_datetime: expected.drop(columns=Columns.Datetime, inplace=True) + if not keep_extra_cols or not include_extra_cols: + expected.drop(columns="extra_col", inplace=True) pd.testing.assert_frame_equal(actual, expected) @pytest.fixture diff --git a/tests/dataset/test_interactions.py b/tests/dataset/test_interactions.py index c56530b9..14df6c46 100644 --- a/tests/dataset/test_interactions.py +++ b/tests/dataset/test_interactions.py @@ -36,6 +36,16 @@ def setup_method(self) -> None: Columns.Item: [0, 1, 0, 1], Columns.Weight: [5, 7.0, 4, 1], Columns.Datetime: [datetime(2021, 9, 8)] * 4, + "extra_col": [1, 2, 3, 4], + } + ) + self.raw_df = pd.DataFrame( + { + Columns.User: ["u1", "u2", "u1", "u1"], + Columns.Item: ["i1", "i2", "i1", "i2"], + Columns.Weight: [5, 7, 4, 1], + Columns.Datetime: ["2021-09-08"] * 4, + "extra_col": [1, 2, 3, 4], } ) @@ -46,8 +56,9 @@ def test_creation(self) -> None: def test_missing_columns_validation(self, subtests: SubTests) -> None: for col in self.df.columns: with subtests.test(f"drop {col} column"): - with pytest.raises(KeyError): - Interactions(self.df.drop(columns=col)) + if col != "extra_col": + with pytest.raises(KeyError): + Interactions(self.df.drop(columns=col)) @pytest.mark.parametrize("column", (Columns.User, Columns.Item)) def test_types_validation(self, column: str) -> None: @@ -60,19 +71,16 @@ def test_positivity_validation(self, column: str) -> None: self.df.at[0, column] = -1 Interactions(self.df) - def test_from_raw_creation(self) -> None: - raw_df = pd.DataFrame( - { - Columns.User: ["u1", "u2", "u1", "u1"], - Columns.Item: ["i1", "i2", "i1", "i2"], - Columns.Weight: [5, 7, 4, 1], - Columns.Datetime: ["2021-09-08"] * 4, - } - ) + @pytest.mark.parametrize("keep_extra_cols", (True, False)) + def test_from_raw_creation(self, keep_extra_cols: bool) -> None: + raw_df = self.raw_df user_id_map = IdMap(np.array(["u0", "u1", "u2"])) item_id_map = IdMap.from_values(["i1", "i2"]) - interactions = Interactions.from_raw(raw_df, user_id_map, item_id_map) - pd.testing.assert_frame_equal(interactions.df, self.df) + interactions = Interactions.from_raw(raw_df, user_id_map, item_id_map, keep_extra_cols=keep_extra_cols) + excepted = self.df + if not keep_extra_cols: + excepted.drop(columns="extra_col", inplace=True) + pd.testing.assert_frame_equal(interactions.df, excepted) @pytest.mark.parametrize( "with_weights,expected_data", @@ -105,12 +113,15 @@ def test_raises_when_datetime_type_incorrect(self) -> None: @pytest.mark.parametrize("include_weight", (True, False)) @pytest.mark.parametrize("include_datetime", (True, False)) - def test_to_external(self, include_weight: bool, include_datetime: bool) -> None: + @pytest.mark.parametrize("include_extra_cols", (True, False)) + def test_to_external(self, include_weight: bool, include_datetime: bool, include_extra_cols: bool) -> None: user_id_map = IdMap(np.array([10, 20, 30])) item_id_map = IdMap(np.array(["i1", "i2"])) interactions = Interactions(self.df) - actual = interactions.to_external(user_id_map, item_id_map, include_weight, include_datetime) + actual = interactions.to_external( + user_id_map, item_id_map, include_weight, include_datetime, include_extra_cols + ) expected = pd.DataFrame( [ [20, "i1"], @@ -124,6 +135,8 @@ def test_to_external(self, include_weight: bool, include_datetime: bool) -> None expected[Columns.Weight] = self.df[Columns.Weight] if include_datetime: expected[Columns.Datetime] = self.df[Columns.Datetime] + if include_extra_cols: + expected["extra_col"] = self.df["extra_col"] pd.testing.assert_frame_equal(actual, expected) @@ -132,7 +145,7 @@ def test_to_external_empty(self) -> None: item_id_map = IdMap(np.array(["i1", "i2"])) interactions = Interactions(self.df.iloc[:0]) - actual = interactions.to_external(user_id_map, item_id_map) + actual = interactions.to_external(user_id_map, item_id_map, include_extra_cols=False) expected = pd.DataFrame( [], columns=Columns.Interactions, diff --git a/tests/model_selection/test_cross_validate.py b/tests/model_selection/test_cross_validate.py index f00eb084..e449aa3e 100644 --- a/tests/model_selection/test_cross_validate.py +++ b/tests/model_selection/test_cross_validate.py @@ -86,7 +86,7 @@ def setup_method(self) -> None: "intersection": Intersection(1), } - self.models = { + self.models: tp.Dict[str, ModelBase] = { "popular": PopularModel(), "random": RandomModel(random_state=42), } diff --git a/tests/models/test_base.py b/tests/models/test_base.py index 9dedaf3d..21641784 100644 --- a/tests/models/test_base.py +++ b/tests/models/test_base.py @@ -16,10 +16,14 @@ import typing as tp import warnings +from datetime import timedelta +from pathlib import Path +from tempfile import NamedTemporaryFile, TemporaryFile import numpy as np import pandas as pd import pytest +import typing_extensions as tpe from rectools import Columns from rectools.dataset import Dataset @@ -29,16 +33,18 @@ FixedColdRecoModelMixin, InternalRecoTriplet, ModelBase, + ModelConfig, Scores, SemiInternalRecoTriplet, ) from rectools.types import ExternalIds, InternalIds +from rectools.utils.config import BaseConfig from .data import DATASET, INTERACTIONS def test_raise_when_recommend_u2i_from_not_fitted() -> None: - model = ModelBase() + model: ModelBase[ModelConfig] = ModelBase() with pytest.raises(NotFittedError): model.recommend( users=np.array([]), @@ -49,7 +55,7 @@ def test_raise_when_recommend_u2i_from_not_fitted() -> None: def test_raise_when_recommend_i2i_from_not_fitted() -> None: - model = ModelBase() + model: ModelBase[ModelConfig] = ModelBase() with pytest.raises(NotFittedError): model.recommend_to_items( target_items=np.array([]), @@ -60,7 +66,7 @@ def test_raise_when_recommend_i2i_from_not_fitted() -> None: @pytest.mark.parametrize("k", (-4, 0)) def test_raise_when_k_is_not_positive_u2i(k: int) -> None: - model = ModelBase() + model: ModelBase[ModelConfig] = ModelBase() model.is_fitted = True with pytest.raises(ValueError): model.recommend( @@ -73,7 +79,7 @@ def test_raise_when_k_is_not_positive_u2i(k: int) -> None: @pytest.mark.parametrize("k", (-4, 0)) def test_raise_when_k_is_not_positive_i2i(k: int) -> None: - model = ModelBase() + model: ModelBase[ModelConfig] = ModelBase() model.is_fitted = True with pytest.raises(ValueError): model.recommend_to_items( @@ -426,6 +432,151 @@ def test_raises_on_incorrect_cold_targets_type(self, dataset_key: str, kind: str self._get_reco(["some_id"], model_key, dataset_key, kind) +class TestConfiguration: + + def setup_method(self) -> None: + class SomeModelSubConfig(BaseConfig): + td: timedelta + + class SomeModelConfig(ModelConfig): + x: int + sc: tp.Optional[SomeModelSubConfig] = None + + class SomeModel(ModelBase[SomeModelConfig]): + config_class = SomeModelConfig + + def __init__(self, x: int, td: tp.Optional[timedelta] = None, verbose: int = 0): + super().__init__(verbose=verbose) + self.x = x + self.td = td + + def _get_config(self) -> SomeModelConfig: + sc = None if self.td is None else SomeModelSubConfig(td=self.td) + return SomeModelConfig(x=self.x, sc=sc, verbose=self.verbose) + + @classmethod + def _from_config(cls, config: SomeModelConfig) -> tpe.Self: + td = None if config.sc is None else config.sc.td + return cls(x=config.x, td=td, verbose=config.verbose) + + self.config_class = SomeModelConfig + self.model_class = SomeModel + + def test_from_pydantic_config(self) -> None: + config = self.config_class(x=10, verbose=1) + model = self.model_class.from_config(config) + assert model.x == 10 + assert model.td is None + assert model.verbose == 1 + + @pytest.mark.parametrize("td", (timedelta(days=2, hours=3), "P2DT3H")) + def test_from_config_dict(self, td: tp.Union[timedelta, str]) -> None: + config = {"x": 10, "verbose": 1, "sc": {"td": td}} + model = self.model_class.from_config(config) + assert model.x == 10 + assert model.td == timedelta(days=2, hours=3) + assert model.verbose == 1 + + def test_from_config_dict_with_missing_keys(self) -> None: + config = {"verbose": 1} + with pytest.raises(ValueError, match="1 validation error for SomeModelConfig\nx\n Field required"): + self.model_class.from_config(config) + + def test_from_config_dict_with_extra_keys(self) -> None: + config = {"x": 10, "extra": "extra"} + with pytest.raises( + ValueError, match="1 validation error for SomeModelConfig\nextra\n Extra inputs are not permitted" + ): + self.model_class.from_config(config) + + def test_get_config_pydantic(self) -> None: + model = self.model_class(x=10, verbose=1) + config = model.get_config(mode="pydantic") + assert config == self.config_class(x=10, verbose=1) + + def test_raises_on_pydantic_with_simple_types(self) -> None: + model = self.model_class(x=10, verbose=1) + with pytest.raises(ValueError, match="`simple_types` is not compatible with `mode='pydantic'"): + model.get_config(mode="pydantic", simple_types=True) + + @pytest.mark.parametrize("simple_types, expected_td", ((False, timedelta(days=2, hours=3)), (True, "P2DT3H"))) + def test_get_config_dict(self, simple_types: bool, expected_td: tp.Union[timedelta, str]) -> None: + model = self.model_class(x=10, verbose=1, td=timedelta(days=2, hours=3)) + config = model.get_config(mode="dict", simple_types=simple_types) + assert config == {"x": 10, "verbose": 1, "sc": {"td": expected_td}} + + def test_raises_on_incorrect_format(self) -> None: + model = self.model_class(x=10, verbose=1) + with pytest.raises(ValueError, match="Unknown mode:"): + model.get_config(mode="incorrect_mode") # type: ignore[call-overload] + + @pytest.mark.parametrize("simple_types, expected_td", ((False, timedelta(days=2, hours=3)), (True, "P2DT3H"))) + def test_get_params(self, simple_types: bool, expected_td: tp.Union[timedelta, str]) -> None: + model = self.model_class(x=10, verbose=1, td=timedelta(days=2, hours=3)) + config = model.get_params(simple_types=simple_types) + assert config == {"x": 10, "verbose": 1, "sc.td": expected_td} + + @pytest.mark.parametrize("simple_types", (False, True)) + def test_get_params_with_empty_subconfig(self, simple_types: bool) -> None: + model = self.model_class(x=10, verbose=1, td=None) + config = model.get_params(simple_types=simple_types) + assert config == {"x": 10, "verbose": 1, "sc": None} + + def test_model_without_implemented_config_from_config(self) -> None: + class MyModelWithoutConfig(ModelBase): + pass + + with pytest.raises( + NotImplementedError, match="`from_config` method is not implemented for `MyModelWithoutConfig` model." + ): + MyModelWithoutConfig.from_config({}) + + def test_model_without_implemented_config_get_config(self) -> None: + class MyModelWithoutConfig(ModelBase): + pass + + with pytest.raises( + NotImplementedError, match="`get_config` method is not implemented for `MyModelWithoutConfig` model" + ): + MyModelWithoutConfig().get_config() + + +class MyModel(ModelBase): + def __init__(self, x: int = 10, verbose: int = 0): + super().__init__(verbose=verbose) + self.x = x + + +class TestSavingAndLoading: + + @pytest.fixture() + def model(self) -> MyModel: + return MyModel() + + def test_save_and_load_to_file(self, model: MyModel) -> None: + with TemporaryFile() as f: + model.save(f) + f.seek(0) + loaded_model = MyModel.load(f) + assert isinstance(loaded_model, MyModel) + assert loaded_model.__dict__ == model.__dict__ + + @pytest.mark.parametrize("use_str", (False, True)) + def test_save_and_load_from_path(self, model: MyModel, use_str: bool) -> None: + with NamedTemporaryFile() as f: + path: tp.Union[Path, str] = Path(f.name) if not use_str else f.name + model.save(path) + loaded_model = MyModel.load(path) + assert isinstance(loaded_model, MyModel) + assert loaded_model.__dict__ == model.__dict__ + + def test_load_fails_on_incorrect_model_type(self, model: MyModel) -> None: + with NamedTemporaryFile() as f: + model.save(f.name) + with pytest.raises(TypeError, match="Loaded object is not a direct instance of `ModelBase`"): + ModelBase.load(f.name) + + class TestFixedColdRecoModelMixin: def test_cold_reco_works(self) -> None: class ColdRecoModel(FixedColdRecoModelMixin, ModelBase): diff --git a/tests/models/test_dssm.py b/tests/models/test_dssm.py index d817e156..a264fd01 100644 --- a/tests/models/test_dssm.py +++ b/tests/models/test_dssm.py @@ -25,7 +25,7 @@ from rectools.models import DSSMModel from rectools.models.dssm import DSSM from rectools.models.vector import ImplicitRanker -from tests.models.utils import assert_second_fit_refits_model +from tests.models.utils import assert_dumps_loads_do_not_change_model, assert_second_fit_refits_model from .data import INTERACTIONS @@ -338,3 +338,8 @@ def test_raises_when_no_features_in_dataset(self, dataset: Dataset, exclude_feat def test_second_fit_refits_model(self, dataset: Dataset) -> None: model = DSSMModel(deterministic=True) assert_second_fit_refits_model(model, dataset, pre_fit_callback=self._seed_everything) + + def test_dumps_loads(self, dataset: Dataset) -> None: + model = DSSMModel() + model.fit(dataset) + assert_dumps_loads_do_not_change_model(model, dataset, check_configs=False) diff --git a/tests/models/test_ease.py b/tests/models/test_ease.py index 2eb75d05..20fc1701 100644 --- a/tests/models/test_ease.py +++ b/tests/models/test_ease.py @@ -23,7 +23,12 @@ from rectools.models import EASEModel from .data import DATASET, INTERACTIONS -from .utils import assert_second_fit_refits_model +from .utils import ( + assert_default_config_and_default_model_params_are_the_same, + assert_dumps_loads_do_not_change_model, + assert_get_config_and_from_config_compatibility, + assert_second_fit_refits_model, +) class TestEASEModel: @@ -220,3 +225,49 @@ def test_i2i_with_warm_and_cold_items(self, item_features: tp.Optional[pd.DataFr dataset=dataset, k=2, ) + + def test_dumps_loads(self, dataset: Dataset) -> None: + model = EASEModel() + model.fit(dataset) + assert_dumps_loads_do_not_change_model(model, dataset) + + +class TestEASEModelConfiguration: + def test_from_config(self) -> None: + config = { + "regularization": 500, + "num_threads": 1, + "verbose": 1, + } + model = EASEModel.from_config(config) + assert model.num_threads == 1 + assert model.verbose == 1 + assert model.regularization == 500 + + def test_get_config(self) -> None: + model = EASEModel( + regularization=500, + num_threads=1, + verbose=1, + ) + config = model.get_config() + expected = { + "regularization": 500, + "num_threads": 1, + "verbose": 1, + } + assert config == expected + + @pytest.mark.parametrize("simple_types", (False, True)) + def test_get_config_and_from_config_compatibility(self, simple_types: bool) -> None: + initial_config = { + "regularization": 500, + "num_threads": 1, + "verbose": 1, + } + assert_get_config_and_from_config_compatibility(EASEModel, DATASET, initial_config, simple_types) + + def test_default_config_and_default_model_params_are_the_same(self) -> None: + default_config: tp.Dict[str, int] = {} + model = EASEModel() + assert_default_config_and_default_model_params_are_the_same(model, default_config) diff --git a/tests/models/test_implicit_als.py b/tests/models/test_implicit_als.py index 4094b4cb..91cc9514 100644 --- a/tests/models/test_implicit_als.py +++ b/tests/models/test_implicit_als.py @@ -26,11 +26,22 @@ from rectools.dataset import Dataset, DenseFeatures, IdMap, Interactions, SparseFeatures from rectools.exceptions import NotFittedError from rectools.models import ImplicitALSWrapperModel -from rectools.models.implicit_als import AnyAlternatingLeastSquares, GPUAlternatingLeastSquares +from rectools.models.implicit_als import ( + AnyAlternatingLeastSquares, + CPUAlternatingLeastSquares, + GPUAlternatingLeastSquares, + get_items_vectors, + get_users_vectors, +) from rectools.models.utils import recommend_from_scores from .data import DATASET -from .utils import assert_second_fit_refits_model +from .utils import ( + assert_default_config_and_default_model_params_are_the_same, + assert_dumps_loads_do_not_change_model, + assert_get_config_and_from_config_compatibility, + assert_second_fit_refits_model, +) @pytest.mark.filterwarnings("ignore:Converting sparse features to dense") @@ -56,6 +67,29 @@ def _init_model_factors_inplace(model: AnyAlternatingLeastSquares, dataset: Data def dataset(self) -> Dataset: return DATASET + @pytest.fixture + def dataset_w_features(self) -> Dataset: + user_id_map = IdMap.from_values(["u1", "u2", "u3"]) + item_id_map = IdMap.from_values(["i1", "i2", "i3"]) + interactions_df = pd.DataFrame( + [ + ["u1", "i1", 0.1, "2021-09-09"], + ["u2", "i1", 0.1, "2021-09-09"], + ["u2", "i2", 0.5, "2021-09-05"], + ["u2", "i3", 0.2, "2021-09-05"], + ["u1", "i3", 0.2, "2021-09-05"], + ["u3", "i1", 0.2, "2021-09-05"], + ], + columns=[Columns.User, Columns.Item, Columns.Weight, Columns.Datetime], + ) + interactions = Interactions.from_raw(interactions_df, user_id_map, item_id_map) + user_features_df = pd.DataFrame({"id": ["u1", "u2", "u3"], "f1": [0.3, 0.4, 0.5]}) + user_features = DenseFeatures.from_dataframe(user_features_df, user_id_map) + item_features_df = pd.DataFrame({"id": ["i1", "i1"], "feature": ["f1", "f2"], "value": [2.1, 100]}) + item_features = SparseFeatures.from_flatten(item_features_df, item_id_map) + dataset = Dataset(user_id_map, item_id_map, interactions, user_features, item_features) + return dataset + @pytest.mark.parametrize( "filter_viewed,expected", ( @@ -198,26 +232,10 @@ def test_with_whitelist( ), ), ) - def test_happy_path_with_features(self, fit_features_together: bool, expected: pd.DataFrame, use_gpu: bool) -> None: - user_id_map = IdMap.from_values(["u1", "u2", "u3"]) - item_id_map = IdMap.from_values(["i1", "i2", "i3"]) - interactions_df = pd.DataFrame( - [ - ["u1", "i1", 0.1, "2021-09-09"], - ["u2", "i1", 0.1, "2021-09-09"], - ["u2", "i2", 0.5, "2021-09-05"], - ["u2", "i3", 0.2, "2021-09-05"], - ["u1", "i3", 0.2, "2021-09-05"], - ["u3", "i1", 0.2, "2021-09-05"], - ], - columns=[Columns.User, Columns.Item, Columns.Weight, Columns.Datetime], - ) - interactions = Interactions.from_raw(interactions_df, user_id_map, item_id_map) - user_features_df = pd.DataFrame({"id": ["u1", "u2", "u3"], "f1": [0.3, 0.4, 0.5]}) - user_features = DenseFeatures.from_dataframe(user_features_df, user_id_map) - item_features_df = pd.DataFrame({"id": ["i1", "i1"], "feature": ["f1", "f2"], "value": [2.1, 100]}) - item_features = SparseFeatures.from_flatten(item_features_df, item_id_map) - dataset = Dataset(user_id_map, item_id_map, interactions, user_features, item_features) + def test_happy_path_with_features( + self, fit_features_together: bool, expected: pd.DataFrame, use_gpu: bool, dataset_w_features: Dataset + ) -> None: + dataset = dataset_w_features # In case of big number of iterations there are differences between CPU and GPU results base_model = AlternatingLeastSquares(factors=32, num_threads=2, use_gpu=use_gpu) @@ -346,3 +364,177 @@ def test_i2i_with_warm_and_cold_items(self, use_gpu: bool, dataset: Dataset) -> dataset=dataset, k=2, ) + + @pytest.mark.parametrize("fit_features_together", (False, True)) + @pytest.mark.parametrize("use_features_in_dataset", (False, True)) + def test_per_epoch_partial_fit_consistent_with_regular_fit( + self, + dataset: Dataset, + dataset_w_features: Dataset, + fit_features_together: bool, + use_features_in_dataset: bool, + use_gpu: bool, + ) -> None: + if use_features_in_dataset: + dataset = dataset_w_features + + iterations = 20 + + base_model_1 = AlternatingLeastSquares( + factors=2, num_threads=2, iterations=iterations, random_state=32, use_gpu=use_gpu + ) + model_1 = ImplicitALSWrapperModel(model=base_model_1, fit_features_together=fit_features_together) + model_1.fit(dataset) + + base_model_2 = AlternatingLeastSquares( + factors=2, num_threads=2, iterations=iterations, random_state=32, use_gpu=use_gpu + ) + model_2 = ImplicitALSWrapperModel(model=base_model_2, fit_features_together=fit_features_together) + for _ in range(iterations): + model_2.fit_partial(dataset, epochs=1) + + assert np.allclose(get_users_vectors(model_1.model), get_users_vectors(model_2.model)) + assert np.allclose(get_items_vectors(model_1.model), get_items_vectors(model_2.model)) + + @pytest.mark.parametrize("fit_features_together", (False, True)) + @pytest.mark.parametrize("use_features_in_dataset", (False, True)) + def test_per_epoch_model_iterations( + self, + dataset: Dataset, + dataset_w_features: Dataset, + fit_features_together: bool, + use_features_in_dataset: bool, + use_gpu: bool, + ) -> None: + if use_features_in_dataset: + dataset = dataset_w_features + + iterations = 20 + base_model = AlternatingLeastSquares( + factors=2, num_threads=2, iterations=iterations, random_state=32, use_gpu=use_gpu + ) + model = ImplicitALSWrapperModel(model=base_model, fit_features_together=fit_features_together) + for n_epoch in range(iterations): + model.fit_partial(dataset, epochs=1) + assert model.model.iterations == n_epoch + 1 + + def test_dumps_loads(self, use_gpu: bool, dataset: Dataset) -> None: + model = ImplicitALSWrapperModel(model=AlternatingLeastSquares(use_gpu=use_gpu)) + model.fit(dataset) + assert_dumps_loads_do_not_change_model(model, dataset) + + +class CustomALS(CPUAlternatingLeastSquares): + pass + + +class TestImplicitALSWrapperModelConfiguration: + + def setup_method(self) -> None: + implicit.gpu.HAS_CUDA = True # To avoid errors when test without cuda + + @pytest.mark.parametrize("use_gpu", (False, True)) + @pytest.mark.parametrize("cls", (None, "AlternatingLeastSquares", "implicit.als.AlternatingLeastSquares")) + def test_from_config(self, use_gpu: bool, cls: tp.Any) -> None: + config: tp.Dict = { + "model": { + "params": { + "factors": 16, + "num_threads": 2, + "iterations": 100, + "use_gpu": use_gpu, + }, + }, + "fit_features_together": True, + "verbose": 1, + } + if cls is not None: + config["model"]["cls"] = cls + model = ImplicitALSWrapperModel.from_config(config) + assert model.fit_features_together is True + assert model.verbose == 1 + inner_model = model._model # pylint: disable=protected-access + assert inner_model.factors == 16 + assert inner_model.iterations == 100 + if not use_gpu: + assert inner_model.num_threads == 2 + expected_model_class = GPUAlternatingLeastSquares if use_gpu else CPUAlternatingLeastSquares + assert isinstance(inner_model, expected_model_class) + + @pytest.mark.parametrize("use_gpu", (False, True)) + @pytest.mark.parametrize("random_state", (None, 42)) + @pytest.mark.parametrize("simple_types", (False, True)) + def test_to_config(self, use_gpu: bool, random_state: tp.Optional[int], simple_types: bool) -> None: + model = ImplicitALSWrapperModel( + model=AlternatingLeastSquares(factors=16, num_threads=2, use_gpu=use_gpu, random_state=random_state), + fit_features_together=True, + verbose=1, + ) + config = model.get_config(simple_types=simple_types) + expected_model_params = { + "factors": 16, + "regularization": 0.01, + "alpha": 1.0, + "dtype": np.float32 if not simple_types else "float32", + "iterations": 15, + "calculate_training_loss": False, + "random_state": random_state, + "use_gpu": use_gpu, + } + if not use_gpu: + expected_model_params.update( + { + "use_native": True, + "use_cg": True, + "num_threads": 2, + } + ) + expected = { + "model": { + "cls": "AlternatingLeastSquares", + "params": expected_model_params, + }, + "fit_features_together": True, + "verbose": 1, + } + assert config == expected + + def test_to_config_fails_when_random_state_is_object(self) -> None: + model = ImplicitALSWrapperModel(model=AlternatingLeastSquares(random_state=np.random.RandomState())) + with pytest.raises( + TypeError, + match="`random_state` must be ``None`` or have ``int`` type to convert it to simple type", + ): + model.get_config(simple_types=True) + + def test_custom_model_class(self) -> None: + cls_path = "tests.models.test_implicit_als.CustomALS" + + config = { + "model": { + "cls": cls_path, + } + } + model = ImplicitALSWrapperModel.from_config(config) + + assert isinstance(model._model, CustomALS) # pylint: disable=protected-access + + returned_config = model.get_config(simple_types=True) + assert returned_config["model"]["cls"] == cls_path # pylint: disable=unsubscriptable-object + + assert model.get_config()["model"]["cls"] == CustomALS # pylint: disable=unsubscriptable-object + + @pytest.mark.parametrize("simple_types", (False, True)) + def test_get_config_and_from_config_compatibility(self, simple_types: bool) -> None: + initial_config = { + "model": { + "params": {"factors": 16, "num_threads": 2, "iterations": 3, "random_state": 42}, + }, + "verbose": 1, + } + assert_get_config_and_from_config_compatibility(ImplicitALSWrapperModel, DATASET, initial_config, simple_types) + + def test_default_config_and_default_model_params_are_the_same(self) -> None: + default_config: tp.Dict[str, tp.Any] = {"model": {}} + model = ImplicitALSWrapperModel(model=AlternatingLeastSquares()) + assert_default_config_and_default_model_params_are_the_same(model, default_config) diff --git a/tests/models/test_implicit_knn.py b/tests/models/test_implicit_knn.py index 2b2298a6..942743af 100644 --- a/tests/models/test_implicit_knn.py +++ b/tests/models/test_implicit_knn.py @@ -17,14 +17,19 @@ import numpy as np import pandas as pd import pytest -from implicit.nearest_neighbours import TFIDFRecommender +from implicit.nearest_neighbours import BM25Recommender, CosineRecommender, ItemItemRecommender, TFIDFRecommender from rectools import Columns from rectools.dataset import Dataset from rectools.models import ImplicitItemKNNWrapperModel from .data import DATASET, INTERACTIONS -from .utils import assert_second_fit_refits_model +from .utils import ( + assert_default_config_and_default_model_params_are_the_same, + assert_dumps_loads_do_not_change_model, + assert_get_config_and_from_config_compatibility, + assert_second_fit_refits_model, +) class TestImplicitItemKNNWrapperModel: @@ -226,3 +231,126 @@ def test_i2i_with_warm_and_cold_items(self, item_features: tp.Optional[pd.DataFr dataset=dataset, k=2, ) + + def test_base_class(self, dataset: Dataset) -> None: + # Base class ItemItemRecommender didn't work due to implicit dtype conversion to np.float64 + base_model = ItemItemRecommender(K=5, num_threads=2) + model = ImplicitItemKNNWrapperModel(model=base_model).fit(dataset) + actual = model.recommend( + users=np.array([10, 20]), + dataset=dataset, + k=2, + filter_viewed=False, + ) + expected = pd.DataFrame( + { + Columns.User: [10, 10, 20, 20], + Columns.Item: [11, 12, 11, 12], + Columns.Score: [9.0, 8.0, 8.0, 7.0], + Columns.Rank: [1, 2, 1, 2], + } + ).astype({Columns.Score: np.float32}) + pd.testing.assert_frame_equal(actual, expected, atol=0.001) + + def test_dumps_loads(self, dataset: Dataset) -> None: + model = ImplicitItemKNNWrapperModel(model=TFIDFRecommender()) + model.fit(dataset) + assert_dumps_loads_do_not_change_model(model, dataset) + + +class CustomKNN(ItemItemRecommender): + pass + + +class TestImplicitItemKNNWrapperModelConfiguration: + + @pytest.mark.parametrize( + "model_class", + ( + TFIDFRecommender, # class object + "ItemItemRecommender", # keyword + "TFIDFRecommender", # keyword + "CosineRecommender", # keyword + "BM25Recommender", # keyword + "tests.models.test_implicit_knn.CustomKNN", # custom class + ), + ) + def test_from_config(self, model_class: tp.Union[tp.Type[ItemItemRecommender], str]) -> None: + params: tp.Dict[str, tp.Any] = {"K": 5} + if model_class == "BM25Recommender": + params.update({"K1": 0.33}) + config = { + "model": { + "cls": model_class, + "params": params, + }, + "verbose": 1, + } + model = ImplicitItemKNNWrapperModel.from_config(config) + assert model.verbose == 1 + inner_model = model._model # pylint: disable=protected-access + assert inner_model.K == 5 + assert inner_model.num_threads == 0 + if model_class == "BM25Recommender": + assert inner_model.K1 == 0.33 + if isinstance(model_class, str): + assert inner_model.__class__.__name__ == model_class.split(".")[-1] + else: + assert inner_model.__class__ is model_class + + @pytest.mark.parametrize("simple_types", (False, True)) + @pytest.mark.parametrize( + "model_class, model_class_str", + ( + (ItemItemRecommender, "ItemItemRecommender"), + (TFIDFRecommender, "TFIDFRecommender"), + (CosineRecommender, "CosineRecommender"), + (BM25Recommender, "BM25Recommender"), + (CustomKNN, "tests.models.test_implicit_knn.CustomKNN"), + ), + ) + def test_to_config( + self, simple_types: bool, model_class: tp.Type[ItemItemRecommender], model_class_str: str + ) -> None: + model = ImplicitItemKNNWrapperModel( + model=model_class(K=5), + verbose=1, + ) + config = model.get_config(simple_types=simple_types) + expected_model_params: tp.Dict[str, tp.Any] = { + "K": 5, + "num_threads": 0, + } + if model_class is BM25Recommender: + expected_model_params.update( + { + "K1": 1.2, + "B": 0.75, + } + ) + expected = { + "model": { + "cls": model_class if not simple_types else model_class_str, + "params": expected_model_params, + }, + "verbose": 1, + } + assert config == expected + + @pytest.mark.parametrize("simple_types", (False, True)) + def test_get_config_and_from_config_compatibility(self, simple_types: bool) -> None: + initial_config = { + "model": { + "cls": TFIDFRecommender, + "params": {"K": 3}, + }, + "verbose": 1, + } + assert_get_config_and_from_config_compatibility( + ImplicitItemKNNWrapperModel, DATASET, initial_config, simple_types + ) + + def test_default_config_and_default_model_params_are_the_same(self) -> None: + default_config: tp.Dict[str, tp.Any] = {"model": {"cls": ItemItemRecommender, "params": {}}} + model = ImplicitItemKNNWrapperModel(model=ItemItemRecommender()) + assert_default_config_and_default_model_params_are_the_same(model, default_config) diff --git a/tests/models/test_lightfm.py b/tests/models/test_lightfm.py index c0d0eeb5..a527013b 100644 --- a/tests/models/test_lightfm.py +++ b/tests/models/test_lightfm.py @@ -30,7 +30,13 @@ from rectools.models import LightFMWrapperModel from rectools.models.utils import recommend_from_scores from rectools.models.vector import Factors -from tests.models.utils import assert_second_fit_refits_model +from tests.models.data import DATASET +from tests.models.utils import ( + assert_default_config_and_default_model_params_are_the_same, + assert_dumps_loads_do_not_change_model, + assert_get_config_and_from_config_compatibility, + assert_second_fit_refits_model, +) pytestmark = pytest.mark.skipif(sys.version_info >= (3, 12), reason="`lightfm` is not compatible with Python >= 3.12") @@ -334,3 +340,113 @@ def _get_items_factors(self, dataset: Dataset) -> Factors: k=2, filter_viewed=False, ) + + def test_dumps_loads(self, dataset: Dataset) -> None: + model = LightFMWrapperModel(LightFM()) + model.fit(dataset) + assert_dumps_loads_do_not_change_model(model, dataset) + + +class CustomLightFM(LightFM): + pass + + +class TestLightFMWrapperModelConfiguration: + + @pytest.mark.parametrize("add_cls", (False, True)) + def test_from_config(self, add_cls: bool) -> None: + config: tp.Dict = { + "model": { + "params": { + "no_components": 16, + "learning_rate": 0.03, + }, + }, + "epochs": 2, + "num_threads": 3, + "verbose": 1, + } + if add_cls: + config["model"]["cls"] = "LightFM" + model = LightFMWrapperModel.from_config(config) + assert model.n_epochs == 2 + assert model.n_threads == 3 + assert model.verbose == 1 + inner_model = model._model # pylint: disable=protected-access + assert inner_model.no_components == 16 + assert inner_model.learning_rate == 0.03 + + @pytest.mark.parametrize("random_state", (None, 42)) + @pytest.mark.parametrize("simple_types", (False, True)) + def test_to_config(self, random_state: tp.Optional[int], simple_types: bool) -> None: + model = LightFMWrapperModel( + model=LightFM(no_components=16, learning_rate=0.03, random_state=random_state), + epochs=2, + num_threads=3, + verbose=1, + ) + config = model.get_config(simple_types=simple_types) + expected_model_params = { + "no_components": 16, + "k": 5, + "n": 10, + "learning_schedule": "adagrad", + "loss": "logistic", + "learning_rate": 0.03, + "rho": 0.95, + "epsilon": 1e-6, + "item_alpha": 0.0, + "user_alpha": 0.0, + "max_sampled": 10, + "random_state": random_state, + } + expected = { + "model": { + "cls": "LightFM" if simple_types else LightFM, + "params": expected_model_params, + }, + "epochs": 2, + "num_threads": 3, + "verbose": 1, + } + assert config == expected + + def test_to_config_fails_when_random_state_is_object(self) -> None: + model = LightFMWrapperModel(model=LightFM(random_state=np.random.RandomState())) + with pytest.raises( + TypeError, + match="`random_state` must be ``None`` or have ``int`` type to convert it to simple type", + ): + model.get_config(simple_types=True) + + def test_custom_model_class(self) -> None: + cls_path = "tests.models.test_lightfm.CustomLightFM" + + config = { + "model": { + "cls": cls_path, + } + } + model = LightFMWrapperModel.from_config(config) + + assert isinstance(model._model, CustomLightFM) # pylint: disable=protected-access + + returned_config = model.get_config(simple_types=True) + assert returned_config["model"]["cls"] == cls_path # pylint: disable=unsubscriptable-object + + assert model.get_config()["model"]["cls"] == CustomLightFM # pylint: disable=unsubscriptable-object + + @pytest.mark.parametrize("simple_types", (False, True)) + def test_get_config_and_from_config_compatibility(self, simple_types: bool) -> None: + initial_config = { + "model": { + "params": {"no_components": 16, "learning_rate": 0.03, "random_state": 42}, + }, + "verbose": 1, + } + assert_get_config_and_from_config_compatibility(LightFMWrapperModel, DATASET, initial_config, simple_types) + + def test_default_config_and_default_model_params_are_the_same(self) -> None: + default_config: tp.Dict[str, tp.Any] = {"model": {}} + model = LightFMWrapperModel(model=LightFM()) + assert_default_config_and_default_model_params_are_the_same(model, default_config) diff --git a/tests/models/test_popular.py b/tests/models/test_popular.py index 8521876e..cb1ab8d7 100644 --- a/tests/models/test_popular.py +++ b/tests/models/test_popular.py @@ -22,7 +22,15 @@ from rectools import Columns from rectools.dataset import Dataset, IdMap, Interactions from rectools.models import PopularModel -from tests.models.utils import assert_second_fit_refits_model +from rectools.models.popular import Popularity +from tests.models.utils import ( + assert_default_config_and_default_model_params_are_the_same, + assert_dumps_loads_do_not_change_model, + assert_get_config_and_from_config_compatibility, + assert_second_fit_refits_model, +) + +from .data import DATASET class TestPopularModel: @@ -142,7 +150,7 @@ def test_with_items_whitelist(self, dataset: Dataset) -> None: def test_raises_when_incorrect_popularity(self) -> None: with pytest.raises(ValueError): - PopularModel(popularity="strange") + PopularModel(popularity="strange") # type: ignore[arg-type] def test_raises_when_both_period_and_begin_from_are_set(self) -> None: with pytest.raises(ValueError): @@ -212,3 +220,135 @@ def test_i2i( def test_second_fit_refits_model(self, dataset: Dataset) -> None: model = PopularModel() assert_second_fit_refits_model(model, dataset) + + def test_dumps_loads(self, dataset: Dataset) -> None: + model = PopularModel() + model.fit(dataset) + assert_dumps_loads_do_not_change_model(model, dataset) + + +class TestPopularModelConfiguration: + @pytest.mark.parametrize( + "begin_from,period,expected_begin_from,expected_period", + ( + (None, timedelta(days=7), None, timedelta(days=7)), + (datetime(2021, 11, 23), None, datetime(2021, 11, 23), None), + ("2021-11-23T10:20:30.400", None, datetime(2021, 11, 23, 10, 20, 30, 400000), None), + ( + None, + { + "days": 7, + "seconds": 123, + "microseconds": 12345, + "milliseconds": 32, + "minutes": 2, + "weeks": 7, + }, + None, + timedelta(days=56, seconds=243, microseconds=44345), + ), + ), + ) + def test_from_config( + self, + period: tp.Optional[tp.Union[timedelta, dict]], + begin_from: tp.Optional[tp.Union[datetime, str]], + expected_begin_from: tp.Optional[datetime], + expected_period: tp.Optional[dict], + ) -> None: + config = { + "popularity": "n_interactions", + "period": period, + "begin_from": begin_from, + "add_cold": True, + "inverse": True, + "verbose": 0, + } + model = PopularModel.from_config(config) + assert model.popularity.value == "n_interactions" + assert model.period == expected_period + assert model.begin_from == expected_begin_from + assert model.add_cold is True + assert model.inverse is True + assert model.verbose == 0 + + @pytest.mark.parametrize( + "begin_from,period,expected_period", + ( + ( + None, + timedelta(weeks=2, days=7, hours=23, milliseconds=12345), + {"days": 21, "microseconds": 345000, "seconds": 82812}, + ), + (datetime(2021, 11, 23, 10, 20, 30, 400000), None, None), + ), + ) + def test_get_config( + self, + period: tp.Optional[timedelta], + begin_from: tp.Optional[datetime], + expected_period: tp.Optional[timedelta], + ) -> None: + model = PopularModel( + popularity="n_users", + period=period, + begin_from=begin_from, + add_cold=False, + inverse=False, + verbose=1, + ) + config = model.get_config() + expected = { + "popularity": Popularity("n_users"), + "period": expected_period, + "begin_from": begin_from, + "add_cold": False, + "inverse": False, + "verbose": 1, + } + assert config == expected + + @pytest.mark.parametrize( + "begin_from,period,simple_types", + ( + ( + None, + timedelta(weeks=1, days=2, hours=3, minutes=4, seconds=5, milliseconds=6000, microseconds=70000), + True, + ), + (datetime(2021, 11, 23), None, False), + ("2021-11-23T10:20:30.400", None, True), + ( + None, + { + "days": 7, + "seconds": 123, + "microseconds": 12345, + "milliseconds": 32, + "minutes": 2, + "weeks": 7, + }, + False, + ), + ), + ) + def test_get_config_and_from_config_compatibility( + self, + period: tp.Optional[timedelta], + begin_from: tp.Optional[datetime], + simple_types: bool, + ) -> None: + initial_config = { + "popularity": "n_users", + "period": period, + "begin_from": begin_from, + "add_cold": True, + "inverse": False, + "verbose": 0, + } + assert_get_config_and_from_config_compatibility(PopularModel, DATASET, initial_config, simple_types) + + def test_default_config_and_default_model_params_are_the_same(self) -> None: + default_config: tp.Dict[str, int] = {} + model = PopularModel() + assert_default_config_and_default_model_params_are_the_same(model, default_config) diff --git a/tests/models/test_popular_in_category.py b/tests/models/test_popular_in_category.py index 10b274fd..f30533d5 100644 --- a/tests/models/test_popular_in_category.py +++ b/tests/models/test_popular_in_category.py @@ -22,69 +22,79 @@ from rectools import Columns from rectools.dataset import Dataset from rectools.models import PopularInCategoryModel -from tests.models.utils import assert_second_fit_refits_model +from rectools.models.popular import Popularity +from rectools.models.popular_in_category import MixingStrategy, RatioStrategy +from tests.models.utils import ( + assert_default_config_and_default_model_params_are_the_same, + assert_dumps_loads_do_not_change_model, + assert_get_config_and_from_config_compatibility, + assert_second_fit_refits_model, +) -@pytest.mark.filterwarnings("ignore") -class TestPopularInCategoryModel: - @pytest.fixture - def interactions_df(self) -> pd.DataFrame: - interactions_df = pd.DataFrame( - [ - [70, 11, 1, "2021-11-30"], - [70, 12, 1, "2021-11-30"], - [10, 11, 1, "2021-11-30"], - [10, 12, 1, "2021-11-29"], - [10, 13, 9, "2021-11-28"], - [20, 11, 1, "2021-11-27"], - [20, 14, 2, "2021-11-26"], - [20, 14, 1, "2021-11-25"], - [20, 14, 1, "2021-11-25"], - [20, 14, 1, "2021-11-25"], - [20, 14, 1, "2021-11-25"], - [20, 14, 1, "2021-11-25"], - [30, 11, 1, "2021-11-24"], - [30, 12, 1, "2021-11-23"], - [30, 14, 1, "2021-11-23"], - [30, 15, 5, "2021-11-21"], - [30, 15, 5, "2021-11-21"], - [40, 11, 1, "2021-11-20"], - [40, 12, 1, "2021-11-19"], - [50, 12, 1, "2021-11-19"], - [60, 12, 1, "2021-11-19"], - ], - columns=Columns.Interactions, - ) - return interactions_df +@pytest.fixture(name="interactions_df") # https://github.com/pylint-dev/pylint/issues/6531 +def _interactions_df() -> pd.DataFrame: + interactions_df = pd.DataFrame( + [ + [70, 11, 1, "2021-11-30"], + [70, 12, 1, "2021-11-30"], + [10, 11, 1, "2021-11-30"], + [10, 12, 1, "2021-11-29"], + [10, 13, 9, "2021-11-28"], + [20, 11, 1, "2021-11-27"], + [20, 14, 2, "2021-11-26"], + [20, 14, 1, "2021-11-25"], + [20, 14, 1, "2021-11-25"], + [20, 14, 1, "2021-11-25"], + [20, 14, 1, "2021-11-25"], + [20, 14, 1, "2021-11-25"], + [30, 11, 1, "2021-11-24"], + [30, 12, 1, "2021-11-23"], + [30, 14, 1, "2021-11-23"], + [30, 15, 5, "2021-11-21"], + [30, 15, 5, "2021-11-21"], + [40, 11, 1, "2021-11-20"], + [40, 12, 1, "2021-11-19"], + [50, 12, 1, "2021-11-19"], + [60, 12, 1, "2021-11-19"], + ], + columns=Columns.Interactions, + ) + return interactions_df - @pytest.fixture - def item_features_df(self) -> pd.DataFrame: - item_features_df = pd.DataFrame( - { - "id": [11, 11, 12, 12, 13, 13, 14, 14, 14], - "feature": ["f1", "f2", "f1", "f2", "f1", "f2", "f1", "f2", "f3"], - "value": [100, "a", 100, "b", 100, "b", 200, "c", 1], - } - ) - return item_features_df - @pytest.fixture - def dataset(self, interactions_df: pd.DataFrame, item_features_df: pd.DataFrame) -> Dataset: - user_features_df = pd.DataFrame( - { - "id": [10, 50], - "feature": ["f1", "f1"], - "value": [1, 1], - } - ) - dataset = Dataset.construct( - interactions_df=interactions_df, - user_features_df=user_features_df, - item_features_df=item_features_df, - cat_item_features=["f2", "f1"], - ) - return dataset +@pytest.fixture(name="item_features_df") +def _item_features_df() -> pd.DataFrame: + item_features_df = pd.DataFrame( + { + "id": [11, 11, 12, 12, 13, 13, 14, 14, 14], + "feature": ["f1", "f2", "f1", "f2", "f1", "f2", "f1", "f2", "f3"], + "value": [100, "a", 100, "b", 100, "b", 200, "c", 1], + } + ) + return item_features_df + +@pytest.fixture(name="dataset") +def _dataset(interactions_df: pd.DataFrame, item_features_df: pd.DataFrame) -> Dataset: + user_features_df = pd.DataFrame( + { + "id": [10, 50], + "feature": ["f1", "f1"], + "value": [1, 1], + } + ) + dataset = Dataset.construct( + interactions_df=interactions_df, + user_features_df=user_features_df, + item_features_df=item_features_df, + cat_item_features=["f2", "f1"], + ) + return dataset + + +@pytest.mark.filterwarnings("ignore") +class TestPopularInCategoryModel: @classmethod def assert_reco( cls, @@ -106,7 +116,7 @@ def assert_reco( def test_raises_when_incorrect_popularity(self) -> None: with pytest.raises(ValueError): - PopularInCategoryModel(popularity="strange", category_feature="f2") + PopularInCategoryModel(popularity="strange", category_feature="f2") # type: ignore[arg-type] def test_raises_when_incorrect_n_categories(self) -> None: with pytest.raises(ValueError): @@ -114,11 +124,11 @@ def test_raises_when_incorrect_n_categories(self) -> None: def test_raises_when_incorrect_mixing_strategy(self) -> None: with pytest.raises(ValueError): - PopularInCategoryModel(mixing_strategy="strange", category_feature="f2") + PopularInCategoryModel(mixing_strategy="strange", category_feature="f2") # type: ignore[arg-type] def test_raises_when_incorrect_ratio_strategy(self) -> None: with pytest.raises(ValueError): - PopularInCategoryModel(ratio_strategy="strange", category_feature="f2") + PopularInCategoryModel(ratio_strategy="strange", category_feature="f2") # type: ignore[arg-type] def test_raises_when_dense_features(self, interactions_df: pd.DataFrame) -> None: item_idx = interactions_df[Columns.Item].unique() @@ -209,7 +219,7 @@ def test_without_filtering_viewed( model = PopularInCategoryModel( category_feature="f2", popularity="mean_weight", - mixing_strategy=mixing_strategy, + mixing_strategy=mixing_strategy, # type: ignore[arg-type] ratio_strategy="proportional", ) model.fit(dataset) @@ -438,9 +448,162 @@ def test_second_fit_refits_model( ) -> None: model = PopularInCategoryModel( category_feature=category_feature, - popularity=popularity, - mixing_strategy=mixing_strategy, - ratio_strategy=ratio_strategy, + popularity=popularity, # type: ignore[arg-type] + mixing_strategy=mixing_strategy, # type: ignore[arg-type] + ratio_strategy=ratio_strategy, # type: ignore[arg-type] n_categories=n_categories, ) assert_second_fit_refits_model(model, dataset) + + def test_dumps_loads(self, dataset: Dataset) -> None: + model = PopularInCategoryModel(category_feature="f1") + model.fit(dataset) + assert_dumps_loads_do_not_change_model(model, dataset) + + +class TestPopularInCategoryModelConfiguration: + @pytest.mark.parametrize( + "begin_from,period,expected_begin_from,expected_period", + ( + (None, timedelta(days=7), None, timedelta(days=7)), + (datetime(2021, 11, 23), None, datetime(2021, 11, 23), None), + ("2021-11-23T10:20:30.400", None, datetime(2021, 11, 23, 10, 20, 30, 400000), None), + ( + None, + { + "days": 7, + "seconds": 123, + "microseconds": 12345, + "milliseconds": 32, + "minutes": 2, + "weeks": 7, + }, + None, + timedelta(days=56, seconds=243, microseconds=44345), + ), + ), + ) + def test_from_config( + self, + period: tp.Optional[tp.Union[timedelta, dict]], + begin_from: tp.Optional[tp.Union[datetime, str]], + expected_begin_from: tp.Optional[datetime], + expected_period: tp.Optional[dict], + ) -> None: + config = { + "category_feature": "f1", + "n_categories": 2, + "mixing_strategy": "group", + "ratio_strategy": "equal", + "popularity": "n_interactions", + "period": period, + "begin_from": begin_from, + "add_cold": True, + "inverse": True, + "verbose": 0, + } + model = PopularInCategoryModel.from_config(config) + assert model.category_feature == "f1" + assert model.n_categories == 2 + assert model.mixing_strategy == MixingStrategy("group") + assert model.ratio_strategy == RatioStrategy("equal") + assert model.popularity == Popularity("n_interactions") + assert model.period == expected_period + assert model.begin_from == expected_begin_from + assert model.add_cold is True + assert model.inverse is True + assert model.verbose == 0 + + @pytest.mark.parametrize( + "begin_from,period,expected_period", + ( + ( + None, + timedelta(weeks=2, days=7, hours=23, milliseconds=12345), + {"days": 21, "microseconds": 345000, "seconds": 82812}, + ), + (datetime(2021, 11, 23, 10, 20, 30, 400000), None, None), + ), + ) + def test_get_config( + self, + period: tp.Optional[timedelta], + begin_from: tp.Optional[datetime], + expected_period: tp.Optional[timedelta], + ) -> None: + model = PopularInCategoryModel( + category_feature="f2", + n_categories=3, + mixing_strategy="rotate", + ratio_strategy="proportional", + popularity="n_users", + period=period, + begin_from=begin_from, + add_cold=False, + inverse=False, + verbose=1, + ) + config = model.get_config() + expected = { + "category_feature": "f2", + "n_categories": 3, + "mixing_strategy": MixingStrategy("rotate"), + "ratio_strategy": RatioStrategy("proportional"), + "popularity": Popularity("n_users"), + "period": expected_period, + "begin_from": begin_from, + "add_cold": False, + "inverse": False, + "verbose": 1, + } + assert config == expected + + @pytest.mark.parametrize( + "begin_from,period,simple_types", + ( + ( + None, + timedelta(weeks=1, days=2, hours=3, minutes=4, seconds=5, milliseconds=6000, microseconds=70000), + True, + ), + (datetime(2021, 11, 23), None, False), + ("2021-11-23T10:20:30.400", None, True), + ( + None, + { + "days": 7, + "seconds": 123, + "microseconds": 12345, + "milliseconds": 32, + "minutes": 2, + "weeks": 7, + }, + False, + ), + ), + ) + def test_get_config_and_from_config_compatibility( + self, + dataset: Dataset, + period: tp.Optional[timedelta], + begin_from: tp.Optional[datetime], + simple_types: bool, + ) -> None: + initial_config = { + "category_feature": "f1", + "n_categories": 2, + "mixing_strategy": "group", + "ratio_strategy": "equal", + "popularity": "n_users", + "period": period, + "begin_from": begin_from, + "add_cold": True, + "inverse": False, + "verbose": 0, + } + assert_get_config_and_from_config_compatibility(PopularInCategoryModel, dataset, initial_config, simple_types) + + def test_default_config_and_default_model_params_are_the_same(self) -> None: + default_config: tp.Dict[str, str] = {"category_feature": "f2"} + model = PopularInCategoryModel(category_feature="f2") + assert_default_config_and_default_model_params_are_the_same(model, default_config) diff --git a/tests/models/test_pure_svd.py b/tests/models/test_pure_svd.py index 43c145a3..a197c150 100644 --- a/tests/models/test_pure_svd.py +++ b/tests/models/test_pure_svd.py @@ -25,10 +25,16 @@ from rectools.models.utils import recommend_from_scores from .data import DATASET, INTERACTIONS -from .utils import assert_second_fit_refits_model +from .utils import ( + assert_default_config_and_default_model_params_are_the_same, + assert_dumps_loads_do_not_change_model, + assert_get_config_and_from_config_compatibility, + assert_second_fit_refits_model, +) class TestPureSVDModel: + @pytest.fixture def dataset(self) -> Dataset: return DATASET @@ -252,3 +258,61 @@ def test_i2i_with_warm_and_cold_items(self, item_features: tp.Optional[pd.DataFr dataset=dataset, k=2, ) + + def test_dumps_loads(self, dataset: Dataset) -> None: + model = PureSVDModel(factors=2) + model.fit(dataset) + assert_dumps_loads_do_not_change_model(model, dataset) + + +class TestPureSVDModelConfiguration: + + def test_from_config(self) -> None: + config = { + "factors": 100, + "tol": 0, + "maxiter": 100, + "random_state": 32, + "verbose": 0, + } + model = PureSVDModel.from_config(config) + assert model.factors == 100 + assert model.tol == 0 + assert model.maxiter == 100 + assert model.random_state == 32 + assert model.verbose == 0 + + @pytest.mark.parametrize("random_state", (None, 42)) + def test_get_config(self, random_state: tp.Optional[int]) -> None: + model = PureSVDModel( + factors=100, + tol=1, + maxiter=100, + random_state=random_state, + verbose=1, + ) + config = model.get_config() + expected = { + "factors": 100, + "tol": 1, + "maxiter": 100, + "random_state": random_state, + "verbose": 1, + } + assert config == expected + + @pytest.mark.parametrize("simple_types", (False, True)) + def test_get_config_and_from_config_compatibility(self, simple_types: bool) -> None: + initial_config = { + "factors": 2, + "tol": 0, + "maxiter": 100, + "random_state": 32, + "verbose": 0, + } + assert_get_config_and_from_config_compatibility(PureSVDModel, DATASET, initial_config, simple_types) + + def test_default_config_and_default_model_params_are_the_same(self) -> None: + default_config: tp.Dict[str, int] = {} + model = PureSVDModel() + assert_default_config_and_default_model_params_are_the_same(model, default_config) diff --git a/tests/models/test_random.py b/tests/models/test_random.py index 618b3741..ab79526c 100644 --- a/tests/models/test_random.py +++ b/tests/models/test_random.py @@ -24,10 +24,16 @@ from rectools.models.random import _RandomGen, _RandomSampler from .data import DATASET, INTERACTIONS -from .utils import assert_second_fit_refits_model +from .utils import ( + assert_default_config_and_default_model_params_are_the_same, + assert_dumps_loads_do_not_change_model, + assert_get_config_and_from_config_compatibility, + assert_second_fit_refits_model, +) class TestRandomSampler: + def test_sample_small_n(self) -> None: gen = _RandomGen(42) sampler = _RandomSampler(np.arange(10), gen) @@ -178,3 +184,45 @@ def test_i2i(self, filter_itself: bool, whitelist: tp.Optional[tp.List[tp.Any]]) def test_second_fit_refits_model(self, dataset: Dataset) -> None: model = RandomModel(random_state=1) assert_second_fit_refits_model(model, dataset) + + def test_dumps_loads(self, dataset: Dataset) -> None: + model = RandomModel() + model.fit(dataset) + assert_dumps_loads_do_not_change_model(model, dataset) + + +class TestRandomModelConfiguration: + def test_from_config(self) -> None: + config = { + "random_state": 32, + "verbose": 0, + } + model = RandomModel.from_config(config) + assert model.random_state == 32 + assert model.verbose == 0 + + @pytest.mark.parametrize("random_state", (None, 42)) + def test_get_config(self, random_state: tp.Optional[int]) -> None: + model = RandomModel( + random_state=random_state, + verbose=1, + ) + config = model.get_config() + expected = { + "random_state": random_state, + "verbose": 1, + } + assert config == expected + + @pytest.mark.parametrize("simple_types", (False, True)) + def test_get_config_and_from_config_compatibility(self, simple_types: bool) -> None: + initial_config = { + "random_state": 32, + "verbose": 0, + } + assert_get_config_and_from_config_compatibility(RandomModel, DATASET, initial_config, simple_types) + + def test_default_config_and_default_model_params_are_the_same(self) -> None: + default_config: tp.Dict[str, int] = {} + model = RandomModel() + assert_default_config_and_default_model_params_are_the_same(model, default_config) diff --git a/tests/models/test_rank.py b/tests/models/test_rank.py index 9bc4da37..56f86af7 100644 --- a/tests/models/test_rank.py +++ b/tests/models/test_rank.py @@ -29,15 +29,15 @@ class TestImplicitRanker: # pylint: disable=protected-access @pytest.fixture def subject_factors(self) -> np.ndarray: - return np.array([[-4, 0, 3], [0, 0, 0]]) + return np.array([[-4, 0, 3], [0, 1, 2]]) @pytest.fixture def object_factors(self) -> np.ndarray: return np.array( [ [-4, 0, 3], - [0, 0, 0], - [1, 1, 1], + [0, 2, 4], + [1, 10, 100], ] ) @@ -60,7 +60,7 @@ def test_neginf_score(self, subject_factors: np.ndarray, object_factors: np.ndar k=1, filter_items=np.array([0]), )[1][0][0] - assert neginf == implicit_ranker._get_neginf_score() + assert neginf <= implicit_ranker._get_neginf_score() <= -1e38 @pytest.mark.parametrize( "dense", @@ -94,12 +94,18 @@ def test_mask_for_correct_scores( @pytest.mark.parametrize( "distance, expected_recs, expected_scores, dense", ( - (Distance.DOT, [0, 1, 2, 2, 1, 0], [25, 0, -1, 0, 0, 0], True), - (Distance.COSINE, [0, 1, 2, 2, 1, 0], [1, 0, -1 / (5 * 3**0.5), 0, 0, 0], True), - (Distance.EUCLIDEAN, [0, 1, 2, 1, 2, 0], [0, 5, 30**0.5, 0, 3**0.5, 5], True), - (Distance.DOT, [0, 1, 2, 2, 1, 0], [25, 0, -1, 0, 0, 0], False), + (Distance.DOT, [2, 0, 1, 2, 1, 0], [296, 25, 12, 210, 10, 6], True), + (Distance.COSINE, [0, 2, 1, 1, 2, 0], [1, 0.5890328, 0.5366563, 1, 0.9344414, 0.5366563], True), + ( + Distance.EUCLIDEAN, + [0, 1, 2, 1, 0, 2], + [0, 4.58257569, 97.64220399, 2.23606798, 4.24264069, 98.41747812], + True, + ), + (Distance.DOT, [2, 0, 1, 2, 1, 0], [296, 25, 12, 210, 10, 6], False), ), ) + @pytest.mark.parametrize("use_gpu", (False, True)) def test_rank( self, distance: Distance, @@ -108,24 +114,26 @@ def test_rank( subject_factors: np.ndarray, object_factors: np.ndarray, dense: bool, + use_gpu: bool, ) -> None: if not dense: subject_factors = sparse.csr_matrix(subject_factors) ranker = ImplicitRanker(distance, subject_factors, object_factors) - _, actual_recs, actual_scores = ranker.rank(subject_ids=[0, 1], k=3) + _, actual_recs, actual_scores = ranker.rank(subject_ids=[0, 1], k=3, use_gpu=use_gpu) np.testing.assert_equal(actual_recs, expected_recs) np.testing.assert_almost_equal(actual_scores, expected_scores) @pytest.mark.parametrize( "distance, expected_recs, expected_scores, dense", ( - (Distance.DOT, [0, 2, 2, 1, 0], [25, -1, 0, 0, 0], True), - (Distance.COSINE, [0, 2, 2, 1, 0], [1, -1 / (5 * 3**0.5), 0, 0, 0], True), - (Distance.EUCLIDEAN, [0, 2, 1, 2, 0], [0, 30**0.5, 0, 3**0.5, 5], True), - (Distance.DOT, [0, 2, 2, 1, 0], [25, -1, 0, 0, 0], False), + (Distance.DOT, [2, 0, 2, 1, 0], [296, 25, 210, 10, 6], True), + (Distance.COSINE, [0, 2, 1, 2, 0], [1, 0.5890328, 1, 0.9344414, 0.5366563], True), + (Distance.EUCLIDEAN, [0, 2, 1, 0, 2], [0, 97.64220399, 2.23606798, 4.24264069, 98.41747812], True), + (Distance.DOT, [2, 0, 2, 1, 0], [296, 25, 210, 10, 6], False), ), ) + @pytest.mark.parametrize("use_gpu", (False, True)) def test_rank_with_filtering_viewed_items( self, distance: Distance, @@ -134,6 +142,7 @@ def test_rank_with_filtering_viewed_items( subject_factors: np.ndarray, object_factors: np.ndarray, dense: bool, + use_gpu: bool, ) -> None: if not dense: subject_factors = sparse.csr_matrix(subject_factors) @@ -145,19 +154,20 @@ def test_rank_with_filtering_viewed_items( ] ) ranker = ImplicitRanker(distance, subject_factors, object_factors) - _, actual_recs, actual_scores = ranker.rank(subject_ids=[0, 1], k=3, filter_pairs_csr=ui_csr) + _, actual_recs, actual_scores = ranker.rank(subject_ids=[0, 1], k=3, filter_pairs_csr=ui_csr, use_gpu=use_gpu) np.testing.assert_equal(actual_recs, expected_recs) np.testing.assert_almost_equal(actual_scores, expected_scores) @pytest.mark.parametrize( "distance, expected_recs, expected_scores, dense", ( - (Distance.DOT, [0, 2, 2, 0], [25, -1, 0, 0], True), - (Distance.COSINE, [0, 2, 2, 0], [1, -1 / (5 * 3**0.5), 0, 0], True), - (Distance.EUCLIDEAN, [0, 2, 2, 0], [0, 30**0.5, 3**0.5, 5], True), - (Distance.DOT, [0, 2, 2, 0], [25, -1, 0, 0], False), + (Distance.DOT, [2, 0, 2, 0], [296, 25, 210, 6], True), + (Distance.COSINE, [0, 2, 2, 0], [1, 0.5890328, 0.9344414, 0.5366563], True), + (Distance.EUCLIDEAN, [0, 2, 0, 2], [0, 97.64220399, 4.24264069, 98.41747812], True), + (Distance.DOT, [2, 0, 2, 0], [296, 25, 210, 6], False), ), ) + @pytest.mark.parametrize("use_gpu", (False, True)) def test_rank_with_objects_whitelist( self, distance: Distance, @@ -166,25 +176,29 @@ def test_rank_with_objects_whitelist( subject_factors: np.ndarray, object_factors: np.ndarray, dense: bool, + use_gpu: bool, ) -> None: if not dense: subject_factors = sparse.csr_matrix(subject_factors) ranker = ImplicitRanker(distance, subject_factors, object_factors) - _, actual_recs, actual_scores = ranker.rank(subject_ids=[0, 1], k=3, sorted_object_whitelist=np.array([0, 2])) + _, actual_recs, actual_scores = ranker.rank( + subject_ids=[0, 1], k=3, sorted_object_whitelist=np.array([0, 2]), use_gpu=use_gpu + ) np.testing.assert_equal(actual_recs, expected_recs) np.testing.assert_almost_equal(actual_scores, expected_scores) @pytest.mark.parametrize( "distance, expected_recs, expected_scores, dense", ( - (Distance.DOT, [2, 2, 0], [-1, 0, 0], True), - (Distance.COSINE, [2, 2, 0], [-1 / (5 * 3**0.5), 0, 0], True), - (Distance.EUCLIDEAN, [2, 2, 0], [30**0.5, 3**0.5, 5], True), - (Distance.DOT, [2, 2, 0], [-1, 0, 0], False), + (Distance.DOT, [2, 2, 0], [296, 210, 6], True), + (Distance.COSINE, [2, 2, 0], [0.5890328, 0.9344414, 0.5366563], True), + (Distance.EUCLIDEAN, [2, 0, 2], [97.64220399, 4.24264069, 98.41747812], True), + (Distance.DOT, [2, 2, 0], [296, 210, 6], False), ), ) + @pytest.mark.parametrize("use_gpu", (False, True)) def test_rank_with_objects_whitelist_and_filtering_viewed_items( self, distance: Distance, @@ -193,6 +207,7 @@ def test_rank_with_objects_whitelist_and_filtering_viewed_items( subject_factors: np.ndarray, object_factors: np.ndarray, dense: bool, + use_gpu: bool, ) -> None: if not dense: subject_factors = sparse.csr_matrix(subject_factors) @@ -205,7 +220,7 @@ def test_rank_with_objects_whitelist_and_filtering_viewed_items( ) ranker = ImplicitRanker(distance, subject_factors, object_factors) _, actual_recs, actual_scores = ranker.rank( - subject_ids=[0, 1], k=3, sorted_object_whitelist=np.array([0, 2]), filter_pairs_csr=ui_csr + subject_ids=[0, 1], k=3, sorted_object_whitelist=np.array([0, 2]), filter_pairs_csr=ui_csr, use_gpu=use_gpu ) np.testing.assert_equal(actual_recs, expected_recs) np.testing.assert_almost_equal(actual_scores, expected_scores) diff --git a/tests/models/test_serialization.py b/tests/models/test_serialization.py new file mode 100644 index 00000000..abe2c6ef --- /dev/null +++ b/tests/models/test_serialization.py @@ -0,0 +1,51 @@ +import sys +import typing as tp +from tempfile import NamedTemporaryFile + +import pytest +from implicit.als import AlternatingLeastSquares +from implicit.nearest_neighbours import ItemItemRecommender + +try: + from lightfm import LightFM +except ImportError: + LightFM = object # it's ok in case we're skipping the tests + + +from rectools.models import ( + ImplicitALSWrapperModel, + ImplicitItemKNNWrapperModel, + LightFMWrapperModel, + PopularInCategoryModel, + load_model, +) +from rectools.models.base import ModelBase + +from .utils import get_final_successors + +MODEL_CLASSES = [ + cls + for cls in get_final_successors(ModelBase) + if cls.__module__.startswith("rectools.models") and not (sys.version_info >= (3, 12) and cls is LightFMWrapperModel) +] + + +def init_default_model(model_cls: tp.Type[ModelBase]) -> ModelBase: + mandatory_params = { + ImplicitItemKNNWrapperModel: {"model": ItemItemRecommender()}, + ImplicitALSWrapperModel: {"model": AlternatingLeastSquares()}, + LightFMWrapperModel: {"model": LightFM()}, + PopularInCategoryModel: {"category_feature": "some_feature"}, + } + params = mandatory_params.get(model_cls, {}) + model = model_cls(**params) + return model + + +@pytest.mark.parametrize("model_cls", MODEL_CLASSES) +def test_load_model(model_cls: tp.Type[ModelBase]) -> None: + model = init_default_model(model_cls) + with NamedTemporaryFile() as f: + model.save(f.name) + loaded_model = load_model(f.name) + assert isinstance(loaded_model, model_cls) diff --git a/tests/models/utils.py b/tests/models/utils.py index 4d321975..34f09662 100644 --- a/tests/models/utils.py +++ b/tests/models/utils.py @@ -15,6 +15,7 @@ import typing as tp from copy import deepcopy +import numpy as np import pandas as pd from rectools.dataset import Dataset @@ -47,3 +48,63 @@ def assert_second_fit_refits_model( reco_i2i_1 = model_1.recommend_to_items(dataset.item_id_map.external_ids, dataset, k, False) reco_i2i_2 = model_2.recommend_to_items(dataset.item_id_map.external_ids, dataset, k, False) pd.testing.assert_frame_equal(reco_i2i_1, reco_i2i_2, atol=0.001) + + +def assert_dumps_loads_do_not_change_model( + model: ModelBase, + dataset: Dataset, + check_configs: bool = True, +) -> None: + def get_reco(model: ModelBase) -> pd.DataFrame: + users = dataset.user_id_map.external_ids[:2] + return model.recommend(users=users, dataset=dataset, k=2, filter_viewed=False) + + dumped = model.dumps() + recovered_model = model.__class__.loads(dumped) + + original_model_reco = get_reco(model) + recovered_model_reco = get_reco(recovered_model) + pd.testing.assert_frame_equal(recovered_model_reco, original_model_reco) + + if check_configs: + original_model_config = model.get_config() + recovered_model_config = recovered_model.get_config() + assert recovered_model_config == original_model_config + + +def assert_default_config_and_default_model_params_are_the_same( + model: ModelBase, default_config: tp.Dict[str, tp.Any] +) -> None: + model_from_config = model.from_config(default_config) + assert model_from_config.get_config() == model.get_config() + + +def assert_get_config_and_from_config_compatibility( + model: tp.Type[ModelBase], dataset: Dataset, initial_config: tp.Dict[str, tp.Any], simple_types: bool +) -> None: + def get_reco(model: ModelBase) -> pd.DataFrame: + return model.fit(dataset).recommend(users=np.array([10, 20]), dataset=dataset, k=2, filter_viewed=False) + + model_1 = model.from_config(initial_config) + reco_1 = get_reco(model_1) + config_1 = model_1.get_config(simple_types=simple_types) + + model_2 = model.from_config(config_1) + reco_2 = get_reco(model_2) + config_2 = model_2.get_config(simple_types=simple_types) + + assert config_1 == config_2 + pd.testing.assert_frame_equal(reco_1, reco_2) + + +def get_final_successors(cls: tp.Type) -> tp.List[tp.Type]: + final_classes = [] + subclasses = cls.__subclasses__() + + if not subclasses: # If there are no subclasses, it's a final class + final_classes.append(cls) + else: + for subclass in subclasses: + final_classes.extend(get_final_successors(subclass)) # Recursively check subclasses + + return final_classes From eca31d4138716170e4e5e1acaaf9cf6471af8737 Mon Sep 17 00:00:00 2001 From: spirinamayya <90619187+spirinamayya@users.noreply.github.com> Date: Fri, 6 Dec 2024 23:40:39 +0300 Subject: [PATCH 11/13] Transformers tutorial (#212) Added Transformers tutorial --- examples/tutorials/sasrec_tutorial.ipynb | 1937 --------------- .../tutorials/transformers_tutorial.ipynb | 2170 +++++++++++++++++ tests/models/test_serialization.py | 13 +- 3 files changed, 2181 insertions(+), 1939 deletions(-) delete mode 100644 examples/tutorials/sasrec_tutorial.ipynb create mode 100644 examples/tutorials/transformers_tutorial.ipynb diff --git a/examples/tutorials/sasrec_tutorial.ipynb b/examples/tutorials/sasrec_tutorial.ipynb deleted file mode 100644 index c49a9d72..00000000 --- a/examples/tutorials/sasrec_tutorial.ipynb +++ /dev/null @@ -1,1937 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# SASRec model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Table of Contents**\n", - "\n", - "* Prepare data\n", - "* Model description\n", - "* Recommendations\n", - "* RecTools implementation\n", - " * Additional details\n", - "* Model application\n", - " * SASRec with item ids embeddings in ItemNetBlock\n", - " * SASRec with item ids and category features embeddings in ItemNetBlock\n", - " * SASRec with category item features embeddings in ItemNetBlock\n", - " * Additional details\n", - "* Under the hood: Dataset processing\n", - "* Under the hood: Transformer layers\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import os\n", - "import pandas as pd\n", - "import torch\n", - "import typing as tp\n", - "\n", - "from lightning_fabric import seed_everything\n", - "from pathlib import Path\n", - "\n", - "from rectools import Columns\n", - "from rectools.dataset import Dataset\n", - "from rectools.models.sasrec import CatFeaturesItemNet, IdEmbeddingsItemNet, SASRecModel\n", - "\n", - "# Enable deterministic behaviour with CUDA >= 10.2\n", - "os.environ[\"CUBLAS_WORKSPACE_CONFIG\"] = \":4096:8\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Prepare data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We are using KION dataset for this tutorial. The data was gathered from the users of MTS KION video streaming platform. To make recommendations only user-item interactions are required, as SASRec implementation does not support user and item features." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Archive: data_en.zip\n", - " inflating: data_en/items_en.csv \n", - " inflating: __MACOSX/data_en/._items_en.csv \n", - " inflating: data_en/interactions.csv \n", - " inflating: __MACOSX/data_en/._interactions.csv \n", - " inflating: data_en/users_en.csv \n", - " inflating: __MACOSX/data_en/._users_en.csv \n", - "CPU times: user 73.6 ms, sys: 46.7 ms, total: 120 ms\n", - "Wall time: 4.07 s\n" - ] - } - ], - "source": [ - "%%time\n", - "!wget -q https://github.com/irsafilo/KION_DATASET/raw/f69775be31fa5779907cf0a92ddedb70037fb5ae/data_en.zip -O data_en.zip\n", - "!unzip -o data_en.zip\n", - "!rm data_en.zip" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(5476251, 5)\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_iditem_iddatetimetotal_durwatched_pct
017654995062021-05-11425072.0
169931716592021-05-298317100.0
\n", - "
" - ], - "text/plain": [ - " user_id item_id datetime total_dur watched_pct\n", - "0 176549 9506 2021-05-11 4250 72.0\n", - "1 699317 1659 2021-05-29 8317 100.0" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Download dataset\n", - "DATA_PATH = Path(\"data_en\")\n", - "items = pd.read_csv(DATA_PATH / 'items_en.csv', index_col=0)\n", - "interactions = (\n", - " pd.read_csv(DATA_PATH / 'interactions.csv', parse_dates=[\"last_watch_dt\"])\n", - " .rename(columns={\"last_watch_dt\": Columns.Datetime})\n", - ")\n", - "print(interactions.shape)\n", - "interactions.head(2)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(5476251, 4)\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_iditem_iddatetimeweight
017654995062021-05-113
169931716592021-05-293
\n", - "
" - ], - "text/plain": [ - " user_id item_id datetime weight\n", - "0 176549 9506 2021-05-11 3\n", - "1 699317 1659 2021-05-29 3" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Process interactions\n", - "interactions[Columns.Weight] = np.where(interactions['watched_pct'] > 10, 3, 1)\n", - "interactions = interactions[[\"user_id\", \"item_id\", \"datetime\", \"weight\"]]\n", - "print(interactions.shape)\n", - "interactions.head(2)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(15963, 16)\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
item_idcontent_typetitletitle_origrelease_yeargenrescountriesfor_kidsage_ratingstudiosdescriptionkeywordsactors_translatedactors_transliterateddirectors_translatedtransliterated
010711filmTalk to herHable con ella2002.0drama, foreign, detective, melodramaSpainNaN16.0NaNMarco, a journalist, interviews the famous Tor...Talk, her, 2002, Spain, friends, love, strong,...Adolfo Fernández, Ana Fernández, Dario Grandin...Adol'fo Fernandes, Ana Fernandes, Dario Grandi...Pedro AlmodovarPedro Al'modovar
12508filmNaked PeppersSearch Party2014.0foreign, adventure, comedyUSANaN16.0NaNThe main character has learned not to invite h...Naked, Peppers, 2014, USA, friends, weddings, ...Adam Palley, Brian Huskey, JB Smoove, Jason Ma...Adam Palli, Brajan Haski, Dzh.B. Smuv, Dzhejso...Scott ArmstrongSkot Armstrong
\n", - "
" - ], - "text/plain": [ - " item_id content_type title title_orig release_year \\\n", - "0 10711 film Talk to her Hable con ella 2002.0 \n", - "1 2508 film Naked Peppers Search Party 2014.0 \n", - "\n", - " genres countries for_kids age_rating \\\n", - "0 drama, foreign, detective, melodrama Spain NaN 16.0 \n", - "1 foreign, adventure, comedy USA NaN 16.0 \n", - "\n", - " studios description \\\n", - "0 NaN Marco, a journalist, interviews the famous Tor... \n", - "1 NaN The main character has learned not to invite h... \n", - "\n", - " keywords \\\n", - "0 Talk, her, 2002, Spain, friends, love, strong,... \n", - "1 Naked, Peppers, 2014, USA, friends, weddings, ... \n", - "\n", - " actors_translated \\\n", - "0 Adolfo Fernández, Ana Fernández, Dario Grandin... \n", - "1 Adam Palley, Brian Huskey, JB Smoove, Jason Ma... \n", - "\n", - " actors_transliterated directors_translated \\\n", - "0 Adol'fo Fernandes, Ana Fernandes, Dario Grandi... Pedro Almodovar \n", - "1 Adam Palli, Brajan Haski, Dzh.B. Smuv, Dzhejso... Scott Armstrong \n", - "\n", - " transliterated \n", - "0 Pedro Al'modovar \n", - "1 Skot Armstrong " - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "print(items.shape)\n", - "items.head(2)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Process item features\n", - "items = items.loc[items[Columns.Item].isin(interactions[Columns.Item])].copy()\n", - "# items = items.loc[items[Columns.Item].isin(interactions[~interactions.isin(test_user)][Columns.Item])].copy()\n", - "items[\"genre\"] = items[\"genres\"].str.lower().str.replace(\", \", \",\", regex=False).str.split(\",\")\n", - "genre_feature = items[[\"item_id\", \"genre\"]].explode(\"genre\")\n", - "genre_feature.columns = [\"id\", \"value\"]\n", - "genre_feature[\"feature\"] = \"genre\"\n", - "content_feature = items.reindex(columns=[Columns.Item, \"content_type\"])\n", - "content_feature.columns = [\"id\", \"value\"]\n", - "content_feature[\"feature\"] = \"content_type\"\n", - "item_features = pd.concat((genre_feature, content_feature))" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idvaluefeature
010711dramagenre
010711foreigngenre
010711detectivegenre
010711melodramagenre
12508foreigngenre
\n", - "
" - ], - "text/plain": [ - " id value feature\n", - "0 10711 drama genre\n", - "0 10711 foreign genre\n", - "0 10711 detective genre\n", - "0 10711 melodrama genre\n", - "1 2508 foreign genre" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "item_features.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# Create datasets\n", - "dataset_no_features = Dataset.construct(\n", - " interactions_df=interactions,\n", - ")\n", - "\n", - "dataset_item_features = Dataset.construct(\n", - " interactions_df=interactions,\n", - " item_features_df=item_features,\n", - " cat_item_features=[\"genre\", \"content_type\"],\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Model description" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "SASRec is a transformer-based sequential model with unidirectional attention mechanism and \"Shifted Sequence\" training objective. \n", - "\n", - "As an input SASRec takes user sequences, containig previous user interaction history. Description of how they are created from user-item interactions can be found in \"Under the hood: Dataset processing\" part. Item embeddings from these sequences are fed to multi-head self-attention to acquire user sequence latent represenation. After one or several stacked attention blocks, resulting embeddings are used to predict next item.\n", - "\n", - "In contrust to BERT4Rec, another transformer-based recommender model, SASRec is a causal model. It applies causal mask to enforce model focus solely on past interactions.\n" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Recommendations" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "After that implicit ranker is applied to make recommendations. Implicit ranker bases on implicit library matrix factorization topk method that:\n", - "* Receives as input:\n", - " * Item embeddings\n", - " * User sequence latent embeddings. Similarly to train stage, user sequence item embeddings are passed through transformer blocks and layer normalization to receive latent representation.\n", - "* Finds relevanace of each item by multiplication of user and item embeddings\n", - "* Returns items within topk with greates relevance\n", - "\n", - "For u2i recommendations DOT distance is applied to find item relevance, for i2i - COSINE" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# RecTools implementation\n", - "Current implementation uses architecture offered by the authors of original article. In contrast to original model, only cross-entropy loss is supported and no negative sampling is provided. However, in the future versions more loss functions are expected." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**TODO: Add category item features emebeddings**" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Additional details\n", - "1. Xavier normal initialization for model parameters\n", - "2. Adam optimizer with betas=(0.9, 0.98) is used\n", - "3. Masked multi-head attention uses attention and timeline mask\n", - "4. Cross-entropy loss without reduction is applied, ignoring 0 index not to take into account pad element. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Model Application" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Seed set to 60\n" - ] - }, - { - "data": { - "text/plain": [ - "60" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "RANDOM_STATE=60\n", - "torch.use_deterministic_algorithms(True)\n", - "seed_everything(RANDOM_STATE, workers=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(82, 4)\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_iditem_iddatetimeweight
017654995062021-05-113
3815176549154692021-05-253
\n", - "
" - ], - "text/plain": [ - " user_id item_id datetime weight\n", - "0 176549 9506 2021-05-11 3\n", - "3815 176549 15469 2021-05-25 3" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Prepare test user\n", - "test_user = [176549] \n", - "print(interactions[interactions[\"user_id\"] == test_user[0]].shape)\n", - "interactions[interactions[\"user_id\"] == test_user[0]].head(2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "* Specify latent embeddings size with `n_factors`\n", - "* Specify number of self-attention blocks with `n_blocks` \n", - "* Specify number of attention heads with `n_heads`\n", - "* Specify `dropout_rate`\n", - "* Specify whether positional encoding should be used with `use_pos_emb`\n", - "* Specify maximum length of user-item interaction history with `session_max_len`\n", - "* Specify `lr` for learning rate \n", - "* Specify `batch_size`\n", - "* Specify `epochs` for number of model training epochs\n", - "* Specify `item_net_block_types` for Item Net blocks" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "n_factors=128\n", - "session_max_len=32" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def recommend(model: SASRecModel, test_user: tp.List[int], dataset: Dataset, k: int, filter_view: bool, on_unsupported_targets: str) -> pd.DataFrame:\n", - " recos = model.recommend(\n", - " users=test_user, \n", - " dataset=dataset,\n", - " k=k,\n", - " filter_viewed=filter_view,\n", - " on_unsupported_targets=on_unsupported_targets,\n", - " )\n", - " return recos.merge(items[[\"item_id\", \"title_orig\"]], on=\"item_id\").sort_values([\"user_id\", \"rank\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### SASRec with item ids embeddings in ItemNetBlock" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `pytorch_lightning` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n" - ] - } - ], - "source": [ - "model = SASRecModel(\n", - " n_factors=n_factors, \n", - " n_blocks=2,\n", - " n_heads=1,\n", - " dropout_rate=0.2,\n", - " use_pos_emb=True,\n", - " session_max_len=session_max_len,\n", - " lr=1e-3,\n", - " batch_size=128,\n", - " epochs=5,\n", - " device=\"cuda:1\",\n", - " loss=\"softmax\",\n", - " verbose=1,\n", - " deterministic=True,\n", - " item_net_block_types=(IdEmbeddingsItemNet, ) # Use only item ids in ItemNetBlock\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "\n", - " | Name | Type | Params\n", - "---------------------------------------------------------------\n", - "0 | torch_model | TransformerBasedSessionEncoder | 2.1 M \n", - "---------------------------------------------------------------\n", - "2.1 M Trainable params\n", - "0 Non-trainable params\n", - "2.1 M Total params\n", - "8.207 Total estimated model params size (MB)\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7ef9f4c7e8db4cf099d29151db02acc4", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: | | 0/? [00:00" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "model.fit(dataset_no_features)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1/1 [00:00<00:00, 22.21it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 818 ms, sys: 1.54 s, total: 2.36 s\n", - "Wall time: 489 ms\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_iditem_idscoreranktitle_orig
0176549117492.8346251Incredibles 2
117654973102.7687712Despicable Me 2
2176549152662.6864913Monsters University
\n", - "
" - ], - "text/plain": [ - " user_id item_id score rank title_orig\n", - "0 176549 11749 2.834625 1 Incredibles 2\n", - "1 176549 7310 2.768771 2 Despicable Me 2\n", - "2 176549 15266 2.686491 3 Monsters University" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "recommend(\n", - " model=model,\n", - " test_user=test_user,\n", - " dataset=dataset_no_features,\n", - " k=3,\n", - " filter_view=True,\n", - " on_unsupported_targets=\"warn\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### SASRec with item ids and category features embeddings in ItemNetBlock" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n" - ] - } - ], - "source": [ - "model = SASRecModel(\n", - " n_factors=n_factors, \n", - " n_blocks=2,\n", - " n_heads=1,\n", - " dropout_rate=0.2,\n", - " use_pos_emb=True,\n", - " session_max_len=session_max_len,\n", - " lr=1e-3,\n", - " batch_size=128,\n", - " epochs=5,\n", - " device=\"cuda:1\",\n", - " loss=\"softmax\",\n", - " verbose=1,\n", - " deterministic=True,\n", - " item_net_block_types=(IdEmbeddingsItemNet, CatFeaturesItemNet) # Use item ids and cat features in ItemNetBlock\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "\n", - " | Name | Type | Params\n", - "---------------------------------------------------------------\n", - "0 | torch_model | TransformerBasedSessionEncoder | 2.1 M \n", - "---------------------------------------------------------------\n", - "2.1 M Trainable params\n", - "0 Non-trainable params\n", - "2.1 M Total params\n", - "8.288 Total estimated model params size (MB)\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "5202a77c2a004c3ca9b01c37e90e946a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: | | 0/? [00:00" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "model.fit(dataset_item_features)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", - " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", - "100%|██████████| 1/1 [00:00<00:00, 217.36it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 528 ms, sys: 561 ms, total: 1.09 s\n", - "Wall time: 209 ms\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_iditem_idscoreranktitle_orig
0176549129653.7080241Cars 3
1176549117493.3445212Incredibles 2
217654967743.3214123Cars 2
\n", - "
" - ], - "text/plain": [ - " user_id item_id score rank title_orig\n", - "0 176549 12965 3.708024 1 Cars 3\n", - "1 176549 11749 3.344521 2 Incredibles 2\n", - "2 176549 6774 3.321412 3 Cars 2" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "recommend(\n", - " model=model,\n", - " test_user=test_user,\n", - " dataset=dataset_item_features,\n", - " k=3,\n", - " filter_view=True,\n", - " on_unsupported_targets=\"warn\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### SASRec with category item features embeddings in ItemNetBlock" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n" - ] - } - ], - "source": [ - "model = SASRecModel(\n", - " n_factors=n_factors, \n", - " n_blocks=2,\n", - " n_heads=1,\n", - " dropout_rate=0.2,\n", - " use_pos_emb=True,\n", - " session_max_len=session_max_len,\n", - " lr=1e-3,\n", - " batch_size=128,\n", - " epochs=5,\n", - " device=\"cuda:1\",\n", - " loss=\"softmax\",\n", - " verbose=1,\n", - " deterministic=True,\n", - " item_net_block_types=(CatFeaturesItemNet, ) # Use only cat item features in ItemNetBlock\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "\n", - " | Name | Type | Params\n", - "---------------------------------------------------------------\n", - "0 | torch_model | TransformerBasedSessionEncoder | 223 K \n", - "---------------------------------------------------------------\n", - "223 K Trainable params\n", - "0 Non-trainable params\n", - "223 K Total params\n", - "0.895 Total estimated model params size (MB)\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/.venv/lib/python3.9/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2de8ecaef7134980b3507d37236e0a18", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: | | 0/? [00:00" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "model.fit(dataset_item_features)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", - " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", - "100%|██████████| 1/1 [00:00<00:00, 222.04it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 531 ms, sys: 512 ms, total: 1.04 s\n", - "Wall time: 128 ms\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_iditem_idscoreranktitle_orig
0176549854.6132781Turbo
1176549128734.3739792Spies in Disguise
217654962144.0657713Early Man
\n", - "
" - ], - "text/plain": [ - " user_id item_id score rank title_orig\n", - "0 176549 85 4.613278 1 Turbo\n", - "1 176549 12873 4.373979 2 Spies in Disguise\n", - "2 176549 6214 4.065771 3 Early Man" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "recommend(\n", - " model=model,\n", - " test_user=test_user,\n", - " dataset=dataset_item_features,\n", - " k=3,\n", - " filter_view=True,\n", - " on_unsupported_targets=\"warn\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Additional details\n", - "It may happen that SASRec filters out users with less than 2 interactions during train stage, as target is a shifted interaction sequence. However, it is still possible to make recommendations for user with one interaction in history if this interaction item was present at training.\n", - "\n", - "As an example consider user 324373, for whom there is only one interaction in the dataset." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1, 4)\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_iditem_iddatetimeweight
2493287324373104402021-06-243
\n", - "
" - ], - "text/plain": [ - " user_id item_id datetime weight\n", - "2493287 324373 10440 2021-06-24 3" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Prepare test user with 1 interaction\n", - "test_user_recs = [324373] \n", - "print(interactions[interactions[\"user_id\"] == test_user_recs[0]].shape)\n", - "interactions[interactions[\"user_id\"] == test_user_recs[0]]" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/dataset/features.py:424: UserWarning: Converting sparse features to dense array may cause MemoryError\n", - " warnings.warn(\"Converting sparse features to dense array may cause MemoryError\")\n", - "100%|██████████| 1/1 [00:00<00:00, 224.93it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 539 ms, sys: 481 ms, total: 1.02 s\n", - "Wall time: 126 ms\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_iditem_idscoreranktitle_orig
032437357473.7533591Station 19
1324373152823.6996452NaN
2324373104663.5966053Adjutant of His Excellency
\n", - "
" - ], - "text/plain": [ - " user_id item_id score rank title_orig\n", - "0 324373 5747 3.753359 1 Station 19\n", - "1 324373 15282 3.699645 2 NaN\n", - "2 324373 10466 3.596605 3 Adjutant of His Excellency" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "\n", - "recommend(\n", - " model=model,\n", - " test_user=test_user_recs,\n", - " dataset=dataset_item_features,\n", - " k=3,\n", - " filter_view=True,\n", - " on_unsupported_targets=\"warn\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Another case is when user had interactions, but all of the items were not present at the train stage. This may happen due to several reasons:\n", - "* Other users with this item were excluded due to lack of interactions\n", - "* User sequence exceeded `session_max_len` and was shortened \n", - "\n", - "If user does not have interactions containg items, which model knows, this user will not get recommendations." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1, 4)\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_iditem_iddatetimeweight
23938771463088712021-03-283
\n", - "
" - ], - "text/plain": [ - " user_id item_id datetime weight\n", - "2393877 14630 8871 2021-03-28 3" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Prepare test user with items unknown by the model\n", - "test_user_no_recs = [14630] \n", - "print(interactions[interactions[\"user_id\"] == test_user_no_recs[0]].shape)\n", - "interactions[interactions[\"user_id\"] == test_user_no_recs[0]].head(2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Flag `on_unsupported_target` allows to monitor the number of users without any known items.\n", - "\n", - "Flag options:\n", - "* \"ignore\" - skip such users, show warning with the number of cold users.\n", - "* \"warn\" - skip such users, show warning with the number of cold users and that cold users are not supported.\n", - "* \"raise\" - stop recommendation procedure." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 72.7 ms, sys: 2.96 ms, total: 75.7 ms\n", - "Wall time: 74.6 ms\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/sasrec.py:635: UserWarning: 1 target users were considered cold because of missing known items\n", - " warnings.warn(explanation)\n", - "/data/home/amsemenov2/git/RecTools_origin/RecTools/rectools/models/base.py:406: UserWarning: \n", - " Model `` doesn't support recommendations for cold users,\n", - " but some of given users are cold: they are not in the `dataset.user_id_map`\n", - " \n", - " warnings.warn(explanation)\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_idscorerankitem_idtitle_orig
\n", - "
" - ], - "text/plain": [ - "Empty DataFrame\n", - "Columns: [user_id, score, rank, item_id, title_orig]\n", - "Index: []" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "\n", - "recommend(\n", - " model=model,\n", - " test_user=test_user_no_recs,\n", - " dataset=dataset_no_features,\n", - " k=3,\n", - " filter_view=True,\n", - " on_unsupported_targets=\"warn\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Links\n", - "1. SASRec original paper: [Self-Attentive Sequential Recommendation](https://arxiv.org/abs/1808.09781)\n", - "2. [Turning Dross Into Gold Loss: is BERT4Rec really better than SASRec?](https://arxiv.org/abs/2309.07602)\n", - "3. [gSASRec: Reducing Overconfidence in Sequential Recommendation Trained with Negative Sampling](https://arxiv.org/pdf/2308.07192)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Under the hood: Dataset processing" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "Preprocessing steps will be shown using toy dataset:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
user_id item_id weight datetime
u1i10.12021-09-09
u2i10.32021-09-09
u2i30.22021-09-05
u1i20.32021-09-07
u3i20.42021-09-05
u1i30.52021-09-08
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "1. Filter out users with less than 2 interactions in train dataset. The model uses shifted user interactions to make next item prediction, thus at least 2 items should be in the history. \n", - "\n", - "2. Leave `session_maxlen` most recent interactions for each user.\n", - "\n", - "After first 2 steps, some users and/or items may be filtered out from train dataset. However, as it will be shown further, it is still possible to make recommendations for a previously unmet user, if interaction is known.\n", - "\n", - "3. Create user sessions: for each user specify items with which there was an interaction in the order from earliest to most recent. Sessions for example dataset are the following:\n", - "$$S^1 = (i2, i3, i1)$$\n", - "$$S^2 = (i3, i1)$$\n", - "\n", - "4. Before train stage each session is divided into train and target. As the task is to predict next item, shifted sequence is considered as target.\n", - "$$S^1_{train} = (i2, i3), S^1_{target} = (i3, i1)$$\n", - "$$S^2_{train} = (i3), S^2_{target} = (i1)$$\n", - "5. Both train and target sequences are adjusted to have user-defined `session_maxlen`:\n", - " * If session is longer than `session_maxlen`, cut earliest items\n", - " * If session is shorter than `session_maxlen`, pad earliest items with PAD element\n", - "$$S^1_{train} = (PAD, PAD, PAD, i2, i3), S^1_{target} = (PAD, PAD, PAD, i3, i1)$$\n", - "$$S^2_{train} = (PAD, PAD, PAD, PAD, i3), S^2_{target} = (PAD, PAD, PAD, PAD, i1)$$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Under the hood: Transformer layers" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "* Multi-head attention layer receives queries after layer normalisarion, keys and values without it. Masked attention is required to forbid model consider future interactions: cannot access element t+2 when predicting element t+1. Following notation from original article: \n", - "$$ \\text{Attention}(Q, K, V) = \\text{softmax} (\\frac {QK^T}{\\sqrt{d}})V $$\n", - "$$S = SA(\\hat{E}) = \\text{Attention} (\\hat{E}W^Q, \\hat{E}W^K, \\hat{E}W^V)$$\n", - "\n", - "where $\\hat{E}$ - input embedding\n", - "* Point-wise feed-forward network has the following structure: $F_i = \\text{FFN}(S_i) = \\text{ReLU}(S_i \\cdot W^{(1)} + b^{(1)}) \\cdot W^{(2)} + b^{(2)}$,\n", - "\n", - "where $S_i, S_j$ - items of user sequence\n", - "\n", - "$W_1, W_2$ - weights\n", - "\n", - "$b_1, b_2$ - biases\n", - "* To avoid overfitting and stabelize training process, 2 residual connections are applied adding data after layer normalization.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "rectools_origin", - "language": "python", - "name": "rectools_origin" - }, - "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.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/tutorials/transformers_tutorial.ipynb b/examples/tutorials/transformers_tutorial.ipynb new file mode 100644 index 00000000..54d410a9 --- /dev/null +++ b/examples/tutorials/transformers_tutorial.ipynb @@ -0,0 +1,2170 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Transformer Models Tutorial\n", + "This tutorial concerns following questions:\n", + "1. How to apply SASRec and BERT4Rec transformer models using RecTools?\n", + "2. How does SASRec and BERT4Rec work under the hood?\n", + "\n", + "Transformer models came to recommendation systems from NLP, where they proved to have a significant impact. As transformers were applied to sequential data it is common to use them for session-based recommendations, where interactions are ordered by the date of their occurrence. In this tutorial focus is on SASRec and BERT4Rec - models which are considered as a common starting point for transformer application in recsys. Due to the fact that transformers base on attention mechanism, they have some advantages compared to RNN, LSTM and CNN:\n", + "1. Unlike other sequence-based architectures(RNN and LSTM), transformers do not struggle with long-range dependencies\n", + "2. Transformers have better scalability, because of process parallelization\n", + "\n", + "### Why transformers from RecTools?\n", + "RecTools library offers efficient and well-performing implementation of SASRec and BERT4Rec. It has easy-to-use interface and provides user with a flexibility to customize models by replacing transformer model blocks." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Table of Contents\n", + "\n", + "* Prepare data\n", + "* SASRec & BERT4Rec\n", + " * SASRec\n", + " * BERT4Rec\n", + " * Main differences\n", + "* RecTools implementation \n", + "* Application of models\n", + " * Basic usage\n", + " * Adding item features to models\n", + " * Selecting losses\n", + " * Customizing model \n", + " * Cross-validation\n", + " * Item-to-item recommendations\n", + " * Inference tricks (inference for cold users)\n", + "* Detailed SASRec and BERT4Rec description\n", + " * Dataset processing\n", + " * Transformer layers\n", + " * Losses\n", + "* Links" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import os\n", + "import pandas as pd\n", + "import torch\n", + "import typing as tp\n", + "import warnings\n", + "\n", + "from lightning_fabric import seed_everything\n", + "from pathlib import Path\n", + "\n", + "from rectools import Columns\n", + "from rectools.dataset import Dataset\n", + "from rectools.metrics import (\n", + " MAP,\n", + " CoveredUsers,\n", + " AvgRecPopularity,\n", + " Intersection,\n", + " HitRate,\n", + " Serendipity,\n", + ")\n", + "from rectools.models import PopularModel, EASEModel\n", + "from rectools.model_selection import TimeRangeSplitter, cross_validate\n", + "from rectools.models.sasrec import ModelBase, CatFeaturesItemNet, IdEmbeddingsItemNet, SASRecModel\n", + "from rectools.models.bert4rec import BERT4RecModel\n", + "from rectools.visuals import MetricsApp\n", + "\n", + "# Enable deterministic behaviour with CUDA >= 10.2\n", + "os.environ[\"CUBLAS_WORKSPACE_CONFIG\"] = \":4096:8\"\n", + "warnings.simplefilter(\"ignore\", UserWarning)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Prepare data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are using KION dataset for this tutorial. The data was gathered from the users of MTS KION video streaming platform." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Archive: data_en.zip\n", + " inflating: data_en/items_en.csv \n", + " inflating: __MACOSX/data_en/._items_en.csv \n", + " inflating: data_en/interactions.csv \n", + " inflating: __MACOSX/data_en/._interactions.csv \n", + " inflating: data_en/users_en.csv \n", + " inflating: __MACOSX/data_en/._users_en.csv \n", + "CPU times: user 165 ms, sys: 73 ms, total: 238 ms\n", + "Wall time: 10.7 s\n" + ] + } + ], + "source": [ + "%%time\n", + "!wget -q https://github.com/irsafilo/KION_DATASET/raw/f69775be31fa5779907cf0a92ddedb70037fb5ae/data_en.zip -O data_en.zip\n", + "!unzip -o data_en.zip\n", + "!rm data_en.zip" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5476251, 5)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_iddatetimetotal_durwatched_pct
017654995062021-05-11425072.0
169931716592021-05-298317100.0
\n", + "
" + ], + "text/plain": [ + " user_id item_id datetime total_dur watched_pct\n", + "0 176549 9506 2021-05-11 4250 72.0\n", + "1 699317 1659 2021-05-29 8317 100.0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Download dataset\n", + "DATA_PATH = Path(\"data_en\")\n", + "items = pd.read_csv(DATA_PATH / 'items_en.csv', index_col=0)\n", + "interactions = (\n", + " pd.read_csv(DATA_PATH / 'interactions.csv', parse_dates=[\"last_watch_dt\"])\n", + " .rename(columns={\"last_watch_dt\": Columns.Datetime})\n", + ")\n", + "print(interactions.shape)\n", + "interactions.head(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5476251, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_iddatetimeweight
017654995062021-05-113
169931716592021-05-293
\n", + "
" + ], + "text/plain": [ + " user_id item_id datetime weight\n", + "0 176549 9506 2021-05-11 3\n", + "1 699317 1659 2021-05-29 3" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Process interactions\n", + "interactions[Columns.Weight] = np.where(interactions['watched_pct'] > 10, 3, 1)\n", + "interactions = interactions[[\"user_id\", \"item_id\", \"datetime\", \"weight\"]]\n", + "print(interactions.shape)\n", + "interactions.head(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(15963, 16)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
item_idcontent_typetitletitle_origrelease_yeargenrescountriesfor_kidsage_ratingstudiosdescriptionkeywordsactors_translatedactors_transliterateddirectors_translatedtransliterated
010711filmTalk to herHable con ella2002.0drama, foreign, detective, melodramaSpainNaN16.0NaNMarco, a journalist, interviews the famous Tor...Talk, her, 2002, Spain, friends, love, strong,...Adolfo Fernández, Ana Fernández, Dario Grandin...Adol'fo Fernandes, Ana Fernandes, Dario Grandi...Pedro AlmodovarPedro Al'modovar
12508filmNaked PeppersSearch Party2014.0foreign, adventure, comedyUSANaN16.0NaNThe main character has learned not to invite h...Naked, Peppers, 2014, USA, friends, weddings, ...Adam Palley, Brian Huskey, JB Smoove, Jason Ma...Adam Palli, Brajan Haski, Dzh.B. Smuv, Dzhejso...Scott ArmstrongSkot Armstrong
\n", + "
" + ], + "text/plain": [ + " item_id content_type title title_orig release_year \\\n", + "0 10711 film Talk to her Hable con ella 2002.0 \n", + "1 2508 film Naked Peppers Search Party 2014.0 \n", + "\n", + " genres countries for_kids age_rating \\\n", + "0 drama, foreign, detective, melodrama Spain NaN 16.0 \n", + "1 foreign, adventure, comedy USA NaN 16.0 \n", + "\n", + " studios description \\\n", + "0 NaN Marco, a journalist, interviews the famous Tor... \n", + "1 NaN The main character has learned not to invite h... \n", + "\n", + " keywords \\\n", + "0 Talk, her, 2002, Spain, friends, love, strong,... \n", + "1 Naked, Peppers, 2014, USA, friends, weddings, ... \n", + "\n", + " actors_translated \\\n", + "0 Adolfo Fernández, Ana Fernández, Dario Grandin... \n", + "1 Adam Palley, Brian Huskey, JB Smoove, Jason Ma... \n", + "\n", + " actors_transliterated directors_translated \\\n", + "0 Adol'fo Fernandes, Ana Fernandes, Dario Grandi... Pedro Almodovar \n", + "1 Adam Palli, Brajan Haski, Dzh.B. Smuv, Dzhejso... Scott Armstrong \n", + "\n", + " transliterated \n", + "0 Pedro Al'modovar \n", + "1 Skot Armstrong " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(items.shape)\n", + "items.head(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Process item features\n", + "items = items.loc[items[Columns.Item].isin(interactions[Columns.Item])].copy()\n", + "items[\"genre\"] = items[\"genres\"].str.lower().str.replace(\", \", \",\", regex=False).str.split(\",\")\n", + "genre_feature = items[[\"item_id\", \"genre\"]].explode(\"genre\")\n", + "genre_feature.columns = [\"id\", \"value\"]\n", + "genre_feature[\"feature\"] = \"genre\"\n", + "content_feature = items.reindex(columns=[Columns.Item, \"content_type\"])\n", + "content_feature.columns = [\"id\", \"value\"]\n", + "content_feature[\"feature\"] = \"content_type\"\n", + "item_features = pd.concat((genre_feature, content_feature))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idvaluefeature
010711dramagenre
010711foreigngenre
010711detectivegenre
010711melodramagenre
12508foreigngenre
\n", + "
" + ], + "text/plain": [ + " id value feature\n", + "0 10711 drama genre\n", + "0 10711 foreign genre\n", + "0 10711 detective genre\n", + "0 10711 melodrama genre\n", + "1 2508 foreign genre" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "item_features.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Create datasets\n", + "dataset_no_features = Dataset.construct(\n", + " interactions_df=interactions,\n", + ")\n", + "\n", + "dataset_item_features = Dataset.construct(\n", + " interactions_df=interactions,\n", + " item_features_df=item_features,\n", + " cat_item_features=[\"genre\", \"content_type\"],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(82, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_iddatetimeweight
017654995062021-05-113
3815176549154692021-05-253
\n", + "
" + ], + "text/plain": [ + " user_id item_id datetime weight\n", + "0 176549 9506 2021-05-11 3\n", + "3815 176549 15469 2021-05-25 3" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Prepare test user\n", + "test_user = [176549] \n", + "print(interactions[interactions[\"user_id\"] == test_user[0]].shape)\n", + "interactions[interactions[\"user_id\"] == test_user[0]].head(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Prepare test item\n", + "test_item = [13865]" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [], + "source": [ + "RANDOM_STATE=60\n", + "torch.use_deterministic_algorithms(True)\n", + "seed_everything(RANDOM_STATE, workers=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SASRec & BERT4Rec" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SASRec\n", + "SASRec is a transformer-based sequential model with unidirectional attention mechanism and \"Shifted Sequence\" training objective. \n", + "\n", + "As an input SASRec takes user sequences, containing previous user interaction history. Description of how they are created from user-item interactions can be found in the \"Detailed SASRec and BERT4Rec description\" part. Item embeddings from these sequences are fed to transformer blocks with multi-head self-attention and feedforward neural network as main components. After one or several stacked attention blocks, resulting user sequence latent representation is used to predict all items in the sequence. Each item prediction bases only on previous item information.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## BERT4Rec\n", + "BERT4Rec is a transformer-based sequential model with bi-directional attention mechanism and \"Item Masking\" training objective.\n", + "\n", + "As an input BERT4Rec receives user sequences, containing previous user interaction history. Description of how they are created from user-item interactions can be found in \"Detailed SASRec and BERT4Rec description\" part. Item embeddings from these sequences are fed to transformer blocks with multi-head self-attention and feedforward neural network as main components. After one or several stacked attention blocks, resulting user sequence latent representation is used to predict masked items." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Main Differences" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DifferenceDifference type SASRec BERT4Rec
TargetConceptualShiftes sequence targetItem masking target
AttentionConceptualUni-directionalBi-directioinal
Transformer block structureCan be modifiedCheck \"Detailed SASRec and BERT4Rec description\" to see block structureCheck \"Detailed SASRec and BERT4Rec description\" to see block structure
Activation functionCan be modifiedReLUGELU
LossCan be modifiedBCE with 1 negative per positiveSoftmax
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Following pictures provide more insights into attention difference:" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# RecTools implementation\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Losses SASRec BERT4Rec
Softmax loss++
BCE loss++
gBCE loss++
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Cusomization options SASRec BERT4Rec
Data preprocessing++
Item embeddings++
Positional encoding++
Transformer layers++
Model training++
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\\* customization options describe what parts of transformer model architecture can be changed by the user flexibly. For that user should inherit from the respective base class and pass a new class as a model parameter." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reference implementations \n", + "\n", + "1. BERT4Rec reference implementation: https://github.com/jaywonchung/BERT4Rec-VAE-Pytorch.git\n", + "2. In addition to original model losses implemented gBCE loss with uniform negative sampling and number of negatives as a hyper-parameter: https://github.com/asash/gSASRec-pytorch.git\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Application of Models\n", + "## Basic usage\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Specify maximum length of user-item interaction history with `session_max_len`\n", + "* Specify `loss` from \"softmax\", \"BCE\", \"gBCE\"\n", + "* Specify latent embeddings size with `n_factors`\n", + "* Specify number of self-attention blocks with `n_blocks` \n", + "* Specify number of attention heads with `n_heads`\n", + "* Specify `dropout_rate`\n", + "* Specify `lr` for learning rate \n", + "* Specify `batch_size`\n", + "* Specify `dataloader_num_workers`\n", + "* Specify `cpu_n_threads`\n", + "* Specify `verbose`\n", + "* Specify `epochs` for number of model training epochs\n", + "\n", + "Parameter specific for BERT4Rec:\n", + "* Specify probability of a sequence item to be masked `mask_prob` " + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "sasrec_non_default_model = SASRecModel(\n", + " n_factors=128, \n", + " n_blocks=2,\n", + " n_heads=1,\n", + " dropout_rate=0.2,\n", + " use_pos_emb=True,\n", + " session_max_len=32,\n", + " lr=1e-3,\n", + " batch_size=128,\n", + " epochs=5,\n", + " loss=\"softmax\",\n", + " verbose=1,\n", + " deterministic=True,\n", + " item_net_block_types=(IdEmbeddingsItemNet, ) # Use only item ids in ItemNetBlock\n", + ")\n", + "\n", + "bert4rec_id_softmax_model = BERT4RecModel(\n", + " mask_prob=0.5,\n", + " item_net_block_types=(IdEmbeddingsItemNet, ),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "sasrec_non_default_model.fit(dataset_no_features)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2e51ab8594f84081b26aef23f32b240d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Predicting: | | 0/? [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_idscoreranktitle_orig
0176549129652.7108801Cars 3
1176549117492.5490642Incredibles 2
217654973102.4956753Despicable Me 2
\n", + "" + ], + "text/plain": [ + " user_id item_id score rank title_orig\n", + "0 176549 12965 2.710880 1 Cars 3\n", + "1 176549 11749 2.549064 2 Incredibles 2\n", + "2 176549 7310 2.495675 3 Despicable Me 2" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "recos = sasrec_non_default_model.recommend(\n", + " users=test_user, \n", + " dataset=dataset_no_features,\n", + " k=3,\n", + " filter_viewed=True,\n", + " on_unsupported_targets=\"warn\"\n", + ")\n", + "recos.merge(items[[\"item_id\", \"title_orig\"]], on=\"item_id\").sort_values([\"user_id\", \"rank\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adding item features to models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Categorical features:\n", + "\n", + "For each pair of feature and feature value categorical feature embedding is created. Categorical feature embeddings are summed up with other embeddings for each item if they are present in the model.\n", + "\n", + "Numerical features:\n", + "\n", + "Are not supported.\n", + "\n", + "\n", + "To add item features it is necessary to pass them to RecTools dataset and add CatFeaturesItemNet to item_net_block_types. Any combination of IdEmbeddingsItemNet and CatFeaturesItemNet is applicable." + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [], + "source": [ + "sasrec_id_softmax_model = SASRecModel(\n", + " item_net_block_types=(IdEmbeddingsItemNet,) # Use item ids and cat features in ItemNetBlock\n", + ")\n", + "sasrec_id_cat_softmax_model = SASRecModel(\n", + " item_net_block_types=(IdEmbeddingsItemNet, CatFeaturesItemNet) # Use item ids and cat features in ItemNetBlock\n", + ")\n", + "sasrec_cat_softmax_model = SASRecModel(\n", + " item_net_block_types=(CatFeaturesItemNet, ) # Use only cat item features in ItemNetBlock\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Selecting losses " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "RecTools supports 3 losses:\n", + "\n", + "1. Softmax: requires no additional parameters\n", + "2. BCE: user can specify number of negatives to be sampled\n", + "3. gBCE: user can specify number of negatives to be sampled and calibration hyperparameter" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "softmax_model_example = SASRecModel(\n", + " loss=\"softmax\",\n", + ")\n", + "sascrec_id_cat_bce_model = SASRecModel(\n", + " loss=\"BCE\",\n", + " n_negatives=15,\n", + ")\n", + "sasrec_id_cat_gbce_model = SASRecModel(\n", + " loss=\"gBCE\",\n", + " n_negatives=15,\n", + " gbce_t=0.2,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Customizing model " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Specify minimum number of user interactions in train dataset with `train_min_user_interaction`\n", + "* Specify whether positional encoding should be used with `use_pos_emb`\n", + "* Specify lightning trainer with `trainer`\n", + "\n", + "For custom classes: inherit from base class and pass custom class as model parameter\n", + "* Specify `item_net_block_types` for Item Net blocks from (IdEmbeddingsItemNet, CatFeaturesItemNet), (IdEmbeddingsItemNet,), (, CatFeaturesItemNet) or custom embedding network. Inherit from `ItemNetBase`\n", + "* Specify `pos_encoding_type` for custom positional encoding logic. Inherit from `PositionalEncodingBase`\n", + "* Specify `transformer_layers_type` for custom transformer layers logic. Inherit from `TransformerLayersBase`\n", + "* Specify `data_preparator_type` for custom data processing logic. Inherit from `SessionEncoderDataPreparatorBase`\n", + "* Specify `lightning_module_type` for custom training logic. Inherit from `SessionEncoderLightningModuleBase`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cross-validation" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Use last week to validate model. Number of folds is set to 1 to speed up training\n", + "splitter = TimeRangeSplitter(\n", + " test_size=\"7D\",\n", + " n_splits=1,\n", + " filter_already_seen=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "# Add PopularModel and EASEModel to compare performance of transformer models\n", + "models = {\n", + " \"popular\": PopularModel(),\n", + " \"ease\": EASEModel(),\n", + " \"sasrec_non_default\": sasrec_non_default_model,\n", + " \"sasrec_id_softmax\": sasrec_id_softmax_model,\n", + " \"sasrec_cat_softmax\": sasrec_cat_softmax_model,\n", + " \"sasrec_id_cat_softmax\": sasrec_id_cat_softmax_model,\n", + " \"sascrec_id_cat_bce\": sascrec_id_cat_bce_model,\n", + " \"sasrec_id_cat_gbce\": sasrec_id_cat_gbce_model,\n", + " \"bert4rec_id_softmax\": bert4rec_id_softmax_model,\n", + "}\n", + "\n", + "metrics = {\n", + " \"HitRate@10\": HitRate(k=10),\n", + " \"MAP@10\": MAP(k=10),\n", + " \"Serendipity@10\": Serendipity(k=10),\n", + " \"CoveredUsers@10\": CoveredUsers(k=10),\n", + " \"AvgRecPopularity@10\": AvgRecPopularity(k=10),\n", + " \"Intersection@10\": Intersection(k=10),\n", + "}\n", + "\n", + "K_RECS = 10\n" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "# %%time\n", + "\n", + "# For each fold generate train and test part of dataset\n", + "# Then fit every model, generate recommendations and calculate metrics\n", + "\n", + "cv_results = cross_validate(\n", + " dataset=dataset_item_features,\n", + " splitter=splitter,\n", + " models=models,\n", + " metrics=metrics,\n", + " k=K_RECS,\n", + " filter_viewed=True,\n", + " ref_models=[\"popular\"],\n", + " validate_ref_models=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
HitRate@10MAP@10AvgRecPopularity@10Serendipity@10Intersection@10_popularCoveredUsers@10
model
ease0.1528490.0272149707.9858210.0002700.0813841.000000
popular0.2743650.08011482236.7617830.0000021.0000001.000000
sasrec_non_default0.3573890.10204656647.3355310.0002250.4636710.999982
sasrec_id_softmax0.3415640.09704859422.4514010.0001430.5083180.999982
sasrec_cat_softmax0.0374470.0068985458.8983100.0000400.0209050.999982
sasrec_id_cat_softmax0.3537560.10096160493.7085990.0001860.5190290.999982
sascrec_id_cat_bce0.3417180.09581863397.9758010.0001080.5321420.999982
sasrec_id_cat_gbce0.3175710.08902267626.8685890.0000640.5861530.999982
bert4rec_id_softmax0.3092680.08409964674.0310900.0000500.6025240.999982
\n", + "
" + ], + "text/plain": [ + " HitRate@10 MAP@10 AvgRecPopularity@10 \\\n", + "model \n", + "ease 0.152849 0.027214 9707.985821 \n", + "popular 0.274365 0.080114 82236.761783 \n", + "sasrec_non_default 0.357389 0.102046 56647.335531 \n", + "sasrec_id_softmax 0.341564 0.097048 59422.451401 \n", + "sasrec_cat_softmax 0.037447 0.006898 5458.898310 \n", + "sasrec_id_cat_softmax 0.353756 0.100961 60493.708599 \n", + "sascrec_id_cat_bce 0.341718 0.095818 63397.975801 \n", + "sasrec_id_cat_gbce 0.317571 0.089022 67626.868589 \n", + "bert4rec_id_softmax 0.309268 0.084099 64674.031090 \n", + "\n", + " Serendipity@10 Intersection@10_popular \\\n", + "model \n", + "ease 0.000270 0.081384 \n", + "popular 0.000002 1.000000 \n", + "sasrec_non_default 0.000225 0.463671 \n", + "sasrec_id_softmax 0.000143 0.508318 \n", + "sasrec_cat_softmax 0.000040 0.020905 \n", + "sasrec_id_cat_softmax 0.000186 0.519029 \n", + "sascrec_id_cat_bce 0.000108 0.532142 \n", + "sasrec_id_cat_gbce 0.000064 0.586153 \n", + "bert4rec_id_softmax 0.000050 0.602524 \n", + "\n", + " CoveredUsers@10 \n", + "model \n", + "ease 1.000000 \n", + "popular 1.000000 \n", + "sasrec_non_default 0.999982 \n", + "sasrec_id_softmax 0.999982 \n", + "sasrec_cat_softmax 0.999982 \n", + "sasrec_id_cat_softmax 0.999982 \n", + "sascrec_id_cat_bce 0.999982 \n", + "sasrec_id_cat_gbce 0.999982 \n", + "bert4rec_id_softmax 0.999982 " + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pivot_results = (\n", + " pd.DataFrame(cv_results[\"metrics\"])\n", + " .drop(columns=\"i_split\")\n", + " .groupby([\"model\"], sort=False)\n", + " .agg([\"mean\"])\n", + ")\n", + "pivot_results.columns = pivot_results.columns.droplevel(1)\n", + "pivot_results" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d1d2c4a1fd7444fdb72f84caf29bde6a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Tab(children=(VBox(children=(HBox(children=(Dropdown(description='Metric X:', options=('MAP@10'…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_metrics = [{\"model\": cv_results_dict[\"model\"], \"MAP@10\": cv_results_dict[\"MAP@10\"], \"Serendipity@10\": cv_results_dict[\"Serendipity@10\"]} \n", + " for cv_results_dict in cv_results[\"metrics\"]]\n", + "app = MetricsApp.construct(\n", + " models_metrics=pd.DataFrame(plot_metrics),\n", + ")\n", + "fig = app.fig\n", + "fig.update_layout(title=\"Cross-validation results\")\n", + "fig.show(\"png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Item-to-item recommendations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "i2i recommendations are generated in the following way:\n", + "1. Get item embeddings received after the train stage\n", + "2. Calculate cosine similarity of item embedding with other item embeddings\n", + "3. Return k most similar items" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6501 Devyataev\n", + "Name: title, dtype: object" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "items[items['item_id'] == test_item[0]][\"title\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.65 s, sys: 2.7 s, total: 4.36 s\n", + "Wall time: 1.92 s\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
target_item_iditem_idscoreranktitle_orig
01386526570.7435361Podslushano
11386537340.7157532Prababushka lyogkogo povedeniya
21386575710.7126223100% Wolf
\n", + "
" + ], + "text/plain": [ + " target_item_id item_id score rank title_orig\n", + "0 13865 2657 0.743536 1 Podslushano\n", + "1 13865 3734 0.715753 2 Prababushka lyogkogo povedeniya\n", + "2 13865 7571 0.712622 3 100% Wolf" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "recos = sasrec_non_default_model.recommend_to_items(\n", + " target_items=test_item, \n", + " dataset=dataset_no_features,\n", + " k=3,\n", + " filter_itself=True,\n", + " items_to_recommend=None,\n", + ")\n", + "recos.merge(items[[\"item_id\", \"title_orig\"]], on=\"item_id\").sort_values([\"item_id\", \"rank\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inference tricks (model known items and inference for cold users)\n", + "It may happen that SASRec or BERT4Rec filters out users with less than `train_min_user_interaction` interactions during the train stage. However, it is still possible to make recommendations for users with one interaction in history if this interaction item was present at training.\n", + "\n", + "As an example consider user 324373, for whom there is only one interaction in the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_iddatetimeweight
2493287324373104402021-06-243
\n", + "
" + ], + "text/plain": [ + " user_id item_id datetime weight\n", + "2493287 324373 10440 2021-06-24 3" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Prepare test user with 1 interaction\n", + "test_user_recs = [324373] \n", + "print(interactions[interactions[\"user_id\"] == test_user_recs[0]].shape)\n", + "interactions[interactions[\"user_id\"] == test_user_recs[0]]" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b83c10e20f6f42a7b197c1ae84cd35fa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Predicting: | | 0/? [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_idscoreranktitle_orig
0324373152975.6961261Klinika schast'ya
132437397284.1986522Wrath of Man
2324373138654.1489873V2. Escape from Hell
\n", + "" + ], + "text/plain": [ + " user_id item_id score rank title_orig\n", + "0 324373 15297 5.696126 1 Klinika schast'ya\n", + "1 324373 9728 4.198652 2 Wrath of Man\n", + "2 324373 13865 4.148987 3 V2. Escape from Hell" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "recos = sasrec_non_default_model.recommend(\n", + " users=test_user_recs, \n", + " dataset=dataset_item_features,\n", + " k=3,\n", + " filter_viewed=True,\n", + " on_unsupported_targets=\"warn\"\n", + ")\n", + "recos.merge(items[[\"item_id\", \"title_orig\"]], on=\"item_id\").sort_values([\"user_id\", \"rank\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another case is when user had interactions, but all of the items were not present at the train stage. This may happen due to several reasons:\n", + "* Other users with this item were excluded due to lack of interactions\n", + "* User sequence exceeded `session_max_len` and was shortened \n", + "\n", + "If a user does not have interactions containing items, which model knows, this user will not get recommendations." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_iditem_iddatetimeweight
23938771463088712021-03-283
\n", + "
" + ], + "text/plain": [ + " user_id item_id datetime weight\n", + "2393877 14630 8871 2021-03-28 3" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Prepare test user with items unknown by the model\n", + "test_user_no_recs = [14630] \n", + "print(interactions[interactions[\"user_id\"] == test_user_no_recs[0]].shape)\n", + "interactions[interactions[\"user_id\"] == test_user_no_recs[0]].head(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Flag `on_unsupported_target` allows to monitor the number of users without any known items.\n", + "\n", + "Flag options:\n", + "* \"ignore\" - skip such users, show warning with the number of cold users.\n", + "* \"warn\" - skip such users, show warning with the number of cold users and that cold users are not supported.\n", + "* \"raise\" - stop recommendation procedure." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 87.2 ms, sys: 629 µs, total: 87.9 ms\n", + "Wall time: 87 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:858: UserWarning: 1 target users were considered cold because of missing known items\n", + " warnings.warn(explanation)\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", + " Model `` doesn't support recommendations for cold users,\n", + " but some of given users are cold: they are not in the `dataset.user_id_map`\n", + " \n", + " warnings.warn(explanation)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_idscorerankitem_idtitle_orig
\n", + "
" + ], + "text/plain": [ + "Empty DataFrame\n", + "Columns: [user_id, score, rank, item_id, title_orig]\n", + "Index: []" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "recos = sasrec_non_default_model.recommend(\n", + " users=test_user_no_recs, \n", + " dataset=dataset_no_features,\n", + " k=3,\n", + " filter_viewed=True,\n", + " on_unsupported_targets=\"warn\"\n", + ")\n", + "recos.merge(items[[\"item_id\", \"title_orig\"]], on=\"item_id\").sort_values([\"user_id\", \"rank\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Detailed SASRec and BERT4Rec description\n", + "## Dataset processing\n", + "\n", + "Preprocessing steps will be shown using toy dataset:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_id item_id weight datetime
u1i10.12021-09-09
u2i10.32021-09-09
u2i30.22021-09-05
u1i20.32021-09-07
u3i20.42021-09-05
u1i30.52021-09-08
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Filter out users with less than `train_min_user_interactions` interactions in the train dataset. \n", + " * SASRec: the model uses shifted user interactions to make next item prediction, thus, at least 2 items should be in the history (`train_min_user_interactions` > 1). \n", + " * BERT4Rec: the model bases on masked language modelling, thus, at least 1 item should be in the history.\n", + "2. Leave `session_maxlen` most recent interactions for each user.\n", + "\n", + "After the first 2 steps, some users and/or items may be filtered out from the train dataset. However, as it will be shown further, it is still possible to make recommendations for a previously unmet user, if interaction is known.\n", + "\n", + "3. Create user sessions: for each user specify items with which there was an interaction in the order from earliest to most recent. Sessions for example dataset are the following:\n", + "$$S^1 = (i2, i3, i1)$$\n", + "$$S^2 = (i3, i1)$$\n", + "\n", + "4. Before the train stage each session is divided into train and target. \n", + " * SASRec: as the task is to predict the next item, the shifted sequence is considered as the target.\n", + " $$S^1_{train} = (i2, i3), S^1_{target} = (i3, i1)$$\n", + " $$S^2_{train} = (i3), S^2_{target} = (i1)$$\n", + " * BERT4Rec: as the task is masked session modelling, following rules are applied:\n", + " \n", + " ```Text\n", + " For each item in the user session generate probability p \n", + " If p < mask_prob: \n", + " p = p / mask_prob\n", + " if p < 0.8:\n", + " replace item with MASK\n", + " if p > 0.8 and p < 0.9:\n", + " replace item with another random item\n", + " If p > mask_prob:\n", + " Replace target for this item with PAD. We will not predict this element\n", + " ```\n", + "\n", + " For our dataset an example of resulting train and target will be:\n", + " $$S^1_{train} = (i2, MASK, i1), S^1_{target} = (i2, i3, PAD)$$\n", + " $$S^2_{train} = (i2, i1), S^2_{target} = (i3, i1)$$\n", + "\n", + " Session used for BERT4Rec is one element longer than the session for SASRec.\n", + "\n", + "5. Both train and target sequences are adjusted to take into account user-defined `session_maxlen`:\n", + " * SASRec:\n", + " * If session is longer than `session_maxlen`, cut earliest items\n", + " * If session is shorter than `session_maxlen`, pad earliest items with PAD element\n", + " $$S^1_{train} = (PAD, PAD, PAD, i2, i3), S^1_{target} = (PAD, PAD, PAD, i3, i1)$$\n", + " $$S^2_{train} = (PAD, PAD, PAD, PAD, i3), S^2_{target} = (PAD, PAD, PAD, PAD, i1)$$\n", + " * BERT4Rec:\n", + " * If session is longer than `session_maxlen + 1`, cut earliest items\n", + " * If session is shorter than `session_maxlen + 1`, pad earliest items with PAD element\n", + "$$S^1_{train} = (PAD, PAD, PAD, i2, MASK, i1), S^1_{target} = (PAD, PAD, PAD, i2, i3, PAD)$$\n", + "$$S^2_{train} = (PAD, PAD, PAD, PAD, i2, i1), S^2_{target} = (PAD, PAD, PAD, PAD, i3, i1)$$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Transformer layers\n", + "### SASRec" + ] + }, + { + "attachments": { + "image-2.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image-2.png](attachment:image-2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In contrast to BERT4Rec, SASRec is a causal model. It applies causal mask to enforce model focus solely on past interactions.\n", + "\n", + "Uni-directional attention is implemented using a causal mask, which prevents model looking in the future." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### BERT4Rec" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Bi-directional attention. In attention only padding mask is used, which masks padding elements not to allow them affect the results." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Additional details\n", + "1. Xavier normal initialization for model parameters\n", + "2. Adam optimizer with betas=(0.9, 0.98)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Losses\n", + "### Softmax loss\n", + "Softmax loss is a Cross Entropy loss calculated over the full catalog of items. As softmax loss finds probability distribution across all items, it returns the most precise results, however, for large catalogs such calculations are prohibitively inefficient. \n", + "\n", + "RecTools implementation uses `torch.nn.CrossEntropyLoss` with 'none' reduction\n", + "$$L = \\{l_1, l_2, ..., l_N\\}^T$$ \n", + "$$l_n = -w_{y_n} log \\frac{exp(x_{n,y_n})}{\\sum_{c=1}^Cexp(x_{n,c})} \\cdot I\\{y_n \\neq \\text{ignore index}\\}$$\n", + "After that 'sum' reduction is applied, excluding padding elements.\n", + "## Losses with negative sampling\n", + "Losses with negative sampling are needed to deal with the problem of computational inefficiency inherent to usage of full catalog. For that n negative items per positive are sampled and used for calculations.\n", + "\n", + "RecTools implementation samples negatives uniformly from training dataset.\n", + "### BCE loss\n", + "Binary Cross Entropy loss aims to improve computational efficiency by using a few sampled negatives instead of the full catalog for calculations. The problem is that in most cases performance degrades.\n", + "\n", + "Logits $(x_n)$ - concat positive and negative logits.\n", + "\n", + "Target $(y_n)$ - positive samples are marked as 1, negative as 0.\n", + "\n", + "RecTools implementation uses `torch.nn.BCEWithLogitsLoss` with 'none' reduction\n", + "$$L = \\{l_1, l_2, ..., l_N\\}^T$$ \n", + "$$l_n = -w_{y_n} [y_n log\\sigma (x_n) + (1 - y_n) log(1 - \\sigma (x_n))]$$\n", + "After that 'sum' reduction is applied, excluding padding elements.\n", + "\n", + "### gBCE loss\n", + "Models trained with negative sampling (BCE loss) tend to overestimate probabilities of positive interactions. To mitigate this effect gBCE loss can be used, which is actually BCE loss applied to transformed logits. It combines efficiency of BCE loss with better performance results.\n", + "\n", + "Logit transformation is applied to positive logits only, negative logits remain unchanged:\n", + "\n", + "$$ \\text{transformed positive logits} = log(\\frac{1}{\\sigma^{-\\beta}(s^+) - 1})$$\n", + "$$\\beta = \\alpha(t(1-\\frac{1}{\\alpha}) + \\frac{1}{\\alpha})$$\n", + "$$\\alpha = \\frac{1}{\\text{number of unique items} - 1}$$\n", + "$$t - \\text{calibration hyperparameter}$$\n", + "\n", + "After that BCE loss is applied to concatenation of transformed positive logits and negative logits." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Links\n", + "1. Transformers: [Attention Is All You Need](https://arxiv.org/abs/1706.03762)\n", + "\n", + "### SASRec\n", + "1. SASRec original paper: [Self-Attentive Sequential Recommendation](https://arxiv.org/abs/1808.09781)\n", + "2. [Turning Dross Into Gold Loss: is BERT4Rec really better than SASRec?](https://arxiv.org/abs/2309.07602)\n", + "3. [gSASRec: Reducing Overconfidence in Sequential Recommendation Trained with Negative Sampling](https://arxiv.org/pdf/2308.07192)\n", + "\n", + "### BERT4Rec\n", + "1. BERT4Rec original paper: [BERT4Rec: Sequential Recommendation with Bidirectional Encoder Representations from Transformer](https://arxiv.org/abs/1904.06690)\n", + "2. Comparison of BERT4Rec implementations: [A Systematic Review and Replicability Study of BERT4Rec for\n", + "Sequential Recommendation](https://arxiv.org/abs/2207.07483)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tests/models/test_serialization.py b/tests/models/test_serialization.py index 66786540..2ca9e79d 100644 --- a/tests/models/test_serialization.py +++ b/tests/models/test_serialization.py @@ -26,11 +26,12 @@ model_from_config, ) from rectools.models.base import ModelBase, ModelConfig +from rectools.models.sasrec import SASRecModel, TransformerModelBase from rectools.models.vector import VectorModel from .utils import get_successors -INTERMEDIATE_MODEL_CLASSES = (VectorModel,) +INTERMEDIATE_MODEL_CLASSES = (VectorModel, TransformerModelBase) EXPOSABLE_MODEL_CLASSES = tuple( cls @@ -41,7 +42,15 @@ and not (sys.version_info >= (3, 12) and cls is LightFMWrapperModel) ) ) -CONFIGURABLE_MODEL_CLASSES = tuple(cls for cls in EXPOSABLE_MODEL_CLASSES if cls not in (DSSMModel,)) +CONFIGURABLE_MODEL_CLASSES = tuple( + cls + for cls in EXPOSABLE_MODEL_CLASSES + if cls + not in ( + DSSMModel, + SASRecModel, + ) +) def init_default_model(model_cls: tp.Type[ModelBase]) -> ModelBase: From 4a5f6492f3cf3d8bbfd96797ceed7799dfbd06a9 Mon Sep 17 00:00:00 2001 From: spirinamayya <90619187+spirinamayya@users.noreply.github.com> Date: Tue, 10 Dec 2024 16:41:49 +0300 Subject: [PATCH 12/13] Device in transformer model recommend (#216) Added recommend ranking kwargs and recommend device --- examples/bert4rec.ipynb | 106 ++--- examples/sasrec_metrics_comp.ipynb | 607 +++++++++++++++++++++++------ rectools/models/bert4rec.py | 11 +- rectools/models/sasrec.py | 110 +++++- 4 files changed, 655 insertions(+), 179 deletions(-) diff --git a/examples/bert4rec.ipynb b/examples/bert4rec.ipynb index f30e17a8..9c6c197f 100644 --- a/examples/bert4rec.ipynb +++ b/examples/bert4rec.ipynb @@ -30,7 +30,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -65,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -79,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -114,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -123,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -147,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -164,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -193,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -209,7 +209,7 @@ "32" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -229,7 +229,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -261,7 +261,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -284,7 +284,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "031d93173b9b455a8b7e04e4933e13c9", + "model_id": "aff9789fb75b422d87b6c43bf651d637", "version_major": 2, "version_minor": 0 }, @@ -306,17 +306,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 8min 28s, sys: 15.6 s, total: 8min 44s\n", - "Wall time: 8min 26s\n" + "CPU times: user 6min 44s, sys: 11 s, total: 6min 55s\n", + "Wall time: 6min 44s\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -328,28 +328,32 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:786: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:858: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", " but some of given users are cold: they are not in the `dataset.user_id_map`\n", " \n", " warnings.warn(explanation)\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "GPU available: True (cuda), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/setup.py:187: GPU available but not used. You can set it by doing `Trainer(accelerator='gpu')`.\n", "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cdbad90214f24244a0505fbe3955c0d4", + "model_id": "a639607c60314282bb187188596ac96e", "version_major": 2, "version_minor": 0 }, @@ -364,7 +368,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 35.2 s, sys: 7.64 s, total: 42.9 s\n", + "CPU times: user 15min 22s, sys: 22 s, total: 15min 44s\n", "Wall time: 30.7 s\n" ] } @@ -382,12 +386,10 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", - "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", "metric_values = calc_metrics(metrics, recos[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", "metric_values[\"model\"] = \"bert4rec_ids\"\n", "features_results.append(metric_values)" @@ -395,7 +397,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -444,7 +446,7 @@ " 2\n", " 73446\n", " 3784\n", - " 0.618742\n", + " 0.618743\n", " 3\n", " \n", " \n", @@ -458,7 +460,7 @@ " 4\n", " 73446\n", " 12192\n", - " 0.298388\n", + " 0.298389\n", " 5\n", " \n", " \n", @@ -479,14 +481,14 @@ " 947046\n", " 857162\n", " 4151\n", - " 1.258312\n", + " 1.258313\n", " 7\n", " \n", " \n", " 947047\n", " 857162\n", " 8636\n", - " 1.227238\n", + " 1.227239\n", " 8\n", " \n", " \n", @@ -509,23 +511,23 @@ "" ], "text/plain": [ - " user_id item_id score rank\n", - "0 73446 7793 0.971350 1\n", - "1 73446 7829 0.933867 2\n", - "2 73446 3784 0.618742 3\n", - "3 73446 9728 0.608745 4\n", - "4 73446 12192 0.298388 5\n", - "... ... ... ... ...\n", - "947045 857162 3734 1.407501 6\n", - "947046 857162 4151 1.258312 7\n", - "947047 857162 8636 1.227238 8\n", - "947048 857162 1844 1.109976 9\n", - "947049 857162 4436 0.998295 10\n", + " user_id item_id score rank\n", + "0 73446 7793 0.971350 1\n", + "1 73446 7829 0.933867 2\n", + "2 73446 3784 0.618743 3\n", + "3 73446 9728 0.608745 4\n", + "4 73446 12192 0.298389 5\n", + "... ... ... ... ...\n", + "947045 857162 3734 1.407501 6\n", + "947046 857162 4151 1.258313 7\n", + "947047 857162 8636 1.227239 8\n", + "947048 857162 1844 1.109976 9\n", + "947049 857162 4436 0.998295 10\n", "\n", "[947050 rows x 4 columns]" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -536,25 +538,25 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[{'MAP@1': 0.0457901198911608,\n", - " 'MAP@5': 0.07710723775026486,\n", - " 'MAP@10': 0.08559323634049909,\n", - " 'MIUF@1': 18.824620072061013,\n", - " 'MIUF@5': 18.824620072061013,\n", - " 'MIUF@10': 18.824620072061013,\n", - " 'Serendipity@1': 0.09274061559579748,\n", - " 'Serendipity@5': 0.056047439499790956,\n", - " 'Serendipity@10': 0.04129842262611581,\n", + " 'MAP@5': 0.07710782436718641,\n", + " 'MAP@10': 0.08559382295742064,\n", + " 'MIUF@1': 3.924831787761523,\n", + " 'MIUF@5': 4.503372187712272,\n", + " 'MIUF@10': 5.001266772685893,\n", + " 'Serendipity@1': 0.0006002121552552989,\n", + " 'Serendipity@5': 0.0005105148686080263,\n", + " 'Serendipity@10': 0.000480783695136143,\n", " 'model': 'bert4rec_ids'}]" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } diff --git a/examples/sasrec_metrics_comp.ipynb b/examples/sasrec_metrics_comp.ipynb index 693760c4..5c3ae15d 100644 --- a/examples/sasrec_metrics_comp.ipynb +++ b/examples/sasrec_metrics_comp.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -128,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -152,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -169,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -198,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -214,7 +214,7 @@ "32" ] }, - "execution_count": 33, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -234,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -257,13 +257,14 @@ " epochs=5,\n", " verbose=1,\n", " deterministic=True,\n", - " item_net_block_types=(IdEmbeddingsItemNet, ) # Use only item ids in ItemNetBlock\n", + " item_net_block_types=(IdEmbeddingsItemNet, ), # Use only item ids in ItemNetBlock\n", + " recommend_device=\"cuda\",\n", ")\n" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -286,7 +287,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4ae70ba676fa4f41b5153c137e3364cb", + "model_id": "d491541cc2584aa4882242b7271a20b1", "version_major": 2, "version_minor": 0 }, @@ -308,17 +309,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 6min 36s, sys: 9.8 s, total: 6min 46s\n", - "Wall time: 6min 25s\n" + "CPU times: user 5min 17s, sys: 8.24 s, total: 5min 26s\n", + "Wall time: 5min 16s\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 35, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -330,20 +331,24 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:790: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:858: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", " but some of given users are cold: they are not in the `dataset.user_id_map`\n", " \n", " warnings.warn(explanation)\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] @@ -351,7 +356,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "12e7dd5ca3cb464ebb9d8baa4dd8e061", + "model_id": "4d6f1ff9c86e48c8b4f59cf9429a9555", "version_major": 2, "version_minor": 0 }, @@ -366,8 +371,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 30.3 s, sys: 3.45 s, total: 33.8 s\n", - "Wall time: 24.3 s\n" + "CPU times: user 27.9 s, sys: 4.57 s, total: 32.4 s\n", + "Wall time: 22.2 s\n" ] } ], @@ -384,17 +389,44 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", - "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", "metric_values = calc_metrics(metrics, recos[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", "metric_values[\"model\"] = \"softmax\"\n", "features_results.append(metric_values)\n" ] }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'MAP@1': 0.04896729054820606,\n", + " 'MAP@5': 0.08284725776567772,\n", + " 'MAP@10': 0.09202214080523476,\n", + " 'MIUF@1': 3.6266752335962402,\n", + " 'MIUF@5': 4.305321882464318,\n", + " 'MIUF@10': 4.9095189017166145,\n", + " 'Serendipity@1': 0.0009307664840571675,\n", + " 'Serendipity@5': 0.0007294075536337563,\n", + " 'Serendipity@10': 0.0006691606986540919,\n", + " 'model': 'softmax'}]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "features_results" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -404,7 +436,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -420,7 +452,7 @@ "32" ] }, - "execution_count": 40, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -433,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -463,7 +495,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -486,7 +518,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "026eb575d3ff4b61b3d6d141c72ae13d", + "model_id": "f5c9eeda0b1f454085ae6d53c1b66e86", "version_major": 2, "version_minor": 0 }, @@ -508,17 +540,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 6min 39s, sys: 11.4 s, total: 6min 50s\n", - "Wall time: 6min 36s\n" + "CPU times: user 5min 28s, sys: 7.82 s, total: 5min 36s\n", + "Wall time: 5min 26s\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 42, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -530,28 +562,38 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:790: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:858: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", " but some of given users are cold: they are not in the `dataset.user_id_map`\n", " \n", " warnings.warn(explanation)\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "GPU available: True (cuda), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/setup.py:187: GPU available but not used. You can set it by doing `Trainer(accelerator='gpu')`.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6489bb7e2f4c498f8fb72f295cf835cf", + "model_id": "9f8cbc9e072247acbede4bbc6c79490f", "version_major": 2, "version_minor": 0 }, @@ -566,8 +608,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 28.7 s, sys: 3.63 s, total: 32.3 s\n", - "Wall time: 22 s\n" + "CPU times: user 12min 30s, sys: 8.6 s, total: 12min 39s\n", + "Wall time: 28.5 s\n" ] } ], @@ -578,18 +620,16 @@ " dataset=dataset_no_features,\n", " k=10,\n", " filter_viewed=True,\n", - " on_unsupported_targets=\"warn\"\n", + " on_unsupported_targets=\"warn\",\n", ")" ] }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ - "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", - "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", "metric_values = calc_metrics(metrics, recos[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", "metric_values[\"model\"] = \"bce\"\n", "features_results.append(metric_values)" @@ -604,7 +644,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -620,7 +660,7 @@ "32" ] }, - "execution_count": 25, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -633,7 +673,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -665,7 +705,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -688,7 +728,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1ff49bfd02a740b4abf2b43eab16915f", + "model_id": "bc1f614b254b4bcdb4c434827c0c35aa", "version_major": 2, "version_minor": 0 }, @@ -710,17 +750,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 2h 26min 4s, sys: 39.6 s, total: 2h 26min 43s\n", - "Wall time: 10min 49s\n" + "CPU times: user 2h 3min 4s, sys: 43.9 s, total: 2h 3min 48s\n", + "Wall time: 10min 16s\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 27, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -732,28 +772,32 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:790: UserWarning: 91202 target users were considered cold because of missing known items\n", + "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/sasrec.py:858: UserWarning: 91202 target users were considered cold because of missing known items\n", " warnings.warn(explanation)\n", "/data/home/maspirina1/tasks/repo/RecTools/rectools/models/base.py:420: UserWarning: \n", " Model `` doesn't support recommendations for cold users,\n", " but some of given users are cold: they are not in the `dataset.user_id_map`\n", " \n", " warnings.warn(explanation)\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "GPU available: True (cuda), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/setup.py:187: GPU available but not used. You can set it by doing `Trainer(accelerator='gpu')`.\n", "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'predict_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "723345dda1cd4b9997ba226476a6dce3", + "model_id": "12441855fb5a42a6bacf38d3fb0d5e31", "version_major": 2, "version_minor": 0 }, @@ -768,8 +812,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 31.5 s, sys: 3.95 s, total: 35.5 s\n", - "Wall time: 26 s\n" + "CPU times: user 12min 9s, sys: 7.14 s, total: 12min 16s\n", + "Wall time: 27.1 s\n" ] } ], @@ -786,12 +830,10 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ - "recos[\"item_id\"] = recos[\"item_id\"].apply(str)\n", - "test[\"item_id\"] = test[\"item_id\"].astype(str)\n", "metric_values = calc_metrics(metrics, recos[[\"user_id\", \"item_id\", \"rank\"]], test, train, catalog)\n", "metric_values[\"model\"] = \"gBCE\"\n", "features_results.append(metric_values)" @@ -828,7 +870,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -881,36 +923,36 @@ " 0.048967\n", " 0.082847\n", " 0.092022\n", - " 18.82462\n", - " 18.82462\n", - " 18.82462\n", - " 0.100744\n", - " 0.060646\n", - " 0.044432\n", + " 3.626675\n", + " 4.305322\n", + " 4.909519\n", + " 0.000931\n", + " 0.000729\n", + " 0.000669\n", " \n", " \n", " gBCE\n", " 0.047546\n", " 0.081190\n", - " 0.089990\n", - " 18.82462\n", - " 18.82462\n", - " 18.82462\n", - " 0.096859\n", - " 0.059654\n", - " 0.043430\n", + " 0.089989\n", + " 3.389033\n", + " 3.982114\n", + " 4.670658\n", + " 0.000666\n", + " 0.000544\n", + " 0.000521\n", " \n", " \n", " bce\n", " 0.043528\n", " 0.074286\n", " 0.083131\n", - " 18.82462\n", - " 18.82462\n", - " 18.82462\n", - " 0.088359\n", - " 0.055013\n", - " 0.041208\n", + " 3.677649\n", + " 4.437024\n", + " 4.988751\n", + " 0.000480\n", + " 0.000509\n", + " 0.000531\n", " \n", " \n", "\n", @@ -919,18 +961,18 @@ "text/plain": [ " MAP@1 MAP@5 MAP@10 MIUF@1 MIUF@5 MIUF@10 \\\n", "model \n", - "softmax 0.048967 0.082847 0.092022 18.82462 18.82462 18.82462 \n", - "gBCE 0.047546 0.081190 0.089990 18.82462 18.82462 18.82462 \n", - "bce 0.043528 0.074286 0.083131 18.82462 18.82462 18.82462 \n", + "softmax 0.048967 0.082847 0.092022 3.626675 4.305322 4.909519 \n", + "gBCE 0.047546 0.081190 0.089989 3.389033 3.982114 4.670658 \n", + "bce 0.043528 0.074286 0.083131 3.677649 4.437024 4.988751 \n", "\n", " Serendipity@1 Serendipity@5 Serendipity@10 \n", "model \n", - "softmax 0.100744 0.060646 0.044432 \n", - "gBCE 0.096859 0.059654 0.043430 \n", - "bce 0.088359 0.055013 0.041208 " + "softmax 0.000931 0.000729 0.000669 \n", + "gBCE 0.000666 0.000544 0.000521 \n", + "bce 0.000480 0.000509 0.000531 " ] }, - "execution_count": 46, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1474,9 +1516,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n" + ] + } + ], "source": [ "model = SASRecModel(\n", " n_blocks=2,\n", @@ -1491,9 +1545,61 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "\n", + " | Name | Type | Params\n", + "---------------------------------------------------------------\n", + "0 | torch_model | TransformerBasedSessionEncoder | 207 K \n", + "---------------------------------------------------------------\n", + "207 K Trainable params\n", + "0 Non-trainable params\n", + "207 K Total params\n", + "0.829 Total estimated model params size (MB)\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=143` in the `DataLoader` to improve performance.\n", + "/data/home/maspirina1/tasks/repo/RecTools/.venv/lib/python3.8/site-packages/pytorch_lightning/loops/fit_loop.py:298: The number of training batches (29) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5101905ad624485aa68869de982bb604", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "#%%time\n", "model.fit(dataset_item_features)" @@ -1537,7 +1643,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -1546,14 +1652,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 586 ms, sys: 23.7 ms, total: 610 ms\n", + "Wall time: 54 ms\n" + ] + } + ], "source": [ "%%time\n", "recos = model.recommend_to_items(\n", " target_items=target_items, \n", - " dataset=dataset,\n", + " dataset=dataset_no_features,\n", " k=10,\n", " filter_itself=True,\n", " items_to_recommend=None, #white_list,\n", @@ -1562,9 +1677,290 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
target_item_iditem_idscorerank
013865103230.2977131
113865152970.2855852
2138651420.2564363
31386597280.2526094
413865104400.2369885
51386537340.2367246
61386541510.2290407
71386591690.2030178
81386544570.1982939
91386575710.19662810
10445714180.2852461
11445756930.2056192
12445799960.1999793
134457138650.1982934
1444571110.1902705
15445764430.1879326
16445786360.1812987
174457129950.1776628
184457117780.1770739
194457104400.17056710
201529741510.3863281
2115297129950.3212552
221529799960.2978653
2315297138650.2855854
241529737340.2372625
25152971420.2188756
261529726570.1954587
2715297147410.1928958
281529747400.1832729
2915297104400.18007310
\n", + "
" + ], + "text/plain": [ + " target_item_id item_id score rank\n", + "0 13865 10323 0.297713 1\n", + "1 13865 15297 0.285585 2\n", + "2 13865 142 0.256436 3\n", + "3 13865 9728 0.252609 4\n", + "4 13865 10440 0.236988 5\n", + "5 13865 3734 0.236724 6\n", + "6 13865 4151 0.229040 7\n", + "7 13865 9169 0.203017 8\n", + "8 13865 4457 0.198293 9\n", + "9 13865 7571 0.196628 10\n", + "10 4457 1418 0.285246 1\n", + "11 4457 5693 0.205619 2\n", + "12 4457 9996 0.199979 3\n", + "13 4457 13865 0.198293 4\n", + "14 4457 111 0.190270 5\n", + "15 4457 6443 0.187932 6\n", + "16 4457 8636 0.181298 7\n", + "17 4457 12995 0.177662 8\n", + "18 4457 11778 0.177073 9\n", + "19 4457 10440 0.170567 10\n", + "20 15297 4151 0.386328 1\n", + "21 15297 12995 0.321255 2\n", + "22 15297 9996 0.297865 3\n", + "23 15297 13865 0.285585 4\n", + "24 15297 3734 0.237262 5\n", + "25 15297 142 0.218875 6\n", + "26 15297 2657 0.195458 7\n", + "27 15297 14741 0.192895 8\n", + "28 15297 4740 0.183272 9\n", + "29 15297 10440 0.180073 10" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "recos" ] @@ -1574,14 +1970,7 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "features_df = (\n", - " pd.DataFrame(features_results)\n", - " .set_index(\"model\")\n", - " .sort_values(by=[\"MAP@10\", \"Serendipity@10\"], ascending=False)\n", - ")\n", - "features_df" - ] + "source": [] } ], "metadata": { diff --git a/rectools/models/bert4rec.py b/rectools/models/bert4rec.py index 6d9285a2..3e2335a4 100644 --- a/rectools/models/bert4rec.py +++ b/rectools/models/bert4rec.py @@ -1,9 +1,10 @@ import typing as tp -from typing import Dict, List, Tuple +from typing import Dict, List, Tuple, Union import numpy as np import torch from pytorch_lightning import Trainer +from pytorch_lightning.accelerators import Accelerator from torch import nn from rectools.models.sasrec import ( @@ -163,7 +164,9 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals epochs: int = 3, verbose: int = 0, deterministic: bool = False, - cpu_n_threads: int = 0, + recommend_device: Union[str, Accelerator] = "auto", + recommend_n_threads: int = 0, + recommend_use_gpu_ranking: bool = True, session_max_len: int = 32, n_negatives: int = 1, batch_size: int = 128, @@ -193,7 +196,9 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals epochs=epochs, verbose=verbose, deterministic=deterministic, - cpu_n_threads=cpu_n_threads, + recommend_device=recommend_device, + recommend_n_threads=recommend_n_threads, + recommend_use_gpu_ranking=recommend_use_gpu_ranking, loss=loss, gbce_t=gbce_t, lr=lr, diff --git a/rectools/models/sasrec.py b/rectools/models/sasrec.py index 4903ef57..6163f372 100644 --- a/rectools/models/sasrec.py +++ b/rectools/models/sasrec.py @@ -1,13 +1,15 @@ import typing as tp import warnings from copy import deepcopy -from typing import Dict, List, Tuple +from typing import Dict, List, Tuple, Union import numpy as np import pandas as pd import torch import typing_extensions as tpe +from implicit.gpu import HAS_CUDA from pytorch_lightning import LightningModule, Trainer +from pytorch_lightning.accelerators import Accelerator from scipy import sparse from torch import nn from torch.utils.data import DataLoader @@ -1101,7 +1103,7 @@ def predict_step(self, batch: Dict[str, torch.Tensor], batch_idx: int) -> torch. Prediction step. Encode user sessions. """ - encoded_sessions = self.torch_model.encode_sessions(batch["x"], self.item_embs)[:, -1, :] + encoded_sessions = self.torch_model.encode_sessions(batch["x"], self.item_embs.to(self.device))[:, -1, :] return encoded_sessions def _xavier_normal_init(self) -> None: @@ -1112,7 +1114,7 @@ def _xavier_normal_init(self) -> None: pass -class TransformerModelBase(ModelBase): +class TransformerModelBase(ModelBase): # pylint: disable=too-many-instance-attributes """ Base model for all recommender algorithms that work on transformer architecture (e.g. SASRec, Bert4Rec). To create a custom transformer model it is necessary to inherit from this class @@ -1137,14 +1139,18 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals epochs: int = 3, verbose: int = 0, deterministic: bool = False, - cpu_n_threads: int = 0, + recommend_device: Union[str, Accelerator] = "auto", + recommend_n_threads: int = 0, + recommend_use_gpu_ranking: bool = True, trainer: tp.Optional[Trainer] = None, item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]] = (IdEmbeddingsItemNet, CatFeaturesItemNet), pos_encoding_type: tp.Type[PositionalEncodingBase] = LearnableInversePositionalEncoding, lightning_module_type: tp.Type[SessionEncoderLightningModuleBase] = SessionEncoderLightningModule, ) -> None: super().__init__(verbose) - self.n_threads = cpu_n_threads + self.recommend_n_threads = recommend_n_threads + self.recommend_device = recommend_device + self.recommend_use_gpu_ranking = recommend_use_gpu_ranking self._torch_model = TransformerBasedSessionEncoder( n_blocks=n_blocks, n_factors=n_factors, @@ -1160,7 +1166,7 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals ) self.lightning_model: SessionEncoderLightningModuleBase self.lightning_module_type = lightning_module_type - self.trainer: Trainer + self.fit_trainer: Trainer if trainer is None: self._trainer = Trainer( max_epochs=epochs, @@ -1198,8 +1204,8 @@ def _fit( n_item_extra_tokens=n_item_extra_tokens, ) - self.trainer = deepcopy(self._trainer) - self.trainer.fit(self.lightning_model, train_dataloader) + self.fit_trainer = deepcopy(self._trainer) + self.fit_trainer.fit(self.lightning_model, train_dataloader) def _custom_transform_dataset_u2i( self, dataset: Dataset, users: ExternalIds, on_unsupported_targets: ErrorBehaviour @@ -1222,8 +1228,9 @@ def _recommend_u2i( if sorted_item_ids_to_recommend is None: # TODO: move to _get_sorted_item_ids_to_recommend sorted_item_ids_to_recommend = self.data_preparator.get_known_items_sorted_internal_ids() # model internal + recommend_trainer = Trainer(devices=1, accelerator=self.recommend_device) recommend_dataloader = self.data_preparator.get_dataloader_recommend(dataset) - session_embs = self.trainer.predict(model=self.lightning_model, dataloaders=recommend_dataloader) + session_embs = recommend_trainer.predict(model=self.lightning_model, dataloaders=recommend_dataloader) if session_embs is not None: user_embs = np.concatenate(session_embs, axis=0) user_embs = user_embs[user_ids] @@ -1242,13 +1249,13 @@ def _recommend_u2i( ui_csr_for_filter = None # TODO: When filter_viewed is not needed and user has GPU, torch DOT and topk should be faster - user_ids_indices, all_reco_ids, all_scores = ranker.rank( subject_ids=np.arange(user_embs.shape[0]), # n_rec_users k=k, filter_pairs_csr=ui_csr_for_filter, # [n_rec_users x n_items + n_item_extra_tokens] sorted_object_whitelist=sorted_item_ids_to_recommend, # model_internal - num_threads=self.n_threads, + num_threads=self.recommend_n_threads, + use_gpu=self.recommend_use_gpu_ranking and HAS_CUDA, ) all_target_ids = user_ids[user_ids_indices] else: @@ -1280,7 +1287,8 @@ def _recommend_i2i( k=k, filter_pairs_csr=None, sorted_object_whitelist=sorted_item_ids_to_recommend, # model internal - num_threads=0, + num_threads=self.recommend_n_threads, + use_gpu=self.recommend_use_gpu_ranking and HAS_CUDA, ) @property @@ -1293,7 +1301,75 @@ def torch_model(self) -> TransformerBasedSessionEncoder: class SASRecModel(TransformerModelBase): - """TODO""" + """ + SASRec model for i2i and u2i recommendations. + + n_blocks: int, default 1 + Number of transformer blocks. + n_heads: int, default 1 + Number of attention heads. + n_factors: int, default 128 + Latent embeddings size. + use_pos_emb: bool, default ``True`` + If ``True``, adds learnable positional encoding to session item embeddings. + use_causal_attn: bool, default ``True`` + If ``True``, uses causal mask as attn_mask in Multi-head Attention. + use_key_padding_mask: bool, default ``False`` + If ``True``, uses key_padding_mask in Multi-head Attention. + dropout_rate: float, default 0.2 + Probability of a hidden unit to be zeroed. + session_max_len: int, default 32 + Maximum length of user sequence. + train_min_user_interaction: int, default 2 + Minimum number of interactions user should have to be used for training. Should be greater than 1. + dataloader_num_workers: int, default 0 + Number of loader worker processes. + batch_size: int, default 128 + How many samples per batch to load. + loss: str, default "softmax" + Loss function. + n_negatives: int, default 1 + Number of negatives for BCE and gBCE losses. + gbce_t: float, default 0.2 + Calibration parameter for gBCE loss. + lr: float, default 0.01 + Learning rate. + epochs: int, default 3 + Number of training epochs. + verbose: int, default 0 + Verbosity level. + deterministic: bool, default ``False`` + If ``True``, sets deterministic algorithms for PyTorch operations. + Use `pytorch_lightning.seed_everything` together with this parameter to fix the random state. + recommend_device: Union[str, Accelerator], default "auto" + Device for recommend. Used at predict_step of lightning module. + If you want to change this parameter after model is initialized, + you can manually assign new value to model `recommend_device` attribute. + recommend_n_threads: int, default 0 + Number of threads to use in ranker. + If you want to change this parameter after model is initialized, + you can manually assign new value to model `recommend_n_threads` attribute. + recommend_use_gpu_ranking: bool, default ``True`` + If ``True`` and HAS_CUDA ``True``, sets use_gpu=True in ImplicitRanker.rank. + If you want to change this parameter after model is initialized, + you can manually assign new value to model `recommend_use_gpu_ranking` attribute. + trainer: Optional(Trainer), default None + Which trainer to use for training. + If trainer is None, default pytorch_lightning Trainer is created. + item_net_block_types: Type(ItemNetBase), default (IdEmbeddingsItemNet, CatFeaturesItemNet) + Type of network returning item enbeddings. + (IdEmbeddingsItemNet,) - item embeddings based on ids. + (, CatFeaturesItemNet) - item embeddings based on categorical features. + (IdEmbeddingsItemNet, CatFeaturesItemNet) - item embeddings based on ids and categorical features. + pos_encoding_type: Type(PositionalEncodingBase), default `LearnableInversePositionalEncoding` + Type of positional encoding. + transformer_layers_type: Type(TransformerLayersBase), default `SasRecTransformerLayers` + Type of transformer layers architecture. + data_preparator_type: Type(SessionEncoderDataPreparatorBase), default `SasRecDataPreparator` + Type of data preparator used for dataset processing and dataloader creation. + lightning_module_type: Type(SessionEncoderLightningModuleBase), default `SessionEncoderLightningModule` + Type of lightning module defining training procedure. + """ def __init__( # pylint: disable=too-many-arguments, too-many-locals self, @@ -1314,7 +1390,9 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals epochs: int = 3, verbose: int = 0, deterministic: bool = False, - cpu_n_threads: int = 0, + recommend_device: Union[str, Accelerator] = "auto", + recommend_n_threads: int = 0, + recommend_use_gpu_ranking: bool = True, train_min_user_interaction: int = 2, trainer: tp.Optional[Trainer] = None, item_net_block_types: tp.Sequence[tp.Type[ItemNetBase]] = (IdEmbeddingsItemNet, CatFeaturesItemNet), @@ -1340,7 +1418,9 @@ def __init__( # pylint: disable=too-many-arguments, too-many-locals epochs=epochs, verbose=verbose, deterministic=deterministic, - cpu_n_threads=cpu_n_threads, + recommend_device=recommend_device, + recommend_n_threads=recommend_n_threads, + recommend_use_gpu_ranking=recommend_use_gpu_ranking, trainer=trainer, item_net_block_types=item_net_block_types, pos_encoding_type=pos_encoding_type, From 07d49b13f1deb933dd48d4753829d59558d5bba8 Mon Sep 17 00:00:00 2001 From: spirinamayya <90619187+spirinamayya@users.noreply.github.com> Date: Wed, 18 Dec 2024 16:01:56 +0300 Subject: [PATCH 13/13] SASRec gpu/cpu multi-device tests (#230) Added gpu/cpu multi-device tests. --- tests/models/test_sasrec.py | 93 +++++++++++++++++++++++++++++++++++-- 1 file changed, 90 insertions(+), 3 deletions(-) diff --git a/tests/models/test_sasrec.py b/tests/models/test_sasrec.py index 613af430..4b88fbc0 100644 --- a/tests/models/test_sasrec.py +++ b/tests/models/test_sasrec.py @@ -24,6 +24,8 @@ from .data import DATASET, INTERACTIONS +# pylint: disable=too-many-lines + class TestSASRecModel: def setup_method(self) -> None: @@ -72,7 +74,41 @@ def trainer(self) -> Trainer: ) @pytest.mark.parametrize( - "filter_viewed,expected", + "accelerator,n_devices,recommend_device", + [ + ("cpu", 1, "cpu"), + pytest.param( + "cpu", + 1, + "gpu", + marks=pytest.mark.skipif(torch.cuda.is_available() is False, reason="GPU is not available"), + ), + ("cpu", 2, "cpu"), + pytest.param( + "gpu", + 1, + "cpu", + marks=pytest.mark.skipif(torch.cuda.is_available() is False, reason="GPU is not available"), + ), + pytest.param( + "gpu", + 1, + "gpu", + marks=pytest.mark.skipif(torch.cuda.is_available() is False, reason="GPU is not available"), + ), + pytest.param( + "gpu", + [0, 1], + "cpu", + marks=pytest.mark.skipif( + torch.cuda.is_available() is False or torch.cuda.device_count() < 2, + reason="GPU is not available or there is only one gpu device", + ), + ), + ], + ) + @pytest.mark.parametrize( + "filter_viewed,expected_cpu_1,expected_cpu_2,expected_gpu", ( ( True, @@ -83,6 +119,20 @@ def trainer(self) -> Trainer: Columns.Rank: [1, 2, 1, 2, 3, 1, 2, 3], } ), + pd.DataFrame( + { + Columns.User: [10, 10, 30, 30, 30, 40, 40, 40], + Columns.Item: [17, 15, 14, 17, 13, 14, 15, 12], + Columns.Rank: [1, 2, 1, 2, 3, 1, 2, 3], + } + ), + pd.DataFrame( + { + Columns.User: [10, 10, 30, 30, 30, 40, 40, 40], + Columns.Item: [15, 17, 14, 13, 17, 12, 14, 13], + Columns.Rank: [1, 2, 1, 2, 3, 1, 2, 3], + } + ), ), ( False, @@ -93,11 +143,41 @@ def trainer(self) -> Trainer: Columns.Rank: [1, 2, 3, 1, 2, 3, 1, 2, 3], } ), + pd.DataFrame( + { + Columns.User: [10, 10, 10, 30, 30, 30, 40, 40, 40], + Columns.Item: [12, 14, 13, 11, 12, 14, 17, 14, 15], + Columns.Rank: [1, 2, 3, 1, 2, 3, 1, 2, 3], + } + ), + pd.DataFrame( + { + Columns.User: [10, 10, 10, 30, 30, 30, 40, 40, 40], + Columns.Item: [13, 14, 15, 14, 13, 12, 12, 17, 14], + Columns.Rank: [1, 2, 3, 1, 2, 3, 1, 2, 3], + } + ), ), ), ) - # TODO: tests do not pass for multiple GPUs - def test_u2i(self, dataset: Dataset, trainer: Trainer, filter_viewed: bool, expected: pd.DataFrame) -> None: + def test_u2i( + self, + dataset: Dataset, + filter_viewed: bool, + accelerator: str, + n_devices: int, + recommend_device: str, + expected_cpu_1: pd.DataFrame, + expected_cpu_2: pd.DataFrame, + expected_gpu: pd.DataFrame, + ) -> None: + trainer = Trainer( + max_epochs=2, + min_epochs=2, + deterministic=True, + devices=n_devices, + accelerator=accelerator, + ) model = SASRecModel( n_factors=32, n_blocks=2, @@ -106,12 +186,19 @@ def test_u2i(self, dataset: Dataset, trainer: Trainer, filter_viewed: bool, expe batch_size=4, epochs=2, deterministic=True, + recommend_device=recommend_device, item_net_block_types=(IdEmbeddingsItemNet,), trainer=trainer, ) model.fit(dataset=dataset) users = np.array([10, 30, 40]) actual = model.recommend(users=users, dataset=dataset, k=3, filter_viewed=filter_viewed) + if accelerator == "cpu" and n_devices == 1: + expected = expected_cpu_1 + elif accelerator == "cpu" and n_devices == 2: + expected = expected_cpu_2 + else: + expected = expected_gpu pd.testing.assert_frame_equal(actual.drop(columns=Columns.Score), expected) pd.testing.assert_frame_equal( actual.sort_values([Columns.User, Columns.Score], ascending=[True, False]).reset_index(drop=True),