sasrec_amazon.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S87AWRDq0X2Y",
        "outputId": "58050dab-0829-46ec-fb75-f58ce95927b0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting ipypb\n",
            "  Downloading ipypb-0.5.2-py3-none-any.whl (8.6 kB)\n",
            "Installing collected packages: ipypb\n",
            "Successfully installed ipypb-0.5.2\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting polara\n",
            "  Cloning https://github.com/evfro/polara.git (to revision develop) to /tmp/pip-install-hs4f3c4e/polara_efa2e6c6cd51445c8384f54277b480e1\n",
            "  Running command git clone --filter=blob:none --quiet https://github.com/evfro/polara.git /tmp/pip-install-hs4f3c4e/polara_efa2e6c6cd51445c8384f54277b480e1\n",
            "  Running command git checkout -b develop --track origin/develop\n",
            "  Switched to a new branch 'develop'\n",
            "  Branch 'develop' set up to track remote branch 'develop' from 'origin'.\n",
            "  Resolved https://github.com/evfro/polara.git to commit 8e48cfd88e616ca53f8bbda1702a3e2c8abaf38e\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Building wheels for collected packages: polara\n",
            "  Building wheel for polara (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for polara: filename=polara-0.7.2.dev0-py3-none-any.whl size=89455 sha256=93f62ede42eacefa546ca5b0744dd40d6ef09032144121d97831921ea71c8c31\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-9ik_u0jf/wheels/d2/cf/bf/e1a3e49c4a733261d717fa4732eadf0303dabcc48ba694ad7a\n",
            "Successfully built polara\n",
            "Installing collected packages: polara\n",
            "Successfully installed polara-0.7.2.dev0\n"
          ]
        }
      ],
      "source": [
        "!pip install ipypb\n",
        "!pip install --upgrade git+https://github.com/evfro/polara.git@develop#egg=polara"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "yPzvtgYd0JPP"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/home/matvey/.pyenv/versions/3.9.16/envs/mts/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
            "  from .autonotebook import tqdm as notebook_tqdm\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from tqdm.auto import tqdm\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "from polara import get_movielens_data\n",
        "from polara.preprocessing.dataframes import reindex, leave_one_out"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "2Yc0yYNw0JPR"
      },
      "outputs": [],
      "source": [
        "def fix_torch_seed(seed):\n",
        "    torch.manual_seed(seed)\n",
        "    torch.cuda.manual_seed_all(seed)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "1Xj_YoJV0y4d"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "\n",
        "def downvote_seen_items(scores, data, data_description):\n",
        "    assert isinstance(scores, np.ndarray), 'Scores must be a dense numpy array!'\n",
        "    itemid = data_description['items']\n",
        "    userid = data_description['users']\n",
        "    # get indices of observed data, corresponding to scores array\n",
        "    # we need to provide correct mapping of rows in scores array into\n",
        "    # the corresponding user index (which is assumed to be sorted)\n",
        "    row_idx, test_users = pd.factorize(data[userid], sort=True)\n",
        "    assert len(test_users) == scores.shape[0]\n",
        "    col_idx = data[itemid].values\n",
        "    # downvote scores at the corresponding positions\n",
        "    scores[row_idx, col_idx] = scores.min() - 1\n",
        "\n",
        "\n",
        "def topn_recommendations(scores, topn=20):\n",
        "    recommendations = np.apply_along_axis(topidx, 1, scores, topn)\n",
        "    return recommendations\n",
        "\n",
        "\n",
        "def topidx(a, topn):\n",
        "    parted = np.argpartition(a, -topn)[-topn:]\n",
        "    return parted[np.argsort(-a[parted])]\n",
        "\n",
        "\n",
        "def model_evaluate(recommended_items, holdout, holdout_description, topn=20):\n",
        "    itemid = holdout_description['items']\n",
        "    holdout_items = holdout[itemid].values\n",
        "    assert recommended_items.shape[0] == len(holdout_items)\n",
        "    hits_mask = recommended_items[:, :topn] == holdout_items.reshape(-1, 1)\n",
        "    # HR calculation\n",
        "    hr = np.mean(hits_mask.any(axis=1))\n",
        "    # MRR calculation\n",
        "    n_test_users = recommended_items.shape[0]\n",
        "    hit_rank = np.where(hits_mask)[1] + 1.0\n",
        "    mrr = np.sum(1 / hit_rank) / n_test_users\n",
        "    # coverage calculation\n",
        "    n_items = holdout_description['n_items']\n",
        "    cov = np.unique(recommended_items).size / n_items\n",
        "    return hr, mrr, cov\n",
        "\n",
        "\n",
        "def calculate_rmse(scores, holdout, holdout_description):\n",
        "    user_idx = np.arange(holdout.shape[0])\n",
        "    item_idx = holdout[holdout_description['items']].values\n",
        "    feedback = holdout[holdout_description['feedback']].values\n",
        "    predicted_rating = scores[user_idx, item_idx]\n",
        "    return np.mean(np.abs(predicted_rating-feedback)**2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "nNRbmUUP01bc"
      },
      "outputs": [],
      "source": [
        "from scipy.sparse import csr_matrix\n",
        "import pandas as pd\n",
        "\n",
        "\n",
        "def leave_last_out(data, userid='userid', timeid='timestamp'):\n",
        "    data_sorted = data.sort_values('timestamp')\n",
        "    holdout = data_sorted.drop_duplicates(\n",
        "        subset=['userid'], keep='last'\n",
        "    ) # split the last item from each user's history\n",
        "    remaining = data.drop(holdout.index) # store the remaining data - will be our training\n",
        "    return remaining, holdout\n",
        "\n",
        "\n",
        "def transform_indices(data, users, items):\n",
        "    '''\n",
        "    Reindex columns that correspond to users and items.\n",
        "    New index is contiguous starting from 0.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    data : pandas.DataFrame\n",
        "        The input data to be reindexed.\n",
        "    users : str\n",
        "        The name of the column in `data` that contains user IDs.\n",
        "    items : str\n",
        "        The name of the column in `data` that contains item IDs.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    pandas.DataFrame, dict\n",
        "        The reindexed data and a dictionary with mapping between original IDs and the new numeric IDs.\n",
        "        The keys of the dictionary are 'users' and 'items'.\n",
        "        The values of the dictionary are pandas Index objects.\n",
        "\n",
        "    Examples\n",
        "    --------\n",
        "    >>> data = pd.DataFrame({'customers': ['A', 'B', 'C'], 'products': ['X', 'Y', 'Z'], 'rating': [1, 2, 3]})\n",
        "    >>> data_reindexed, data_index = transform_indices(data, 'customers', 'products')\n",
        "    >>> data_reindexed\n",
        "       users  items  rating\n",
        "    0      0      0       1\n",
        "    1      1      1       2\n",
        "    2      2      2       3\n",
        "    >>> data_index\n",
        "    {\n",
        "        'users': Index(['A', 'B', 'C'], dtype='object', name='customers'),\n",
        "        'items': Index(['X', 'Y', 'Z'], dtype='object', name='products')\n",
        "    }\n",
        "    '''\n",
        "    data_index = {}\n",
        "    for entity, field in zip(['users', 'items'], [users, items]):\n",
        "        new_index, data_index[entity] = to_numeric_id(data, field)\n",
        "        data = data.assign(**{f'{field}': new_index}) # makes a copy of dataset!\n",
        "    return data, data_index\n",
        "\n",
        "\n",
        "def to_numeric_id(data, field):\n",
        "    \"\"\"\n",
        "    This function takes in two arguments, data and field. It converts the data field\n",
        "    into categorical values and creates a new contiguous index. It then creates an\n",
        "    idx_map which is a renamed version of the field argument. Finally, it returns the\n",
        "    idx and idx_map variables. \n",
        "    \"\"\"\n",
        "    idx_data = data[field].astype(\"category\")\n",
        "    idx = idx_data.cat.codes\n",
        "    idx_map = idx_data.cat.categories.rename(field)\n",
        "    return idx, idx_map\n",
        "\n",
        "\n",
        "def reindex_data(data, data_index, fields=None):\n",
        "    '''\n",
        "    Reindex provided data with the specified index mapping.\n",
        "    By default, will take the name of the fields to reindex from `data_index`.\n",
        "    It is also possible to specify which field to reindex by providing `fields`.\n",
        "    '''\n",
        "    if fields is None:\n",
        "        fields = data_index.keys()\n",
        "    if isinstance(fields, str): # handle single field provided as a string\n",
        "        fields = [fields]\n",
        "    for field in fields:\n",
        "        entity_name = data_index[field].name\n",
        "        new_index = data_index[field].get_indexer(data[entity_name])\n",
        "        data = data.assign(**{f'{entity_name}': new_index}) # makes a copy of dataset!\n",
        "    return data\n",
        "\n",
        "\n",
        "def generate_interactions_matrix(data, data_description, rebase_users=False):\n",
        "    '''\n",
        "    Converts a pandas dataframe with user-item interactions into a sparse matrix representation.\n",
        "    Allows reindexing user ids, which help ensure data consistency at the scoring stage\n",
        "    (assumes user ids are sorted in the scoring array).\n",
        "    \n",
        "    Args:\n",
        "        data (pandas.DataFrame): The input dataframe containing the user-item interactions.\n",
        "        data_description (dict): A dictionary containing the data description with the following keys:\n",
        "            - 'n_users' (int): The total number of unique users in the data.\n",
        "            - 'n_items' (int): The total number of unique items in the data.\n",
        "            - 'users' (str): The name of the column in the dataframe containing the user ids.\n",
        "            - 'items' (str): The name of the column in the dataframe containing the item ids.\n",
        "            - 'feedback' (str): The name of the column in the dataframe containing the user-item interaction feedback.\n",
        "        rebase_users (bool, optional): Whether to reindex the user ids to make contiguous index starting from 0. Defaults to False.\n",
        "\n",
        "    Returns:\n",
        "        scipy.sparse.csr_matrix: A sparse matrix of shape (n_users, n_items) containing the user-item interactions.\n",
        "    '''\n",
        "        \n",
        "    n_users = data_description['n_users']\n",
        "    n_items = data_description['n_items']\n",
        "    # get indices of observed data\n",
        "    user_idx = data[data_description['users']].values\n",
        "    if rebase_users: # handle non-contiguous index of test users\n",
        "        # This ensures that all user ids are contiguous and start from 0,\n",
        "        # which helps ensure data consistency at the scoring stage.\n",
        "        user_idx, user_index = pd.factorize(user_idx, sort=True)\n",
        "        n_users = len(user_index)\n",
        "    item_idx = data[data_description['items']].values\n",
        "    feedback = data[data_description['feedback']].values\n",
        "    # construct rating matrix\n",
        "    return csr_matrix((feedback, (user_idx, item_idx)), shape=(n_users, n_items))\n",
        "\n",
        "\n",
        "def verify_time_split(before, after, target_field='userid', timeid='timestamp'):\n",
        "    '''\n",
        "    Check that items from `after` dataframe have later timestamps than\n",
        "    any corresponding item from the `before` dataframe. Compare w.r.t target_field.\n",
        "    Usage example: assert that for any user, the holdout items are the most recent ones.\n",
        "    '''\n",
        "    before_ts = before.groupby(target_field)[timeid].max()\n",
        "    after_ts = after.groupby(target_field)[timeid].min()\n",
        "    assert (\n",
        "        before_ts\n",
        "        .reindex(after_ts.index)\n",
        "        .combine(after_ts, lambda x, y: True if x!=x else x <= y)\n",
        "    ).all()\n",
        "\n",
        "\n",
        "\n",
        "def timepoint_split(data, time_split_q=0.95):\n",
        "    \"\"\"\n",
        "    Split data into training, testset, and holdout datasets based on a timepoint split\n",
        "    and according to the `warm-start` evaluation strategy.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    data : pd.DataFrame\n",
        "        The input dataset containing columns `userid`, `movieid`, and `timestamp`.\n",
        "    time_split_q : float, optional\n",
        "        The quantile value used to split the dataset based on the `timestamp` column.\n",
        "        Default is 0.95.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]\n",
        "        A tuple of three pandas DataFrames: training, testset, and holdout.\n",
        "        `training` is a subset of `data` used for training the recommender system.\n",
        "        `testset` is a subset of `data` used for generating recommendations for the test users.\n",
        "        `holdout` is a subset excluded from `testset` containing only the most recent interactions for each test user.\n",
        "\n",
        "    Notes\n",
        "    -----\n",
        "    The function splits the input `data` into three subsets: `training`, `testset`, and `holdout`.\n",
        "    The split is performed based on the `timestamp` column of `data`, using `time_split_q` as the quantile value.\n",
        "    The `holdout` dataset contains only the immediate interactions following the fixed timepoint for each test user from the `testset`.\n",
        "    The set of users in `training` is disjoint with the set of users in the `testset`, which implements the `warm-start` scenario.\n",
        "    \"\"\"    \n",
        "    timepoint = data.timestamp.quantile(q=time_split_q, interpolation='nearest')\n",
        "    test_ = data.query('timestamp >= @timepoint')\n",
        "    rest_ = data.drop(test_.index)\n",
        "    holdout_ = (\n",
        "        test_\n",
        "        .sort_values('timestamp')\n",
        "        .drop_duplicates(subset=['userid'], keep='first')\n",
        "    )\n",
        "    # the holdout dataframe contains interactions closest to certain timepoint from the right,\n",
        "    # i.e., the corresponding items are the first in each test user profile after this timepoint\n",
        "    training = rest_.query('userid not in @holdout_.userid')\n",
        "    train_items = training.itemid.unique()\n",
        "    testset_ = rest_.query('userid in @holdout_.userid and itemid in @train_items')\n",
        "    test_users = testset_.userid.unique()\n",
        "    holdout = holdout_.query(\n",
        "        # if user is not in `test_users` then no evluation is possible,\n",
        "        # if item is not in `train_items` it's cold start -> must be excluded\n",
        "        'userid in @test_users and itemid in @train_items'\n",
        "    ).sort_values('userid')\n",
        "    testset = testset_.query(\n",
        "        # make sure testset and holdout contain the same set of users\n",
        "        'userid in @holdout.userid'\n",
        "    ).sort_values('userid')\n",
        "    return training, testset, holdout"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4u7Jjway0JPS"
      },
      "source": [
        "# Preparing data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NVBhQIng1ENo",
        "outputId": "d50be272-31f6-42b7-ab32-7c5dddce48d5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "--2023-03-29 16:12:22--  https://jmcauley.ucsd.edu/data/amazon_v2/categoryFilesSmall/Grocery_and_Gourmet_Food.csv\n",
            "Resolving jmcauley.ucsd.edu (jmcauley.ucsd.edu)... 137.110.160.73\n",
            "Connecting to jmcauley.ucsd.edu (jmcauley.ucsd.edu)|137.110.160.73|:443... connected.\n",
            "WARNING: cannot verify jmcauley.ucsd.edu's certificate, issued by ‘CN=InCommon RSA Server CA,OU=InCommon,O=Internet2,L=Ann Arbor,ST=MI,C=US’:\n",
            "  Unable to locally verify the issuer's authority.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 211781981 (202M) [text/csv]\n",
            "Saving to: ‘Grocery_and_Gourmet_Food.csv’\n",
            "\n",
            "Grocery_and_Gourmet 100%[===================>] 201.97M  85.9MB/s    in 2.4s    \n",
            "\n",
            "2023-03-29 16:12:24 (85.9 MB/s) - ‘Grocery_and_Gourmet_Food.csv’ saved [211781981/211781981]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "!mkdir -p data/amazon_reviews\n",
        "!wget https://jmcauley.ucsd.edu/data/amazon_v2/categoryFilesSmall/Grocery_and_Gourmet_Food.csv --no-check-certificate\n",
        "!mv Grocery_and_Gourmet_Food.csv data/amazon_reviews"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "c4sC4Cy01JFr"
      },
      "outputs": [],
      "source": [
        "reviews = pd.read_csv(\"data/amazon_reviews/Grocery_and_Gourmet_Food.csv\", names=[\"userid\", \"itemid\", \"rating\", \"timestamp\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "lSB3PVEJ1cfB"
      },
      "outputs": [],
      "source": [
        "k_filter = 20\n",
        "\n",
        "n_interactions = reviews.groupby(\"userid\").size()\n",
        "enough = n_interactions[n_interactions > k_filter].index\n",
        "reviews = reviews[reviews.userid.isin(enough)]\n",
        "\n",
        "n_interactions = reviews.groupby(\"itemid\").size()\n",
        "enough = n_interactions[n_interactions > k_filter].index\n",
        "reviews = reviews[reviews.itemid.isin(enough)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XBxwq23Z1Lzg",
        "outputId": "3c18b8f2-d1b5-4609-cba6-495b756a4a6b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(107153, 74000, 4421)"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "_train, _test, _holdout = timepoint_split(reviews, time_split_q=0.95)\n",
        "\n",
        "len(_train), len(_test), len(_holdout)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "HmVPl6-g13Zm"
      },
      "outputs": [],
      "source": [
        "def reindex_all(train, test, holdout=None, userid='userid', itemid='itemid'):\n",
        "    train_new, data_index = transform_indices(train, userid, itemid)\n",
        "    test_new = reindex_data(test, data_index, fields='items')\n",
        "    \n",
        "    if holdout is None:\n",
        "        return train_new, test_new, data_index\n",
        "    \n",
        "    holdout_new = reindex_data(holdout, data_index, fields='items')\n",
        "    return train_new, test_new, holdout_new, data_index"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "PfgWKXEa1pia"
      },
      "outputs": [],
      "source": [
        "train, test, holdout, data_index = reindex_all(_train, _test, _holdout)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I6KBcNgZ0JPV"
      },
      "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": 10,
      "metadata": {
        "id": "w22udb8l0JPW"
      },
      "outputs": [],
      "source": [
        "testset_, holdout_ = leave_one_out(\n",
        "    test, 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": {
        "id": "Z8gDnLdT0JPW"
      },
      "source": [
        "Let's focus on validation part."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "lXr5oY230JPW"
      },
      "outputs": [],
      "source": [
        "userid = data_index['users'].name\n",
        "test_users = pd.Index(\n",
        "    # ensure test users are the same across testing data\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": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Msn0q-6p0JPW",
        "outputId": "75633b97-d04b-498d-b007-6693d0b08144"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "userid       3267\n",
              "itemid       5569\n",
              "rating          5\n",
              "timestamp    3399\n",
              "dtype: int64"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "testset_valid.nunique()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cbx44QUZ0JPW",
        "outputId": "5baf3e6f-3744-4b20-dd81-14dedc15df43"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(3267, 4)"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "holdout_valid.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "kweQ8Lm00JPf"
      },
      "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": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2HwVrt4w0JPg",
        "outputId": "b43cf1ae-8a6a-4ee2-bf50-bdcdb1933006"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'users': 'userid',\n",
              " 'items': 'itemid',\n",
              " 'order': 'timestamp',\n",
              " 'feedback': 'rating',\n",
              " 'n_users': 22920,\n",
              " 'n_items': 5604}"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "data_description = dict(\n",
        "    users = data_index['users'].name,\n",
        "    items = data_index['items'].name,\n",
        "    order = 'timestamp',\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": {
        "id": "Sc8xl4Uk0JPg"
      },
      "source": [
        "# Batch Sampler"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "ULX_vonn0JPg"
      },
      "outputs": [],
      "source": [
        "def sequential_batch_sampler(user_train, usernum, itemnum, batch_size, maxlen, seed, pad_token=None):\n",
        "    if pad_token is None:\n",
        "        pad_token = itemnum\n",
        "    \n",
        "    def sample(random_state):\n",
        "        user = random_state.randint(usernum)\n",
        "        while len(user_train.get(user, [])) <= 1:\n",
        "            user = random_state.randint(usernum)\n",
        "        user_items = user_train[user]\n",
        "        seq = np.full(maxlen, pad_token, dtype=np.int32)\n",
        "        pos = np.full(maxlen, pad_token, dtype=np.int32)\n",
        "        neg = np.full(maxlen, pad_token, dtype=np.int32)\n",
        "        nxt = user_items[-1]\n",
        "        idx = maxlen - 1\n",
        "        ts = set(user_items)\n",
        "        for i in reversed(user_items[:-1]):\n",
        "            seq[idx] = i\n",
        "            pos[idx] = nxt\n",
        "            neg[idx] = random_neq(0, itemnum, ts, random_state)\n",
        "            nxt = i\n",
        "            idx -= 1\n",
        "            if idx == -1:\n",
        "                break\n",
        "        return (user, seq, pos, neg)\n",
        "    \n",
        "    random_state = np.random.RandomState(seed)\n",
        "    while True:\n",
        "        yield zip(*(sample(random_state) for _ in range(batch_size)))\n",
        "\n",
        "\n",
        "def random_neq(l, r, s, random_state):\n",
        "    t = random_state.randint(l, r)\n",
        "    while t in s:\n",
        "        t = random_state.randint(l, r)\n",
        "    return t"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hql836il0JPh"
      },
      "source": [
        "# SASRec model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GwC6h09o0JPh"
      },
      "source": [
        "The code is adapted from https://github.com/pmixer/SASRec.pytorch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "lRNmj9Rn0JPj"
      },
      "outputs": [],
      "source": [
        "class PointWiseFeedForward(nn.Module):\n",
        "    def __init__(self, hidden_units, dropout_rate):\n",
        "        super(PointWiseFeedForward, self).__init__()\n",
        "        self.conv1 = nn.Conv1d(hidden_units, hidden_units, kernel_size=1)\n",
        "        self.dropout1 = nn.Dropout(p=dropout_rate)\n",
        "        self.relu = nn.ReLU()\n",
        "        self.conv2 = nn.Conv1d(hidden_units, hidden_units, kernel_size=1)\n",
        "        self.dropout2 = nn.Dropout(p=dropout_rate)\n",
        "\n",
        "    def forward(self, inputs):\n",
        "        outputs = self.dropout2(self.conv2(self.relu(self.dropout1(self.conv1(inputs.transpose(-1, -2))))))\n",
        "        outputs = outputs.transpose(-1, -2) # as Conv1D requires (N, C, Length)\n",
        "        outputs += inputs\n",
        "        return outputs\n",
        "\n",
        "\n",
        "class SASRec(nn.Module):\n",
        "    def __init__(self, item_num, config):\n",
        "        super(SASRec, self).__init__()\n",
        "        self.item_num = item_num\n",
        "        self.pad_token = item_num\n",
        "\n",
        "        self.item_emb = nn.Embedding(self.item_num+1, config['hidden_units'], padding_idx=self.pad_token)\n",
        "        self.pos_emb = nn.Embedding(config['maxlen'], config['hidden_units'])\n",
        "        self.emb_dropout = nn.Dropout(p=config['dropout_rate'])\n",
        "\n",
        "        self.attention_layernorms = nn.ModuleList() # to be Q for self-attention\n",
        "        self.attention_layers = nn.ModuleList()\n",
        "        self.forward_layernorms = nn.ModuleList()\n",
        "        self.forward_layers = nn.ModuleList()\n",
        "        self.last_layernorm = nn.LayerNorm(config['hidden_units'], eps=1e-8)\n",
        "\n",
        "        for _ in range(config['num_blocks']):\n",
        "            new_attn_layernorm = nn.LayerNorm(config['hidden_units'], eps=1e-8)\n",
        "            self.attention_layernorms.append(new_attn_layernorm)\n",
        "            new_attn_layer =  nn.MultiheadAttention(\n",
        "                config['hidden_units'],config['num_heads'],config['dropout_rate']\n",
        "            )\n",
        "            self.attention_layers.append(new_attn_layer)\n",
        "\n",
        "            new_fwd_layernorm = nn.LayerNorm(config['hidden_units'], eps=1e-8)\n",
        "            self.forward_layernorms.append(new_fwd_layernorm)\n",
        "\n",
        "            new_fwd_layer = PointWiseFeedForward(config['hidden_units'], config['dropout_rate'])\n",
        "            self.forward_layers.append(new_fwd_layer)\n",
        "        \n",
        "        fix_torch_seed(config['manual_seed'])\n",
        "        self.initialize()\n",
        "\n",
        "\n",
        "    def initialize(self):\n",
        "        for name, param in self.named_parameters():\n",
        "            try:\n",
        "                torch.nn.init.xavier_uniform_(param.data)\n",
        "            except:\n",
        "                pass # just ignore those failed init layers\n",
        "\n",
        "\n",
        "    def log2feats(self, log_seqs):\n",
        "        device = log_seqs.device\n",
        "        seqs = self.item_emb(log_seqs)\n",
        "        seqs *= self.item_emb.embedding_dim ** 0.5\n",
        "        positions = np.tile(np.arange(log_seqs.shape[1]), [log_seqs.shape[0], 1])\n",
        "        seqs += self.pos_emb(torch.LongTensor(positions).to(device))\n",
        "        seqs = self.emb_dropout(seqs)\n",
        "\n",
        "        timeline_mask = log_seqs == self.pad_token\n",
        "        seqs *= ~timeline_mask.unsqueeze(-1) # broadcast in last dim\n",
        "\n",
        "        tl = seqs.shape[1] # time dim len for enforce causality\n",
        "        attention_mask = ~torch.tril(torch.full((tl, tl), True, device=device))\n",
        "\n",
        "        for i in range(len(self.attention_layers)):\n",
        "            seqs = torch.transpose(seqs, 0, 1)\n",
        "            Q = self.attention_layernorms[i](seqs)\n",
        "            mha_outputs, _ = self.attention_layers[i](\n",
        "                Q, seqs, seqs, attn_mask=attention_mask\n",
        "            )\n",
        "        \n",
        "            seqs = Q + mha_outputs\n",
        "            seqs = torch.transpose(seqs, 0, 1)\n",
        "\n",
        "            seqs = self.forward_layernorms[i](seqs)\n",
        "            seqs = self.forward_layers[i](seqs)\n",
        "            seqs *=  ~timeline_mask.unsqueeze(-1)\n",
        "\n",
        "        log_feats = self.last_layernorm(seqs) # (U, T, C) -> (U, -1, C)\n",
        "\n",
        "        return log_feats\n",
        "\n",
        "    def forward(self, log_seqs, pos_seqs, neg_seqs):\n",
        "        log_feats = self.log2feats(log_seqs)\n",
        "        pos_embs = self.item_emb(pos_seqs)\n",
        "        neg_embs = self.item_emb(neg_seqs)\n",
        "\n",
        "        pos_logits = (log_feats * pos_embs).sum(dim=-1)\n",
        "        neg_logits = (log_feats * neg_embs).sum(dim=-1)\n",
        "\n",
        "        return pos_logits, neg_logits\n",
        "\n",
        "\n",
        "    def score(self, seq):\n",
        "        '''\n",
        "        Takes 1d sequence as input and returns prediction scores.\n",
        "        '''\n",
        "        maxlen = self.pos_emb.num_embeddings\n",
        "        log_seqs = torch.full([maxlen], self.pad_token, dtype=torch.int64, device=seq.device)\n",
        "        log_seqs[-len(seq):] = seq[-maxlen:]\n",
        "        log_feats = self.log2feats(log_seqs.unsqueeze(0))\n",
        "        final_feat = log_feats[:, -1, :] # only use last QKV classifier\n",
        "\n",
        "        item_embs = self.item_emb.weight\n",
        "        logits = item_embs.matmul(final_feat.unsqueeze(-1)).squeeze(-1)\n",
        "        return logits"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5j2wvige0JPp"
      },
      "source": [
        "## Training "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "U50P5aEt0JPq"
      },
      "outputs": [],
      "source": [
        "def data_to_sequences(data, data_description):\n",
        "    userid = data_description['users']\n",
        "    itemid = data_description['items']\n",
        "    sequences = (\n",
        "        data.sort_values([userid, data_description['order']])\n",
        "        .groupby(userid, sort=False)[itemid].apply(list)\n",
        "    )\n",
        "    return sequences"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "ibN8tsmb0JPs"
      },
      "outputs": [],
      "source": [
        "def prepare_sasrec_model(config, data, data_description):\n",
        "    n_users = data_description['n_users']    \n",
        "    n_items = data_description['n_items']    \n",
        "    model = SASRec(n_items, config)\n",
        "    criterion = torch.nn.BCEWithLogitsLoss()\n",
        "    if torch.cuda.is_available():\n",
        "        model = model.cuda()\n",
        "        criterion = criterion.cuda()\n",
        "\n",
        "    train_sequences = data_to_sequences(data, data_description)\n",
        "    sampler = sequential_batch_sampler(\n",
        "        train_sequences, n_users, n_items,\n",
        "        batch_size = config['batch_size'],\n",
        "        maxlen = config['maxlen'],\n",
        "        seed = config['sampler_seed'],\n",
        "        pad_token = model.pad_token\n",
        "    )\n",
        "    n_batches = len(train_sequences) // config['batch_size']\n",
        "    optimizer = torch.optim.Adam(\n",
        "        model.parameters(),\n",
        "        lr = config['learning_rate'],\n",
        "        betas = (0.9, 0.98)\n",
        "    )\n",
        "    return model, sampler, n_batches, criterion, optimizer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "DueyEyeA0JPu"
      },
      "outputs": [],
      "source": [
        "def train_sasrec_epoch(model, num_batch, l2_emb, sampler, optimizer, criterion, device):\n",
        "    model.train()\n",
        "    pad_token = model.pad_token\n",
        "    losses = []\n",
        "    for _ in range(num_batch):\n",
        "        _, *seq_data = next(sampler)\n",
        "        # convert batch data into torch tensors\n",
        "        seq, pos, neg = (torch.LongTensor(np.array(x)).to(device) for x in seq_data)\n",
        "        pos_logits, neg_logits = model(seq, pos, neg)\n",
        "        pos_labels = torch.ones(pos_logits.shape, device=device)\n",
        "        neg_labels = torch.zeros(neg_logits.shape, device=device)\n",
        "        optimizer.zero_grad()\n",
        "        indices = torch.where(pos != pad_token)\n",
        "        loss = criterion(pos_logits[indices], pos_labels[indices])\n",
        "        loss += criterion(neg_logits[indices], neg_labels[indices])\n",
        "        if l2_emb != 0:\n",
        "            for param in model.item_emb.parameters():\n",
        "                loss += l2_emb * torch.norm(param)**2\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        losses.append(loss.item())\n",
        "    return losses"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "c6MbltG50JPw"
      },
      "outputs": [],
      "source": [
        "def build_sasrec_model(config, data, data_description):\n",
        "    '''Simple MF training routine without early stopping'''\n",
        "    model, sampler, n_batches, criterion, optimizer = prepare_sasrec_model(config, data, data_description)\n",
        "    device = 'cpu'\n",
        "    if torch.cuda.is_available():\n",
        "        device = torch.device(f'cuda:{torch.cuda.current_device()}') \n",
        "    losses = {}\n",
        "    for epoch in tqdm(range(config['num_epochs'])):\n",
        "        losses[epoch] = train_sasrec_epoch(\n",
        "            model, n_batches, config['l2_emb'], sampler, optimizer, criterion, device\n",
        "        )\n",
        "    return model, losses"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "id": "1B07Kdj10JPx"
      },
      "outputs": [],
      "source": [
        "config = dict(\n",
        "    num_epochs = 100,\n",
        "    maxlen = 200,\n",
        "    hidden_units = 128,\n",
        "    dropout_rate = 0.2,\n",
        "    num_blocks = 3,\n",
        "    num_heads = 1,\n",
        "    batch_size = 64,\n",
        "    sampler_seed = 99,\n",
        "    manual_seed = 111,\n",
        "    learning_rate = 1e-3,\n",
        "    l2_emb = 0,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 49,
          "referenced_widgets": [
            "73ecd96dda2e4fbe874e3158862647ab",
            "7a5f9e1ca1ba47399c05b953264a1f82",
            "f13356ac076a4baba7334707776d9103",
            "b7b8072192ae44d5ad4c4fe49ad82af3",
            "c3b865f06b7e488b9902a7914d3c7835",
            "b8165fc4609c4e929d1abccca4c1d397",
            "c68dcd45731c4363997ef124ac68467a",
            "29df7547e5b848a79d740ace16ef5c0d",
            "2b98f663b3c645dfa791afa1e1321eac",
            "6ddca754312e4949a13b0ebc1d0d13b8",
            "c20ab7702a274be5bed781c88338da7a"
          ]
        },
        "id": "exGnvvWC0JPx",
        "outputId": "96a2d91e-6609-4eb1-e35c-0175304af026"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 200/200 [34:37<00:00, 10.39s/it]\n"
          ]
        }
      ],
      "source": [
        "model, losses = build_sasrec_model(config, train, data_description)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "NuYkmA3h0JPy",
        "outputId": "710143ee-95ba-4976-a3fe-47db593ad1b2"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "pd.Series(losses).apply(np.mean).plot(title='Evolution of SASRec loss', xlabel='Epoch', ylabel='Loss');"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 351
        },
        "id": "BIhHMvv10JPy",
        "outputId": "89cbbec0-1239-4284-e5fd-acedce92745c"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "epoch = 0\n",
        "epoch_loss_series = pd.Series(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": {
        "id": "4Mlp7faD0JPz"
      },
      "source": [
        "# Evaluation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {
        "id": "rh4wpsri0JPz"
      },
      "outputs": [],
      "source": [
        "def sasrec_model_scoring(params, data, data_description):\n",
        "    model = params\n",
        "    model.eval()\n",
        "    tensor = torch.cuda.LongTensor if torch.cuda.is_available() else torch.LongTensor\n",
        "    test_sequences = data_to_sequences(data, data_description)\n",
        "    # perform scoring on a user-batch level\n",
        "    scores = []\n",
        "    for _, seq in test_sequences.items():\n",
        "        with torch.no_grad():\n",
        "            predictions = model.score(tensor(seq))\n",
        "        scores.append(predictions.detach().cpu().numpy())\n",
        "    return np.concatenate(scores, axis=0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {
        "id": "BBzErZuQ0JPz"
      },
      "outputs": [],
      "source": [
        "sasrec_scores = sasrec_model_scoring(model, test, data_description)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {
        "id": "pFrqs2MI0JPz"
      },
      "outputs": [],
      "source": [
        "downvote_seen_items(sasrec_scores, test, data_description)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(0.02126215788283194, 0.004688964052319567, 0.8611705924339758)"
            ]
          },
          "execution_count": 47,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "sasrec_recs = topn_recommendations(sasrec_scores, topn=20)\n",
        "model_evaluate(sasrec_recs, holdout, data_description)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "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.16"
    },
    "orig_nbformat": 4,
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "29df7547e5b848a79d740ace16ef5c0d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "2b98f663b3c645dfa791afa1e1321eac": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "6ddca754312e4949a13b0ebc1d0d13b8": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "73ecd96dda2e4fbe874e3158862647ab": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_7a5f9e1ca1ba47399c05b953264a1f82",
              "IPY_MODEL_f13356ac076a4baba7334707776d9103",
              "IPY_MODEL_b7b8072192ae44d5ad4c4fe49ad82af3"
            ],
            "layout": "IPY_MODEL_c3b865f06b7e488b9902a7914d3c7835"
          }
        },
        "7a5f9e1ca1ba47399c05b953264a1f82": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_b8165fc4609c4e929d1abccca4c1d397",
            "placeholder": "​",
            "style": "IPY_MODEL_c68dcd45731c4363997ef124ac68467a",
            "value": "100%"
          }
        },
        "b7b8072192ae44d5ad4c4fe49ad82af3": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_6ddca754312e4949a13b0ebc1d0d13b8",
            "placeholder": "​",
            "style": "IPY_MODEL_c20ab7702a274be5bed781c88338da7a",
            "value": " 20/20 [01:29&lt;00:00,  4.46s/it]"
          }
        },
        "b8165fc4609c4e929d1abccca4c1d397": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "c20ab7702a274be5bed781c88338da7a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "c3b865f06b7e488b9902a7914d3c7835": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "c68dcd45731c4363997ef124ac68467a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "f13356ac076a4baba7334707776d9103": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_29df7547e5b848a79d740ace16ef5c0d",
            "max": 20,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_2b98f663b3c645dfa791afa1e1321eac",
            "value": 20
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}