nextrec 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

nextrec/models/ranking/masknet.py

@@ -1,20 +1,142 @@
 """
 Date: create on 09/11/2025
-Author:
-    Yang Zhou,zyaztec@gmail.com
+Checkpoint: edit on 24/11/2025
+Author: Yang Zhou, zyaztec@gmail.com
 Reference:
-    [1] Pan Z, Sun F, Liu J, et al. MaskNet: Introducing feature-wise gating blocks for high-dimensional
-        sparse recommendation data (CCF-Tencent CTR competition solution, 2020).
+[1] Wang Z, She Q, Zhang J. MaskNet: Introducing Feature-Wise
+Multiplication to CTR Ranking Models by Instance-Guided Mask.
+
+MaskNet is a CTR prediction model that introduces instance-guided,
+feature-wise multiplicative interactions into deep ranking networks.
+Instead of relying solely on additive feature interactions from MLPs,
+MaskNet generates a personalized “mask” vector for each instance based
+on its embedding representation. This mask selectively scales hidden
+features through element-wise multiplication, enabling the network to
+emphasize informative dimensions and suppress irrelevant noise.
+
+Each MaskBlock consists of:
+  (1) Instance-Guided Mask Generation (two-layer MLP)
+  (2) Feature-wise Multiplication with hidden representations
+  (3) Layer Normalization and nonlinear transformation
+
+By stacking (SerialMaskNet) or parallelizing (ParallelMaskNet) multiple
+MaskBlocks, MaskNet enhances expressive power while remaining efficient,
+improving CTR performance without heavy feature engineering.
+
+Key Advantages:
+- Learns higher-order interactions via multiplicative gating
+- Instance-adaptive feature importance modulation
+- Better discrimination of informative vs. noisy dimensions
+- Flexible architecture for both sequential and parallel design
+
+MaskNet 是一种用于 CTR 预估的模型，它在深度排序网络中引入了
+基于实例（Instance-Guided）的特征级逐元素（Feature-wise）
+乘法交互机制。
+
+与传统仅依赖 MLP 的加性特征交互不同，MaskNet 会根据每个样本的
+embedding 表示生成一个个性化的 “mask” 向量，通过逐元素的乘法
+选择性地放大有效特征维度、抑制无关或噪声特征。
+
+每个 MaskBlock 包含以下关键步骤：
+  (1) 基于当前样本 embedding 的双层 MLP Mask 生成
+  (2) Mask 与隐藏表示之间的逐元素乘法交互
+  (3) Layer Normalization 与非线性变换
+
+通过串联（SerialMaskNet）或并联（ParallelMaskNet）
+多个 MaskBlock，MaskNet 在保持高效的同时显著增强了特征表达能力，
+在无需大量特征工程的情况下提升 CTR 模型性能。
+
+核心优势：
+- 通过乘法门控学习高阶特征交互关系
+- 针对每个样本自适应调整特征重要性
+- 有效区分信息特征与噪声特征
+- 支持灵活的串行与并行网络结构设计
 """
 
 import torch
 import torch.nn as nn
+import torch.nn.functional as F
 
 from nextrec.basic.model import BaseModel
-from nextrec.basic.layers import EmbeddingLayer, LR, MLP, PredictionLayer
+from nextrec.basic.layers import EmbeddingLayer, MLP, PredictionLayer
 from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature
 
 
+class InstanceGuidedMask(nn.Module):
+    def __init__(self, input_dim: int, hidden_dim: int, output_dim: int):
+        super().__init__()
+        self.fc1 = nn.Linear(input_dim, hidden_dim)
+        self.fc2 = nn.Linear(hidden_dim, output_dim)
+
+    def forward(self, v_emb_flat: torch.Tensor) -> torch.Tensor:
+        # v_emb_flat: [batch, features count * embedding_dim] 
+        x = self.fc1(v_emb_flat)
+        x = F.relu(x)
+        v_mask = self.fc2(x)
+        return v_mask
+
+class MaskBlockOnEmbedding(nn.Module):
+    def __init__(
+        self,
+        num_fields: int,
+        embedding_dim: int,
+        mask_hidden_dim: int,
+        hidden_dim: int,
+    ):
+        super().__init__()
+        self.num_fields = num_fields
+        self.embedding_dim = embedding_dim
+        self.input_dim = num_fields * embedding_dim  # input_dim = features count * embedding_dim
+        self.ln_emb = nn.LayerNorm(embedding_dim)
+        self.mask_gen = InstanceGuidedMask(input_dim=self.input_dim, hidden_dim=mask_hidden_dim, output_dim=self.input_dim,)
+        self.ffn = nn.Linear(self.input_dim, hidden_dim)
+        self.ln_hid = nn.LayerNorm(hidden_dim)
+
+    # different from MaskBlockOnHidden: input is field embeddings
+    def forward(self, field_emb: torch.Tensor, v_emb_flat: torch.Tensor) -> torch.Tensor:
+        B = field_emb.size(0)
+        norm_emb = self.ln_emb(field_emb)        # [B, features count, embedding_dim]
+        norm_emb_flat = norm_emb.view(B, -1)     # [B, features count * embedding_dim]
+        v_mask = self.mask_gen(v_emb_flat)       # [B, features count * embedding_dim]
+        v_masked_emb = v_mask * norm_emb_flat    # [B, features count * embedding_dim]
+        hidden = self.ffn(v_masked_emb)          # [B, hidden_dim]
+        hidden = self.ln_hid(hidden)
+        hidden = F.relu(hidden)
+
+        return hidden
+
+
+class MaskBlockOnHidden(nn.Module):
+    def __init__(
+        self,
+        num_fields: int,
+        embedding_dim: int,
+        mask_hidden_dim: int,
+        hidden_dim: int,
+    ):
+        super().__init__()
+        self.num_fields = num_fields
+        self.embedding_dim = embedding_dim
+        self.hidden_dim = hidden_dim
+        self.v_emb_dim = num_fields * embedding_dim
+
+        self.ln_input = nn.LayerNorm(hidden_dim)
+        self.ln_output = nn.LayerNorm(hidden_dim)
+
+        self.mask_gen = InstanceGuidedMask(input_dim=self.v_emb_dim, hidden_dim=mask_hidden_dim, output_dim=hidden_dim,)
+        self.ffn = nn.Linear(hidden_dim, hidden_dim)
+
+    # different from MaskBlockOnEmbedding: input is hidden representation
+    def forward(self, hidden_in: torch.Tensor, v_emb_flat: torch.Tensor) -> torch.Tensor:
+        norm_hidden = self.ln_input(hidden_in)  
+        v_mask = self.mask_gen(v_emb_flat)
+        v_masked_hid = v_mask * norm_hidden     
+        out = self.ffn(v_masked_hid)  
+        out = self.ln_output(out)
+        out = F.relu(out)
+        return out
+
+
 class MaskNet(BaseModel):
     @property
     def model_name(self):
@@ -22,29 +144,39 @@ class MaskNet(BaseModel):
 
     @property
     def task_type(self):
-        return "binary"
-    
-    def __init__(self,
-                 dense_features: list[DenseFeature] | list = [],
-                 sparse_features: list[SparseFeature] | list = [],
-                 sequence_features: list[SequenceFeature] | list = [],
-                 num_blocks: int = 3,
-                 mask_hidden_dim: int = 64,
-                 block_dropout: float = 0.1,
-                 mlp_params: dict = {},
-                 target: list[str] | list = [],
-                 optimizer: str = "adam",
-                 optimizer_params: dict = {},
-                 loss: str | nn.Module | None = "bce",
-                 loss_params: dict | list[dict] | None = None,
-                 device: str = 'cpu',
-                 embedding_l1_reg=1e-6,
-                 dense_l1_reg=1e-5,
-                 embedding_l2_reg=1e-5,
-                 dense_l2_reg=1e-4,
-                 **kwargs):
-        
-        super(MaskNet, self).__init__(
+        return "binary_classification"
+
+    def __init__(
+        self,
+        dense_features: list[DenseFeature] | None = None,
+        sparse_features: list[SparseFeature] | None = None,
+        sequence_features: list[SequenceFeature] | None = None,
+        model_type: str = "parallel",         # "serial" or "parallel"
+        num_blocks: int = 3,
+        mask_hidden_dim: int = 64,
+        block_hidden_dim: int = 256,
+        block_dropout: float = 0.0,
+        mlp_params: dict | None = None,
+        target: list[str] | None = None,
+        optimizer: str = "adam",
+        optimizer_params: dict | None = None,
+        loss: str | nn.Module | None = "bce",
+        loss_params: dict | list[dict] | None = None,
+        device: str = "cpu",
+        embedding_l1_reg: float = 1e-6,
+        dense_l1_reg: float = 1e-5,
+        embedding_l2_reg: float = 1e-5,
+        dense_l2_reg: float = 1e-4,
+        **kwargs,
+    ):
+        dense_features = dense_features or []
+        sparse_features = sparse_features or []
+        sequence_features = sequence_features or []
+        target = target or []
+        mlp_params = mlp_params or {}
+        optimizer_params = optimizer_params or {}
+
+        super().__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
@@ -56,45 +188,99 @@ class MaskNet(BaseModel):
             embedding_l2_reg=embedding_l2_reg,
             dense_l2_reg=dense_l2_reg,
             early_stop_patience=20,
-            **kwargs
+            **kwargs,
         )
 
+        if loss is None:
+            loss = "bce"
         self.loss = loss
-        if self.loss is None:
-            self.loss = "bce"
-            
-        self.mask_features = sparse_features + sequence_features
-        if len(self.mask_features) == 0:
-            raise ValueError("MaskNet requires at least one sparse/sequence feature.")
+
+        self.dense_features = dense_features
+        self.sparse_features = sparse_features
+        self.sequence_features = sequence_features
+        self.mask_features = self.sparse_features + self.sequence_features + self.dense_features
+        assert len(self.mask_features) > 0, "MaskNet requires at least one feature for masking."
 
         self.embedding = EmbeddingLayer(features=self.mask_features)
+
         self.num_fields = len(self.mask_features)
-        self.embedding_dim = self.mask_features[0].embedding_dim
-        if any(f.embedding_dim != self.embedding_dim for f in self.mask_features):
-            raise ValueError("MaskNet expects identical embedding_dim across mask_features.")
 
-        self.num_blocks = max(1, num_blocks)
-        self.field_dim = self.num_fields * self.embedding_dim
-
-        self.linear = LR(self.field_dim)
-        self.mask_generators = nn.ModuleList()
-        for _ in range(self.num_blocks):
-            self.mask_generators.append(
-                nn.Sequential(
-                    nn.Linear(self.field_dim, mask_hidden_dim),
-                    nn.ReLU(),
-                    nn.Linear(mask_hidden_dim, self.num_fields)
+        self.embedding_dim = getattr(self.mask_features[0], "embedding_dim", None)
+        assert self.embedding_dim is not None, "MaskNet requires mask_features to have 'embedding_dim' defined."
+
+        for f in self.mask_features:
+            edim = getattr(f, "embedding_dim", None)
+            if edim is None or edim != self.embedding_dim:
+                raise ValueError(
+                    f"MaskNet expects identical embedding_dim across all mask_features, "
+                    f"but got {edim} for feature {getattr(f, 'name', type(f))}."
                 )
+
+        self.v_emb_dim = self.num_fields * self.embedding_dim
+
+        self.model_type = model_type.lower()
+        assert self.model_type in ("serial", "parallel"), "model_type must be either 'serial' or 'parallel'."
+
+        self.num_blocks = max(1, num_blocks)
+        self.block_hidden_dim = block_hidden_dim
+        self.block_dropout = nn.Dropout(block_dropout) if block_dropout > 0 else nn.Identity()
+
+        if self.model_type == "serial":
+            self.first_block = MaskBlockOnEmbedding(
+                num_fields=self.num_fields,
+                embedding_dim=self.embedding_dim,
+                mask_hidden_dim=mask_hidden_dim,
+                hidden_dim=block_hidden_dim,
+            )
+
+            self.hidden_blocks = nn.ModuleList(
+                [
+                    MaskBlockOnHidden(
+                        num_fields=self.num_fields,
+                        embedding_dim=self.embedding_dim,
+                        mask_hidden_dim=mask_hidden_dim,
+                        hidden_dim=block_hidden_dim,
+                    )
+                    for _ in range(self.num_blocks - 1)
+                ]
+            )
+
+            self.mask_blocks = nn.ModuleList([self.first_block, *self.hidden_blocks])
+            self.output_layer = nn.Linear(block_hidden_dim, 1)
+            self.final_mlp = None
+
+        else:  # parallel
+            self.mask_blocks = nn.ModuleList(
+                [
+                    MaskBlockOnEmbedding(
+                        num_fields=self.num_fields,
+                        embedding_dim=self.embedding_dim,
+                        mask_hidden_dim=mask_hidden_dim,
+                        hidden_dim=block_hidden_dim,
+                    )
+                    for _ in range(self.num_blocks)
+                ]
             )
 
-        self.block_dropout = nn.Dropout(block_dropout)
-        self.final_mlp = MLP(input_dim=self.field_dim * self.num_blocks, **mlp_params)
+            self.final_mlp = MLP(
+                input_dim=self.num_blocks * block_hidden_dim,
+                **mlp_params,
+            )
+            self.output_layer = None
+
         self.prediction_layer = PredictionLayer(task_type=self.task_type)
 
-        self._register_regularization_weights(
-            embedding_attr='embedding',
-            include_modules=['linear', 'mask_generators', 'final_mlp']
-        )
+        if self.model_type == "serial":
+            self._register_regularization_weights(
+                embedding_attr="embedding",
+                include_modules=["mask_blocks", "output_layer"],
+            )
+        # serial
+        else:
+            self._register_regularization_weights(
+                embedding_attr="embedding",
+                include_modules=["mask_blocks", "final_mlp"],
+            )
 
         self.compile(
             optimizer=optimizer,
@@ -103,25 +289,31 @@ class MaskNet(BaseModel):
             loss_params=loss_params,
         )
 
-    def forward(self, x):
+    def forward(self, x: dict[str, torch.Tensor]) -> torch.Tensor:
         field_emb = self.embedding(x=x, features=self.mask_features, squeeze_dim=False)
-        flat_input = field_emb.flatten(start_dim=1)
-        y_linear = self.linear(flat_input)
-
-        block_input = field_emb
-        mask_input = flat_input
-        block_outputs = []
-        for mask_gen in self.mask_generators:
-            mask_logits = mask_gen(mask_input)
-            mask = torch.sigmoid(mask_logits).unsqueeze(-1)
-            masked_emb = block_input * mask
-            block_output = self.block_dropout(masked_emb.flatten(start_dim=1))
-            block_outputs.append(block_output)
-            mask_input = block_output
-            block_input = masked_emb.view_as(field_emb)
-
-        stacked = torch.cat(block_outputs, dim=1)
-        y_deep = self.final_mlp(stacked)
-
-        y = y_linear + y_deep
-        return self.prediction_layer(y)
+        B = field_emb.size(0)
+        v_emb_flat = field_emb.view(B, -1)  # flattened embeddings 
+
+        if self.model_type == "parallel":
+            block_outputs = []
+            for block in self.mask_blocks:
+                h = block(field_emb, v_emb_flat)  # [B, block_hidden_dim]
+                h = self.block_dropout(h)
+                block_outputs.append(h)
+
+            concat_hidden = torch.cat(block_outputs, dim=-1)
+            logit = self.final_mlp(concat_hidden)  # [B, 1]
+
+        # serial
+        else: 
+            hidden = self.first_block(field_emb, v_emb_flat)
+            hidden = self.block_dropout(hidden)
+
+            for block in self.hidden_blocks:
+                hidden = block(hidden, v_emb_flat)
+                hidden = self.block_dropout(hidden)
+
+            logit = self.output_layer(hidden)  # [B, 1]
+
+        y = self.prediction_layer(logit)
+        return y

nextrec/utils/__init__.py

@@ -1,14 +1,17 @@
 from .optimizer import get_optimizer, get_scheduler
 from .initializer import get_initializer
 from .embedding import get_auto_embedding_dim
-from . import optimizer, initializer, embedding
+from .common import resolve_device
+from . import optimizer, initializer, embedding, common
 
 __all__ = [
     'get_optimizer',
     'get_scheduler',
     'get_initializer',
     'get_auto_embedding_dim',
+    'resolve_device',
     'optimizer',
     'initializer',
     'embedding',
+    'common',
 ]

nextrec/utils/common.py

@@ -0,0 +1,16 @@
+import torch
+import platform
+
+def resolve_device() -> str:
+    """Select a usable device with graceful fallback."""
+    if torch.cuda.is_available():
+        return "cuda"
+    if torch.backends.mps.is_available():
+        mac_ver = platform.mac_ver()[0]
+        try:
+            major, minor = (int(x) for x in mac_ver.split(".")[:2])
+        except Exception:
+            major, minor = 0, 0
+        if major >= 14:
+            return "mps"
+    return "cpu"

{nextrec-0.2.3.dist-info → nextrec-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrec
-Version: 0.2.3
+Version: 0.2.5
 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
@@ -61,7 +61,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.2.3-orange.svg)
+![Version](https://img.shields.io/badge/Version-0.2.5-orange.svg)
 
 English | [中文版](README_zh.md)
 

{nextrec-0.2.3.dist-info → nextrec-0.2.5.dist-info}/RECORD

@@ -1,21 +1,21 @@
 nextrec/__init__.py,sha256=CvocnY2uBp0cjNkhrT6ogw0q2bN9s1GNp754FLO-7lo,1117
-nextrec/__version__.py,sha256=PNiDER4qM19h9zdsdfgKt2_dT4WgYK7EguJ8RU2qA_g,22
+nextrec/__version__.py,sha256=Xsa3ayOMVkhUWm4t06YeyHE0apjpZefxLH4ylp0CDtU,22
 nextrec/basic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nextrec/basic/activation.py,sha256=9EfYmwE0brTSKwx_0FIGQ_rybFBT9n_G-UWA7NAhMsI,2804
 nextrec/basic/callback.py,sha256=qkq3k8rP0g4BW2C3FSCdVt_CyCcJwJ-rUXjhT2p4LP8,1035
-nextrec/basic/features.py,sha256=TJfJgzWuy68lBKOeCzztcUK3ZtjHhK8oSMs8k0vXGlg,3961
-nextrec/basic/layers.py,sha256=mDNApSlPkmPSnIPj3BDHfDEjviLybWuSGrh61Zog2uk,38290
+nextrec/basic/features.py,sha256=pQyqs-hGFN8T6goTxIjaXxw9S5PG57OWX7EpsKFlb4c,4194
+nextrec/basic/layers.py,sha256=AezH_WYvU45eLw5EHmyAC69MCUkRTv_ZKbNW4WBC5iE,38071
 nextrec/basic/loggers.py,sha256=x8lzyyK-uqBN5XGOm1Cb33dmfc2bl114n6QeFTtE54k,3752
 nextrec/basic/metrics.py,sha256=w8tGe2tTbBNz9A1TNZF3jSpxcNC6QvFP5I0lWRd0Nw4,20398
-nextrec/basic/model.py,sha256=mtVttDWmrhdW-L1PAelJ90a1BW0q6bzG9roMvrPTU0U,66342
+nextrec/basic/model.py,sha256=k9dbV4CP-1wvr-QLJ0dF6nYtGugXQIFR6J8kZDS9iSs,63968
 nextrec/basic/session.py,sha256=2kogEjgKAN1_ygelbwoqOs187BAcUnDTqXG1w_Pgb9I,4791
 nextrec/data/__init__.py,sha256=HLnARJrqDEVPTcofPSAEimy2Oj15vbomj-7UvT4ze_4,767
-nextrec/data/data_utils.py,sha256=vGZ378YM_JQXO9npRB7JqojJx1ovjbJCWI-7lQJkicA,6298
-nextrec/data/dataloader.py,sha256=LAKpcSHhq53scq8PKwF8uqxa8wQLG0FshjY3TQwIvBU,20459
-nextrec/data/preprocessor.py,sha256=N7m4PYGZE6AND0XyYRvXKYAUub9aHGb1qmxbBRxlZKA,42294
-nextrec/loss/__init__.py,sha256=t-wkqxcu5wdYlrb67-CxX9aOGom0CpMJK8Fe8KGDSEE,857
+nextrec/data/data_utils.py,sha256=xz0xVBA7UzHXz7r_Yf0eMB5RrarPKg_1ZTdWvAqRZCM,7623
+nextrec/data/dataloader.py,sha256=vtgt2B7rUmIG7wg-HE2ZesBaD6cuS2PwklFCWGA9tCw,14142
+nextrec/data/preprocessor.py,sha256=J-3fo_LIz100spqCHoSpewYcneiZwhaCKyRdroPSjeY,41548
+nextrec/loss/__init__.py,sha256=mO5t417BneZ8Ysa51GyjDaffjWyjzFgPXIQrrggasaQ,827
 nextrec/loss/listwise.py,sha256=LcYIPf6PGRtjV_AoWaAyp3rse904S2MghE5t032I07I,5628
-nextrec/loss/loss_utils.py,sha256=LnTkpMTS2bhbq4Lsjf3AUn1uBaOg1TaH5VO2R8hwARc,5324
+nextrec/loss/loss_utils.py,sha256=cFNSvv-eaFwcfjLgxN3yNmf0L7ofC0ysgkUYjliLBpE,2535
 nextrec/loss/pairwise.py,sha256=RuQuTE-EkLaHQvT9m0CTAXxneTnVQLF1Pi9wblEClI8,3289
 nextrec/loss/pointwise.py,sha256=6QveizdohzQTxAoBKTVSoCBpp-fy3JC8vCjImXa7jL0,7157
 nextrec/models/generative/hstu.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -26,28 +26,29 @@ nextrec/models/match/dssm_v2.py,sha256=ywtqTy3YN9ke_7kzcDp7Fhtldw9RJz6yfewxALJb6
 nextrec/models/match/mind.py,sha256=XSUDlZ-V95JXHHBDUl5sz99SaVuQKDvf3TArVjwUexs,9417
 nextrec/models/match/sdm.py,sha256=96yfMQ6arP6JRhAkDTGEjlBiTteznMykrDV_3jqvvVk,10920
 nextrec/models/match/youtube_dnn.py,sha256=pnrz9LYu65Fj4neOriFF45B5k2-yYiiREtQICxxYXZ0,7546
-nextrec/models/multi_task/esmm.py,sha256=E9B6TlpnPUeyldTofyFg4B7SKByyxbiW2fUGHLOryO4,4883
+nextrec/models/multi_task/esmm.py,sha256=U9DkYxwAhD_uWB8H2tsx1zfIStp5Xp8bvM6sc8S9tu4,4889
 nextrec/models/multi_task/mmoe.py,sha256=zhQr43Vfz7Kgi6B9pKPmaenp_38a_D7w4VvlpwCyF6Y,6165
 nextrec/models/multi_task/ple.py,sha256=otP6oLgzrJhwkLFItzNE-AtIPouObDkafRvWzTCxfNo,11335
 nextrec/models/multi_task/share_bottom.py,sha256=LL5HBVlvvBzHV2fLBRQMGIwpqmlxILTgU4c51XyTCo4,4517
 nextrec/models/ranking/__init__.py,sha256=-qe34zQEVwmxeTPGYCa6gbql9quT8DwB7-buHfA7Iig,428
 nextrec/models/ranking/afm.py,sha256=r9m1nEnc0m5d4pMtOxRMqOaXaBNCEkjJBFB-5wSHeFA,4540
-nextrec/models/ranking/autoint.py,sha256=GYzRynjn6Csq4b3qYIFWxLQ4Yl57_OQBeF2IY0Zhr9Q,5654
+nextrec/models/ranking/autoint.py,sha256=TyA45mnXP7pZHhY6AbyK84qLpniGFXst7v7E_RlYiZM,7754
 nextrec/models/ranking/dcn.py,sha256=dUV5GbHypBGc9vVozk6aGYfIXq23c0deX-HFnIhZueg,4208
 nextrec/models/ranking/deepfm.py,sha256=y28yJxF__TZR3O1G2ufKZVtBRLgCgmlXWqvPgLzwm3U,3510
 nextrec/models/ranking/dien.py,sha256=E6s9TDwQfGSwtzzh8hG2F5gwgVxzVZPcptYvHLNzOLA,8475
 nextrec/models/ranking/din.py,sha256=j5tkT5k91CbsMlMr5vJOySrcY2_rFGxmEgJJ0McW7-Q,7196
 nextrec/models/ranking/fibinet.py,sha256=X6CbQbritvq5jql_Tvs4bn_tRla2zpWPplftZv8k6f0,4853
 nextrec/models/ranking/fm.py,sha256=3Qx_Fgowegr6UPQtEeTmHtOrbWzkvqH94ZTjOqRLu-E,2961
-nextrec/models/ranking/masknet.py,sha256=Bu0mZl2vKqcGnqCuUjPHjPRd1f-cDTeVwFj8Y_6v3C8,4639
+nextrec/models/ranking/masknet.py,sha256=Tx5deIv7oShm4DdXX1IJL8Hz8-5uGqcPMK7pj00xTHg,12230
 nextrec/models/ranking/pnn.py,sha256=5RxIKdxD0XcGq-b_QDdwGRwk6b_5BQjyMvCw3Ibv2Kk,4957
 nextrec/models/ranking/widedeep.py,sha256=b6ctElaZPv5WSYDA4piYUBo3je0eJpWpWECwcuWavM4,3716
 nextrec/models/ranking/xdeepfm.py,sha256=I00J5tfE4tPluqeW-qrNtE4V_9fC7-rgFvA0Fxqka7o,4274
-nextrec/utils/__init__.py,sha256=6x3OZbqks2gtgJd00y_-Y8QiAT42x5t14ARHQ-ULQDo,350
+nextrec/utils/__init__.py,sha256=A3mH6M-DmDBWQ1stIIaTsNzvUy_AKaUWtRmrzU5R3FE,429
+nextrec/utils/common.py,sha256=-n4wSbP-EptpzLcJv6fV-ytBzPliOj6m-mrK_Qk6s4A,458
 nextrec/utils/embedding.py,sha256=yxYSdFx0cJITh3Gf-K4SdhwRtKGcI0jOsyBgZ0NLa_c,465
 nextrec/utils/initializer.py,sha256=ffYOs5QuIns_d_-5e40iNtg6s1ftgREJN-ueq_NbDQE,1647
 nextrec/utils/optimizer.py,sha256=85ifoy2IQgjPHOqLqr1ho7XBGE_0ry1yEB9efS6C2lM,2446
-nextrec-0.2.3.dist-info/METADATA,sha256=SpkwkLdg4MQLeysCCr_0fJXak-Vo139Cz3HFLXR-4Z0,11425
-nextrec-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nextrec-0.2.3.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
-nextrec-0.2.3.dist-info/RECORD,,
+nextrec-0.2.5.dist-info/METADATA,sha256=Ya8KTj9x1ozIaciXYTKnTFBLGiC4buUBIz-jVHHAM3s,11425
+nextrec-0.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nextrec-0.2.5.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
+nextrec-0.2.5.dist-info/RECORD,,