nextrec 0.1.11__py3-none-any.whl → 0.2.2__py3-none-any.whl

nextrec/loss/match_losses.py

@@ -1,294 +0,0 @@
-"""
-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/utils/common.py

@@ -1,14 +0,0 @@
-"""
-Common utilities for NextRec
-
-Date: create on 13/11/2025
-Author:
-    Yang Zhou, zyaztec@gmail.com
-"""
-
-
-def get_task_type(model) -> str:
-    """
-    Get task type from model.
-    """
-    return model.task_type

nextrec-0.1.11.dist-info/RECORD

@@ -1,51 +0,0 @@
-nextrec/__init__.py,sha256=CvocnY2uBp0cjNkhrT6ogw0q2bN9s1GNp754FLO-7lo,1117
-nextrec/__version__.py,sha256=nllDrH0jyChMuuYrK0CC55iTBKUNTUjejtcwxyUF2EQ,23
-nextrec/basic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nextrec/basic/activation.py,sha256=XJDTFzmacpLq8DMNbFVhZ3WhlOmKDE88vp0udnVpXtE,2808
-nextrec/basic/callback.py,sha256=c0QeolbPJzCYhJnPf9rrZwFU13zmLxg59nvQGbpetNo,1039
-nextrec/basic/dataloader.py,sha256=roG1a7VRPpdy9XBv0rJg7wz00ggok9WNHU_EoDIxY2c,18898
-nextrec/basic/features.py,sha256=wJbiDqE_qWA5gArUm-NYHaLgk7AMxpA7loaovf84dSU,2526
-nextrec/basic/layers.py,sha256=dvMir_0PJQfZv0uCUeqyiJpb-QOz0f2CUu2Cuuxh7iA,38300
-nextrec/basic/loggers.py,sha256=0fupxPiHrKcBEJTBm0Sjcim0rU-n0gYKuy6IiCYX1Bw,3480
-nextrec/basic/metrics.py,sha256=p79-IRRprLcXjjicrG41vM0zwRGtUY5tTPoybpvz-io,20402
-nextrec/basic/model.py,sha256=HeExyUkhihiARJvCXfLztkMDfUELR9WGJKtn26QAfPc,65879
-nextrec/data/__init__.py,sha256=vvBNAdHcVO54aaaT-SyYHWsPHhoH8GvrlZ2hMRjqyF8,524
-nextrec/data/data_utils.py,sha256=rpcj5CIWw8RlLn1NYva_gEOlpYG1cy65rB1BSv23XAM,4113
-nextrec/data/preprocessor.py,sha256=0gYc_nH6ek3QxgncSZ8B8KyYmIYdCFMx9rSEdo4-aFw,26442
-nextrec/loss/__init__.py,sha256=kBanUB5rxQKwXTd6f-2hOI_CF7cp_MClAwAeVXIkpig,647
-nextrec/loss/loss_utils.py,sha256=3zeeLBG4lNIXCO94jx-BYlSHl14t-U7L06dQuzVSPJ8,4752
-nextrec/loss/match_losses.py,sha256=BaH4GKVSFU_PNhHPP_JuAM5zwjOIPxcbuNLYpK0-EWA,11652
-nextrec/models/generative/hstu.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nextrec/models/generative/tiger.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nextrec/models/match/__init__.py,sha256=ASZB5abqKPhDbk8NErNNNa0DHuWpsVxvUtyEn5XMx6Y,215
-nextrec/models/match/dssm.py,sha256=rl-8-4pG5_DgxM0VYZuPzLP1lhvDF1BbQQoqxBMMqYw,7702
-nextrec/models/match/dssm_v2.py,sha256=eyWrCo8g8y-e_fq5168iTA_xuHdYWBT9v96GaPor6-o,6407
-nextrec/models/match/mind.py,sha256=5g7b-VOShPQ9D4FG-1z8exKYFLJS_z_Lt2bvU_qSC98,8735
-nextrec/models/match/sdm.py,sha256=rJK49438-49JvzNQX2Vi6Zn1sn9twjyOb2YG2lVaGlc,10238
-nextrec/models/match/youtube_dnn.py,sha256=Su5kwrHGRXrv_4psXZgr9hXpUF5bdosXqdmtHb5J2Vs,6834
-nextrec/models/multi_task/esmm.py,sha256=0dn8pJ7BAQh5oqpNZISSiTb6sgXddsG99eOdpQVMSTU,4817
-nextrec/models/multi_task/mmoe.py,sha256=vly9c8e-Xc_m9AjWUmTGtidf67bjiHPwwbAFbXc0XpM,6099
-nextrec/models/multi_task/ple.py,sha256=mM8shre3BX-sg_peokMh35_-wQAMG5UI2eUfhyRzTgs,11269
-nextrec/models/multi_task/share_bottom.py,sha256=MzShugQya1rSovhbvmTDD4Uf1MRCGfgIKqKXVsz0RTo,4451
-nextrec/models/ranking/__init__.py,sha256=GMn3R5TkE9W17dzHuQoASJsQCoM_EIHuUhnMS2jMdZw,291
-nextrec/models/ranking/afm.py,sha256=BZvGyJZ9aAoL3P8ebsMoQ9HqX2UyKkFdktfz3_VMalA,4483
-nextrec/models/ranking/autoint.py,sha256=D9jeEP0w-IssbporOIPzTzi6PveiYVcgN7D6AXYxyLc,5580
-nextrec/models/ranking/dcn.py,sha256=HyXXzooS1zqOWU6MAPi6tBdmDs4o64HP9vBV5fYdKO4,4134
-nextrec/models/ranking/deepfm.py,sha256=Yl95d4r0dytcZSn4A8ukgxOQ8eaF0t5MqDd9KPfkdPI,3453
-nextrec/models/ranking/dien.py,sha256=2maimf_c6L-I0JpJNbmpIjbMV8uCndrdFiqvjwxMaj8,8401
-nextrec/models/ranking/din.py,sha256=Qs4IxfvCmT2lGtZ6BvgdzMoT0lCy88yaXE1FecaMo2c,7122
-nextrec/models/ranking/fibinet.py,sha256=h6a738bo3VikKHKZhOzk_p9YGNs7hWcpEOkJvOMDR88,4779
-nextrec/models/ranking/fm.py,sha256=WsbQV8RUc2O7b66GRZicNWaWOtin_QLO8e_Skjk5aIY,2887
-nextrec/models/ranking/masknet.py,sha256=ADki3oMR7PwWgcf5GhIUQJxto-gFNmIlU-GRsdi04Jk,4565
-nextrec/models/ranking/pnn.py,sha256=ZhsUh-O_kLJLfK28dp81DMGYnzMkO-L86CgESlT2TB0,4883
-nextrec/models/ranking/widedeep.py,sha256=7EylqHFaxrclRr-PVhKRxBLOOf8E5-AJbWfJqZpdzy0,3642
-nextrec/models/ranking/xdeepfm.py,sha256=p2PrQHxmvABdQl1wLnP5VyRy5Chdp7Xcw1FJw7m1LFY,4200
-nextrec/utils/__init__.py,sha256=-wyEzZrYQ9QL5zPbWdBIWzg-HbT-2wmmbH2Kceuzlzk,510
-nextrec/utils/common.py,sha256=-LrRY1MFAhgeyZkKyqdVQGxev6eH3gigNtlRKw5f8Iw,214
-nextrec/utils/embedding.py,sha256=Xl5bXAdxdGc0FV3FthNqJe9MP0M_rZI1uaOlPi3vLj8,478
-nextrec/utils/initializer.py,sha256=ka5sgXWqAb9x5hQS6ypgonR93OUajBVUAwO7q-JPjIE,1660
-nextrec/utils/optimizer.py,sha256=g9IETUdflM89YKSzInP_iS_hTnDy_cjpm6Wcq9V9_vE,2468
-nextrec-0.1.11.dist-info/METADATA,sha256=DNNd7XuW1MZH4fa4tLqQsxKfcveloyR6Oo1YMBIr34A,11425
-nextrec-0.1.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nextrec-0.1.11.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
-nextrec-0.1.11.dist-info/RECORD,,