Add code for benchmarking

benchmarks/.gitignore

@@ -0,0 +1 @@
+__pycache__/

benchmarks/Dockerfile

@@ -0,0 +1,22 @@
+# cuda11.8 due to implicit
+FROM pytorch/pytorch:2.7.0-cuda11.8-cudnn9-devel@sha256:e567ea2642d4e25ef647e9872d09980613a7b1ecc8d2973e339c60a07343046f
+
+WORKDIR /yambda
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        libsuitesparse-dev \
+        build-essential \
+        git
+
+
+ENV CUDACXX=/usr/local/cuda/bin/nvcc \
+    SUITESPARSE_INCLUDE_DIR=/usr/include/suitesparse \
+    SUITESPARSE_LIBRARY_DIR=/usr/lib
+
+RUN pip install implicit
+
+RUN git clone https://github.com/glami/sansa.git  && cd sansa && pip install . && cd ..
+
+COPY . .
+RUN pip install -e .

benchmarks/lint.sh

@@ -0,0 +1,2 @@
+ruff check --fix ./
+ruff format ./

benchmarks/models/README.md

@@ -0,0 +1,124 @@
+# Reproducibility Guide
+
+## Overview
+
+This part of repo contains the implementation and experiments. This guide will help you reproduce the results using Docker or manual installation.
+
+---
+
+## Docker Setup (Recommended)
+
+### 1. Build Docker Image
+
+```bash
+docker build -t yambda-image .
+```
+
+### 2. Run Container with GPU Support
+
+```bash
+docker run --gpus all \
+           --runtime=nvidia \
+           -it \
+           -v </absolute/path/to/local/data>:/yambda/data \
+           yambda-image
+```
+
+---
+
+## Data Organization
+
+Create following structure in mounted data directory:
+
+```bash
+data/
+├── flat/
+│   └── 50m/
+│       ├── likes.parquet
+│       ├── listens.parquet
+│       └── ...
+└── sequential/
+    └── 50m/
+        ├── likes.parquet
+        ├── listens.parquet
+        └── ...
+```
+
+Note:
+    Sequential data is only needed for sasrec. You can build it from flat using scripts/transform2sequential.py or download
+
+---
+
+## Running Experiments
+
+### General Usage
+
+```bash
+# For example random_rec
+
+cd models/random_rec/
+
+# Show help for main script
+python main.py --help
+
+# Basic execution
+python main.py
+```
+
+### Specific Methods
+
+#### BPR/ALS
+
+```bash
+cd models/bpr_als
+
+python main.py --model bpr
+python main.py --model als
+```
+
+#### SASRec
+
+```bash
+cd models/sasrec
+
+# Training
+python train.py --exp_name exp1
+
+# Evaluation
+python eval.py --exp_name exp1 
+```
+---
+
+## Manual Installation (Not Recommedned)
+
+### 1. Install Core Dependencies
+
+```bash
+pip install torch torchvision torchaudio
+```
+
+### 2. Install Implicit (CUDA 11.8 required)
+
+Implicit works only with cuda<12. See reasons [here](https://github.com/NVIDIA/nvidia-docker/issues/700#issuecomment-381073278)
+
+```bash
+CUDACXX=/usr/local/cuda-11.8/bin/nvcc \
+pip install implicit
+```
+
+### 3. Install SANSA
+
+```bash
+sudo apt-get install libsuitesparse-dev
+git clone https://github.com/glami/sansa.git
+cd sansa && \
+SUITESPARSE_INCLUDE_DIR=/usr/include/suitesparse \
+SUITESPARSE_LIBRARY_DIR=/usr/lib \
+pip install .
+```
+
+### 4. Install Project Package
+
+```bash
+pip install .  # In root directory
+```

benchmarks/models/bpr_als/main.py

@@ -0,0 +1,301 @@
+import json
+from pathlib import Path
+from typing import Any
+
+import click
+import numpy as np
+import optuna
+import polars as pl
+import scipy.sparse as sp
+import torch
+from implicit.gpu.als import AlternatingLeastSquares
+from implicit.gpu.bpr import BayesianPersonalizedRanking
+
+from yambda.constants import Constants
+from yambda.evaluation.metrics import calc_metrics
+from yambda.evaluation.ranking import Embeddings, Targets, rank_items
+from yambda.processing import timesplit
+from yambda.utils import mean_dicts
+
+
+@click.command()
+@click.option(
+    '--data_dir', required=True, type=str, default="../../data/flat", show_default=True, help="Expects flat data"
+)
+@click.option(
+    '--size',
+    required=True,
+    type=click.Choice(['50m', '500m', "5b"]),
+    default=["50m"],
+    multiple=True,
+    show_default=True,
+)
+@click.option(
+    '--interaction',
+    required=True,
+    type=click.Choice(['likes', 'listens']),
+    default=["likes"],
+    multiple=True,
+    show_default=True,
+)
+@click.option(
+    "--model",
+    required=True,
+    type=click.Choice(['als', 'bpr']),
+    multiple=False,
+    show_default=True,
+)
+@click.option('--validation_metric', required=True, type=str, default="ndcg@100", show_default=True)
+@click.option('--report_metrics', required=True, type=str, default=Constants.METRICS, multiple=True, show_default=True)
+@click.option('--device', required=True, type=str, default="cuda:0", show_default=True)
+def main(
+    data_dir: str,
+    size: list[str],
+    interaction: list[str],
+    model: str,
+    validation_metric: str,
+    report_metrics: list[str],
+    device: str,
+):
+    print(f"REPORT METRICS: {report_metrics}")
+
+    for s in size:
+        for i in interaction:
+            print(f"SIZE {s}, INTERACTION {i}")
+            result = bpr_als(
+                data_dir, s, i, device, model, validation_metric=validation_metric, report_metrics=report_metrics
+            )
+            print(json.dumps(result, indent=2))
+
+
+def scan(path: str, dataset_size: str, dataset_name: str) -> pl.LazyFrame:
+    path: Path = Path(path) / dataset_size / dataset_name
+    df = pl.scan_parquet(path.with_suffix(".parquet"))
+    return df
+
+
+def preprocess(
+    df: pl.LazyFrame, interaction: str, val_size: int
+) -> tuple[pl.LazyFrame, pl.LazyFrame | None, pl.LazyFrame]:
+    if interaction == "listens":
+        df = df.filter(pl.col("played_ratio_pct") >= Constants.TRACK_LISTEN_THRESHOLD).select(
+            "uid", "item_id", "timestamp"
+        )
+
+    train, val, test = timesplit.flat_split_train_val_test(
+        df, val_size=val_size, test_timestamp=Constants.TEST_TIMESTAMP
+    )
+
+    return (
+        train,
+        val.collect(engine="streaming").lazy() if val is not None else None,
+        test.collect(engine="streaming").lazy(),
+    )
+
+
+def process_train_data(df: pl.LazyFrame) -> tuple[pl.LazyFrame, list[int], list[int]]:
+    unique_pairs = df.select("uid", "item_id").unique()
+
+    unique_uids = df.select("uid").unique().sort("uid").collect(engine="streaming")["uid"].to_list()
+    unique_item_ids = df.select("item_id").unique().sort("item_id").collect(engine="streaming")["item_id"].to_list()
+
+    return unique_pairs, unique_uids, unique_item_ids
+
+
+def build_csr_matrix(pairs: pl.LazyFrame, unique_uids: list[int], unique_item_ids: list[int]) -> sp.csr_matrix:
+    uid_to_idx = {uid: i for i, uid in enumerate(unique_uids)}
+    item_id_to_idx = {item_id: i for i, item_id in enumerate(unique_item_ids)}
+
+    pairs = pairs.select(
+        pl.col("uid").replace_strict(uid_to_idx, return_dtype=pl.UInt32),
+        pl.col("item_id").replace_strict(item_id_to_idx, return_dtype=pl.UInt32),
+    ).collect(engine="streaming")
+
+    rows, cols = pairs["uid"].to_numpy(), pairs["item_id"].to_numpy()
+    values = np.ones_like(rows, dtype=np.int32)
+
+    return sp.coo_matrix(
+        (values, (rows, cols)), dtype=np.float32, shape=(len(unique_uids), len(unique_item_ids))
+    ).tocsr()
+
+
+def train_embbedings_with_als(
+    user_item_interactions: sp.csr_matrix,
+    regularization: float = 0.01,
+    iterations: int = 100,
+    random_state: int = 42,
+    factors: int = 64,
+) -> tuple[np.ndarray, np.ndarray]:
+    als = AlternatingLeastSquares(
+        factors=factors,
+        regularization=regularization,
+        iterations=iterations,
+        random_state=random_state,
+        calculate_training_loss=False,
+    )
+    als.fit(user_item_interactions, show_progress=False)
+    return als.user_factors.to_numpy(), als.item_factors.to_numpy()
+
+
+def train_embbedings_with_bpr(
+    user_item_interactions: sp.csr_matrix,
+    learning_rate: float = 0.01,
+    regularization: float = 0.01,
+    iterations: int = 100,
+    random_state: int = 42,
+    factors: int = 64,
+) -> tuple[np.ndarray, np.ndarray]:
+    bpr = BayesianPersonalizedRanking(
+        factors=factors,
+        learning_rate=learning_rate,
+        regularization=regularization,
+        iterations=iterations,
+        random_state=random_state,
+        verify_negative_samples=True,
+    )
+    bpr.fit(user_item_interactions, show_progress=False)
+    return bpr.user_factors.to_numpy(), bpr.item_factors.to_numpy()
+
+
+def calc_embeddings_metrics(
+    user_emb: np.ndarray,
+    item_emb: np.ndarray,
+    uid_tensor: torch.Tensor,
+    item_id_tensor: torch.Tensor,
+    targets: Targets,
+    metrics: list[str],
+    device: str,
+) -> dict[str, dict[int, float]]:
+    num_ranked_items = max([int(x.split("@")[1]) for x in metrics])
+    user_emb = Embeddings(uid_tensor, torch.from_numpy(user_emb).to(device))
+    item_emb = Embeddings(item_id_tensor, torch.from_numpy(item_emb).to(device))
+
+    ranked_items = rank_items(user_emb, item_emb, num_ranked_items)
+    return calc_metrics(ranked_items, targets, metrics)
+
+
+def hyperopt(
+    train: pl.LazyFrame,
+    val: pl.LazyFrame,
+    n_trials: int,
+    model: str,
+    validation_metric: str,
+    device: str,
+) -> dict[str, float | int]:
+    pairs, unique_uids, unique_item_ids = process_train_data(train)
+
+    user_item_interactions = build_csr_matrix(pairs, unique_uids, unique_item_ids)
+
+    targets = Targets.from_sequential(val.group_by("uid").agg("item_id").collect(engine="streaming"), device)
+
+    def objective(trial: optuna.Trial) -> float:
+        iterations = trial.suggest_int(name="iterations", low=10, high=300, log=True)
+        regularization = trial.suggest_float(name="regularization", low=1e-5, high=1, log=True)
+
+        if model == "als":
+            user_emb, item_emb = train_embbedings_with_als(user_item_interactions, regularization, iterations)
+        else:
+            learning_rate = trial.suggest_float(name="learning_rate", low=1e-5, high=0.1, log=True)
+            user_emb, item_emb = train_embbedings_with_bpr(
+                user_item_interactions, learning_rate, regularization, iterations
+            )
+
+        metrics = calc_embeddings_metrics(
+            user_emb,
+            item_emb,
+            torch.tensor(unique_uids, device=device),
+            torch.tensor(unique_item_ids, device=device),
+            targets,
+            [validation_metric],
+            device,
+        )
+
+        t, k = validation_metric.split('@')
+        return metrics[t][int(k)]
+
+    optuna.logging.set_verbosity(optuna.logging.WARNING)
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=n_trials)
+
+    return study.best_params
+
+
+def evaluation(
+    train: pl.LazyFrame,
+    test: pl.LazyFrame,
+    model: str,
+    hp: dict[str, Any],
+    random_seeds: list[int],
+    report_metrics: list[str],
+    device: str,
+) -> dict[str, dict[int, float]]:
+    train, unique_uids, unique_item_ids = process_train_data(train)
+
+    user_item_interactions = build_csr_matrix(train, unique_uids, unique_item_ids)
+
+    targets = Targets.from_sequential(
+        test.group_by("uid").agg("item_id").collect(engine="streaming"),
+        device,
+    )
+
+    metrics_list = []
+
+    for seed in random_seeds:
+        if model == "als":
+            user_emb, item_emb = train_embbedings_with_als(
+                user_item_interactions, hp["regularization"], hp["iterations"], seed
+            )
+        else:
+            user_emb, item_emb = train_embbedings_with_bpr(
+                user_item_interactions, hp["learning_rate"], hp["regularization"], hp["iterations"], seed
+            )
+
+        metrics = calc_embeddings_metrics(
+            user_emb,
+            item_emb,
+            torch.tensor(unique_uids, device=device),
+            torch.tensor(unique_item_ids, device=device),
+            targets,
+            report_metrics,
+            device,
+        )
+        metrics_list.append(metrics)
+
+    return mean_dicts(metrics_list)
+
+
+def bpr_als(
+    data_dir: str,
+    size: str,
+    interaction: str,
+    device: str,
+    model: str,
+    validation_metric: str,
+    report_metrics: list[str],
+    n_trials: dict[str, int] = {"50m": 10, "500m": 2, "5b": 2},
+):
+    df = scan(data_dir, size, interaction)
+
+    # hyperopt by validation
+    train, val, _ = preprocess(df, interaction, val_size=Constants.VAL_SIZE)
+    hp = hyperopt(train, val, n_trials[size], model, validation_metric, device)
+
+    print("Best HP:")
+    print(json.dumps(hp, indent=2))
+
+    # final model
+    train, _, test = preprocess(df, interaction, val_size=0)
+
+    return evaluation(
+        train,
+        test,
+        model,
+        hp,
+        random_seeds=[41, 42, 43],
+        report_metrics=report_metrics,
+        device=device,
+    )
+
+
+if __name__ == "__main__":
+    main()

benchmarks/models/itemknn/README.md

@@ -0,0 +1,21 @@
+## ItemKNN
+
+We employ cosine similarity to measure the similarity between vectors. The item vectors are num_users-dimensional vectors derived from the user-item interaction matrix. In the simplest case, we generate top-k recommendations by retrieving the nearest vectors to the user’s most recent item (which corresponds to a decay parameter $\tau \rightarrow 0$). The more general formulation is as follows:
+
+$score(user_i, item_j) = cos(V[i, :], U[:,j])$, 
+
+where $U$ is num_user x num_items interaction matrix,
+
+$V$ is num_users x num_users matrix, $V[i, :] = \sum_{(t, k) \in A_i} \tau^{max_t(i) - t} \cdot U[:, k]^T$, where $A_i$ is set of $i$-th user's (interaction_timestamp, item_index) pairs, $max_t(i)$ is last $i$-th user's interaction timestamp, $\tau$ is the decay coefficient (per second).
+
+The hyperparameter “hour” defines the time period (in hours) associated with a decay factor of 0.9.
+
+For 5b datasets, the matrix multiplications [num_users × num_item] and [num_item × num_items] to obtain [num_user x num_user]  matrix of user embeddings exceed memory constraints. We also use cosine similarity to the mean embedding instead of pairwise similarities to avoid new dimension (x basket_size).
+
+
+
+
+
+
+
+

benchmarks/models/itemknn/main.py

@@ -0,0 +1,253 @@
+import gc
+import json
+from pathlib import Path
+from typing import Any
+
+import click
+import polars as pl
+import torch
+
+from yambda.constants import Constants
+from yambda.evaluation.metrics import calc_metrics
+from yambda.evaluation.ranking import Embeddings, Targets, rank_items
+from yambda.processing import timesplit
+from yambda.utils import argmax
+
+
+DEFAULT_GRIDS = {
+    "50m": {
+        "likes": [0, 0.001, 0.25, 0.5, 1, 2, 3, 4, 6],
+        "listens": [0, 0.001, 0.002, 0.004, 0.008, 0.016, 0.032, 0.064, 0.128, 0.256, 0.5, 1.0, 2],
+    },
+    "500m": {
+        "likes": [0, 0.002, 0.004, 0.008, 0.016, 0.032, 0.064, 0.128, 0.256, 0.5, 1.0],
+        "listens": [0, 0.001, 0.002, 0.004, 0.008],
+    },
+}
+
+
+@click.command()
+@click.option(
+    '--data_dir', required=True, type=str, default="../../data/flat", show_default=True, help="Expects flat data"
+)
+@click.option(
+    '--size',
+    required=True,
+    type=click.Choice(['50m', '500m']),  # 5b is not supported
+    default="50m",
+    multiple=False,
+    show_default=True,
+    help="5b is not supported due to (num_user, num_user) matrix",
+)
+@click.option(
+    '--interaction',
+    required=True,
+    type=click.Choice(['likes', 'listens']),
+    default="likes",
+    multiple=False,
+    show_default=True,
+)
+@click.option(
+    '--hours',
+    required=True,
+    type=float,
+    default=[-1],
+    multiple=True,
+    show_default=True,
+    help="Hyperparameter. If -1 default grid will be used",
+)
+@click.option('--validation_metric', required=True, type=str, default="ndcg@100", show_default=True)
+@click.option('--report_metrics', required=True, type=str, default=Constants.METRICS, multiple=True, show_default=True)
+@click.option('--device', required=True, type=str, default="cuda:0", show_default=True)
+def main(
+    data_dir: str,
+    size: str,
+    interaction: str,
+    hours: list[float],
+    validation_metric: str,
+    report_metrics: list[str],
+    device: str,
+):
+    print(f"REPORT METRICS: {report_metrics}")
+    print(f"SIZE {size}, INTERACTION {interaction}")
+    result = item_knn(
+        data_dir,
+        size,
+        interaction,
+        device,
+        hours=hours if hours[0] != -1 else DEFAULT_GRIDS[size][interaction],
+        validation_metric=validation_metric,
+        report_metrics=report_metrics,
+    )
+    print(json.dumps(result, indent=2))
+
+
+def scan(path: str, dataset_size: str, dataset_name: str) -> pl.LazyFrame:
+    path = Path(path) / dataset_size / dataset_name
+    df = pl.scan_parquet(path.with_suffix(".parquet"))
+    return df
+
+
+def preprocess(
+    df: pl.LazyFrame, interaction: str, val_size: int
+) -> tuple[pl.LazyFrame, pl.LazyFrame | None, pl.LazyFrame]:
+    if interaction == "listens":
+        df = df.filter(pl.col("played_ratio_pct") >= Constants.TRACK_LISTEN_THRESHOLD)
+
+    train, val, test = timesplit.flat_split_train_val_test(
+        df, val_size=val_size, test_timestamp=Constants.TEST_TIMESTAMP
+    )
+
+    return (
+        train,
+        val.collect(engine="streaming").lazy() if val is not None else None,
+        test.collect(engine="streaming").lazy(),
+    )
+
+
+def eliminate_zeros(x: torch.Tensor, threshold: float = 1e-9) -> torch.Tensor:
+    mask = (x._values() > threshold).nonzero()
+    nv = x._values().index_select(0, mask.view(-1))
+    ni = x._indices().index_select(1, mask.view(-1))
+    return torch.sparse_coo_tensor(ni, nv, x.shape)
+
+
+def create_weighted_sparse_tensor(train: pl.LazyFrame, tau: float) -> torch.Tensor:
+    uid_mapping = (
+        train.select("uid").unique().with_columns(pl.col("uid").rank(method="dense").alias("uid_idx") - 1).collect()
+    )
+
+    item_mapping = (
+        train.select("item_id")
+        .unique()
+        .with_columns(pl.col("item_id").rank(method="dense").alias("item_idx") - 1)
+        .collect()
+    )
+
+    processed = (
+        train.with_columns(pl.max("timestamp").over("uid").alias("max_timestamp"))
+        .with_columns((pl.col("max_timestamp") - pl.col("timestamp")).alias("delta"))
+        .with_columns((tau ** pl.col("delta")).alias("weight"))
+        .join(uid_mapping.lazy(), on="uid", how="inner")
+        .join(item_mapping.lazy(), on="item_id", how="inner")
+    )
+
+    coo_data = processed.group_by(["uid_idx", "item_idx"]).agg(pl.sum("weight").alias("total_weight")).collect()
+
+    indices = torch.concat([coo_data["uid_idx"].to_torch()[None, :], coo_data["item_idx"].to_torch()[None, :]], dim=0)
+    values = torch.tensor(coo_data["total_weight"].to_numpy(), dtype=torch.float)
+
+    return eliminate_zeros(
+        torch.sparse_coo_tensor(
+            indices=indices, values=values, size=(uid_mapping["uid_idx"].max() + 1, item_mapping["item_idx"].max() + 1)
+        )
+    )
+
+
+def sparse_normalize(sparse_tensor: torch.Tensor, dim=0, eps=1e-12):
+    indices = sparse_tensor.coalesce().indices()
+    values = sparse_tensor.coalesce().values()
+
+    unique_dim_indices, inverse = torch.unique(indices[dim], return_inverse=True)
+    squared_values = values**2
+    sum_squared = torch.zeros_like(unique_dim_indices, dtype=torch.float32)
+    sum_squared.scatter_add_(0, inverse, squared_values)
+
+    norms = torch.sqrt(sum_squared + eps)
+    normalized_values = values / norms[inverse]
+
+    return torch.sparse_coo_tensor(indices, normalized_values, sparse_tensor.size())
+
+
+def training(
+    train: pl.LazyFrame, hour: float, user_item: torch.Tensor, user_ids: torch.Tensor, device: str, decay: float = 0.9
+) -> Embeddings:
+    tau = 0.0 if hour == 0 else decay ** (1 / 24 / 60 / 60 / (hour / 24))
+
+    user_item_with_tau = create_weighted_sparse_tensor(train, tau)
+    user_embeddings = (user_item_with_tau @ user_item.T).to_dense()
+    user_embeddings = torch.nn.functional.normalize(user_embeddings, dim=-1)
+
+    return Embeddings(user_ids, user_embeddings.to(device))
+
+
+def evaluation(
+    train: pl.LazyFrame, val: pl.LazyFrame, device: str, hours: list[float], metrics: list[str]
+) -> list[dict[str, Any]]:
+    num_ranked_items = max([int(x.split("@")[1]) for x in metrics])
+
+    unique_user_ids = train.select("uid").unique().sort("uid").collect(engine="streaming")["uid"].to_torch().to(device)
+    unique_item_ids = (
+        train.select("item_id").unique().sort("item_id").collect(engine="streaming")["item_id"].to_torch().to(device)
+    )
+
+    user_item = create_weighted_sparse_tensor(train, 1.0)
+    item_embeddings = sparse_normalize(user_item.T.to(device), dim=-1)
+    item_embeddings = Embeddings(unique_item_ids, item_embeddings)
+
+    targets = Targets.from_sequential(
+        val.group_by('uid', maintain_order=True).agg(pl.all().exclude('uid')).select(['uid', 'item_id']),
+        device,
+    )
+
+    hour2metrics = []
+    for hour in hours:
+        user_embeddings = training(
+            train=train,
+            hour=hour,
+            user_item=user_item,
+            user_ids=unique_user_ids,
+            device=device,
+        )
+
+        ranked = rank_items(
+            users=user_embeddings,
+            items=item_embeddings,
+            num_items=num_ranked_items,
+            batch_size=128,
+        )
+
+        del user_embeddings
+        gc.collect()
+
+        hour2metrics.append(calc_metrics(ranked, targets, metrics))
+
+    del unique_user_ids
+    del unique_item_ids
+    del item_embeddings
+    del targets
+    gc.collect()
+
+    return hour2metrics
+
+
+def item_knn(
+    data_dir: str,
+    size: str,
+    interaction: str,
+    device: str,
+    hours: list[float],
+    validation_metric: str,
+    report_metrics: list[str],
+) -> dict[str, Any]:
+    df = scan(data_dir, size, interaction)
+
+    # hyperopt by validation
+    train, val, _ = preprocess(df, interaction, val_size=Constants.VAL_SIZE)
+
+    results = evaluation(train, val, device, hours, [validation_metric])
+
+    metric_name, k = validation_metric.split('@')
+
+    best_hour = hours[argmax(results, lambda x: x[metric_name][int(k)])]
+
+    print(f"FINAL HYPERPARAMS {best_hour=}")
+
+    # train final model
+    train, _, test = preprocess(df, interaction, val_size=0)
+
+    return evaluation(train, test, device, [best_hour], report_metrics)[0]
+
+
+if __name__ == "__main__":
+    main()

benchmarks/models/popularity/main.py

@@ -0,0 +1,183 @@
+import json
+from pathlib import Path
+from typing import Any
+
+import click
+import polars as pl
+import torch
+
+from yambda.constants import Constants
+from yambda.evaluation.metrics import calc_metrics
+from yambda.evaluation.ranking import Embeddings, Ranked, Targets
+from yambda.processing import timesplit
+from yambda.utils import argmax
+
+
+@click.command()
+@click.option(
+    '--data_dir', required=True, type=str, default="../../data/flat", show_default=True, help="Expects flat data"
+)
+@click.option(
+    '--size',
+    required=True,
+    type=click.Choice(['50m', '500m', "5b"]),
+    default=["50m"],
+    multiple=True,
+    show_default=True,
+)
+@click.option(
+    '--interaction',
+    required=True,
+    type=click.Choice(['likes', 'listens']),
+    default=["likes"],
+    multiple=True,
+    show_default=True,
+)
+@click.option(
+    '--hours',
+    required=True,
+    type=float,
+    default=[0.5, 1, 2, 3, 6, 12, 24],
+    multiple=True,
+    show_default=True,
+    help="Hyperparameter",
+)
+@click.option('--validation_metric', required=True, type=str, default="ndcg@100", show_default=True)
+@click.option('--report_metrics', required=True, type=str, default=Constants.METRICS, multiple=True, show_default=True)
+@click.option('--device', required=True, type=str, default="cuda:0", show_default=True)
+def main(
+    data_dir: str,
+    size: list[str],
+    interaction: list[str],
+    hours: list[float],
+    validation_metric: str,
+    report_metrics: list[str],
+    device: str,
+):
+    print(f"REPORT METRICS: {report_metrics}")
+    for s in size:
+        for i in interaction:
+            print(f"SIZE {s}, INTERACTION {i}")
+            result = popularity(
+                data_dir,
+                s,
+                i,
+                device,
+                hours=hours,
+                validation_metric=validation_metric,
+                report_metrics=report_metrics,
+            )
+            print(json.dumps(result, indent=2))
+
+
+def scan(path: str, dataset_size: str, dataset_name: str) -> pl.LazyFrame:
+    path: Path = Path(path) / dataset_size / dataset_name
+    df = pl.scan_parquet(path.with_suffix(".parquet"))
+    return df
+
+
+def preprocess(
+    df: pl.LazyFrame, interaction: str, val_size: int
+) -> tuple[pl.LazyFrame, pl.LazyFrame | None, pl.LazyFrame]:
+    if interaction == "listens":
+        df = df.filter(pl.col("played_ratio_pct") >= Constants.TRACK_LISTEN_THRESHOLD)
+
+    train, val, test = timesplit.flat_split_train_val_test(
+        df, val_size=val_size, test_timestamp=Constants.TEST_TIMESTAMP
+    )
+
+    return (
+        train,
+        val.collect(engine="streaming").lazy() if val is not None else None,
+        test.collect(engine="streaming").lazy(),
+    )
+
+
+def training(hour: float, train: pl.LazyFrame, max_timestamp: float, device: str, decay: float = 0.9) -> Embeddings:
+    if hour == 0:
+        embeddings = train.group_by("item_id").agg(pl.count().alias("item_embedding")).collect(engine="streaming")
+    else:
+        tau = decay ** (1 / Constants.DAY_SECONDS / (hour / 24))
+
+        embeddings = (
+            train.select(
+                "item_id",
+                (tau ** (max_timestamp - pl.col("timestamp"))).alias("value"),
+            )
+            .group_by("item_id")
+            .agg(pl.col("value").sum().alias("item_embedding"))
+            .collect(engine="streaming")
+        )
+
+    item_ids = embeddings["item_id"].to_torch().to(device)
+
+    item_embeddings = embeddings["item_embedding"].to_torch().to(device)[:, None]
+
+    return Embeddings(item_ids, item_embeddings)
+
+
+def evaluation(
+    train: pl.LazyFrame, val: pl.LazyFrame, device: str, hours: list[float], metrics: list[str]
+) -> list[dict[str, Any]]:
+    num_ranked_items = max([int(x.split("@")[1]) for x in metrics])
+
+    max_timestamp = train.select(pl.col("timestamp").max()).collect(engine="streaming").item()
+    user_ids = train.select("uid").unique().collect(engine="streaming")["uid"].to_torch().to(device)
+
+    targets = Targets.from_sequential(
+        val.group_by('uid', maintain_order=True).agg("item_id"),
+        device,
+    )
+
+    hour2metrics = []
+    for hour in hours:
+        item_embeddings = training(
+            hour=hour,
+            train=train,
+            max_timestamp=max_timestamp,
+            device=device,
+        )
+
+        ranked = Ranked(
+            user_ids=user_ids,
+            item_ids=item_embeddings.ids[torch.topk(item_embeddings.embeddings, num_ranked_items, dim=0).indices]
+            .ravel()
+            .expand((user_ids.shape[0], num_ranked_items)),
+            num_item_ids=item_embeddings.ids.shape[0],
+        )
+
+        hour2metrics.append(calc_metrics(ranked, targets, metrics))
+
+    return hour2metrics
+
+
+def popularity(
+    data_dir: str,
+    size: str,
+    interaction: str,
+    device: str,
+    hours: list[float],
+    validation_metric: str,
+    report_metrics: list[str],
+) -> dict[str, Any]:
+    df = scan(data_dir, size, interaction)
+
+    # hyperopt by validation
+    train, val, _ = preprocess(df, interaction, val_size=Constants.VAL_SIZE)
+
+    results = evaluation(train, val, device, hours, [validation_metric])
+
+    metric_name, k = validation_metric.split('@')
+
+    best_hour = hours[argmax(results, lambda x: x[metric_name][int(k)])]
+
+    print(f"FINAL HYPERPARAMS {best_hour=}")
+
+    # train final model
+    train, _, test = preprocess(df, interaction, val_size=0)
+
+    return evaluation(train, test, device, [best_hour], report_metrics)[0]
+
+
+if __name__ == "__main__":
+    main()

benchmarks/models/random_rec/main.py

@@ -0,0 +1,128 @@
+import json
+from pathlib import Path
+
+import click
+import polars as pl
+import torch
+
+from yambda.constants import Constants
+from yambda.evaluation.metrics import calc_metrics
+from yambda.evaluation.ranking import Ranked, Targets
+from yambda.processing import timesplit
+from yambda.utils import mean_dicts
+
+
+@click.command()
+@click.option(
+    '--data_dir',
+    required=True,
+    type=str,
+    default="../../data/flat",
+    show_default=True,
+    help="Expects flat data",
+)
+@click.option(
+    '--size',
+    required=True,
+    type=click.Choice(['50m', '500m', "5b"]),
+    default=["50m"],
+    multiple=True,
+    show_default=True,
+)
+@click.option(
+    '--interaction',
+    required=True,
+    type=click.Choice(['likes', 'listens']),
+    default=["likes"],
+    multiple=True,
+    show_default=True,
+)
+@click.option('--device', required=True, type=str, default="cuda:0", show_default=True)
+@click.option('--num_repeats', required=True, type=int, default=2, show_default=True)
+def main(
+    data_dir: str,
+    size: list[str],
+    interaction: list[str],
+    device: str,
+    num_repeats: int,
+):
+    print(f"calc metrics: {Constants.METRICS}")
+    for s in size:
+        for i in interaction:
+            print(f"SIZE {s}, INTERACTION {i}")
+            result = random_rec(data_dir, s, i, num_repeats, device)
+            print(json.dumps(result, indent=2))
+
+
+def scan(path: str, dataset_size: str, dataset_name: str) -> pl.LazyFrame:
+    path: Path = Path(path) / dataset_size / dataset_name
+    return pl.scan_parquet(path.with_suffix(".parquet"))
+
+
+def preprocess(
+    df: pl.LazyFrame, interaction: str, val_size: int
+) -> tuple[pl.LazyFrame, pl.LazyFrame | None, pl.LazyFrame]:
+    if interaction == "listens":
+        df = df.filter(pl.col("played_ratio_pct") >= Constants.TRACK_LISTEN_THRESHOLD)
+
+    train, val, test = timesplit.flat_split_train_val_test(
+        df, val_size=val_size, test_timestamp=Constants.TEST_TIMESTAMP
+    )
+
+    return (
+        train,
+        val.collect(engine="streaming").lazy() if val is not None else None,
+        test.collect(engine="streaming").lazy(),
+    )
+
+
+def random_rec(
+    data_dir: str,
+    size: str,
+    interaction: str,
+    num_repeats: int,
+    device: str,
+) -> dict[str, dict[int, float]]:
+    df = scan(data_dir, size, interaction)
+
+    train, _, test = preprocess(df, interaction, val_size=0)
+
+    unique_user_ids = train.select("uid").unique().sort("uid").collect(engine="streaming")["uid"].to_torch().to(device)
+
+    unique_item_ids = (
+        train.select("item_id").unique().sort("item_id").collect(engine="streaming")["item_id"].to_torch().to(device)
+    )
+
+    print(f"NUM_USERS {unique_user_ids.shape[0]}, NUM_ITEMS {unique_item_ids.shape[0]}")
+
+    targets = Targets.from_sequential(
+        test.group_by('uid', maintain_order=True).agg("item_id"),
+        device,
+    )
+
+    metrics_list = []
+
+    for _ in range(num_repeats):
+        ranked = Ranked(
+            user_ids=unique_user_ids,
+            item_ids=unique_item_ids[
+                torch.randint(
+                    0, unique_item_ids.shape[0] - 1, size=(unique_user_ids.shape[0], Constants.NUM_RANKED_ITEMS)
+                )
+            ],
+            num_item_ids=unique_item_ids.shape[0],
+        )
+
+        metrics_list.append(
+            calc_metrics(
+                ranked,
+                targets,
+                metrics=Constants.METRICS,
+            )
+        )
+
+    return mean_dicts(metrics_list)
+
+
+if __name__ == "__main__":
+    main()

benchmarks/models/sansa/README.md

@@ -0,0 +1,9 @@
+## SANSA
+
+Training SANSA on Yambda-500M with Listens, on Yambda-5B with Likes and on Yambda-5B with Listens is infeasible due to the memory explosion during sparse matrix multiplication. 
+
+For example, given the base weights density of $5e-5$, the sparse matrix multiplication for Yambda-500M with Listens requires $466512103 * (3004578 ^ 2 * 5e-5) = 2.1e17 $ operations.
+
+One may observe that the good solution is to try to reduce the weights density. However given the results on Yambda-50M with Listens, further reducing density would collapse the model’s capacity, it becomes obvious that it is just practically futile. 
+
+Unfortunately the main SANSA repository is not optimized for large datasets, so even on the Yambda-50M with Listens at least 100GB of RAM is required.

benchmarks/models/sansa/main.py

@@ -0,0 +1,284 @@
+import heapq
+import json
+import os
+import time
+from typing import Any
+
+import click
+import numpy as np
+import polars as pl
+import scipy.sparse as sp
+import torch
+from sansa import SANSA, ICFGramianFactorizerConfig, SANSAConfig, UMRUnitLowerTriangleInverterConfig
+from tqdm import tqdm
+
+from yambda.constants import Constants
+from yambda.evaluation import metrics, ranking
+from yambda.processing import timesplit
+
+
+RANDOM_SEED = 42
+
+
+@click.command()
+@click.option(
+    '--data_dir', required=True, type=str, default="../../data/flat", show_default=True, help="Expects flat data"
+)
+@click.option(
+    '--size',
+    required=True,
+    type=click.Choice(['50m', '500m']),
+    default="50m",
+    multiple=False,
+    show_default=True,
+)
+@click.option(
+    '--interaction',
+    required=True,
+    type=click.Choice(['likes', 'listens']),
+    default="likes",
+    multiple=False,
+    show_default=True,
+)
+@click.option('--report_metrics', required=True, type=str, default=Constants.METRICS, multiple=True, show_default=True)
+@click.option('--device', required=True, type=str, default="cuda:0", show_default=True)
+def main(
+    data_dir: str,
+    size: str,
+    interaction: str,
+    report_metrics: list[str],
+    device: str,
+):
+    print(f"REPORT METRICS: {report_metrics}")
+    print(f"SIZE {size}, INTERACTION {interaction}")
+    result = train_sansa_model(
+        data_dir,
+        size=size,
+        dataset_type=interaction,
+        device=device,
+        report_metrics=report_metrics,
+    )
+    print(json.dumps(result, indent=2))
+
+
+def train_sansa_model(
+    data_path: str,
+    size: str,
+    dataset_type: str,
+    device: str,
+    report_metrics: list[str],
+) -> dict[str, Any]:
+    np.random.seed(RANDOM_SEED)
+
+    curr_time = time.time()
+    print()
+    print(curr_time)
+    print(f"Size: {size}, Dataset: {dataset_type}")
+    df, grouped_test, train, test = get_train_val_test_matrices(
+        data_path=data_path,
+        size=size,
+        dataset_type=dataset_type,
+    )
+    data_finished = time.time()
+    print(f"Data is loaded in {data_finished - curr_time} seconds")
+
+    model = get_sansa_model()
+    model.fit(train)
+    train_finished = time.time()
+
+    print(f"Model is trained in {train_finished - data_finished}")
+    print(model)
+
+    if report_metrics:
+        calculated_metrics = evaluate_sansa(
+            df=df,
+            model=model,
+            device=device,
+            report_metrics=report_metrics,
+            grouped_test=grouped_test,
+            sparse_train=train,
+            sparse_test=test,
+        )
+
+        print(f"Model is evaluated in {time.time() - train_finished}")
+
+        return calculated_metrics
+
+    return {}
+
+
+def get_train_val_test_matrices(
+    data_path: str,
+    size: str = "50m",
+    dataset_type: str = "likes",
+) -> tuple[pl.LazyFrame, pl.LazyFrame, sp.csr_matrix, sp.csr_matrix]:
+    df = pl.scan_parquet(os.path.join(os.path.join(data_path, size, f"{dataset_type}.parquet")))
+
+    if dataset_type == "listens":
+        df = df.filter(pl.col("played_ratio_pct") >= Constants.TRACK_LISTEN_THRESHOLD)
+
+    flat_train, _, flat_test = timesplit.flat_split_train_val_test(
+        df, val_size=0, test_timestamp=Constants.TEST_TIMESTAMP
+    )
+
+    all_uids = set(flat_train.collect().get_column("uid").to_list())
+    all_items = set(flat_train.collect().get_column("item_id").to_list())
+
+    print(f"Dataset, users_num: {len(all_uids)}, items_num: {len(all_items)}")
+
+    # Create mapping to create sparse matrix
+    uid_to_idx = {uid: i for i, uid in enumerate(all_uids)}
+    item_id_to_idx = {item_id: i for i, item_id in enumerate(all_items)}
+
+    sparse_train, _ = get_sparse_data(flat_train, uid_to_idx, item_id_to_idx)
+    sparse_test, grouped_test = get_sparse_data(flat_test, uid_to_idx, item_id_to_idx)
+
+    print(f"Sparse train shape: {sparse_train.shape}, test shape: {sparse_test.shape}")
+
+    return df, grouped_test, sparse_train, sparse_test
+
+
+def get_sparse_data(
+    df: pl.LazyFrame, uid_to_idx: dict[int, int], item_id_to_idx: dict[int, int]
+) -> tuple[sp.csr_matrix, pl.LazyFrame]:
+    df = df.with_columns(
+        pl.col("uid").replace_strict(uid_to_idx).alias("uid"),
+        pl.col("item_id").replace_strict(item_id_to_idx, default=len(item_id_to_idx)).alias("item_id"),
+        pl.lit(1).alias("action"),
+    )
+
+    grouped_df = df.group_by('uid', maintain_order=True).agg(
+        [pl.col('item_id').alias('item_id'), pl.col('action').alias('actions')]
+    )
+
+    rows = []
+    cols = []
+    values = []
+
+    for user_id, item_ids, actions in tqdm(grouped_df.select('uid', 'item_id', 'actions').collect().rows()):
+        rows.extend([user_id] * len(item_ids))
+        cols.extend(item_ids)
+        values.extend(actions)
+
+    user_item_data = sp.csr_matrix(
+        (values, (rows, cols)),
+        dtype=np.float32,
+        shape=(len(uid_to_idx), len(item_id_to_idx) + 1),  # +1 for default unknown test items
+    )
+
+    return user_item_data, grouped_df
+
+
+def get_sansa_model() -> SANSA:
+    factorizer_config = ICFGramianFactorizerConfig(
+        # reordering_use_long=True,
+        factorization_shift_step=1e-3,  # initial diagonal shift if incomplete factorization fails
+        factorization_shift_multiplier=2.0,  # multiplier for the shift for subsequent attempts
+    )
+
+    inverter_config = UMRUnitLowerTriangleInverterConfig(
+        scans=1,  # number of scans through all columns of the matrix
+        finetune_steps=15,  # number of finetuning steps, targeting worst columns
+    )
+
+    config = SANSAConfig(
+        l2=10.0,  # regularization strength
+        weight_matrix_density=5e-5,  # desired density of weights
+        gramian_factorizer_config=factorizer_config,  # factorizer configuration
+        lower_triangle_inverter_config=inverter_config,  # inverter configuration
+    )
+
+    print(config)
+
+    model = SANSA(config)
+
+    return model
+
+
+def evaluate_sansa(
+    df: pl.LazyFrame,
+    model: SANSA,
+    device: str,
+    report_metrics: list[str],
+    grouped_test: pl.LazyFrame,
+    sparse_train: sp.csr_matrix,
+    sparse_test: sp.csr_matrix,
+) -> dict[str, Any]:
+    num_items_for_metrics = len(set(df.collect().get_column("item_id").to_list()))
+    print(num_items_for_metrics)
+
+    test_targets = ranking.Targets.from_sequential(grouped_test, device=device)
+    print(len(test_targets.user_ids))
+
+    # to free some RAM
+    del df, grouped_test
+
+    train_pred_sparse = model.forward(sparse_train)
+    print(f"Train prediction shape: {train_pred_sparse.shape}")
+
+    A = train_pred_sparse
+    num_users = A.shape[0]
+    num_items_k = 150
+
+    # 0 if there is no such item
+    top_items_idx = np.full((num_users, num_items_k), 0, dtype=int)
+
+    # -1 score if there is no such item
+    top_items_score = np.full((num_users, num_items_k), -1, dtype=A.data.dtype)
+
+    for row in tqdm(range(num_users)):
+        start, end = A.indptr[row], A.indptr[row + 1]
+        row_scores = A.data[start:end]
+        row_cols = A.indices[start:end]
+
+        if len(row_scores) == 0:
+            continue
+
+        k_here = min(num_items_k, len(row_scores))
+        top_k = heapq.nlargest(k_here, zip(row_scores, row_cols), key=lambda x: x[0])
+
+        # Fill in
+        for i, (score, idx) in enumerate(top_k):
+            top_items_idx[row, i] = idx
+            top_items_score[row, i] = score
+
+    user_ids = torch.arange(top_items_idx.shape[0], dtype=torch.int32, device="cpu")
+    print(user_ids.shape)
+
+    scores = torch.as_tensor(top_items_score, dtype=torch.float32, device="cpu")
+    print(scores.shape)
+
+    scores_indices = torch.as_tensor(top_items_idx, dtype=torch.long, device="cpu")
+    print(scores_indices.shape)
+
+    targets = torch.as_tensor(sparse_test.toarray(), dtype=torch.bool, device="cpu")
+    print(targets.shape)
+
+    targets = targets.to(dtype=torch.bool, device=device)
+    not_zero_user_indices = targets.any(dim=1)
+    print(torch.sum(not_zero_user_indices))
+
+    not_zero_user_indices = not_zero_user_indices.to(dtype=torch.bool, device="cpu")
+
+    user_ids = user_ids[not_zero_user_indices]
+    scores = scores[not_zero_user_indices]
+    print(f"After removing zero users scores shape: {scores.shape}, targets shape: {targets.shape}")
+
+    scores_indices = scores_indices[not_zero_user_indices]
+    print(scores_indices.shape)
+
+    test_ranked = ranking.Ranked(
+        user_ids=user_ids.to(device),
+        scores=scores.to(device),
+        item_ids=scores_indices.to(device),
+        num_item_ids=num_items_for_metrics,
+    )
+
+    calculated_metrics = metrics.calc_metrics(test_ranked, test_targets, report_metrics)
+    print(calculated_metrics)
+
+    return calculated_metrics
+
+
+if __name__ == "__main__":
+    main()

benchmarks/models/sasrec/data.py

@@ -0,0 +1,194 @@
+import logging
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import Dict, List
+
+import numpy as np
+import polars as pl
+import torch
+
+from yambda.constants import Constants
+from yambda.processing import timesplit
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Data:
+    train: pl.LazyFrame
+    validation: pl.LazyFrame | None
+    test: pl.LazyFrame
+    item_id_to_idx: dict[int, int]
+
+    _train_user_ids: torch.Tensor | None = field(init=False, default=None)
+
+    @property
+    def num_items(self):
+        return len(self.item_id_to_idx)
+
+    @cached_property
+    def num_train_users(self):
+        return self.train.select(pl.len()).collect(engine="streaming").item()
+
+    def train_user_ids(self, device):
+        if self._train_user_ids is None or self._train_user_ids.device != device:
+            self._train_user_ids = self.train.select('uid').collect(engine="streaming")['uid'].to_torch().to(device)
+        return self._train_user_ids
+
+
+def preprocess(df: pl.LazyFrame, interaction: str, val_size=Constants.VAL_SIZE, max_seq_len: int = 200) -> Data:
+    """
+    Preprocesses raw interaction data for recommendation system modeling.
+
+    Args:
+        df (pl.LazyFrame): Raw input data containing user interaction sequences
+        interaction (str): Type of interaction to process. Must be either 'likes' or 'listens'.
+        val_size (float): Proportion of data to use for validation (default: from Constants)
+
+    Returns:
+        Data: Named tuple containing:
+            - train (pl.LazyFrame): Training data
+            - val (pl.LazyFrame): Validation data
+            - test (pl.LazyFrame): Test data
+            - item_id_to_idx (dict): Mapping from original item IDs to model indices
+
+    Note:
+        - For 'listens' interactions, uses strict engagement threshold
+        - Item indices start at 1 to reserve 0 for padding/masking
+    """
+    if interaction == 'listens':
+        df = df.select(
+            'uid',
+            pl.col('item_id', 'timestamp').list.gather(
+                pl.col('played_ratio_pct').list.eval(pl.arg_where(pl.element() >= Constants.TRACK_LISTEN_THRESHOLD))
+            ),
+        ).filter(pl.col('item_id').list.len() > 0)
+
+    unique_item_ids = (
+        df.select(pl.col("item_id").explode().unique().sort()).collect(engine="streaming")["item_id"].to_list()
+    )
+
+    item_id_to_idx = {int(item_id): i + 1 for i, item_id in enumerate(unique_item_ids)}
+
+    train, val, test = timesplit.sequential_split_train_val_test(
+        df, val_size=val_size, test_timestamp=Constants.TEST_TIMESTAMP, drop_non_train_items=False
+    )
+
+    def replace_strict(df):
+        return (
+            df.select(
+                pl.col("item_id").list.eval(pl.element().replace_strict(item_id_to_idx)),
+                pl.all().exclude("item_id"),
+            )
+            .collect(engine="streaming")
+            .lazy()
+        )
+
+    # polars requires too much memory for replace strict if list is too big
+    train = train.select('uid', pl.all().exclude('uid').list.slice(-max_seq_len, max_seq_len))
+    train = replace_strict(train)
+
+    if val is not None:
+        val = replace_strict(val)
+
+    test = replace_strict(test)
+
+    return Data(train, val, test, item_id_to_idx)
+
+
+class TrainDataset:
+    def __init__(self, dataset: pl.DataFrame, num_items: int, max_seq_len: int):
+        self._dataset = dataset
+        self._num_items = num_items
+        self._max_seq_len = max_seq_len
+
+    @property
+    def dataset(self) -> pl.DataFrame:
+        return self._dataset
+
+    def __len__(self) -> int:
+        return len(self._dataset)
+
+    def __getitem__(self, index: int) -> Dict[str, List[int] | int]:
+        sample = self._dataset.row(index, named=True)
+
+        item_sequence = sample['item_id'][:-1][-self._max_seq_len :]
+        positive_sequence = sample['item_id'][1:][-self._max_seq_len :]
+        negative_sequence = np.random.randint(1, self._num_items + 1, size=(len(item_sequence),)).tolist()
+
+        return {
+            'user.ids': [sample['uid']],
+            'user.length': 1,
+            'item.ids': item_sequence,
+            'item.length': len(item_sequence),
+            'positive.ids': positive_sequence,
+            'positive.length': len(positive_sequence),
+            'negative.ids': negative_sequence,
+            'negative.length': len(negative_sequence),
+        }
+
+
+class EvalDataset:
+    def __init__(self, dataset: pl.DataFrame, max_seq_len: int):
+        self._dataset = dataset
+        self._max_seq_len = max_seq_len
+
+    @property
+    def dataset(self) -> pl.DataFrame:
+        return self._dataset
+
+    def __len__(self) -> int:
+        return len(self._dataset)
+
+    def __getitem__(self, index: int) -> Dict[str, List[int] | int]:
+        sample = self._dataset.row(index, named=True)
+
+        item_sequence = sample['item_id_train'][-self._max_seq_len :]
+        next_items = sample['item_id_valid']
+
+        return {
+            'user.ids': [sample['uid']],
+            'user.length': 1,
+            'item.ids': item_sequence,
+            'item.length': len(item_sequence),
+            'labels.ids': next_items,
+            'labels.length': len(next_items),
+        }
+
+
+def collate_fn(batch: List[Dict]) -> Dict[str, torch.Tensor]:
+    """
+    Collates a batch of samples into batched tensors suitable for model input.
+
+    This function processes a list of dictionaries, each containing keys like '{prefix}.ids'
+    and '{prefix}.length' (the length of the sequence for that prefix). For each such prefix, it:
+        - Concatenates all '{prefix}.ids' lists from the batch into a single flat list.
+        - Collects all '{prefix}.length' values into a list.
+        - Converts the resulting lists into torch.LongTensor objects.
+
+    Args:
+        batch (List[Dict]): List of sample dictionaries. Each sample must contain keys of the form
+            '{prefix}.ids' (list of ints) and '{prefix}.length' (int).
+
+    Returns:
+        Dict[str, torch.Tensor]: Dictionary with keys '{prefix}.ids' and '{prefix}.length' for each prefix,
+            where values are 1D torch.LongTensor objects suitable for model input.
+    """
+    processed_batch = {}
+    for key in batch[0].keys():
+        if key.endswith('.ids'):
+            prefix = key.split('.')[0]
+            assert '{}.length'.format(prefix) in batch[0]
+
+            processed_batch[f'{prefix}.ids'] = []
+            processed_batch[f'{prefix}.length'] = []
+
+            for sample in batch:
+                processed_batch[f'{prefix}.ids'].extend(sample[f'{prefix}.ids'])
+                processed_batch[f'{prefix}.length'].append(sample[f'{prefix}.length'])
+
+    for part, values in processed_batch.items():
+        processed_batch[part] = torch.tensor(values, dtype=torch.long)
+
+    return processed_batch

benchmarks/models/sasrec/eval.py

@@ -0,0 +1,127 @@
+import logging
+import pathlib as Path
+import random
+
+import click
+import numpy as np
+import polars as pl
+import torch
+from model import SASRecEncoder
+from torch.utils.data import DataLoader
+
+from data import Data, EvalDataset, collate_fn, preprocess
+from yambda.evaluation.metrics import calc_metrics
+from yambda.evaluation.ranking import Embeddings, Targets, rank_items
+
+
+logging.basicConfig(
+    level=logging.DEBUG, format='[%(asctime)s] [%(levelname)s]: %(message)s', datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+
+def infer_users(eval_dataloader: DataLoader, model: torch.nn.Module, device: str):
+    user_ids = []
+    user_embeddings = []
+
+    model.eval()
+    for batch in eval_dataloader:
+        for key in batch.keys():
+            batch[key] = batch[key].to(device)
+
+        user_ids.append(batch['user.ids'])  # (batch_size)
+        user_embeddings.append(model(batch))  # (batch_size, embedding_dim)
+
+    return torch.cat(user_ids, dim=0), torch.cat(user_embeddings, dim=0)
+
+
+def infer_items(model: SASRecEncoder):
+    return model.item_embeddings.weight.data
+
+
+@click.command()
+@click.option('--exp_name', required=True, type=str)
+@click.option('--data_dir', required=True, type=str, default='../../data/', show_default=True)
+@click.option(
+    '--size',
+    required=True,
+    type=click.Choice(['50m', '500m', '5b']),
+    default='50m',
+    show_default=True,
+)
+@click.option(
+    '--interaction',
+    required=True,
+    type=click.Choice(['likes', 'listens']),
+    default='likes',
+    show_default=True,
+)
+@click.option('--batch_size', required=True, type=int, default=256, show_default=True)
+@click.option('--max_seq_len', required=False, type=int, default=200, show_default=True)
+@click.option('--seed', required=False, type=int, default=42, show_default=True)
+@click.option('--device', required=True, type=str, default='cuda:0', show_default=True)
+def main(
+    exp_name: str,
+    data_dir: str,
+    size: str,
+    interaction: str,
+    batch_size: int,
+    max_seq_len: int,
+    seed: int,
+    device: str,
+):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.set_float32_matmul_precision('high')
+
+    path = Path.Path(data_dir) / 'sequential' / size / interaction
+    df = pl.scan_parquet(path.with_suffix('.parquet'))
+
+    logger.debug('Preprocessing data...')
+    data: Data = preprocess(df, interaction, val_size=0, max_seq_len=max_seq_len)
+    train_df = data.train.collect(engine="streaming")
+    eval_df = data.test.collect(engine="streaming")
+    logger.debug('Preprocessing data has finished!')
+
+    eval_df = train_df.join(eval_df, on='uid', how='inner', suffix='_valid').select(
+        pl.col('uid'), pl.col('item_id').alias('item_id_train'), pl.col('item_id_valid')
+    )
+    eval_dataset = EvalDataset(dataset=eval_df, max_seq_len=max_seq_len)
+
+    eval_dataloader = DataLoader(
+        dataset=eval_dataset,
+        batch_size=batch_size,
+        collate_fn=collate_fn,
+        drop_last=False,
+        shuffle=True,
+    )
+
+    model = torch.load(f'./checkpoints/{exp_name}_best_state.pth', weights_only=False).to(device)
+    model.eval()
+    with torch.inference_mode():
+        user_ids, user_embeddings = infer_users(eval_dataloader=eval_dataloader, model=model, device=device)
+
+        item_embeddings = infer_items(model=model)
+
+    item_embeddings = Embeddings(
+        ids=torch.arange(start=0, end=item_embeddings.shape[0], device=device), embeddings=item_embeddings
+    )
+    user_embeddings = Embeddings(ids=user_ids, embeddings=user_embeddings)
+
+    df_user_ids = torch.tensor(eval_df['uid'].to_list(), dtype=torch.long, device=device)
+    df_target_ids = [
+        torch.tensor(item_ids, dtype=torch.long, device=device) for item_ids in eval_df['item_id_valid'].to_list()
+    ]
+    targets = Targets(user_ids=df_user_ids, item_ids=df_target_ids)
+    with torch.no_grad():
+        ranked = rank_items(users=user_embeddings, items=item_embeddings, num_items=100)
+
+    metric_names = [f'{name}@{k}' for name in ["recall", "ndcg", "coverage"] for k in [10, 50, 100]]
+    metrics = calc_metrics(ranked, targets, metrics=metric_names)
+    print(metrics)
+
+
+if __name__ == '__main__':
+    main()

benchmarks/models/sasrec/model.py

@@ -0,0 +1,270 @@
+from typing import Dict, Tuple
+
+import torch
+import torch.nn as nn
+
+
+def create_masked_tensor(data: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Converts a batch of variable-length sequences into a padded tensor and corresponding mask.
+
+    Args:
+        data (torch.Tensor): Input tensor containing flattened sequences.
+            - For indices: shape (total_elements,) of dtype long
+            - For embeddings: shape (total_elements, embedding_dim)
+        lengths (torch.Tensor): 1D tensor of sequence lengths, shape (batch_size,)
+
+    Returns:
+        Tuple[torch.Tensor, torch.Tensor]:
+            - padded_tensor: Padded tensor of shape:
+                - (batch_size, max_seq_len) for indices
+                - (batch_size, max_seq_len, embedding_dim) for embeddings
+            - mask: Boolean mask of shape (batch_size, max_seq_len) where True indicates valid elements
+
+    Note:
+        - Zero-padding is added to the right of shorter sequences
+    """
+    batch_size = lengths.shape[0]
+    max_sequence_length = int(lengths.max().item())
+
+    if len(data.shape) == 1:  # indices
+        padded_tensor = torch.zeros(
+            batch_size, max_sequence_length, dtype=data.dtype, device=data.device
+        )  # (batch_size, max_seq_len)
+    else:
+        assert len(data.shape) == 2  # embeddings
+        padded_tensor = torch.zeros(
+            batch_size, max_sequence_length, *data.shape[1:], dtype=data.dtype, device=data.device
+        )  # (batch_size, max_seq_len, embedding_dim)
+
+    mask = (
+        torch.arange(end=max_sequence_length, device=lengths.device)[None] < lengths[:, None]
+    )  # (batch_size, max_seq_len)
+
+    padded_tensor[mask] = data
+
+    return padded_tensor, mask
+
+
+class SASRecEncoder(nn.Module):
+    def __init__(
+        self,
+        num_items: int,
+        max_sequence_length: int,
+        embedding_dim: int,
+        num_heads: int,
+        num_layers: int,
+        dim_feedforward: int | None = None,
+        dropout: float = 0.0,
+        activation: nn.Module = nn.GELU(),
+        layer_norm_eps: float = 1e-9,
+        initializer_range: float = 0.02,
+    ) -> None:
+        super().__init__()
+        self._num_items = num_items
+        self._num_heads = num_heads
+        self._embedding_dim = embedding_dim
+
+        self._item_embeddings = nn.Embedding(
+            num_embeddings=num_items + 1,  # add zero id embedding
+            embedding_dim=embedding_dim,
+        )
+        self._position_embeddings = nn.Embedding(num_embeddings=max_sequence_length, embedding_dim=embedding_dim)
+
+        self._layernorm = nn.LayerNorm(embedding_dim, eps=layer_norm_eps)
+        self._dropout = nn.Dropout(dropout)
+
+        transformer_encoder_layer = nn.TransformerEncoderLayer(
+            d_model=embedding_dim,
+            nhead=num_heads,
+            dim_feedforward=dim_feedforward or 4 * embedding_dim,
+            dropout=dropout,
+            activation=activation,
+            layer_norm_eps=layer_norm_eps,
+            batch_first=True,
+        )
+        self._encoder = nn.TransformerEncoder(transformer_encoder_layer, num_layers)
+
+        self._init_weights(initializer_range)
+
+    @property
+    def item_embeddings(self) -> nn.Module:
+        return self._item_embeddings
+
+    @property
+    def num_items(self) -> int:
+        return self._num_items
+
+    def _apply_sequential_encoder(self, events: torch.Tensor, lengths: torch.Tensor):
+        """
+        Processes variable-length event sequences through a transformer encoder with positional embeddings.
+
+        Args:
+            events (torch.Tensor): Flattened tensor of event indices, shape (total_events,)
+            lengths (torch.Tensor): 1D tensor of sequence lengths, shape (batch_size,)
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor]:
+                - embeddings: Processed sequence embeddings, shape (batch_size, seq_len, embedding_dim)
+                - mask: Boolean mask indicating valid elements, shape (batch_size, seq_len)
+
+        Processing Steps:
+            1. Embedding Lookup:
+                - Converts event indices to dense embeddings
+            2. Positional Encoding:
+                - Generates reverse-order positions (newest event first)
+                - Adds positional embeddings to item embeddings
+            3. Transformer Processing:
+                - Applies layer norm and dropout
+                - Uses causal attention mask for autoregressive modeling
+                - Uses padding mask to ignore invalid positions
+
+        Note:
+            - Position indices are generated in reverse chronological order (newest event = position 0)
+        """
+        embeddings = self._item_embeddings(events)  # (total_batch_events, embedding_dim)
+
+        embeddings, mask = create_masked_tensor(
+            data=embeddings, lengths=lengths
+        )  # (batch_size, seq_len, embedding_dim), (batch_size, seq_len)
+
+        batch_size = mask.shape[0]
+        seq_len = mask.shape[1]
+
+        positions = (
+            torch.arange(start=seq_len - 1, end=-1, step=-1, device=mask.device)[None].tile([batch_size, 1]).long()
+        )  # (batch_size, seq_len)
+        positions_mask = positions < lengths[:, None]  # (batch_size, max_seq_len)
+
+        positions = positions[positions_mask]  # (total_batch_events)
+        position_embeddings = self._position_embeddings(positions)  # (total_batch_events, embedding_dim)
+        position_embeddings, _ = create_masked_tensor(
+            data=position_embeddings, lengths=lengths
+        )  # (batch_size, seq_len, embedding_dim)
+
+        embeddings = embeddings + position_embeddings  # (batch_size, seq_len, embedding_dim)
+        embeddings = self._layernorm(embeddings)  # (batch_size, seq_len, embedding_dim)
+        embeddings = self._dropout(embeddings)  # (batch_size, seq_len, embedding_dim)
+        embeddings[~mask] = 0
+
+        causal_mask = torch.tril(torch.ones(seq_len, seq_len)).bool().to(mask.device)  # (seq_len, seq_len)
+        embeddings = self._encoder(
+            src=embeddings, mask=~causal_mask, src_key_padding_mask=~mask
+        )  # (batch_size, seq_len, embedding_dim)
+
+        return embeddings, mask
+
+    @torch.no_grad()
+    def _init_weights(self, initializer_range: float) -> None:
+        """
+        Initialize all model parameters (weights and biases) in-place.
+
+        For each parameter in the model:
+            - If the parameter name contains 'weight':
+                - If it also contains 'norm' (e.g., for normalization layers), initialize with ones.
+                - Otherwise, initialize with a truncated normal distribution (mean=0, std=initializer_range)
+                and values clipped to the range [-2 * initializer_range, 2 * initializer_range].
+            - If the parameter name contains 'bias', initialize with zeros.
+            - If the parameter name does not match either case, raise a ValueError.
+
+        Args:
+            initializer_range (float): Standard deviation for the truncated normal distribution
+                used to initialize non-normalization weights.
+
+        Note:
+            This method should be called during model initialization to ensure all weights and biases
+            are properly set. It runs in a no-grad context and does not track gradients.
+        """
+        for key, value in self.named_parameters():
+            if 'weight' in key:
+                if 'norm' in key:
+                    nn.init.ones_(value.data)
+                else:
+                    nn.init.trunc_normal_(
+                        value.data, std=initializer_range, a=-2 * initializer_range, b=2 * initializer_range
+                    )
+            else:
+                assert 'bias' in key
+                nn.init.zeros_(value.data)
+
+    @staticmethod
+    def _get_last_embedding(embeddings: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+        """
+        Extracts the embedding of the last valid (non-padded) element from each sequence in a batch.
+
+        Args:
+            embeddings (torch.Tensor): Tensor of shape (batch_size, seq_len, embedding_dim)
+                containing embeddings for each element in each sequence.
+            mask (torch.Tensor): Boolean tensor of shape (batch_size, seq_len) indicating
+                valid (True) and padded (False) positions in each sequence.
+
+        Returns:
+            torch.Tensor: Tensor of shape (batch_size, embedding_dim) containing the embedding
+                of the last valid element for each sequence in the batch.
+        """
+        flatten_embeddings = embeddings[mask]  # (total_batch_events, embedding_dim)
+        lengths = torch.sum(mask, dim=-1)  # (batch_size)
+        offsets = torch.cumsum(lengths, dim=0)  # (batch_size)
+        last_embeddings = flatten_embeddings[offsets.long() - 1]  # (batch_size, embedding_dim)
+        return last_embeddings
+
+    def forward(self, inputs: Dict) -> torch.Tensor:
+        """
+        Forward pass of the model, handling both training and evaluation modes.
+
+        Args:
+            inputs (Dict): Input dictionary containing:
+                - 'item.ids' (torch.LongTensor): Flattened tensor of item IDs for all sequences in the batch.
+                    Shape: (total_batch_events,)
+                - 'item.length' (torch.LongTensor): Sequence lengths for each sample in the batch.
+                    Shape: (batch_size,)
+                - 'positive.ids' (torch.LongTensor, training only): Positive sample IDs for contrastive learning.
+                    Shape: (total_batch_events,)
+                - 'negative.ids' (torch.LongTensor, training only): Negative sample IDs for contrastive learning.
+                    Shape: (total_batch_events,)
+
+        Returns:
+            torch.Tensor:
+                - During training: Binary cross-entropy loss between positive/negative sample scores.
+                    Shape: (1,)
+                - During evaluation: Embeddings of the last valid item in each sequence.
+                    Shape: (batch_size, embedding_dim)
+        """
+        all_sample_events = inputs['item.ids']  # (total_batch_events)
+        all_sample_lengths = inputs['item.length']  # (batch_size)
+
+        embeddings, mask = self._apply_sequential_encoder(
+            all_sample_events, all_sample_lengths
+        )  # (batch_size, seq_len, embedding_dim), (batch_size, seq_len)
+
+        if self.training:  # training mode
+            # queries
+            in_batch_queries_embeddings = embeddings[mask]  # (total_batch_events, embedding_dim)
+
+            # positives
+            in_batch_positive_events = inputs['positive.ids']  # (total_batch_events)
+            in_batch_positive_embeddings = self._item_embeddings(
+                in_batch_positive_events
+            )  # (total_batch_events, embedding_dim)
+            positive_scores = torch.einsum(
+                'bd,bd->b', in_batch_queries_embeddings, in_batch_positive_embeddings
+            )  # (total_batch_events)
+
+            # negatives
+            in_batch_negative_events = inputs['negative.ids']  # (total_batch_events)
+            in_batch_negative_embeddings = self._item_embeddings(
+                in_batch_negative_events
+            )  # (total_batch_events, embedding_dim)
+            negative_scores = torch.einsum(
+                'bd,bd->b', in_batch_queries_embeddings, in_batch_negative_embeddings
+            )  # (total_batch_events)
+
+            loss = nn.functional.binary_cross_entropy_with_logits(
+                torch.cat([positive_scores, negative_scores], dim=0),
+                torch.cat([torch.ones_like(positive_scores), torch.zeros_like(negative_scores)]),
+            )  # (1)
+
+            return loss
+        else:  # eval mode
+            last_embeddings = self._get_last_embedding(embeddings, mask)  # (batch_size, embedding_dim)
+            return last_embeddings

benchmarks/models/sasrec/train.py

@@ -0,0 +1,150 @@
+import logging
+import os
+import pathlib as Path
+import random
+
+import click
+import numpy as np
+import polars as pl
+import torch
+from model import SASRecEncoder
+from torch.utils.data import DataLoader
+
+from data import Data, TrainDataset, collate_fn, preprocess
+
+
+logging.basicConfig(
+    level=logging.DEBUG, format='[%(asctime)s] [%(levelname)s]: %(message)s', datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+
+def train(
+    train_dataloader: DataLoader,
+    model: SASRecEncoder,
+    optimizer: torch.optim.Optimizer,
+    device: str = 'cpu',
+    num_epochs: int = 100,
+):
+    logger.debug('Start training...')
+
+    model.train()
+
+    for epoch_num in range(num_epochs):
+        logger.debug(f'Start epoch {epoch_num + 1}')
+        for batch in train_dataloader:
+            for key in batch.keys():
+                batch[key] = batch[key].to(device)
+
+            loss = model(batch)
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+    logger.debug('Training procedure has been finished!')
+    return model.state_dict()
+
+
+@click.command()
+@click.option('--exp_name', required=True, type=str)
+@click.option('--data_dir', required=True, type=str, default='../../data/', show_default=True)
+@click.option('--checkpoint_dir', required=True, type=str, default='./checkpoints/', show_default=True)
+@click.option(
+    '--size',
+    required=True,
+    type=click.Choice(['50m', '500m', '5b']),
+    default='50m',
+    show_default=True,
+)
+@click.option(
+    '--interaction',
+    required=True,
+    type=click.Choice(['likes', 'listens']),
+    default='likes',
+    show_default=True,
+)
+@click.option('--batch_size', required=True, type=int, default=256, show_default=True)
+@click.option('--max_seq_len', required=False, type=int, default=200, show_default=True)
+@click.option('--embedding_dim', required=False, type=int, default=64, show_default=True)
+@click.option('--num_heads', required=False, type=int, default=2, show_default=True)
+@click.option('--num_layers', required=False, type=int, default=2, show_default=True)
+@click.option('--learning_rate', required=False, type=float, default=1e-3, show_default=True)
+@click.option('--dropout', required=False, type=float, default=0.0, show_default=True)
+@click.option('--seed', required=False, type=int, default=42, show_default=True)
+@click.option('--device', required=True, type=str, default='cuda:0', show_default=True)
+@click.option('--num_epochs', required=True, type=int, default=100, show_default=True)
+def main(
+    exp_name: str,
+    data_dir: str,
+    checkpoint_dir: str,
+    size: str,
+    interaction: str,
+    batch_size: int,
+    max_seq_len: int,
+    embedding_dim: int,
+    num_heads: int,
+    num_layers: int,
+    learning_rate: float,
+    dropout: float,
+    seed: int,
+    device: str,
+    num_epochs: int,
+):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.set_float32_matmul_precision('high')
+
+    data_path = Path.Path(data_dir) / 'sequential' / size / interaction
+    df = pl.scan_parquet(data_path.with_suffix('.parquet'))
+
+    checkpoint_path = Path.Path(checkpoint_dir) / f'{exp_name}_best_state.pth'
+    os.makedirs(checkpoint_dir, exist_ok=True)
+
+    logger.debug('Preprocessing data...')
+    data: Data = preprocess(df, interaction, val_size=0, max_seq_len=max_seq_len)
+    train_df = data.train.collect(engine="streaming")
+    logger.debug('Preprocessing data has finished!')
+
+    train_dataset = TrainDataset(dataset=train_df, num_items=data.num_items, max_seq_len=max_seq_len)
+
+    train_dataloader = DataLoader(
+        dataset=train_dataset,
+        batch_size=batch_size,
+        collate_fn=collate_fn,
+        drop_last=True,
+        shuffle=True,
+        num_workers=3,
+        prefetch_factor=10,
+        pin_memory_device="cuda",
+        pin_memory=True,
+    )
+
+    model = SASRecEncoder(
+        num_items=data.num_items,
+        max_sequence_length=max_seq_len,
+        embedding_dim=embedding_dim,
+        num_heads=num_heads,
+        num_layers=num_layers,
+        dropout=dropout,
+    ).to(device)
+
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+
+    best_checkpoint = train(
+        train_dataloader=train_dataloader, model=model, optimizer=optimizer, device=device, num_epochs=num_epochs
+    )
+
+    logger.debug('Saving model...')
+
+    os.makedirs(checkpoint_dir, exist_ok=True)
+
+    model.load_state_dict(best_checkpoint)
+    torch.save(model, checkpoint_path)
+    logger.debug(f'Saved model as {checkpoint_path}')
+
+
+if __name__ == '__main__':
+    main()

benchmarks/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "yambda"
+version = "0.1.0"
+description = ""
+authors = [
+    {name = "Yandex"}
+]
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "torch",
+    "polars-u64-idx==1.28.1", # https://github.com/pola-rs/polars/issues/22741
+    "click",
+    "scipy",
+    "numpy",
+    "optuna",
+    "tqdm",
+    "matplotlib"
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+# list of all codes - https://docs.astral.sh/ruff/rules/
+select = [
+    "E",     # pycodestyle errors
+    "F",     # pyflakes
+    "W",     # pycodestyle warnings
+    "I",     # isort
+]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+known-first-party = ["yambda"]
+
+[tool.ruff.format]
+quote-style = "preserve"

benchmarks/scripts/get_dataset_stats.py

@@ -0,0 +1,210 @@
+import enum
+import os
+from pathlib import Path
+
+import click
+import matplotlib.pyplot as plt
+import polars as pl
+
+
+class ImageFormat(enum.Enum):
+    PNG = "png"
+    JPEG = "jpg"
+
+
+@click.command()
+@click.option(
+    "--src_dir",
+    type=click.Path(exists=True, file_okay=False),
+    required=True,
+    help="Path to the directory containing dataset, e.g., './data'.",
+)
+@click.option(
+    "--dst_dir",
+    type=click.Path(file_okay=False),
+    required=False,
+    help="Path to the directory where statisics will be saved. "
+    "If not specified, statistics is saved in '{src_dir}/stats'. e.g., './stats'.",
+)
+@click.option(
+    "--file_name",
+    type=str,
+    default="multi_event",
+    help="Base name for multi-event file. Default is 'multi_event'.",
+)
+def cli(src_dir: str, dst_dir: str, file_name: str):
+    if dst_dir is None:
+        dst_dir = f"{src_dir}/stats"
+    generate_dataset_stats(src_dir, dst_dir, file_name)
+
+
+def generate_dataset_stats(src_dir: str, dst_dir: str, file_name: str):
+    src_dir, dst_dir = Path(src_dir), Path(dst_dir)
+    src_dir_flat, src_dir_seq = src_dir / "flat", src_dir / "sequential"
+
+    file_name = f"{file_name}.parquet"
+    sizes = sorted(path.name for path in src_dir_flat.iterdir())
+    for size in sizes:
+        path_flat, path_seq = src_dir_flat / size, src_dir_seq / size
+        assert path_seq.exists(), f"Cannot find sequential data in '{path_seq}'"
+        assert (path_flat / file_name).exists(), (
+            "Please, generate flat multi-event file using "
+            "'make_multievent.py' or specify correct name using --file_name"
+        )
+        assert (path_seq / file_name).exists(), (
+            "Please, generate sequential multi-event file "
+            "using 'transform2sequential.py' script or specify correct name "
+            "using --file_name"
+        )
+
+        print(f"Gathering stats for {size}...")
+        dst_dir_size = dst_dir / size
+        dst_dir_size.mkdir(parents=True, exist_ok=True)
+
+        df = pl.scan_parquet(path_seq / file_name)
+        generate_user_history_graph(df, dst_dir_size / "user_history_len.png")
+        generate_log_user_history_graph(df, dst_dir_size / "user_history_log_len.png")
+
+        df = pl.scan_parquet(path_flat / file_name)
+        generate_item_interactions_graph(df, dst_dir_size / "item_interactions.png")
+        get_recom_stats(df).write_csv(dst_dir_size / "recom_event_count.csv")
+        get_history_len_stats(df).write_csv(dst_dir_size / "event_history_len.csv")
+        get_dataset_stats(df).write_csv(dst_dir_size / "dataset_event_stats.csv")
+
+
+def make_history_len_graph(
+    df: pl.DataFrame,
+    *,
+    qs: tuple[float] | None = None,
+    color: str = "lightskyblue",
+    num_bins: int = 100,
+    title: str | None = None,
+    xlabel: str | None = None,
+    ylabel: str | None = None,
+    ax: plt.Axes | None = None,
+) -> plt.Axes:
+    if ax is None:
+        _, ax = plt.subplots(figsize=(12, 5))
+
+    count, _, _ = ax.hist(df["value"], bins=num_bins, ec="k", lw=1.0, color=color)
+    ylim = count.max() * 1.05
+
+    xs = {"max": df["value"].max()}
+    if qs is not None:
+        xs.update((f"q{q * 100:.0f}", df["value"].quantile(q)) for q in qs)
+
+    dx = 0.01 * (xs["max"] - df["value"].min())
+    template = "{label}={x:.3f}" if xs["max"] <= 10 else "{label}={x:.0f}"
+    for label, x in xs.items():
+        ax.plot([x, x], [0, ylim], ls="--", c="k")
+        text = template.format(label=label, x=x)
+        ax.text(x + dx, ylim // 2, text, rotation=90, fontsize=16, bbox=dict(alpha=0.1, color="r"))
+
+    if title is not None:
+        ax.set_title(title, fontsize=24)
+    ax.set_xlabel(xlabel or "Value", fontsize=22)
+    ax.set_ylabel(ylabel or "Count", fontsize=22)
+
+    ax.set_ylim([0, ylim])
+
+    ax.tick_params(labelsize=16)
+    ax.ticklabel_format(style="sci", useMathText=True)
+
+
+def save_graph(output_path: os.PathLike, fmt: ImageFormat = ImageFormat.PNG):
+    output_path = Path(output_path)
+    if not output_path.suffix:
+        output_path = output_path.with_suffix(f".{fmt.value}")
+
+    if output_path.exists():
+        print(f"Rewriting file '{output_path}'")
+    else:
+        print(f"Saving to '{output_path}'")
+
+    plt.savefig(output_path, dpi=300, format=fmt.value)
+
+
+def generate_user_history_graph(df: pl.LazyFrame, out_path: os.PathLike):
+    _, ax = plt.subplots(figsize=(12, 5))
+
+    make_history_len_graph(
+        df.select(value=pl.col("item_id").list.len()).collect(),
+        num_bins=100,
+        qs=(0.5, 0.9, 0.95),
+        xlabel="Events",
+        ylabel="Users",
+        ax=ax,
+    )
+    plt.tight_layout()
+    save_graph(out_path)
+
+
+def generate_log_user_history_graph(df: pl.LazyFrame, out_path: os.PathLike):
+    _, ax = plt.subplots(figsize=(12, 5))
+
+    make_history_len_graph(
+        df.select(value=pl.col("item_id").list.len().log10()).collect(),
+        num_bins=40,
+        xlabel="$Log_{10}$(Events)",
+        ylabel="Users",
+        color="lightgreen",
+        ax=ax,
+    )
+    plt.tight_layout()
+    save_graph(out_path)
+
+
+def generate_item_interactions_graph(df: pl.LazyFrame, out_path: os.PathLike):
+    _, ax = plt.subplots(figsize=(12, 5))
+
+    make_history_len_graph(
+        df.group_by("item_id").len().select(value=pl.col("len").log10()).collect(),
+        num_bins=30,
+        qs=(0.5, 0.9, 0.95),
+        xlabel="$Log_{10}$(Events)",
+        ylabel="Items",
+        color="orange",
+        ax=ax,
+    )
+    plt.tight_layout()
+    save_graph(out_path)
+
+
+def get_recom_stats(df: pl.LazyFrame) -> pl.DataFrame:
+    print("Computing recom stats")
+    df_cnt = df.group_by(("event_type", "is_organic")).len().collect()
+    df_recom = df_cnt.filter(pl.col("is_organic").eq(0)).select(pl.col("event_type"), pl.col("len").alias("recom"))
+    df_total = df_cnt.group_by("event_type").sum().select(pl.col("event_type"), pl.col("len").alias("total"))
+    return df_total.join(df_recom, on="event_type").with_columns(ratio=pl.col("recom") / pl.col("total"))
+
+
+def get_history_len_stats(df: pl.LazyFrame) -> pl.DataFrame:
+    print("Computing event history length stats")
+    return (
+        df.group_by(("event_type", "uid"))
+        .len()
+        .group_by("event_type")
+        .agg(
+            median=pl.col("len").quantile(0.5).cast(pl.Int32),
+            q90=pl.col("len").quantile(0.9).cast(pl.Int32),
+            q95=pl.col("len").quantile(0.95).cast(pl.Int32),
+        )
+        .collect()
+    )
+
+
+def get_dataset_stats(df: pl.LazyFrame) -> pl.DataFrame:
+    print("Computing dataset stats")
+    return df.select(
+        users=pl.col("uid").unique().len(),
+        items=pl.col("item_id").unique().len(),
+        listens=pl.col("event_type").filter(pl.col("event_type").eq("listen")).len(),
+        likes=pl.col("event_type").filter(pl.col("event_type").eq("like")).len(),
+        dislikes=pl.col("event_type").filter(pl.col("event_type").eq("dislike")).len(),
+        unlikes=pl.col("event_type").filter(pl.col("event_type").eq("unlike")).len(),
+        undislikes=pl.col("event_type").filter(pl.col("event_type").eq("undislike")).len(),
+    ).collect()
+
+
+if __name__ == "__main__":
+    cli()

benchmarks/scripts/make_multievent.py

@@ -0,0 +1,88 @@
+import os
+
+import click
+import polars as pl
+
+
+@click.command()
+@click.option(
+    "--src_dir",
+    type=click.Path(exists=True, file_okay=False),
+    required=True,
+    help="Path to the directory containing source parquet files, e.g., './50m'.",
+)
+@click.option(
+    "--dst_dir",
+    type=click.Path(file_okay=False),
+    required=False,
+    help="Path to the directory where Parquet files will be saved. "
+    "If not specified, Parquet files are saved in 'src_dir'. e.g., './out'.",
+)
+@click.option(
+    "--file_name",
+    type=str,
+    default="multi_event",
+    help="Base name for the output Parquet file. Default is 'multi_event'.",
+)
+def cli(src_dir: str, dst_dir: str, file_name: str):
+    if dst_dir is None:
+        dst_dir = src_dir
+
+    print(f"{src_dir=}, {dst_dir=}, {file_name=}")
+    make_multievent_dataset(src_dir, dst_dir, file_name)
+
+
+def make_multievent_dataset(src_dir: str, dst_dir: str, file_name: str):
+    os.makedirs(dst_dir, exist_ok=True)
+
+    dislikes = pl.scan_parquet(os.path.join(src_dir, "dislikes.parquet"))
+    likes = pl.scan_parquet(os.path.join(src_dir, "likes.parquet"))
+    listens = pl.scan_parquet(os.path.join(src_dir, "listens.parquet"))
+    undislikes = pl.scan_parquet(os.path.join(src_dir, "undislikes.parquet"))
+    unlikes = pl.scan_parquet(os.path.join(src_dir, "unlikes.parquet"))
+
+    events = pl.Enum(["listen", "dislike", "like", "undislike", "unlike"])
+
+    combined_df = pl.concat(
+        [
+            listens.with_columns(
+                pl.lit("listen").cast(events).alias("event_type"),
+            ),
+            dislikes.with_columns(
+                pl.lit(None).alias("played_ratio_pct"),
+                pl.lit(None).alias("track_length_seconds"),
+                pl.lit("dislike").cast(events).alias("event_type"),
+            ),
+            likes.with_columns(
+                pl.lit(None).alias("played_ratio_pct"),
+                pl.lit(None).alias("track_length_seconds"),
+                pl.lit("like").cast(events).alias("event_type"),
+            ),
+            undislikes.with_columns(
+                pl.lit(None).alias("played_ratio_pct"),
+                pl.lit(None).alias("track_length_seconds"),
+                pl.lit("undislike").cast(events).alias("event_type"),
+            ),
+            unlikes.with_columns(
+                pl.lit(None).alias("played_ratio_pct"),
+                pl.lit(None).alias("track_length_seconds"),
+                pl.lit("unlike").cast(events).alias("event_type"),
+            ),
+        ]
+    ).sort(
+        by=[
+            "uid",
+            "timestamp",
+        ],
+        maintain_order=True,
+    )
+
+    combined_df.with_columns(pl.col("event_type").cast(events)).sink_parquet(
+        os.path.join(dst_dir, file_name + ".parquet"),
+        compression="lz4",
+        statistics=True,
+    )
+
+
+if __name__ == "__main__":
+    cli()

benchmarks/scripts/transform2sequential.py

@@ -0,0 +1,76 @@
+import os
+
+import click
+import polars as pl
+
+
+@click.command()
+@click.option(
+    "--src_dir",
+    type=click.Path(exists=True, file_okay=False),
+    required=True,
+    help="Path to the directory containing source Parquet files, e.g., './50m'.",
+)
+@click.option(
+    "--dst_dir",
+    type=click.Path(file_okay=False),
+    required=False,
+    help="Path to the directory where Parquet files will be saved. "
+    "If not specified, Parquet files are saved in 'src_dir' with prefix 'seq_'.",
+)
+@click.option(
+    "--files",
+    type=str,
+    multiple=True,
+    help="List of parquet filenames to convert. If not specified, all Parquet files in 'src_dir' will be converted. "
+    "For example, '--files dislike.parquet --files like.parquet'.",
+)
+@click.option(
+    "--aggregation",
+    type=click.Choice(["structs", "columns"]),
+    required=True,
+    help="Agg method: 'structs' for a sequence of structs per 'uid', 'columns' for individual column aggregation.",
+)
+def cli(src_dir: str, dst_dir: str, files: list[str], aggregation: str):
+    transform2sequential(src_dir, dst_dir, files, aggregation)
+
+
+def transform2sequential(src_dir: str, dst_dir: str, files: list[str], aggregation: str):
+    for file in files:
+        print(f"Processing file: {file}")
+
+        src_path = os.path.join(src_dir, file)
+
+        parquet_path = os.path.join(dst_dir, file)
+
+        if os.path.exists(parquet_path):
+            parquet_path = os.path.join(dst_dir, f"{aggregation}_" + file)
+            assert not os.path.exists(parquet_path)
+
+        os.makedirs(dst_dir, exist_ok=True)
+
+        df = pl.scan_parquet(src_path)
+
+        if aggregation == "structs":
+            seq_df = (
+                df.select("uid", pl.struct(pl.all().exclude("uid")).alias("events"))
+                .group_by("uid", maintain_order=True)
+                .agg(pl.col("events"))
+            )
+            seq_df.sink_parquet(
+                parquet_path,
+                compression="lz4",
+                statistics=True,
+            )
+
+        elif aggregation == "columns":
+            col_agg_df = df.group_by("uid", maintain_order=True).agg(pl.all().exclude("uid"))
+            col_agg_df.sink_parquet(
+                parquet_path,
+                compression="lz4",
+                statistics=True,
+            )
+
+
+if __name__ == "__main__":
+    cli()

benchmarks/tests/test_timesplit.py

@@ -0,0 +1,50 @@
+import numpy as np
+import polars as pl
+
+from yambda.processing.timesplit import flat_split_train_val_test, sequential_split_train_val_test
+
+
+def create_dataframe(n: int = 1000) -> pl.DataFrame:
+    uids = np.random.randint(1, int(n * 0.05), size=n)
+    item_ids = np.random.randint(100, 200, size=n)
+
+    timestamps = np.random.randint(0, 100_000, size=n)
+    is_organic = np.random.choice([True, False], size=n)
+
+    df = pl.DataFrame(
+        {"uid": uids, "item_id": item_ids, "timestamp": timestamps, "is_organic": is_organic},
+        schema={"uid": pl.UInt32, "item_id": pl.UInt32, "timestamp": pl.UInt32, "is_organic": pl.UInt8},
+    )
+
+    df = df.sort(["uid", "timestamp"])
+
+    return df
+
+
+def test_cross_check():
+    df = create_dataframe(10000)
+
+    q75_timestamp = int(df["timestamp"].quantile(0.75))
+
+    print(q75_timestamp)
+
+    flat_train, flat_val, flat_test = flat_split_train_val_test(
+        df.lazy(), test_timestamp=q75_timestamp, gap_size=1000, val_size=1000
+    )
+
+    assert flat_val is not None
+
+    df.group_by("uid", maintain_order=True).agg(pl.all().exclude("uid")).lazy()
+
+    seq_train, seq_val, seq_test = sequential_split_train_val_test(
+        df.group_by("uid", maintain_order=True).agg(pl.all().exclude("uid")).lazy(),
+        test_timestamp=q75_timestamp,
+        gap_size=1000,
+        val_size=1000,
+    )
+
+    assert seq_val is not None
+
+    assert seq_train.explode(pl.all().exclude("uid")).collect().equals(flat_train.collect())
+    assert seq_val.explode(pl.all().exclude("uid")).collect().equals(flat_val.collect())
+    assert seq_test.explode(pl.all().exclude("uid")).collect().equals(flat_test.collect())

benchmarks/yambda/constants.py

@@ -0,0 +1,29 @@
+class Constants:
+    HOUR_SECONDS = 60 * 60
+    DAY_SECONDS = 24 * HOUR_SECONDS
+
+    GAP_SIZE = HOUR_SECONDS // 2
+    VAL_SIZE = 1 * DAY_SECONDS
+    TEST_SIZE = 1 * DAY_SECONDS
+
+    LAST_TIMESTAMP = 26000000
+    TEST_TIMESTAMP = LAST_TIMESTAMP - TEST_SIZE
+
+    TRACK_LISTEN_THRESHOLD = 50
+
+    NUM_RANKED_ITEMS = 100
+
+    METRICS = [
+        "ndcg@10",
+        "ndcg@50",
+        "ndcg@100",
+        "dcg@10",
+        "dcg@50",
+        "dcg@100",
+        "recall@10",
+        "recall@50",
+        "recall@100",
+        "coverage@10",
+        "coverage@50",
+        "coverage@100",
+    ]

benchmarks/yambda/evaluation/metrics.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from typing import Any, Iterable
+
+import torch
+from tqdm import tqdm
+
+from .ranking import Ranked, Targets
+
+
+def cut_off_ranked(ranked: Ranked, targets: Targets) -> Ranked:
+    mask = torch.isin(ranked.user_ids, targets.user_ids)
+
+    assert ranked.scores is not None
+
+    ranked = Ranked(
+        user_ids=ranked.user_ids[mask],
+        scores=ranked.scores[mask, :],
+        item_ids=ranked.item_ids[mask, :],
+        num_item_ids=ranked.num_item_ids,
+    )
+
+    assert ranked.item_ids.shape[0] == len(targets), "Ranked doesn't contain all targets.user_ids"
+
+    return ranked
+
+
+class Metric(ABC):
+    @abstractmethod
+    def __call__(
+        self, ranked: Ranked | None, targets: Targets | None, target_mask: torch.Tensor | None, ks: Iterable[int]
+    ) -> dict[int, float]:
+        pass
+
+
+class Recall(Metric):
+    def __call__(
+        self, ranked: Ranked | None, targets: Targets, target_mask: torch.Tensor, ks: Iterable[int]
+    ) -> dict[int, float]:
+        assert all(0 < k <= target_mask.shape[1] for k in ks)
+
+        values = {}
+
+        for k in ks:
+            num_positives = targets.lengths.to(torch.float32)
+            num_positives[num_positives == 0] = torch.inf
+
+            values[k] = target_mask[:, :k].to(torch.float32).sum(dim=-1) / num_positives
+
+            values[k] = torch.mean(values[k]).item()
+
+        return values
+
+
+class Precision(Metric):
+    def __call__(
+        self, ranked: Ranked | None, targets: Targets | None, target_mask: torch.Tensor, ks: Iterable[int]
+    ) -> dict[int, float]:
+        assert all(0 < k <= target_mask.shape[1] for k in ks)
+
+        values = {}
+
+        for k in ks:
+            values[k] = target_mask[:, :k].to(torch.float32).sum(dim=-1) / k
+            values[k] = torch.mean(values[k]).item()
+
+        return values
+
+
+class Coverage(Metric):
+    def __init__(self, cut_off_ranked: bool = False):
+        self.cut_off_ranked = cut_off_ranked
+
+    def __call__(
+        self, ranked: Ranked, targets: Targets | None, target_mask: torch.Tensor | None, ks: Iterable[int]
+    ) -> dict[int, float]:
+        if self.cut_off_ranked:
+            assert targets is not None
+            ranked = cut_off_ranked(ranked, targets)
+
+        assert all(0 < k <= ranked.item_ids.shape[1] for k in ks)
+
+        assert ranked.num_item_ids is not None
+
+        values = {}
+        for k in ks:
+            values[k] = ranked.item_ids[:, :k].flatten().unique().shape[0] / ranked.num_item_ids
+
+        return values
+
+
+class MRR(Metric):
+    def __call__(
+        self, ranked: Ranked | None, targets: Targets, target_mask: torch.Tensor, ks: Iterable[int]
+    ) -> dict[int, float]:
+        assert all(0 < k <= target_mask.shape[1] for k in ks)
+
+        values = {}
+        for k in ks:
+            num_positives = targets.lengths.to(torch.float32)
+
+            indexes = torch.argmax(target_mask[:, :k].to(torch.float32), dim=-1).to(torch.float32) + 1
+            indexes[num_positives == 0] = torch.inf
+
+            rr = 1 / indexes
+
+            values[k] = torch.mean(rr).item()
+
+        return values
+
+
+class DCG(Metric):
+    def __call__(
+        self, ranked: Ranked | None, targets: Targets | None, target_mask: torch.Tensor, ks: Iterable[int]
+    ) -> dict[int, float]:
+        assert all(0 < k <= target_mask.shape[1] for k in ks)
+
+        values = {}
+
+        discounts = 1.0 / torch.log2(
+            torch.arange(2, target_mask.shape[1] + 2, device=target_mask.device, dtype=torch.float32)
+        )
+
+        for k in ks:
+            dcg_k = torch.sum(target_mask[:, :k] * discounts[:k], dim=1)
+            values[k] = torch.mean(dcg_k).item()
+
+        return values
+
+
+class NDCG(Metric):
+    def __call__(
+        self, ranked: Ranked | None, targets: Targets, target_mask: torch.Tensor, ks: Iterable[int]
+    ) -> dict[int, float]:
+        actual_dcg = DCG()(ranked, targets, target_mask, ks)
+
+        ideal_target_mask = (
+            torch.arange(target_mask.shape[1], device=targets.device)[None, :] < targets.lengths[:, None]
+        ).to(torch.float32)
+        assert target_mask.shape == ideal_target_mask.shape
+
+        ideal_dcg = DCG()(ranked, targets, ideal_target_mask, ks)
+
+        ndcg_values = {k: (actual_dcg[k] / ideal_dcg[k] if ideal_dcg[k] != 0 else 0.0) for k in ks}
+
+        return ndcg_values
+
+
+REGISTERED_METRIC_FN = {
+    "recall": Recall(),
+    "precision": Precision(),
+    "mrr": MRR(),
+    "dcg": DCG(),
+    "ndcg": NDCG(),
+    "coverage": Coverage(cut_off_ranked=False),
+}
+
+
+def _parse_metrics(metric_names: list[str]) -> dict[str, list[int]]:
+    parsed_metrics = []
+
+    for metric in metric_names:
+        parts = metric.split('@')
+        name = parts[0]
+
+        assert len(parts) > 1, f"Invalid metric: {metric}, specify @k"
+
+        value = int(parts[1])
+        parsed_metrics.append((name, value))
+
+    metrics = defaultdict(list)
+    for m in parsed_metrics:
+        metrics[m[0]].append(m[1])
+
+    return metrics
+
+
+def create_target_mask(ranked: Ranked, targets: Targets) -> torch.Tensor:
+    ranked = cut_off_ranked(ranked, targets)
+
+    assert ranked.device == targets.device
+    assert ranked.item_ids.shape[0] == len(targets)
+
+    target_mask = ranked.item_ids.new_zeros(ranked.item_ids.shape, dtype=torch.float32)
+
+    for i, target in enumerate(tqdm(targets.item_ids, desc="Making target mask")):
+        target_mask[i, torch.isin(ranked.item_ids[i], target)] = 1.0
+
+    return target_mask
+
+
+def calc_metrics(ranked: Ranked, targets: Targets, metrics: list[str]) -> dict[str, Any]:
+    grouped_metrics = _parse_metrics(metrics)
+
+    result = {}
+
+    target_mask = create_target_mask(ranked, targets)
+
+    for name, ks in grouped_metrics.items():
+        result[name] = REGISTERED_METRIC_FN[name](ranked, targets, target_mask, ks=ks)
+
+    return result

benchmarks/yambda/evaluation/ranking.py

@@ -0,0 +1,145 @@
+import dataclasses
+from functools import cached_property
+
+import numpy as np
+import polars as pl
+import torch
+from tqdm import tqdm
+
+
+@dataclasses.dataclass
+class Embeddings:
+    ids: torch.Tensor
+    embeddings: torch.Tensor
+
+    def __post_init__(self):
+        assert self.ids.dim() == 1
+        assert self.embeddings.dim() == 2
+        assert self.ids.shape[0] == self.embeddings.shape[0]
+
+        assert self.ids.device == self.embeddings.device
+
+        if not torch.all(self.ids[:-1] <= self.ids[1:]):
+            indexes = torch.argsort(self.ids, descending=False)
+            self.embeddings = self.embeddings[indexes, :]
+            self.ids = self.ids[indexes]
+
+        assert torch.all(self.ids[:-1] < self.ids[1:]), "ids should be unique"
+
+    @property
+    def device(self):
+        return self.ids.device
+
+    def save(self, file_path: str):
+        ids_np = self.ids.cpu().numpy()
+        embeddings_np = self.embeddings.cpu().numpy()
+        np.savez(file_path, ids=ids_np, embeddings=embeddings_np)
+
+    @classmethod
+    def load(cls, file_path: str, device: torch.device = torch.device('cpu')) -> 'Embeddings':
+        with np.load(file_path) as data:
+            ids_np = data['ids']
+            embeddings_np = data['embeddings']
+
+        ids = torch.from_numpy(ids_np).to(device)
+        embeddings = torch.from_numpy(embeddings_np).to(device)
+
+        return cls(ids=ids, embeddings=embeddings)
+
+
+@dataclasses.dataclass
+class Targets:
+    user_ids: torch.Tensor
+    item_ids: list[torch.Tensor]
+
+    def __post_init__(self):
+        assert len(self.item_ids) > 0
+        assert self.user_ids.dim() == 1
+        assert self.user_ids.shape[0] == len(self.item_ids)
+        assert all(x.dim() == 1 for x in self.item_ids), "all ids should be 1D"
+
+        assert all(x.device == self.item_ids[0].device for x in self.item_ids), "all ids should be on the same device"
+        assert self.user_ids.device == self.item_ids[0].device
+
+        if not torch.all(self.user_ids[:-1] <= self.user_ids[1:]):
+            indexes = torch.argsort(self.user_ids, descending=False)
+            self.item_ids = [self.item_ids[i] for i in indexes]
+            self.user_ids = self.user_ids[indexes]
+
+        assert torch.all(self.user_ids[:-1] < self.user_ids[1:]), "user_ids should be unique"
+
+    @cached_property
+    def lengths(self):
+        return torch.tensor([ids.shape[0] for ids in self.item_ids], device=self.item_ids[0].device)
+
+    def __len__(self):
+        return len(self.item_ids)
+
+    @property
+    def device(self):
+        return self.user_ids.device
+
+    @classmethod
+    def from_sequential(cls, df: pl.LazyFrame | pl.DataFrame, device: torch.device | str) -> 'Targets':
+        df = df.lazy()
+        return cls(
+            df.select("uid").collect()["uid"].to_torch().to(device),
+            [torch.tensor(x, device=device) for x in df.select("item_id").collect()["item_id"].to_list()],
+        )
+
+
+@dataclasses.dataclass
+class Ranked:
+    user_ids: torch.Tensor
+    item_ids: torch.Tensor
+    scores: torch.Tensor | None = None
+
+    num_item_ids: int | None = None  # number of all items. Useful for coverage and etc.
+
+    def __post_init__(self):
+        if self.scores is None:
+            self.scores = torch.arange(
+                self.item_ids.shape[1], 0, -1, device=self.item_ids.device, dtype=torch.float32
+            ).expand((self.user_ids.shape[0], self.item_ids.shape[1]))
+
+        assert self.user_ids.dim() == 1
+        assert self.scores.dim() == 2
+        assert self.scores.shape == self.item_ids.shape
+        assert self.user_ids.shape[0] == self.scores.shape[0]
+
+        assert self.user_ids.device == self.scores.device == self.item_ids.device
+
+        assert torch.all(self.scores[:, :-1] >= self.scores[:, 1:]), "scores should be sorted"
+
+        if not torch.all(self.user_ids[:-1] <= self.user_ids[1:]):
+            indexes = torch.argsort(self.user_ids, descending=False)
+            self.item_ids = self.item_ids[indexes, :]
+            self.scores = self.scores[indexes, :]
+
+    @property
+    def device(self):
+        return self.user_ids.device
+
+
+def rank_items(users: Embeddings, items: Embeddings, num_items: int, batch_size: int = 128) -> Ranked:
+    assert users.device == items.device
+
+    num_users = users.ids.shape[0]
+
+    scores = users.embeddings.new_empty((num_users, num_items))
+    item_ids = users.embeddings.new_empty((num_users, num_items), dtype=torch.long)
+
+    for batch_idx in tqdm(range((num_users + batch_size - 1) // batch_size), desc="Calc topk by batches"):
+        start_idx = batch_idx * batch_size
+        end_idx = (batch_idx + 1) * batch_size
+
+        batch_scores = users.embeddings[start_idx:end_idx, :] @ items.embeddings.T
+
+        sort_indices = batch_scores.topk(num_items, dim=-1).indices
+        scores[start_idx:end_idx, :] = torch.gather(batch_scores, dim=-1, index=sort_indices)
+
+        item_ids[start_idx:end_idx, :] = torch.gather(
+            items.ids.expand(sort_indices.shape[0], items.ids.shape[0]), dim=-1, index=sort_indices
+        )
+
+    return Ranked(user_ids=users.ids, item_ids=item_ids, scores=scores, num_item_ids=items.ids.shape[0])

benchmarks/yambda/processing/chunk_read.py

@@ -0,0 +1,79 @@
+import math
+from typing import Any, Generator
+
+import polars as pl
+import torch
+
+
+# https://github.com/pola-rs/polars/issues/10683
+def iter_slices(df: pl.LazyFrame, batch_size: int) -> Generator[pl.DataFrame, None, None]:
+    assert isinstance(df, pl.LazyFrame), "df must be a LazyFrame"
+
+    def get_batch(df: pl.LazyFrame, offset: int, batch_size: int) -> pl.DataFrame:
+        batch = df.slice(offset, batch_size)
+        batch = batch.collect()
+        return batch
+
+    batch = get_batch(df, 0, batch_size)
+
+    yield batch
+
+    offset = len(batch)
+    if offset:
+        while True:
+            batch = get_batch(df, offset, batch_size)
+            len_ = len(batch)
+            if len_:
+                offset += len_
+                yield batch
+            else:
+                break
+
+
+def iter_rows(df: pl.LazyFrame, batch_size: int) -> Generator[dict[str, Any], None, None]:
+    for batch in iter_slices(df, batch_size):
+        for row in batch.iter_rows(named=True):
+            yield row
+
+
+class YambdaIterableDataset(torch.utils.data.IterableDataset):
+    def __init__(self, df: pl.LazyFrame | pl.DataFrame):
+        super().__init__()
+
+        self.start = 0
+        self.end = df.lazy().select(pl.len()).collect().item()
+
+        self.df = df.lazy()
+
+    def __iter__(self):
+        worker_info = torch.utils.data.get_worker_info()
+
+        df = self.df
+
+        start = self.start
+        end = self.end
+
+        if worker_info is not None:
+            per_worker = int(math.ceil((self.end - self.start) / float(worker_info.num_workers)))
+            worker_id = worker_info.id
+            start = self.start + worker_id * per_worker
+            end = min(start + per_worker, self.end)
+
+        df_slice = df.slice(start, end - start)
+
+        for row in iter_rows(df_slice, 2048):
+            yield row
+
+
+def get_default_dataloader(dataset: YambdaIterableDataset, collator, batch_size: int):
+    return torch.utils.data.DataLoader(
+        dataset,
+        multiprocessing_context="spawn",
+        num_workers=3,
+        prefetch_factor=10,
+        batch_size=batch_size,
+        collate_fn=collator,
+        pin_memory=True,
+        pin_memory_device="cuda",
+        persistent_workers=True,
+    )

benchmarks/yambda/processing/timesplit.py

@@ -0,0 +1,214 @@
+import polars as pl
+
+from ..constants import Constants
+
+
+def flat_split_train_val_test(
+    df: pl.LazyFrame,
+    test_timestamp: int,
+    val_size: int = 0,
+    gap_size: int = Constants.GAP_SIZE,
+    drop_non_train_items: bool = False,
+    engine: str = "streaming",
+) -> tuple[pl.LazyFrame, pl.LazyFrame | None, pl.LazyFrame]:
+    """
+    Splits the dataset into training, validation, and test segments based on the provided timestamps.
+
+    The segments are defined as follows:
+    - Training set: [0, test_timestamp - gap_size - val_size - gap_size) if val_size != 0,
+                    otherwise [0, test_timestamp - gap_size)
+    - Validation set: [test_timestamp - val_size - gap_size, test_timestamp - gap_size), if val_size != 0
+    - Test set: [test_timestamp, +inf)
+
+    It retains only those users and items in the validation and test sets that exist in the training set.
+
+    Parameters:
+    ----------
+    df : LazyFrame
+        The dataset in Polars' LazyFrame format.
+    test_timestamp : int | None
+        The timestamp marking the start of the test set;
+    val_size : int | None
+        The size of validation. If 0, no validation set is created.
+    gap_size : int
+        The duration of gap between training and validation/test sets.
+    drop_non_train_items : bool
+        Whether to drop items that are not in the training set.
+
+    Returns:
+    -------
+    tuple[LazyFrame, LazyFrame | None, LazyFrame]
+        A tuple containing LazyFrames for the training, validation (if applicable), and test sets.
+    """
+
+    def drop(df: pl.LazyFrame, unique_train_item_ids) -> pl.LazyFrame:
+        if not drop_non_train_items:
+            return df
+
+        return (
+            df.with_columns(
+                pl.col("item_id").is_in(unique_train_item_ids.get_column("item_id").implode()).alias("item_id_in_train")
+            )
+            .filter("item_id_in_train")
+            .drop("item_id_in_train")
+        )
+
+    train_timestamp = test_timestamp - gap_size - val_size - (gap_size if val_size != 0 else 0)
+
+    assert gap_size >= 0
+    assert val_size >= 0
+    assert train_timestamp > 0
+
+    df_lazy = df.lazy()
+
+    train = df_lazy.filter(pl.col("timestamp") < train_timestamp)
+
+    unique_train_uids = train.select("uid").unique().collect(engine=engine)
+    unique_train_item_ids = train.select("item_id").unique().collect(engine=engine)
+
+    validation = None
+    if val_size != 0:
+        validation = (
+            df_lazy.filter(
+                (pl.col("timestamp") >= test_timestamp - val_size - gap_size)
+                & (pl.col("timestamp") < test_timestamp - gap_size)
+            )
+            #
+            .with_columns(
+                pl.col("uid").is_in(unique_train_uids.get_column("uid").implode()).alias("uid_in_train")
+            )  # to prevent filter reordering
+            .filter("uid_in_train")
+            .drop("uid_in_train")
+        )
+
+        validation = drop(validation, unique_train_item_ids)
+
+    test = (
+        df_lazy.filter(pl.col("timestamp") >= test_timestamp)
+        #
+        .with_columns(
+            pl.col("uid").is_in(unique_train_uids.get_column("uid").implode()).alias("uid_in_train")
+        )  # to prevent filter reordering
+        .filter("uid_in_train")
+        .drop("uid_in_train")
+    )
+
+    test = drop(test, unique_train_item_ids)
+
+    return train, validation, test
+
+
+def sequential_split_train_val_test(
+    df: pl.LazyFrame,
+    test_timestamp: int,
+    val_size: int = 0,
+    gap_size: int = Constants.GAP_SIZE,
+    drop_non_train_items: bool = False,
+    engine: str = "streaming",
+) -> tuple[pl.LazyFrame, pl.LazyFrame | None, pl.LazyFrame]:
+    """
+    Splits the dataset into training, validation, and test segments based on the provided timestamps.
+
+    The segments are defined as follows:
+    - Training set: [0, test_timestamp - gap_size - val_size - gap_size) if val_size != 0,
+                    otherwise [0, test_timestamp - gap_size)
+    - Validation set: [test_timestamp - val_size - gap_size, test_timestamp - gap_size), if val_size != 0
+    - Test set: [test_timestamp, +inf)
+
+    It retains only those users and items in the validation and test sets that exist in the training set.
+
+    Parameters:
+    ----------
+    df : LazyFrame
+        The dataset in Polars' LazyFrame format.
+    test_timestamp : int | None
+        The timestamp marking the start of the test set;
+    val_size : int | None
+        The size of validation. If 0, no validation set is created.
+    gap_size : int
+        The duration of gap between training and validation/test sets.
+    drop_non_train_items : bool
+        Whether to drop items that are not in the training set.
+
+    Returns:
+    -------
+    tuple[LazyFrame, LazyFrame | None, LazyFrame]
+        A tuple containing LazyFrames for the training, validation (if applicable), and test sets.
+    """
+
+    def drop(df: pl.LazyFrame, unique_train_item_ids) -> pl.LazyFrame:
+        if not drop_non_train_items:
+            return df
+
+        return df.select(
+            "uid",
+            pl.all()
+            .exclude("uid")
+            .list.gather(
+                pl.col("item_id").list.eval(
+                    pl.arg_where(pl.element().is_in(unique_train_item_ids.get_column("item_id").implode()))
+                )
+            ),
+        ).filter(pl.col("item_id").list.len() > 0)
+
+    train_timestamp = test_timestamp - gap_size - val_size - (gap_size if val_size != 0 else 0)
+
+    assert gap_size >= 0
+    assert val_size >= 0
+    assert train_timestamp > 0
+
+    df_lazy = df.lazy()
+
+    train = df_lazy.select(
+        "uid",
+        pl.all()
+        .exclude("uid")
+        .list.gather(pl.col("timestamp").list.eval(pl.arg_where(pl.element() < train_timestamp))),
+    ).filter(pl.col("item_id").list.len() > 0)
+
+    unique_train_uids = train.select("uid").unique().collect(engine=engine)
+    unique_train_item_ids = train.explode("item_id").select("item_id").unique().collect(engine=engine)
+
+    validation = None
+    if val_size != 0:
+        validation = (
+            df_lazy.select(
+                "uid",
+                pl.all()
+                .exclude("uid")
+                .list.gather(
+                    pl.col("timestamp").list.eval(
+                        pl.arg_where(
+                            (pl.element() >= test_timestamp - val_size - gap_size)
+                            & (pl.element() < test_timestamp - gap_size)
+                        )
+                    )
+                ),
+            )
+            .with_columns(
+                pl.col("uid").is_in(unique_train_uids.get_column("uid").implode()).alias("uid_in_train")
+            )  # to prevent filter reordering
+            .filter("uid_in_train")
+            .drop("uid_in_train")
+        )
+
+        validation = drop(validation, unique_train_item_ids).filter(pl.col("item_id").list.len() > 0)
+
+    test = (
+        df_lazy.select(
+            "uid",
+            pl.all()
+            .exclude("uid")
+            .list.gather(pl.col("timestamp").list.eval(pl.arg_where(pl.element() >= test_timestamp))),
+        )
+        #
+        .with_columns(
+            pl.col("uid").is_in(unique_train_uids.get_column("uid").implode()).alias("uid_in_train")
+        )  # to prevent filter reordering
+        .filter("uid_in_train")
+        .drop("uid_in_train")
+    )
+
+    test = drop(test, unique_train_item_ids).filter(pl.col("item_id").list.len() > 0)
+
+    return train, validation, test

benchmarks/yambda/utils.py

@@ -0,0 +1,42 @@
+import functools
+from typing import Any
+
+
+def sum_dicts(d1: dict[Any, Any], d2: dict[Any, Any]) -> dict[Any, Any]:
+    if len(d1) == 0:
+        return d2
+    if len(d2) == 0:
+        return d1
+
+    if d1.keys() != d2.keys():
+        raise ValueError("Keys do not match.")
+
+    result = {}
+    for key in d1:
+        assert isinstance(d1, type(d2))
+
+        if isinstance(d1[key], dict) and isinstance(d2[key], dict):
+            result[key] = sum_dicts(d1[key], d2[key])
+        else:
+            result[key] = d1[key] + d2[key]
+
+    return result
+
+
+def divide_dict(d: dict[Any, Any], denom: float) -> dict[Any, Any]:
+    result = {}
+    for key in d:
+        if isinstance(d[key], dict):
+            result[key] = divide_dict(d[key], denom)
+        else:
+            result[key] = d[key] / denom
+
+    return result
+
+
+def mean_dicts(arr: list[dict[Any, Any]]) -> dict[Any, Any]:
+    return divide_dict(functools.reduce(sum_dicts, arr), len(arr))
+
+
+def argmax(a: list[Any], key=lambda x: x) -> Any:
+    return max(range(len(a)), key=lambda x: key(a[x]))