nextrec 0.3.6__py3-none-any.whl → 0.4.2__py3-none-any.whl

nextrec/models/ranking/din.py

@@ -12,7 +12,12 @@ import torch
 import torch.nn as nn
 
 from nextrec.basic.model import BaseModel
-from nextrec.basic.layers import EmbeddingLayer, MLP, AttentionPoolingLayer, PredictionLayer
+from nextrec.basic.layers import (
+    EmbeddingLayer,
+    MLP,
+    AttentionPoolingLayer,
+    PredictionLayer,
+)
 from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature
 
 
@@ -22,78 +27,91 @@ class DIN(BaseModel):
         return "DIN"
 
     @property
-    def task_type(self):
+    def default_task(self):
         return "binary"
-    
-    def __init__(self,
-                 dense_features: list[DenseFeature],
-                 sparse_features: list[SparseFeature],
-                 sequence_features: list[SequenceFeature],
-                 mlp_params: dict,
-                 attention_hidden_units: list[int] = [80, 40],
-                 attention_activation: str = 'sigmoid',
-                 attention_use_softmax: bool = True,
-                 target: list[str] = [],
-                 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):
-        
+
+    def __init__(
+        self,
+        dense_features: list[DenseFeature],
+        sparse_features: list[SparseFeature],
+        sequence_features: list[SequenceFeature],
+        mlp_params: dict,
+        attention_hidden_units: list[int] = [80, 40],
+        attention_activation: str = "sigmoid",
+        attention_use_softmax: bool = True,
+        target: list[str] = [],
+        task: str | list[str] | None = None,
+        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(DIN, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
             target=target,
-            task=self.task_type,
+            task=task or self.default_task,
             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=20,
-            **kwargs
+            **kwargs,
         )
 
         self.loss = loss
         if self.loss is None:
             self.loss = "bce"
-        
+
         # Features classification
         # DIN requires: candidate item + user behavior sequence + other features
         if len(sequence_features) == 0:
-            raise ValueError("DIN requires at least one sequence feature for user behavior history")
-        
+            raise ValueError(
+                "DIN requires at least one sequence feature for user behavior history"
+            )
+
         self.behavior_feature = sequence_features[0]  # User behavior sequence
-        self.candidate_feature = sparse_features[-1] if sparse_features else None  # Candidate item
-        
+        self.candidate_feature = (
+            sparse_features[-1] if sparse_features else None
+        )  # Candidate item
+
         # Other features (excluding behavior sequence in final concatenation)
-        self.other_sparse_features = sparse_features[:-1] if self.candidate_feature else sparse_features
+        self.other_sparse_features = (
+            sparse_features[:-1] if self.candidate_feature else sparse_features
+        )
         self.dense_features_list = dense_features
-        
+
         # All features for embedding
         self.all_features = dense_features + sparse_features + sequence_features
 
         # Embedding layer
         self.embedding = EmbeddingLayer(features=self.all_features)
-        
+
         # Attention layer for behavior sequence
         behavior_emb_dim = self.behavior_feature.embedding_dim
         self.candidate_attention_proj = None
-        if self.candidate_feature is not None and self.candidate_feature.embedding_dim != behavior_emb_dim:
-            self.candidate_attention_proj = nn.Linear(self.candidate_feature.embedding_dim, behavior_emb_dim)
+        if (
+            self.candidate_feature is not None
+            and self.candidate_feature.embedding_dim != behavior_emb_dim
+        ):
+            self.candidate_attention_proj = nn.Linear(
+                self.candidate_feature.embedding_dim, behavior_emb_dim
+            )
         self.attention = AttentionPoolingLayer(
             embedding_dim=behavior_emb_dim,
             hidden_units=attention_hidden_units,
             activation=attention_activation,
-            use_softmax=attention_use_softmax
+            use_softmax=attention_use_softmax,
         )
-        
+
         # Calculate MLP input dimension
         # candidate + attention_pooled_behavior + other_sparse + dense
         mlp_input_dim = 0
@@ -101,16 +119,18 @@ class DIN(BaseModel):
             mlp_input_dim += self.candidate_feature.embedding_dim
         mlp_input_dim += behavior_emb_dim  # attention pooled
         mlp_input_dim += sum([f.embedding_dim for f in self.other_sparse_features])
-        mlp_input_dim += sum([getattr(f, "embedding_dim", 1) or 1 for f in dense_features])
-        
+        mlp_input_dim += sum(
+            [getattr(f, "embedding_dim", 1) or 1 for f in dense_features]
+        )
+
         # MLP for final prediction
         self.mlp = MLP(input_dim=mlp_input_dim, **mlp_params)
-        self.prediction_layer = PredictionLayer(task_type=self.task_type)
+        self.prediction_layer = PredictionLayer(task_type=self.task)
 
         # Register regularization weights
         self.register_regularization_weights(
-            embedding_attr='embedding',
-            include_modules=['attention', 'mlp', 'candidate_attention_proj']
+            embedding_attr="embedding",
+            include_modules=["attention", "mlp", "candidate_attention_proj"],
         )
 
         self.compile(
@@ -123,61 +143,69 @@ class DIN(BaseModel):
     def forward(self, x):
         # Get candidate item embedding
         if self.candidate_feature:
-            candidate_emb = self.embedding.embed_dict[self.candidate_feature.embedding_name](
+            candidate_emb = self.embedding.embed_dict[
+                self.candidate_feature.embedding_name
+            ](
                 x[self.candidate_feature.name].long()
             )  # [B, emb_dim]
         else:
             candidate_emb = None
-        
+
         # Get behavior sequence embedding
         behavior_seq = x[self.behavior_feature.name].long()  # [B, seq_len]
         behavior_emb = self.embedding.embed_dict[self.behavior_feature.embedding_name](
             behavior_seq
         )  # [B, seq_len, emb_dim]
-        
+
         # Create mask for padding
         if self.behavior_feature.padding_idx is not None:
-            mask = (behavior_seq != self.behavior_feature.padding_idx).unsqueeze(-1).float()
+            mask = (
+                (behavior_seq != self.behavior_feature.padding_idx)
+                .unsqueeze(-1)
+                .float()
+            )
         else:
             mask = (behavior_seq != 0).unsqueeze(-1).float()
-        
+
         # Apply attention pooling
         if candidate_emb is not None:
             candidate_query = candidate_emb
             if self.candidate_attention_proj is not None:
                 candidate_query = self.candidate_attention_proj(candidate_query)
             pooled_behavior = self.attention(
-                query=candidate_query,
-                keys=behavior_emb,
-                mask=mask
+                query=candidate_query, keys=behavior_emb, mask=mask
             )  # [B, emb_dim]
         else:
             # If no candidate, use mean pooling
-            pooled_behavior = torch.sum(behavior_emb * mask, dim=1) / (mask.sum(dim=1) + 1e-9)
-        
+            pooled_behavior = torch.sum(behavior_emb * mask, dim=1) / (
+                mask.sum(dim=1) + 1e-9
+            )
+
         # Get other features
         other_embeddings = []
-        
+
         if candidate_emb is not None:
             other_embeddings.append(candidate_emb)
-        
+
         other_embeddings.append(pooled_behavior)
-        
+
         # Other sparse features
         for feat in self.other_sparse_features:
-            feat_emb = self.embedding.embed_dict[feat.embedding_name](x[feat.name].long())
+            feat_emb = self.embedding.embed_dict[feat.embedding_name](
+                x[feat.name].long()
+            )
             other_embeddings.append(feat_emb)
-        
+
         # Dense features
         for feat in self.dense_features_list:
             val = x[feat.name].float()
             if val.dim() == 1:
                 val = val.unsqueeze(1)
             other_embeddings.append(val)
-        
+
         # Concatenate all features
         concat_input = torch.cat(other_embeddings, dim=-1)  # [B, total_dim]
-        
+
         # MLP prediction
         y = self.mlp(concat_input)  # [B, 1]
         return self.prediction_layer(y)

nextrec/models/ranking/fibinet.py

@@ -28,62 +28,72 @@ class FiBiNET(BaseModel):
         return "FiBiNET"
 
     @property
-    def task_type(self):
+    def default_task(self):
         return "binary"
-    
-    def __init__(self,
-                 dense_features: list[DenseFeature] | list = [],
-                 sparse_features: list[SparseFeature] | list = [],
-                 sequence_features: list[SequenceFeature] | list = [],
-                 mlp_params: dict = {},
-                 bilinear_type: str = "field_interaction",
-                 senet_reduction: int = 3,
-                 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):
-        
+
+    def __init__(
+        self,
+        dense_features: list[DenseFeature] | list = [],
+        sparse_features: list[SparseFeature] | list = [],
+        sequence_features: list[SequenceFeature] | list = [],
+        mlp_params: dict = {},
+        bilinear_type: str = "field_interaction",
+        senet_reduction: int = 3,
+        target: list[str] | list = [],
+        task: str | list[str] | None = None,
+        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(FiBiNET, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
             target=target,
-            task=self.task_type,
+            task=task or self.default_task,
             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=20,
-            **kwargs
+            **kwargs,
         )
 
         self.loss = loss
         if self.loss is None:
             self.loss = "bce"
-            
+
         self.linear_features = sparse_features + sequence_features
         self.deep_features = dense_features + sparse_features + sequence_features
         self.interaction_features = sparse_features + sequence_features
 
         if len(self.interaction_features) < 2:
-            raise ValueError("FiBiNET requires at least two sparse/sequence features for interactions.")
+            raise ValueError(
+                "FiBiNET requires at least two sparse/sequence features for interactions."
+            )
 
         self.embedding = EmbeddingLayer(features=self.deep_features)
 
         self.num_fields = len(self.interaction_features)
         self.embedding_dim = self.interaction_features[0].embedding_dim
-        if any(f.embedding_dim != self.embedding_dim for f in self.interaction_features):
-            raise ValueError("All interaction features must share the same embedding_dim in FiBiNET.")
-
-        self.senet = SENETLayer(num_fields=self.num_fields, reduction_ratio=senet_reduction)
+        if any(
+            f.embedding_dim != self.embedding_dim for f in self.interaction_features
+        ):
+            raise ValueError(
+                "All interaction features must share the same embedding_dim in FiBiNET."
+            )
+
+        self.senet = SENETLayer(
+            num_fields=self.num_fields, reduction_ratio=senet_reduction
+        )
         self.bilinear_standard = BiLinearInteractionLayer(
             input_dim=self.embedding_dim,
             num_fields=self.num_fields,
@@ -101,12 +111,18 @@ class FiBiNET(BaseModel):
         num_pairs = self.num_fields * (self.num_fields - 1) // 2
         interaction_dim = num_pairs * self.embedding_dim * 2
         self.mlp = MLP(input_dim=interaction_dim, **mlp_params)
-        self.prediction_layer = PredictionLayer(task_type=self.task_type)
+        self.prediction_layer = PredictionLayer(task_type=self.default_task)
 
         # Register regularization weights
         self.register_regularization_weights(
-            embedding_attr='embedding',
-            include_modules=['linear', 'senet', 'bilinear_standard', 'bilinear_senet', 'mlp']
+            embedding_attr="embedding",
+            include_modules=[
+                "linear",
+                "senet",
+                "bilinear_standard",
+                "bilinear_senet",
+                "mlp",
+            ],
         )
 
         self.compile(
@@ -117,10 +133,14 @@ class FiBiNET(BaseModel):
         )
 
     def forward(self, x):
-        input_linear = self.embedding(x=x, features=self.linear_features, squeeze_dim=True)
+        input_linear = self.embedding(
+            x=x, features=self.linear_features, squeeze_dim=True
+        )
         y_linear = self.linear(input_linear)
 
-        field_emb = self.embedding(x=x, features=self.interaction_features, squeeze_dim=False)
+        field_emb = self.embedding(
+            x=x, features=self.interaction_features, squeeze_dim=False
+        )
         senet_emb = self.senet(field_emb)
 
         bilinear_standard = self.bilinear_standard(field_emb).flatten(start_dim=1)

nextrec/models/ranking/fm.py

@@ -9,7 +9,12 @@ Reference:
 import torch.nn as nn
 
 from nextrec.basic.model import BaseModel
-from nextrec.basic.layers import EmbeddingLayer, FM as FMInteraction, LR, PredictionLayer
+from nextrec.basic.layers import (
+    EmbeddingLayer,
+    FM as FMInteraction,
+    LR,
+    PredictionLayer,
+)
 from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature
 
 
@@ -19,44 +24,46 @@ class FM(BaseModel):
         return "FM"
 
     @property
-    def task_type(self):
+    def default_task(self):
         return "binary"
-    
-    def __init__(self,
-                 dense_features: list[DenseFeature] | list = [],
-                 sparse_features: list[SparseFeature] | list = [],
-                 sequence_features: list[SequenceFeature] | list = [],
-                 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):
-        
+
+    def __init__(
+        self,
+        dense_features: list[DenseFeature] | list = [],
+        sparse_features: list[SparseFeature] | list = [],
+        sequence_features: list[SequenceFeature] | list = [],
+        target: list[str] | list = [],
+        task: str | list[str] | None = None,
+        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(FM, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
             target=target,
-            task=self.task_type,
+            task=task or self.default_task,
             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=20,
-            **kwargs
+            **kwargs,
         )
 
         self.loss = loss
         if self.loss is None:
             self.loss = "bce"
-            
+
         self.fm_features = sparse_features + sequence_features
         if len(self.fm_features) == 0:
             raise ValueError("FM requires at least one sparse or sequence feature.")
@@ -66,12 +73,11 @@ class FM(BaseModel):
         fm_input_dim = sum([f.embedding_dim for f in self.fm_features])
         self.linear = LR(fm_input_dim)
         self.fm = FMInteraction(reduce_sum=True)
-        self.prediction_layer = PredictionLayer(task_type=self.task_type)
+        self.prediction_layer = PredictionLayer(task_type=self.task)
 
         # Register regularization weights
         self.register_regularization_weights(
-            embedding_attr='embedding',
-            include_modules=['linear']
+            embedding_attr="embedding", include_modules=["linear"]
         )
 
         self.compile(