nextrec 0.1.1__py3-none-any.whl

nextrec/loss/loss_utils.py

@@ -0,0 +1,136 @@
+"""
+Loss utilities for NextRec
+
+Date: create on 09/11/2025
+Author:
+    Yang Zhou,zyaztec@gmail.com
+"""
+import torch
+import torch.nn as nn
+from typing import Literal
+
+from nextrec.loss.match_losses import (
+    BPRLoss, 
+    HingeLoss, 
+    TripletLoss, 
+    SampledSoftmaxLoss,
+    CosineContrastiveLoss, 
+    InfoNCELoss
+)
+
+# Valid task types for validation
+VALID_TASK_TYPES = ['binary', 'multiclass', 'regression', 'multivariate_regression', 'match', 'ranking', 'multitask', 'multilabel']
+
+
+def get_loss_fn(
+    task_type: str = "binary",
+    training_mode: str | None = None,
+    loss: str | nn.Module | None = None,
+    **loss_kwargs
+) -> nn.Module:
+    """
+    Get loss function based on task type and training mode.
+    
+    Examples:
+        # Ranking task (binary classification)
+        >>> loss_fn = get_loss_fn(task_type="binary", loss="bce")
+        
+        # Match task with pointwise training
+        >>> loss_fn = get_loss_fn(task_type="match", training_mode="pointwise")
+        
+        # Match task with pairwise training
+        >>> loss_fn = get_loss_fn(task_type="match", training_mode="pairwise", loss="bpr")
+        
+        # Match task with listwise training
+        >>> loss_fn = get_loss_fn(task_type="match", training_mode="listwise", loss="sampled_softmax")
+    """
+
+    if isinstance(loss, nn.Module):
+        return loss
+
+    if task_type == "match":
+        if training_mode == "pointwise":
+            # Pointwise training uses binary cross entropy
+            if loss is None or loss == "bce" or loss == "binary_crossentropy":
+                return nn.BCELoss(**loss_kwargs)
+            elif loss == "cosine_contrastive":
+                return CosineContrastiveLoss(**loss_kwargs)
+            elif isinstance(loss, str):
+                raise ValueError(f"Unsupported pointwise loss: {loss}")
+        
+        elif training_mode == "pairwise":
+            if loss is None or loss == "bpr":
+                return BPRLoss(**loss_kwargs)
+            elif loss == "hinge":
+                return HingeLoss(**loss_kwargs)
+            elif loss == "triplet":
+                return TripletLoss(**loss_kwargs)
+            elif isinstance(loss, str):
+                raise ValueError(f"Unsupported pairwise loss: {loss}")
+        
+        elif training_mode == "listwise":
+            if loss is None or loss == "sampled_softmax" or loss == "softmax":
+                return SampledSoftmaxLoss(**loss_kwargs)
+            elif loss == "infonce":
+                return InfoNCELoss(**loss_kwargs)
+            elif loss == "crossentropy" or loss == "ce":
+                return nn.CrossEntropyLoss(**loss_kwargs)
+            elif isinstance(loss, str):
+                raise ValueError(f"Unsupported listwise loss: {loss}")
+        
+        else:
+            raise ValueError(f"Unknown training_mode: {training_mode}")
+
+    elif task_type in ["ranking", "multitask", "binary"]:
+        if loss is None or loss == "bce" or loss == "binary_crossentropy":
+            return nn.BCELoss(**loss_kwargs)
+        elif loss == "mse":
+            return nn.MSELoss(**loss_kwargs)
+        elif loss == "mae":
+            return nn.L1Loss(**loss_kwargs)
+        elif loss == "crossentropy" or loss == "ce":
+            return nn.CrossEntropyLoss(**loss_kwargs)
+        elif isinstance(loss, str):
+            raise ValueError(f"Unsupported loss function: {loss}")
+
+    elif task_type == "multiclass":
+        if loss is None or loss == "crossentropy" or loss == "ce":
+            return nn.CrossEntropyLoss(**loss_kwargs)
+        elif isinstance(loss, str):
+            raise ValueError(f"Unsupported multiclass loss: {loss}")
+    
+    elif task_type == "regression":
+        if loss is None or loss == "mse":
+            return nn.MSELoss(**loss_kwargs)
+        elif loss == "mae":
+            return nn.L1Loss(**loss_kwargs)
+        elif isinstance(loss, str):
+            raise ValueError(f"Unsupported regression loss: {loss}")
+    
+    else:
+        raise ValueError(f"Unsupported task_type: {task_type}")
+    
+    return loss
+
+
+def validate_training_mode(
+    training_mode: str,
+    support_training_modes: list[str],
+    model_name: str = "Model"
+) -> None:
+    """
+    Validate that the requested training mode is supported by the model.
+    
+    Args:
+        training_mode: Requested training mode
+        support_training_modes: List of supported training modes
+        model_name: Name of the model (for error messages)
+    
+    Raises:
+        ValueError: If training mode is not supported
+    """
+    if training_mode not in support_training_modes:
+        raise ValueError(
+            f"{model_name} does not support training_mode='{training_mode}'. "
+            f"Supported modes: {support_training_modes}"
+        )

nextrec/loss/match_losses.py

@@ -0,0 +1,294 @@
+"""
+Loss functions for matching tasks
+
+Date: create on 13/11/2025
+Author:
+    Yang Zhou,zyaztec@gmail.com
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional
+
+
+class BPRLoss(nn.Module):
+    def __init__(self, reduction: str = 'mean'):
+        super(BPRLoss, self).__init__()
+        self.reduction = reduction
+    
+    def forward(self, pos_score: torch.Tensor, neg_score: torch.Tensor) -> torch.Tensor:
+        if neg_score.dim() == 2:
+            pos_score = pos_score.unsqueeze(1)  # [batch_size, 1]
+            diff = pos_score - neg_score  # [batch_size, num_neg]
+            loss = -torch.log(torch.sigmoid(diff) + 1e-8)
+            if self.reduction == 'mean':
+                return loss.mean()
+            elif self.reduction == 'sum':
+                return loss.sum()
+            else:
+                return loss
+        else:
+            diff = pos_score - neg_score
+            loss = -torch.log(torch.sigmoid(diff) + 1e-8)
+            if self.reduction == 'mean':
+                return loss.mean()
+            elif self.reduction == 'sum':
+                return loss.sum()
+            else:
+                return loss
+
+
+class HingeLoss(nn.Module): 
+    def __init__(self, margin: float = 1.0, reduction: str = 'mean'):
+        super(HingeLoss, self).__init__()
+        self.margin = margin
+        self.reduction = reduction
+    
+    def forward(self, pos_score: torch.Tensor, neg_score: torch.Tensor) -> torch.Tensor:
+        if neg_score.dim() == 2:
+            pos_score = pos_score.unsqueeze(1)  # [batch_size, 1]
+        
+        diff = pos_score - neg_score
+        loss = torch.clamp(self.margin - diff, min=0)
+        
+        if self.reduction == 'mean':
+            return loss.mean()
+        elif self.reduction == 'sum':
+            return loss.sum()
+        else:
+            return loss
+
+
+class TripletLoss(nn.Module):
+    def __init__(self, margin: float = 1.0, reduction: str = 'mean', distance: str = 'euclidean'):
+        super(TripletLoss, self).__init__()
+        self.margin = margin
+        self.reduction = reduction
+        self.distance = distance
+    
+    def forward(self, anchor: torch.Tensor, positive: torch.Tensor, negative: torch.Tensor) -> torch.Tensor:
+        if self.distance == 'euclidean':
+            pos_dist = torch.sum((anchor - positive) ** 2, dim=-1)
+            
+            if negative.dim() == 3:
+                anchor_expanded = anchor.unsqueeze(1)  # [batch_size, 1, dim]
+                neg_dist = torch.sum((anchor_expanded - negative) ** 2, dim=-1)  # [batch_size, num_neg]
+            else:
+                neg_dist = torch.sum((anchor - negative) ** 2, dim=-1)
+            
+            if neg_dist.dim() == 2:
+                pos_dist = pos_dist.unsqueeze(1)  # [batch_size, 1]
+        
+        elif self.distance == 'cosine':
+            pos_dist = 1 - F.cosine_similarity(anchor, positive, dim=-1)
+            
+            if negative.dim() == 3:
+                anchor_expanded = anchor.unsqueeze(1)  # [batch_size, 1, dim]
+                neg_dist = 1 - F.cosine_similarity(anchor_expanded, negative, dim=-1)
+            else:
+                neg_dist = 1 - F.cosine_similarity(anchor, negative, dim=-1)
+            
+            if neg_dist.dim() == 2:
+                pos_dist = pos_dist.unsqueeze(1)
+        else:
+            raise ValueError(f"Unsupported distance: {self.distance}")
+        
+        loss = torch.clamp(pos_dist - neg_dist + self.margin, min=0)
+        
+        if self.reduction == 'mean':
+            return loss.mean()
+        elif self.reduction == 'sum':
+            return loss.sum()
+        else:
+            return loss
+
+
+class SampledSoftmaxLoss(nn.Module):
+    def __init__(self, reduction: str = 'mean'):
+        super(SampledSoftmaxLoss, self).__init__()
+        self.reduction = reduction
+    
+    def forward(self, pos_logits: torch.Tensor, neg_logits: torch.Tensor) -> torch.Tensor:
+        pos_logits = pos_logits.unsqueeze(1)  # [batch_size, 1]
+        all_logits = torch.cat([pos_logits, neg_logits], dim=1)  # [batch_size, 1 + num_neg]
+        targets = torch.zeros(all_logits.size(0), dtype=torch.long, device=all_logits.device)
+        loss = F.cross_entropy(all_logits, targets, reduction=self.reduction)
+        
+        return loss
+
+
+class CosineContrastiveLoss(nn.Module):
+    def __init__(self, margin: float = 0.5, reduction: str = 'mean'):
+        super(CosineContrastiveLoss, self).__init__()
+        self.margin = margin
+        self.reduction = reduction
+    
+    def forward(self, user_emb: torch.Tensor, item_emb: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:
+        similarity = F.cosine_similarity(user_emb, item_emb, dim=-1)
+        pos_loss = (1 - similarity) * labels
+
+        neg_loss = torch.clamp(similarity - self.margin, min=0) * (1 - labels)
+        
+        loss = pos_loss + neg_loss
+        
+        if self.reduction == 'mean':
+            return loss.mean()
+        elif self.reduction == 'sum':
+            return loss.sum()
+        else:
+            return loss
+
+
+class InfoNCELoss(nn.Module):
+    def __init__(self, temperature: float = 0.07, reduction: str = 'mean'):
+        super(InfoNCELoss, self).__init__()
+        self.temperature = temperature
+        self.reduction = reduction
+    
+    def forward(self, query: torch.Tensor, pos_key: torch.Tensor, neg_keys: torch.Tensor) -> torch.Tensor:
+        pos_sim = torch.sum(query * pos_key, dim=-1) / self.temperature  # [batch_size]
+        pos_sim = pos_sim.unsqueeze(1)  # [batch_size, 1]
+        query_expanded = query.unsqueeze(1)  # [batch_size, 1, dim]
+        neg_sim = torch.sum(query_expanded * neg_keys, dim=-1) / self.temperature  # [batch_size, num_neg]
+        logits = torch.cat([pos_sim, neg_sim], dim=1)  # [batch_size, 1 + num_neg]
+        labels = torch.zeros(logits.size(0), dtype=torch.long, device=logits.device)
+
+        loss = F.cross_entropy(logits, labels, reduction=self.reduction)
+        
+        return loss
+
+
+class ListNetLoss(nn.Module):
+    """
+    ListNet loss using top-1 probability distribution
+    Reference: Cao et al. Learning to Rank: From Pairwise Approach to Listwise Approach (ICML 2007)
+    """
+    def __init__(self, temperature: float = 1.0, reduction: str = 'mean'):
+        super(ListNetLoss, self).__init__()
+        self.temperature = temperature
+        self.reduction = reduction
+    
+    def forward(self, scores: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:
+        # Convert scores and labels to probability distributions
+        pred_probs = F.softmax(scores / self.temperature, dim=1)
+        true_probs = F.softmax(labels / self.temperature, dim=1)
+        
+        # Cross entropy between two distributions
+        loss = -torch.sum(true_probs * torch.log(pred_probs + 1e-10), dim=1)
+        
+        if self.reduction == 'mean':
+            return loss.mean()
+        elif self.reduction == 'sum':
+            return loss.sum()
+        else:
+            return loss
+
+
+class ListMLELoss(nn.Module):
+    """
+    ListMLE (Maximum Likelihood Estimation) loss
+    Reference: Xia et al. Listwise approach to learning to rank: theory and algorithm (ICML 2008)
+    """
+    def __init__(self, reduction: str = 'mean'):
+        super(ListMLELoss, self).__init__()
+        self.reduction = reduction
+    
+    def forward(self, scores: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:
+        # Sort by labels in descending order to get ground truth ranking
+        sorted_labels, sorted_indices = torch.sort(labels, descending=True, dim=1)
+        
+        # Reorder scores according to ground truth ranking
+        batch_size, list_size = scores.shape
+        batch_indices = torch.arange(batch_size, device=scores.device).unsqueeze(1).expand(-1, list_size)
+        sorted_scores = scores[batch_indices, sorted_indices]
+        
+        # Compute log likelihood
+        # For each position, compute log(exp(score_i) / sum(exp(score_j) for j >= i))
+        loss = torch.tensor(0.0, device=scores.device)
+        for i in range(list_size):
+            # Log-sum-exp trick for numerical stability
+            remaining_scores = sorted_scores[:, i:]
+            log_sum_exp = torch.logsumexp(remaining_scores, dim=1)
+            loss = loss + (log_sum_exp - sorted_scores[:, i]).sum()
+        
+        if self.reduction == 'mean':
+            return loss / batch_size
+        elif self.reduction == 'sum':
+            return loss
+        else:
+            return loss / batch_size
+
+
+class ApproxNDCGLoss(nn.Module):
+    """
+    Approximate NDCG loss for learning to rank
+    Reference: Qin et al. A General Approximation Framework for Direct Optimization of 
+               Information Retrieval Measures (Information Retrieval 2010)
+    """
+    def __init__(self, temperature: float = 1.0, reduction: str = 'mean'):
+        super(ApproxNDCGLoss, self).__init__()
+        self.temperature = temperature
+        self.reduction = reduction
+    
+    def _dcg(self, relevance: torch.Tensor, k: Optional[int] = None) -> torch.Tensor:
+        if k is not None:
+            relevance = relevance[:, :k]
+        
+        # DCG = sum(rel_i / log2(i + 2)) for i in range(list_size)
+        positions = torch.arange(1, relevance.size(1) + 1, device=relevance.device, dtype=torch.float32)
+        discounts = torch.log2(positions + 1.0)
+        dcg = torch.sum(relevance / discounts, dim=1)
+        
+        return dcg
+    
+    def forward(self, scores: torch.Tensor, labels: torch.Tensor, k: Optional[int] = None) -> torch.Tensor:
+        """
+        Args:
+            scores: Predicted scores [batch_size, list_size]
+            labels: Ground truth relevance labels [batch_size, list_size]
+            k: Top-k items for NDCG@k (if None, use all items)
+        
+        Returns:
+            Approximate NDCG loss (1 - NDCG)
+        """
+        batch_size = scores.size(0)
+        
+        # Use differentiable sorting approximation with softmax
+        # Create pairwise comparison matrix
+        scores_expanded = scores.unsqueeze(2)  # [batch_size, list_size, 1]
+        scores_tiled = scores.unsqueeze(1)     # [batch_size, 1, list_size]
+        
+        # Compute pairwise probabilities using sigmoid
+        pairwise_diff = (scores_expanded - scores_tiled) / self.temperature
+        pairwise_probs = torch.sigmoid(pairwise_diff)  # [batch_size, list_size, list_size]
+        
+        # Approximate ranking positions
+        # ranking_probs[i, j] ≈ probability that item i is ranked at position j
+        # We use softmax approximation for differentiable ranking
+        ranking_weights = F.softmax(scores / self.temperature, dim=1)
+        
+        # Sort labels to get ideal DCG
+        ideal_labels, _ = torch.sort(labels, descending=True, dim=1)
+        ideal_dcg = self._dcg(ideal_labels, k)
+        
+        # Compute approximate DCG using soft ranking
+        # Weight each item's relevance by its soft ranking position
+        positions = torch.arange(1, scores.size(1) + 1, device=scores.device, dtype=torch.float32)
+        discounts = 1.0 / torch.log2(positions + 1.0)
+        
+        # Approximate DCG by weighting relevance with ranking probabilities
+        approx_dcg = torch.sum(labels * ranking_weights * discounts, dim=1)
+        
+        # Normalize by ideal DCG to get NDCG
+        ndcg = approx_dcg / (ideal_dcg + 1e-10)
+        
+        # Loss is 1 - NDCG (we want to maximize NDCG, so minimize 1 - NDCG)
+        loss = 1.0 - ndcg
+        
+        if self.reduction == 'mean':
+            return loss.mean()
+        elif self.reduction == 'sum':
+            return loss.sum()
+        else:
+            return loss

nextrec/models/match/__init__.py

@@ -0,0 +1,13 @@
+from .dssm import DSSM
+from .dssm_v2 import DSSM_v2
+from .youtube_dnn import YoutubeDNN
+from .mind import MIND
+from .sdm import SDM
+
+__all__ = [
+    'DSSM',
+    'DSSM_v2',
+    'YoutubeDNN',
+    'MIND',
+    'SDM',
+]

nextrec/models/match/dssm.py

@@ -0,0 +1,200 @@
+"""
+Date: create on 09/11/2025
+Author:
+    Yang Zhou,zyaztec@gmail.com
+Reference:
+    [1] Huang P S, He X, Gao J, et al. Learning deep structured semantic models for web search using clickthrough data[C]
+        //Proceedings of the 22nd ACM international conference on Information & Knowledge Management. 2013: 2333-2338.
+"""
+import torch
+import torch.nn as nn
+from typing import Optional, Literal
+
+from nextrec.basic.model import BaseMatchModel
+from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature
+from nextrec.basic.layers import MLP, EmbeddingLayer
+
+
+class DSSM(BaseMatchModel):
+    """
+    Deep Structured Semantic Model
+    
+    双塔模型，分别对user和item特征编码为embedding，通过余弦相似度或点积计算匹配分数
+    """
+    
+    @property
+    def model_name(self) -> str:
+        return "DSSM"
+    
+    def __init__(self,
+                 user_dense_features: list[DenseFeature] | None = None,
+                 user_sparse_features: list[SparseFeature] | None = None,
+                 user_sequence_features: list[SequenceFeature] | None = None,
+                 item_dense_features: list[DenseFeature] | None = None,
+                 item_sparse_features: list[SparseFeature] | None = None,
+                 item_sequence_features: list[SequenceFeature] | None = None,
+                 user_dnn_hidden_units: list[int] = [256, 128, 64],
+                 item_dnn_hidden_units: list[int] = [256, 128, 64],
+                 embedding_dim: int = 64,
+                 dnn_activation: str = 'relu',
+                 dnn_dropout: float = 0.0,
+                 training_mode: Literal['pointwise', 'pairwise', 'listwise'] = 'pointwise',
+                 num_negative_samples: int = 4,
+                 temperature: float = 1.0,
+                 similarity_metric: Literal['dot', 'cosine', 'euclidean'] = 'cosine',
+                 device: str = 'cpu',
+                 embedding_l1_reg: float = 0.0,
+                 dense_l1_reg: float = 0.0,
+                 embedding_l2_reg: float = 0.0,
+                 dense_l2_reg: float = 0.0,
+                 early_stop_patience: int = 20,
+                 model_id: str = 'dssm'):
+        
+        super(DSSM, self).__init__(
+            user_dense_features=user_dense_features,
+            user_sparse_features=user_sparse_features,
+            user_sequence_features=user_sequence_features,
+            item_dense_features=item_dense_features,
+            item_sparse_features=item_sparse_features,
+            item_sequence_features=item_sequence_features,
+            training_mode=training_mode,
+            num_negative_samples=num_negative_samples,
+            temperature=temperature,
+            similarity_metric=similarity_metric,
+            device=device,
+            embedding_l1_reg=embedding_l1_reg,
+            dense_l1_reg=dense_l1_reg,
+            embedding_l2_reg=embedding_l2_reg,
+            dense_l2_reg=dense_l2_reg,
+            early_stop_patience=early_stop_patience,
+            model_id=model_id
+        )
+        
+        self.embedding_dim = embedding_dim
+        self.user_dnn_hidden_units = user_dnn_hidden_units
+        self.item_dnn_hidden_units = item_dnn_hidden_units
+        
+        # User tower embedding layer
+        user_features = []
+        if user_dense_features:
+            user_features.extend(user_dense_features)
+        if user_sparse_features:
+            user_features.extend(user_sparse_features)
+        if user_sequence_features:
+            user_features.extend(user_sequence_features)
+        
+        if len(user_features) > 0:
+            self.user_embedding = EmbeddingLayer(user_features)
+            
+            # 计算user tower输入维度
+            user_input_dim = 0
+            for feat in user_dense_features or []:
+                user_input_dim += 1
+            for feat in user_sparse_features or []:
+                user_input_dim += feat.embedding_dim
+            for feat in user_sequence_features or []:
+                user_input_dim += feat.embedding_dim
+            
+            # User DNN
+            user_dnn_units = user_dnn_hidden_units + [embedding_dim]
+            self.user_dnn = MLP(
+                input_dim=user_input_dim,
+                dims=user_dnn_units,
+                output_layer=False,
+                dropout=dnn_dropout,
+                activation=dnn_activation
+            )
+        
+        # Item tower embedding layer
+        item_features = []
+        if item_dense_features:
+            item_features.extend(item_dense_features)
+        if item_sparse_features:
+            item_features.extend(item_sparse_features)
+        if item_sequence_features:
+            item_features.extend(item_sequence_features)
+        
+        if len(item_features) > 0:
+            self.item_embedding = EmbeddingLayer(item_features)
+            
+            # 计算item tower输入维度
+            item_input_dim = 0
+            for feat in item_dense_features or []:
+                item_input_dim += 1
+            for feat in item_sparse_features or []:
+                item_input_dim += feat.embedding_dim
+            for feat in item_sequence_features or []:
+                item_input_dim += feat.embedding_dim
+            
+            # Item DNN
+            item_dnn_units = item_dnn_hidden_units + [embedding_dim]
+            self.item_dnn = MLP(
+                input_dim=item_input_dim,
+                dims=item_dnn_units,
+                output_layer=False,
+                dropout=dnn_dropout,
+                activation=dnn_activation
+            )
+        
+        # 注册正则化权重
+        self._register_regularization_weights(
+            embedding_attr='user_embedding',
+            include_modules=['user_dnn']
+        )
+        self._register_regularization_weights(
+            embedding_attr='item_embedding',
+            include_modules=['item_dnn']
+        )
+        
+        self.compile(
+            optimizer="adam",
+            optimizer_params={"lr": 1e-3, "weight_decay": 1e-5},
+        )
+
+        self.to(device)
+    
+    def user_tower(self, user_input: dict) -> torch.Tensor:
+        """
+        User tower: 将user特征编码为embedding
+        
+        Args:
+            user_input: user特征字典
+        
+        Returns:
+            user_emb: [batch_size, embedding_dim]
+        """
+        # 获取user特征的embedding
+        all_user_features = self.user_dense_features + self.user_sparse_features + self.user_sequence_features
+        user_emb = self.user_embedding(user_input, all_user_features, squeeze_dim=True)
+        
+        # 通过user DNN
+        user_emb = self.user_dnn(user_emb)
+        
+        # L2 normalize for cosine similarity
+        if self.similarity_metric == 'cosine':
+            user_emb = torch.nn.functional.normalize(user_emb, p=2, dim=1)
+        
+        return user_emb
+    
+    def item_tower(self, item_input: dict) -> torch.Tensor:
+        """
+        Item tower: 将item特征编码为embedding
+        
+        Args:
+            item_input: item特征字典
+        
+        Returns:
+            item_emb: [batch_size, embedding_dim] 或 [batch_size, num_items, embedding_dim]
+        """
+        # 获取item特征的embedding
+        all_item_features = self.item_dense_features + self.item_sparse_features + self.item_sequence_features
+        item_emb = self.item_embedding(item_input, all_item_features, squeeze_dim=True)
+        
+        # 通过item DNN
+        item_emb = self.item_dnn(item_emb)
+        
+        # L2 normalize for cosine similarity
+        if self.similarity_metric == 'cosine':
+            item_emb = torch.nn.functional.normalize(item_emb, p=2, dim=1)
+        
+        return item_emb