benchmarks/models/sasrec/model.py

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