AutoEncoders.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up Colab environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "username = 'SkoltechAI'\n",
    "repo = 'Recommender-Systems-Intro-Sber-2022'\n",
    "\n",
    "# remove local directory if it already exists\n",
    "if os.path.isdir(repo):\n",
    "    !rm -rf {repo}\n",
    "\n",
    "!git clone https://github.com/{username}/{repo}.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git clone https://github.com/evfro/cofida.git\n",
    "!pip install --no-cache-dir --upgrade git+https://github.com/evfro/polara.git@develop#egg=polara"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from polara import get_movielens_data\n",
    "from polara.preprocessing.dataframes import leave_one_out, reindex\n",
    "\n",
    "from cofida.datasets import observations_loader, UserBatchDataset\n",
    "\n",
    "# navigating to cloned repo directory in Colab\n",
    "%cd {repo} \n",
    "from dataprep import transform_indices, matrix_from_data\n",
    "from evaluation import topn_recommendations, model_evaluate, downvote_seen_items\n",
    "# restoring original location\n",
    "%cd -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fix_torch_seed(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preparing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "mldata = get_movielens_data(include_time=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_timepoint = mldata['timestamp'].quantile(\n",
    "    q=0.95, interpolation='nearest'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data_ = mldata.query('timestamp >= @test_timepoint')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "userid         813\n",
       "movieid       3249\n",
       "rating           5\n",
       "timestamp    33729\n",
       "dtype: int64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_data_.nunique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_ = mldata.query(\n",
    "    'userid not in @test_data_.userid.unique() and timestamp < @test_timepoint'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "training, data_index = transform_indices(train_data_.copy(), 'userid', 'movieid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filtered 64 invalid observations.\n"
     ]
    }
   ],
   "source": [
    "test_data = reindex(test_data_, data_index['items'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "userid         813\n",
       "movieid       3220\n",
       "rating           5\n",
       "timestamp    33678\n",
       "dtype: int64"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_data.nunique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We sample the last item for each test user.  \n",
    "As all these users are excluded from the training, and training is additionally filtered by timestamp,\n",
    "there will be no \"recommendation from future\" issue - our model is unaware of future correlations.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "testset_, holdout_ = leave_one_out(\n",
    "    test_data, target='timestamp', sample_top=True, random_state=0\n",
    ")\n",
    "testset_valid_, holdout_valid_ = leave_one_out(\n",
    "    testset_, target='timestamp', sample_top=True, random_state=0\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's focus on validation part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([  20,   23,   36,   44,   59,   65,   74,   89,   90,   99,\n",
       "            ...\n",
       "            5956, 5972, 5991, 5995, 5996, 5998, 6001, 6002, 6016, 6040],\n",
       "           dtype='int64', length=750)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "userid = data_index['users'].name\n",
    "test_users = pd.Index(\n",
    "    np.intersect1d(\n",
    "        testset_valid_[userid].unique(),\n",
    "        holdout_valid_[userid].unique()\n",
    "    )\n",
    ")\n",
    "testset_valid = (\n",
    "    testset_valid_\n",
    "    # reindex warm-start users for convenience\n",
    "    .assign(**{userid: lambda x: test_users.get_indexer(x[userid])})\n",
    "    .query(f'{userid} >= 0')\n",
    "    .sort_values('userid')\n",
    ")\n",
    "holdout_valid = (\n",
    "    holdout_valid_\n",
    "    # reindex warm-start users for convenience\n",
    "    .assign(**{userid: lambda x: test_users.get_indexer(x[userid])})\n",
    "    .query(f'{userid} >= 0')\n",
    "    .sort_values('userid')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "userid         750\n",
       "movieid       3202\n",
       "rating           5\n",
       "timestamp    32400\n",
       "dtype: int64"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testset_valid.nunique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(750, 4)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "holdout_valid.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert holdout_valid.set_index('userid')['timestamp'].ge(\n",
    "    testset_valid\n",
    "    .groupby('userid')\n",
    "    ['timestamp'].max()\n",
    ").all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'users': 'userid',\n",
       " 'items': 'movieid',\n",
       " 'feedback': 'rating',\n",
       " 'n_users': 5227,\n",
       " 'n_items': 3652}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_description = dict(\n",
    "    users = data_index['users'].name,\n",
    "    items = data_index['items'].name,\n",
    "    feedback = 'rating',\n",
    "    n_users = len(data_index['users']),\n",
    "    n_items = len(data_index['items']),\n",
    ")\n",
    "data_description"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# User-batch Dataloader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike the MF case, where you worked on a per observations sample in a batch, here you'll need to adapt to a per-user batch sampling strategy. You can write your on sampler, or reuse some predefined ones. Below is an example based on the `cofida` package. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = observations_loader(\n",
    "    observations = matrix_from_data(training, data_description),\n",
    "    batch_size = batch_size, # number of users in the batch\n",
    "    shuffle = True, # return user batches in random order\n",
    "    data_factory = UserBatchDataset,\n",
    "    sparse_batch = True  # can use .to_dense on a batch for calculations\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(indices=tensor([[  32,   32,   32,  ...,  105,  105,  105],\n",
       "                       [   1,    6,    9,  ..., 3410, 3421, 3431]]),\n",
       "       values=tensor([1., 4., 4.,  ..., 3., 3., 5.]),\n",
       "       device='cuda:0', size=(128, 3652), nnz=17372, layout=torch.sparse_coo)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch = next(iter(train_loader))\n",
    "batch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Single-layer Autoencoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AutoEncoderSL(nn.Module):\n",
    "    def __init__(self, num_items, latent_dim, bias=True):\n",
    "        super().__init__()\n",
    "\n",
    "        self.encode = nn.Sequential(\n",
    "            nn.Linear(num_items, latent_dim, bias=bias),\n",
    "            nn.Tanh()\n",
    "        )\n",
    "        self.decode = nn.Linear(latent_dim, num_items, bias=bias)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        return self.decode(self.encode(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_ae_model(config, data_description):\n",
    "    model = AutoEncoderSL(\n",
    "        data_description['n_items'],\n",
    "        config['dim']\n",
    "    )\n",
    "    # transfer model to GPU if available\n",
    "    device = None\n",
    "    if torch.cuda.is_available():\n",
    "        if not next(model.parameters()).is_cuda:\n",
    "            model = model.cuda()\n",
    "        device = next(model.parameters()).device\n",
    "    # define loss function    \n",
    "    criterion = torch.nn.BCEWithLogitsLoss().to(device)\n",
    "    # alternatively: criterion = nn.MSELoss().to(device)\n",
    "    # define optimizer\n",
    "    optimizer = torch.optim.Adam(\n",
    "        model.parameters(),\n",
    "        lr = config['learning_rate'],\n",
    "        weight_decay = config['l2_reg']\n",
    "    )    \n",
    "    return model, criterion, optimizer, device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_ae_epoch(loader, model, criterion, optimizer, scheduler=None, masked_loss=False):\n",
    "    model.train()\n",
    "    losses = []\n",
    "    for batch in loader:\n",
    "        optimizer.zero_grad()\n",
    "        dense_batch = batch.to_dense()\n",
    "        predictions = model(dense_batch)\n",
    "\n",
    "        if masked_loss:\n",
    "            mask = dense_batch > 0\n",
    "            loss = criterion(predictions.masked_select(mask), dense_batch.masked_select(mask))\n",
    "        else:\n",
    "            loss = criterion(predictions, dense_batch)\n",
    "\n",
    "        loss = criterion(predictions, dense_batch)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        losses.append(loss.item())\n",
    "    \n",
    "    if scheduler is not None:\n",
    "        scheduler.step()\n",
    "    return losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_ae_model(config, data, data_description):\n",
    "    '''Simple MF training routine without early stopping'''\n",
    "    model, criterion, optimizer, device = prepare_ae_model(config, data_description)\n",
    "    loader = observations_loader(\n",
    "        observations = matrix_from_data(data, data_description),\n",
    "        batch_size = batch_size, # number of users in the batch\n",
    "        shuffle = True, # return user batches in random order\n",
    "        data_factory = UserBatchDataset,\n",
    "        sparse_batch = True  # can use .to_dense on a batch for calculations\n",
    "    )\n",
    "    losses = {}\n",
    "    for epoch in tqdm(range(config['epochs'])):\n",
    "        losses[epoch] = train_ae_epoch(\n",
    "            loader, model, criterion, optimizer, masked_loss=config['masked_loss']\n",
    "        )\n",
    "    return model, losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = dict(\n",
    "    dim = 64,\n",
    "    learning_rate = 1e-2,\n",
    "    epochs = 100,\n",
    "    l2_reg = 0, # L2 regularization\n",
    "    masked_loss = True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [02:02<00:00,  1.23s/it]\n"
     ]
    }
   ],
   "source": [
    "ae_model, ae_losses = build_ae_model(config, training, data_description)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd.Series(ae_losses).apply(np.mean).plot(title='Evolution of AE loss', xlabel='Epoch', ylabel='Loss');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "epoch = 0\n",
    "epoch_loss_series = pd.Series(ae_losses[epoch], name='Loss').rename_axis('batch')\n",
    "ax = epoch_loss_series.reset_index().plot.scatter(\n",
    "    x='batch', y='Loss', title=f'Batch loss at epoch {epoch} '\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scoring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ae_model_scoring(params, data, data_description):\n",
    "    model = params\n",
    "    model.eval()\n",
    "    # prepare user and item index for scoring\n",
    "    test_matrix = matrix_from_data(\n",
    "        data,\n",
    "        # need to account for the warm-users -> they have new index\n",
    "        # hence, the shape of matrix needs to be set appropriately:\n",
    "        {**data_description, 'n_users': holdout_valid.shape[0]}\n",
    "    )\n",
    "    loader = observations_loader(\n",
    "        observations = test_matrix,\n",
    "        batch_size = batch_size, # number of users in the batch\n",
    "        shuffle = False, # preserve order to ensure alignment with holdout\n",
    "        data_factory = UserBatchDataset,\n",
    "        sparse_batch = True  # can use .to_dense on a batch for calculations\n",
    "    )\n",
    "    # perform scoring on a user-batch level\n",
    "    scores = []\n",
    "    for user_batch in loader:\n",
    "        dense_batch = user_batch.to_dense()\n",
    "        with torch.no_grad():\n",
    "            predictions = model(dense_batch)\n",
    "        scores.append(predictions.detach().cpu().numpy())\n",
    "    return np.concatenate(scores, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "ae_scores = ae_model_scoring(ae_model, testset_valid, data_description)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "downvote_seen_items(ae_scores, testset_valid, data_description)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.021333333333333333, 0.009012698412698413, 0.1541621029572837)"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ae_recs = topn_recommendations(ae_scores, topn=10)\n",
    "model_evaluate(ae_recs, holdout_valid, data_description)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vanilla Autoencoders typically perform poorly. To make it work better, one may go several ways.\n",
    "\n",
    "1. Use more complex models, e.g. MultVAE [Liang et al. 2018] or RecVAE [Shenbin et al. 2019].\n",
    "2. Use better representation, e.g. hyperbolic geometry [Mirvakhabova and Frolov et al. 2020].\n",
    "\n",
    "However, even much simpler models like EASEr may provide comparable quality [Steck 2019]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example of MultVAE model definition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Source code adapted form https://github.com/postBG/VAE4REC.pytorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "    def __init__(self, p_dims: List[int], dropout: List[float]):\n",
    "        super().__init__()\n",
    "\n",
    "        decoder_layers = []\n",
    "        for i, (p, inp, out) in enumerate(zip(dropout, p_dims[:-1], p_dims[1:])):\n",
    "            decoder_layers.append(f'dropout_{i}', nn.Dropout(p))\n",
    "            decoder_layers.append(f'linear_{i}', nn.Linear(inp, out))\n",
    "        self.p_layers = nn.Sequential(*decoder_layers)\n",
    "\n",
    "    def forward(self, X):\n",
    "        h = X\n",
    "        n_layers = len(self.p_layers)\n",
    "        for i, layer in enumerate(self.p_layers, start=1):\n",
    "            h = layer(h)\n",
    "            if i < n_layers:\n",
    "                h = torch.tanh(h)\n",
    "        return h\n",
    "\n",
    "\n",
    "class VAEEncoder(nn.Module):\n",
    "    def __init__(self, q_dims: List[int], dropout: List[float]):\n",
    "        super().__init__()\n",
    "\n",
    "        self.q_dims = q_dims\n",
    "        q_dims_ = self.q_dims[:-1] + [self.q_dims[-1] * 2]\n",
    "        encoder_layers = []\n",
    "        for i, (p, inp, out) in enumerate(zip(dropout, q_dims_[:-1], q_dims_[1:])):\n",
    "            encoder_layers.append(f'dropout_{i}', nn.Dropout(p))\n",
    "            encoder_layers.append(f'linear_{i}', nn.Linear(inp, out))\n",
    "        self.q_layers = nn.Sequential(*encoder_layers)\n",
    "\n",
    "    def forward(self, X):\n",
    "        h = F.normalize(X, p=2, dim=1)\n",
    "        n_layers = len(self.q_layers)\n",
    "        for i, layer in enumerate(self.q_layers, start=1):\n",
    "            h = layer(h)\n",
    "            if i < n_layers:\n",
    "                h = torch.tanh(h)\n",
    "            else:\n",
    "                mu, logvar = torch.split(h, self.q_dims[-1], dim=1)\n",
    "        return mu, logvar\n",
    "\n",
    "\n",
    "class MultiVAE(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        p_dims: List[int],\n",
    "        q_dims: List[int],\n",
    "        dropout_enc: List[float],\n",
    "        dropout_dec: List[float],\n",
    "    ):\n",
    "        super().__init__()\n",
    "\n",
    "        self.encode = VAEEncoder(q_dims, dropout_enc)\n",
    "        self.decode = Decoder(p_dims, dropout_dec)\n",
    "\n",
    "    def forward(self, X):\n",
    "        mu, logvar = self.encode(X)\n",
    "        sampled = mu\n",
    "        if self.training:\n",
    "            std = torch.exp(0.5 * logvar)\n",
    "            eps = torch.randn_like(std)\n",
    "            sampled = sampled + eps * std\n",
    "        return self.decode(sampled), mu, logvar\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "e587e8b75394de48c2e2a47def3a5e72a23054844b7abdff48af37dc7e76636d"
  },
  "kernelspec": {
   "display_name": "Python 3.9.10 ('torch')",
   "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.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}