nextrec 0.4.12__py3-none-any.whl → 0.4.13__py3-none-any.whl

nextrec/__version__.py

@@ -1 +1 @@
-__version__ = "0.4.12"
+__version__ = "0.4.13"

nextrec/basic/model.py

@@ -50,12 +50,14 @@ from nextrec.data.dataloader import (
 )
 from nextrec.loss import (
     BPRLoss,
+    GradNormLossWeighting,
     HingeLoss,
     InfoNCELoss,
     SampledSoftmaxLoss,
     TripletLoss,
     get_loss_fn,
 )
+from nextrec.loss.grad_norm import get_grad_norm_shared_params
 from nextrec.utils.console import display_metrics_table, progress
 from nextrec.utils.torch_utils import (
     add_distributed_sampler,
@@ -177,6 +179,8 @@ class BaseModel(FeatureSet, nn.Module):
         self.logger_initialized = False
         self.training_logger = None
         self.callbacks = CallbackList(callbacks) if callbacks else CallbackList()
+        self.grad_norm: GradNormLossWeighting | None = None
+        self.grad_norm_shared_params: list[torch.nn.Parameter] | None = None
 
     def register_regularization_weights(
         self,
@@ -377,7 +381,7 @@ class BaseModel(FeatureSet, nn.Module):
         scheduler_params: dict | None = None,
         loss: str | nn.Module | list[str | nn.Module] | None = "bce",
         loss_params: dict | list[dict] | None = None,
-        loss_weights: int | float | list[int | float] | None = None,
+        loss_weights: int | float | list[int | float] | dict | str | None = None,
         callbacks: list[Callback] | None = None,
     ):
         """
@@ -390,6 +394,7 @@ class BaseModel(FeatureSet, nn.Module):
             loss: Loss function name, instance, or list for multi-task. e.g., 'bce', 'mse', or torch.nn.BCELoss(), you can also use custom loss functions.
             loss_params: Loss function parameters, or list for multi-task. e.g., {'weight': tensor([0.25, 0.75])}.
             loss_weights: Weights for each task loss, int/float for single-task or list for multi-task. e.g., 1.0, or [1.0, 0.5].
+                Use "grad_norm" or {"method": "grad_norm", ...} to enable GradNorm for multi-task loss balancing.
             callbacks: Additional callbacks to add to the existing callback list. e.g., [EarlyStopper(), CheckpointSaver()].
         """
         if loss_params is None:
@@ -443,7 +448,31 @@ class BaseModel(FeatureSet, nn.Module):
             for i in range(self.nums_task)
         ]
 
-        if loss_weights is None:
+        self.grad_norm = None
+        self.grad_norm_shared_params = None
+        if isinstance(loss_weights, str) and loss_weights.lower() == "grad_norm":
+            if self.nums_task == 1:
+                raise ValueError(
+                    "[BaseModel-compile Error] GradNorm requires multi-task setup."
+                )
+            self.grad_norm = GradNormLossWeighting(
+                num_tasks=self.nums_task, device=self.device
+            )
+            self.loss_weights = None
+        elif (
+            isinstance(loss_weights, dict) and loss_weights.get("method") == "grad_norm"
+        ):
+            if self.nums_task == 1:
+                raise ValueError(
+                    "[BaseModel-compile Error] GradNorm requires multi-task setup."
+                )
+            grad_norm_params = dict(loss_weights)
+            grad_norm_params.pop("method", None)
+            self.grad_norm = GradNormLossWeighting(
+                num_tasks=self.nums_task, device=self.device, **grad_norm_params
+            )
+            self.loss_weights = None
+        elif loss_weights is None:
             self.loss_weights = None
         elif self.nums_task == 1:
             if isinstance(loss_weights, (list, tuple)):
@@ -508,9 +537,20 @@ class BaseModel(FeatureSet, nn.Module):
             y_pred_i = y_pred[:, start:end]
             y_true_i = y_true[:, start:end]
             task_loss = self.loss_fn[i](y_pred_i, y_true_i)
-            if isinstance(self.loss_weights, (list, tuple)):
-                task_loss *= self.loss_weights[i]
             task_losses.append(task_loss)
+        if self.grad_norm is not None:
+            if self.grad_norm_shared_params is None:
+                self.grad_norm_shared_params = get_grad_norm_shared_params(
+                    self, getattr(self, "grad_norm_shared_modules", None)
+                )
+            return self.grad_norm.compute_weighted_loss(
+                task_losses, self.grad_norm_shared_params
+            )
+        if isinstance(self.loss_weights, (list, tuple)):
+            task_losses = [
+                task_loss * self.loss_weights[i]
+                for i, task_loss in enumerate(task_losses)
+            ]
         return torch.stack(task_losses).sum()
 
     def prepare_data_loader(
@@ -1053,6 +1093,8 @@ class BaseModel(FeatureSet, nn.Module):
             params = model.parameters() if self.ddp_model is not None else self.parameters()  # type: ignore # ddp model parameters or self parameters
             nn.utils.clip_grad_norm_(params, self.max_gradient_norm)
             self.optimizer_fn.step()
+            if self.grad_norm is not None:
+                self.grad_norm.step()
             accumulated_loss += loss.item()
 
             if (
@@ -1637,7 +1679,7 @@ class BaseModel(FeatureSet, nn.Module):
             add_timestamp=add_timestamp,
         )
         model_path = Path(target_path)
-        
+
         ddp_model = getattr(self, "ddp_model", None)
         if ddp_model is not None:
             model_to_save = ddp_model.module
@@ -2067,7 +2109,7 @@ class BaseMatchModel(BaseModel):
         scheduler_params: dict | None = None,
         loss: str | nn.Module | list[str | nn.Module] | None = "bce",
         loss_params: dict | list[dict] | None = None,
-        loss_weights: int | float | list[int | float] | None = None,
+        loss_weights: int | float | list[int | float] | dict | str | None = None,
         callbacks: list[Callback] | None = None,
     ):
         """

nextrec/cli.py

@@ -380,6 +380,7 @@ def train_model(train_config_path: str) -> None:
         optimizer_params=train_cfg.get("optimizer_params", {}),
         loss=train_cfg.get("loss", "focal"),
         loss_params=train_cfg.get("loss_params", {}),
+        loss_weights=train_cfg.get("loss_weights"),
     )
 
     model.fit(

nextrec/loss/__init__.py

@@ -5,6 +5,7 @@ from nextrec.loss.listwise import (
     ListNetLoss,
     SampledSoftmaxLoss,
 )
+from nextrec.loss.grad_norm import GradNormLossWeighting
 from nextrec.loss.loss_utils import VALID_TASK_TYPES, get_loss_fn, get_loss_kwargs
 from nextrec.loss.pairwise import BPRLoss, HingeLoss, TripletLoss
 from nextrec.loss.pointwise import (
@@ -30,6 +31,8 @@ __all__ = [
     "ListNetLoss",
     "ListMLELoss",
     "ApproxNDCGLoss",
+    # Multi-task weighting
+    "GradNormLossWeighting",
     # Utilities
     "get_loss_fn",
     "get_loss_kwargs",

nextrec/loss/grad_norm.py

@@ -0,0 +1,232 @@
+"""
+GradNorm loss weighting for multi-task learning.
+
+Date: create on 27/10/2025
+Checkpoint: edit on 20/12/2025
+Author: Yang Zhou,zyaztec@gmail.com
+
+Reference:
+Chen, Zhao, et al. "GradNorm: Gradient Normalization for Adaptive Loss Balancing
+in Deep Multitask Networks." ICML 2018.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def get_grad_norm_shared_params(
+    model: torch.nn.Module,
+    shared_modules: Iterable[str] | None = None,
+) -> list[torch.nn.Parameter]:
+    if not shared_modules:
+        return [p for p in model.parameters() if p.requires_grad]
+    shared_params = []
+    seen = set()
+    for name in shared_modules:
+        module = getattr(model, name, None)
+        if module is None:
+            continue
+        for param in module.parameters():
+            if param.requires_grad and id(param) not in seen:
+                shared_params.append(param)
+                seen.add(id(param))
+    if not shared_params:
+        return [p for p in model.parameters() if p.requires_grad]
+    return shared_params
+
+
+class GradNormLossWeighting:
+    """
+    Adaptive multi-task loss weighting with GradNorm.
+
+    Args:
+        num_tasks: Number of tasks.
+        alpha: GradNorm balancing strength.
+        lr: Learning rate for the weight optimizer.
+        init_weights: Optional initial weights per task.
+        device: Torch device for weights.
+        ema_decay: Optional EMA decay for smoothing loss ratios.
+        init_ema_steps: Number of steps to build EMA for initial losses.
+        init_ema_decay: EMA decay for initial losses when init_ema_steps > 0.
+        eps: Small value for numerical stability.
+    """
+
+    def __init__(
+        self,
+        num_tasks: int,
+        alpha: float = 1.5,
+        lr: float = 0.025,
+        init_weights: Iterable[float] | None = None,
+        device: torch.device | str | None = None,
+        ema_decay: float | None = None,
+        init_ema_steps: int = 0,
+        init_ema_decay: float = 0.9,
+        eps: float = 1e-8,
+    ) -> None:
+        if num_tasks <= 1:
+            raise ValueError("GradNorm requires num_tasks > 1.")
+        self.num_tasks = num_tasks
+        self.alpha = alpha
+        self.eps = eps
+        if ema_decay is not None:
+            ema_decay = ema_decay
+            if ema_decay < 0.0 or ema_decay >= 1.0:
+                raise ValueError("ema_decay must be in [0.0, 1.0).")
+        self.ema_decay = ema_decay
+        self.init_ema_steps = init_ema_steps
+        if self.init_ema_steps < 0:
+            raise ValueError("init_ema_steps must be >= 0.")
+        self.init_ema_decay = init_ema_decay
+        if self.init_ema_decay < 0.0 or self.init_ema_decay >= 1.0:
+            raise ValueError("init_ema_decay must be in [0.0, 1.0).")
+        self.init_ema_count = 0
+
+        if init_weights is None:
+            weights = torch.ones(self.num_tasks, dtype=torch.float32)
+        else:
+            weights = torch.tensor(list(init_weights), dtype=torch.float32)
+            if weights.numel() != self.num_tasks:
+                raise ValueError(
+                    "init_weights length must match num_tasks for GradNorm."
+                )
+        if device is not None:
+            weights = weights.to(device)
+        self.weights = nn.Parameter(weights)
+        self.optimizer = torch.optim.Adam([self.weights], lr=float(lr))
+
+        self.initial_losses = None
+        self.initial_losses_ema = None
+        self.loss_ema = None
+        self.pending_grad = None
+
+    def to(self, device):
+        device = torch.device(device)
+        self.weights.data = self.weights.data.to(device)
+        if self.initial_losses is not None:
+            self.initial_losses = self.initial_losses.to(device)
+        if self.initial_losses_ema is not None:
+            self.initial_losses_ema = self.initial_losses_ema.to(device)
+        if self.loss_ema is not None:
+            self.loss_ema = self.loss_ema.to(device)
+        return self
+
+    def compute_weighted_loss(
+        self,
+        task_losses: list[torch.Tensor],
+        shared_params: Iterable[torch.nn.Parameter],
+    ) -> torch.Tensor:
+        """
+        Return weighted total loss and update task weights with GradNorm.
+        """
+        if len(task_losses) != self.num_tasks:
+            raise ValueError(
+                f"Expected {self.num_tasks} task losses, got {len(task_losses)}."
+            )
+        shared_params = [p for p in shared_params if p.requires_grad]
+        if not shared_params:
+            return torch.stack(task_losses).sum()
+
+        with torch.no_grad():
+            loss_values = torch.tensor(
+                [loss.item() for loss in task_losses], device=self.weights.device
+            )
+            if self.initial_losses is None:
+                if self.init_ema_steps > 0:
+                    if self.initial_losses_ema is None:
+                        self.initial_losses_ema = loss_values
+                    else:
+                        self.initial_losses_ema = (
+                            self.init_ema_decay * self.initial_losses_ema
+                            + (1.0 - self.init_ema_decay) * loss_values
+                        )
+                    self.init_ema_count += 1
+                    if self.init_ema_count >= self.init_ema_steps:
+                        self.initial_losses = self.initial_losses_ema.clone()
+                else:
+                    self.initial_losses = loss_values
+
+        weights_detached = self.weights.detach()
+        weighted_losses = [
+            weights_detached[i] * task_losses[i] for i in range(self.num_tasks)
+        ]
+        total_loss = torch.stack(weighted_losses).sum()
+
+        grad_norms = self.compute_grad_norms(task_losses, shared_params)
+        with torch.no_grad():
+            if self.ema_decay is not None:
+                if self.loss_ema is None:
+                    self.loss_ema = loss_values
+                else:
+                    self.loss_ema = (
+                        self.ema_decay * self.loss_ema
+                        + (1.0 - self.ema_decay) * loss_values
+                    )
+                ratio_source = self.loss_ema
+            else:
+                ratio_source = loss_values
+            if self.initial_losses is not None:
+                base_initial = self.initial_losses
+            elif self.initial_losses_ema is not None:
+                base_initial = self.initial_losses_ema
+            else:
+                base_initial = loss_values
+            loss_ratios = ratio_source / (base_initial + self.eps)
+            inv_rate = loss_ratios / (loss_ratios.mean() + self.eps)
+            target = grad_norms.mean() * (inv_rate**self.alpha)
+
+        grad_norm_loss = F.l1_loss(grad_norms, target.detach(), reduction="sum")
+        grad_w = torch.autograd.grad(grad_norm_loss, self.weights, retain_graph=True)[0]
+        self.pending_grad = grad_w.detach()
+
+        return total_loss
+
+    def compute_grad_norms(self, task_losses, shared_params):
+        grad_norms = []
+        for i, task_loss in enumerate(task_losses):
+            grads = torch.autograd.grad(
+                self.weights[i] * task_loss,
+                shared_params,
+                retain_graph=True,
+                create_graph=True,
+                allow_unused=True,
+            )
+
+            sq_sum = torch.zeros((), device=self.weights.device)
+            any_used = False
+            for g in grads:
+                if g is not None:
+                    any_used = True
+                    sq_sum = sq_sum + g.pow(2).sum()
+
+            if not any_used:
+                total_norm = torch.tensor(self.eps, device=self.weights.device)
+            else:
+                total_norm = torch.sqrt(sq_sum + self.eps)
+
+            grad_norms.append(total_norm)
+
+        return torch.stack(grad_norms)
+
+    def step(self) -> None:
+        if self.pending_grad is None:
+            return
+
+        self.optimizer.zero_grad(set_to_none=True)
+
+        if self.weights.grad is None:
+            self.weights.grad = torch.zeros_like(self.weights)
+        self.weights.grad.copy_(self.pending_grad)
+
+        self.optimizer.step()
+
+        with torch.no_grad():
+            w = self.weights.clamp(min=self.eps)
+            w = w * self.num_tasks / (w.sum() + self.eps)
+            self.weights.copy_(w)
+
+        self.pending_grad = None

nextrec/loss/loss_utils.py

@@ -60,7 +60,7 @@ def build_cb_focal(kw):
     return ClassBalancedFocalLoss(**kw)
 
 
-def get_loss_fn(loss = None, **kw) -> nn.Module:
+def get_loss_fn(loss=None, **kw) -> nn.Module:
     """
     Get loss function by name or return the provided loss module.
 

nextrec/models/multi_task/esmm.py

@@ -138,6 +138,7 @@ class ESMM(BaseModel):
 
         # CVR tower
         self.cvr_tower = MLP(input_dim=input_dim, output_layer=True, **cvr_params)
+        self.grad_norm_shared_modules = ["embedding"]
         self.prediction_layer = PredictionLayer(
             task_type=self.default_task, task_dims=[1, 1]
         )

nextrec/models/multi_task/mmoe.py

@@ -165,6 +165,7 @@ class MMOE(BaseModel):
         for _ in range(self.num_tasks):
             gate = nn.Sequential(nn.Linear(input_dim, num_experts), nn.Softmax(dim=1))
             self.gates.append(gate)
+        self.grad_norm_shared_modules = ["embedding", "experts", "gates"]
 
         # Task-specific towers
         self.towers = nn.ModuleList()

nextrec/models/multi_task/ple.py

@@ -295,6 +295,7 @@ class PLE(BaseModel):
             )
             self.cgc_layers.append(cgc_layer)
             expert_output_dim = cgc_layer.output_dim
+        self.grad_norm_shared_modules = ["embedding", "cgc_layers"]
 
         # Task-specific towers
         self.towers = nn.ModuleList()

nextrec/models/multi_task/poso.py

@@ -483,6 +483,10 @@ class POSO(BaseModel):
                 ]
             )
             self.tower_heads = None
+        if self.architecture == "mlp":
+            self.grad_norm_shared_modules = ["embedding"]
+        else:
+            self.grad_norm_shared_modules = ["embedding", "mmoe"]
         self.prediction_layer = PredictionLayer(
             task_type=self.default_task,
             task_dims=[1] * self.num_tasks,

nextrec/models/multi_task/share_bottom.py

@@ -129,6 +129,7 @@ class ShareBottom(BaseModel):
 
         # Shared bottom network
         self.bottom = MLP(input_dim=input_dim, output_layer=False, **bottom_params)
+        self.grad_norm_shared_modules = ["embedding", "bottom"]
 
         # Get bottom output dimension
         if "dims" in bottom_params and len(bottom_params["dims"]) > 0:

{nextrec-0.4.12.dist-info → nextrec-0.4.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrec
-Version: 0.4.12
+Version: 0.4.13
 Summary: A comprehensive recommendation library with match, ranking, and multi-task learning models
 Project-URL: Homepage, https://github.com/zerolovesea/NextRec
 Project-URL: Repository, https://github.com/zerolovesea/NextRec
@@ -66,7 +66,7 @@ Description-Content-Type: text/markdown
 ![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)
 ![PyTorch](https://img.shields.io/badge/PyTorch-1.10+-ee4c2c.svg)
 ![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)
-![Version](https://img.shields.io/badge/Version-0.4.12-orange.svg)
+![Version](https://img.shields.io/badge/Version-0.4.13-orange.svg)
 
 中文文档 | [English Version](README_en.md)
 
@@ -99,7 +99,7 @@ NextRec是一个基于PyTorch的现代推荐系统框架，旨在为研究工程
 
 ## NextRec近期进展
 
-- **12/12/2025** 在v0.4.12中加入了[RQ-VAE](/nextrec/models/representation/rqvae.py)模块。配套的[数据集](/dataset/ecommerce_task.csv)和[代码](tutorials/notebooks/zh/使用RQ-VAE构建语义ID.ipynb)已经同步在仓库中
+- **12/12/2025** 在v0.4.13中加入了[RQ-VAE](/nextrec/models/representation/rqvae.py)模块。配套的[数据集](/dataset/ecommerce_task.csv)和[代码](tutorials/notebooks/zh/使用RQ-VAE构建语义ID.ipynb)已经同步在仓库中
 - **07/12/2025** 发布了NextRec CLI命令行工具，它允许用户根据配置文件进行一键训练和推理，我们提供了相关的[教程](/nextrec_cli_preset/NextRec-CLI_zh.md)和[教学代码](/nextrec_cli_preset)
 - **03/12/2025** NextRec获得了100颗🌟！感谢大家的支持
 - **06/12/2025** 在v0.4.1中支持了单机多卡的分布式DDP训练，并且提供了配套的[代码](tutorials/distributed)
@@ -128,7 +128,7 @@ pip install nextrec # or pip install -e .
 - [movielen_ranking_deepfm.py](/tutorials/movielen_ranking_deepfm.py) - movielen 100k数据集上的 DeepFM 模型训练示例
 - [example_ranking_din.py](/tutorials/example_ranking_din.py) - 电商数据集上的DIN 深度兴趣网络训练示例
 - [example_multitask.py](/tutorials/example_multitask.py) - 电商数据集上的ESMM多任务学习训练示例
-- [movielen_match_dssm.py](/tutorials/example_match_dssm.py) - 基于movielen 100k数据集训练的 DSSM 召回模型示例
+- [movielen_match_dssm.py](/tutorials/movielen_match_dssm.py) - 基于movielen 100k数据集训练的 DSSM 召回模型示例
 
 - [example_distributed_training.py](/tutorials/distributed/example_distributed_training.py) - 使用NextRec进行单机多卡训练的代码示例
 
@@ -240,11 +240,11 @@ nextrec --mode=train --train_config=path/to/train_config.yaml
 nextrec --mode=predict --predict_config=path/to/predict_config.yaml
 ```
 
-> 截止当前版本0.4.12，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
+> 截止当前版本0.4.13，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
 
 ## 兼容平台
 
-当前最新版本为0.4.12，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
+当前最新版本为0.4.13，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
 
 | 平台 | 配置 | 
 |------|------|

{nextrec-0.4.12.dist-info → nextrec-0.4.13.dist-info}/RECORD

@@ -1,6 +1,6 @@
 nextrec/__init__.py,sha256=_M3oUqyuvQ5k8Th_3wId6hQ_caclh7M5ad51XN09m98,235
-nextrec/__version__.py,sha256=lYNcyjtUgDCdtQI4PJHV2HTSNhaeqv8synl2jjobziM,23
-nextrec/cli.py,sha256=d6-2VyerK022vltXJFtbkWRdBPprwjzhxSMOhn_n1X0,23926
+nextrec/__version__.py,sha256=ARFl7G-gCe12exBb-FIsJnbsUD5V9okxkHUUdQqb0RA,23
+nextrec/cli.py,sha256=6nBY8O8-0931h428eQS8CALkKn1FmizovJme7Q1c_O0,23978
 nextrec/basic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nextrec/basic/activation.py,sha256=uzTWfCOtBSkbu_Gk9XBNTj8__s241CaYLJk6l8nGX9I,2885
 nextrec/basic/callback.py,sha256=nn1f8FG9c52vJ-gvwteqPbk3-1QuNS1vmhBlkENdb0I,14636
@@ -8,7 +8,7 @@ nextrec/basic/features.py,sha256=GyCUzGPuizUofrZSSOdqHK84YhnX4MGTdu7Cx2OGhUA,465
 nextrec/basic/layers.py,sha256=ZM3Nka3e2cit3e3peL0ukJCMgKZK1ovNFfAWvVOwlos,28556
 nextrec/basic/loggers.py,sha256=Zh1A5DVAFqlGglyaQ4_IMgvFbWAcXX5H3aHbCWA82nE,6524
 nextrec/basic/metrics.py,sha256=saNgM7kuHk9xqDxZF6x33irTaxeXCU-hxYTUQauuGgg,23074
-nextrec/basic/model.py,sha256=YYOU_ZfuNbnUk4ssoaZ7ecP3Yy69GLlPyD_hpMNpdOE,100581
+nextrec/basic/model.py,sha256=b_O81WSv1XxBAS5oQk92DlLdYAtnikr_epaV5T9RSxs,102570
 nextrec/basic/session.py,sha256=UOG_-EgCOxvqZwCkiEd8sgNV2G1sm_HbzKYVQw8yYDI,4483
 nextrec/data/__init__.py,sha256=YZQjpty1pDCM7q_YNmiA2sa5kbujUw26ObLHWjMPjKY,1194
 nextrec/data/batch_utils.py,sha256=0bYGVX7RlhnHv_ZBaUngjDIpBNw-igCk98DgOsF7T6o,2879
@@ -16,19 +16,20 @@ nextrec/data/data_processing.py,sha256=lKXDBszrO5fJMAQetgSPr2mSQuzOluuz1eHV4jp0T
 nextrec/data/data_utils.py,sha256=0Ls1cnG9lBz0ovtyedw5vwp7WegGK_iF-F8e_3DEddo,880
 nextrec/data/dataloader.py,sha256=xTORNbaQVa20sk2S3kyV0SSngscvq8bNqHr0AmYjFqM,18768
 nextrec/data/preprocessor.py,sha256=K-cUP-YdlQx1VJ2m1CXuprncpjDJe2ERVO5xCSoxHKI,44470
-nextrec/loss/__init__.py,sha256=-sibZK8QXLblVNWqdqjrPPzMCDyIXSq7yd2eZ57p9Nw,810
+nextrec/loss/__init__.py,sha256=ZCgsfyR5YAecv6MdOsnUjkfacvZg2coQVjuKAfPvmRo,923
+nextrec/loss/grad_norm.py,sha256=91Grspx95Xu_639TkL_WZRX1xt5QOTZCzBeJWbUGPiE,8385
 nextrec/loss/listwise.py,sha256=UT9vJCOTOQLogVwaeTV7Z5uxIYnngGdxk-p9e97MGkU,5744
-nextrec/loss/loss_utils.py,sha256=M2L382eEyoVttAH3syqZ3v2YX3a3p12yyzeqI9_aSos,4581
+nextrec/loss/loss_utils.py,sha256=xMmT_tWcKah_xcU3FzVMmSEzyZfxiMKZWUbwkAspcDg,4579
 nextrec/loss/pairwise.py,sha256=X9yg-8pcPt2IWU0AiUhWAt3_4W_3wIF0uSdDYTdoPFY,3398
 nextrec/loss/pointwise.py,sha256=o9J3OznY0hlbDsUXqn3k-BBzYiuUH5dopz8QBFqS_kQ,7343
 nextrec/models/generative/__init__.py,sha256=0MV3P-_ainPaTxmRBGWKUVCEt14KJvuvEHmRB3OQ1Fs,176
 nextrec/models/generative/tiger.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nextrec/models/multi_task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nextrec/models/multi_task/esmm.py,sha256=3QQePhSkOcM4t472S4E5xU9_KiLiSwHb9CfdkEgmqqk,6491
-nextrec/models/multi_task/mmoe.py,sha256=uFTbc0MiFBDTCIt8mTW6xs0oyOn1EesIHHZo81HR35k,8583
-nextrec/models/multi_task/ple.py,sha256=z32etizNlTLwwR7CYKxy8u9owAbtiRh492Fje_y64hQ,13016
-nextrec/models/multi_task/poso.py,sha256=foH7XDUz0XN0s0zoyHLuTmrcs3QOT8-x4YGxLX1Lxxg,19016
-nextrec/models/multi_task/share_bottom.py,sha256=rmEnsX3LA3pNsLKfG1ir5WDLdkSY-imO_ASiclirJiA,6519
+nextrec/models/multi_task/esmm.py,sha256=AqesBZ4tOFNm7POCrHZ90h1zWWSViZAYfydUVOh2dEU,6545
+nextrec/models/multi_task/mmoe.py,sha256=aaQKcx4PL_mAanW3tkjAR886KmMCHTdBuu4p9EIKQJo,8657
+nextrec/models/multi_task/ple.py,sha256=fqkujPFGxxQOO_6nBZEz_UcxLEUoX_vCJsk0YOpxTg4,13084
+nextrec/models/multi_task/poso.py,sha256=J_Btxhm9JpFJMdQQHNNf9mMRHOgO7j1ts6VN5o4qJnk,19193
+nextrec/models/multi_task/share_bottom.py,sha256=DTWm6fpLCLiXimD-qk_0YIKT_9THMFDrnx4GDViXc_g,6583
 nextrec/models/ranking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nextrec/models/ranking/afm.py,sha256=96jGUPL4yTWobMIVBjHpOxl9AtAzCAGR8yw7Sy2JmdQ,10125
 nextrec/models/ranking/autoint.py,sha256=S6Cxnp1q2OErSYqmIix5P-b4qLWR-0dY6TMStuU6WLg,8109
@@ -70,8 +71,8 @@ nextrec/utils/embedding.py,sha256=akAEc062MG2cD7VIOllHaqtwzAirQR2gq5iW7oKpGAU,14
 nextrec/utils/feature.py,sha256=rsUAv3ELyDpehVw8nPEEsLCCIjuKGTJJZuFaWB_wrPk,633
 nextrec/utils/model.py,sha256=3B85a0IJCggI26dxv25IX8R_5yQPo7wXI0JIAns6bkQ,1727
 nextrec/utils/torch_utils.py,sha256=AKfYbSOJjEw874xsDB5IO3Ote4X7vnqzt_E0jJny0o8,13468
-nextrec-0.4.12.dist-info/METADATA,sha256=lr9yOH4bSPen9rTy-hsmFPkiHu91mkpwjVpu7Bk-L84,20957
-nextrec-0.4.12.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nextrec-0.4.12.dist-info/entry_points.txt,sha256=NN-dNSdfMRTv86bNXM7d3ZEPW2BQC6bRi7QP7i9cIps,45
-nextrec-0.4.12.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
-nextrec-0.4.12.dist-info/RECORD,,
+nextrec-0.4.13.dist-info/METADATA,sha256=BcBFpd0l4OdNRlXtG5R1UT-jMcAdloQJjOAG33E4KRE,20958
+nextrec-0.4.13.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nextrec-0.4.13.dist-info/entry_points.txt,sha256=NN-dNSdfMRTv86bNXM7d3ZEPW2BQC6bRi7QP7i9cIps,45
+nextrec-0.4.13.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
+nextrec-0.4.13.dist-info/RECORD,,