nextrec 0.4.21__py3-none-any.whl → 0.4.23__py3-none-any.whl

nextrec/models/multi_task/poso.py

@@ -42,7 +42,7 @@ from __future__ import annotations
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-
+from typing import Literal
 from nextrec.basic.activation import activation_layer
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import MLP, EmbeddingLayer
@@ -307,9 +307,9 @@ class POSO(BaseModel):
         pc_sparse_features: list[str] | None,
         pc_sequence_features: list[str] | None,
         tower_params_list: list[dict],
-        target: list[str],
+        target: list[str] | None = None,
         task: str | list[str] = "binary",
-        architecture: str = "mlp",
+        architecture: Literal["mlp", "mmoe"] = "mlp",
         # POSO gating defaults
         gate_hidden_dim: int = 32,
         gate_scale_factor: float = 2.0,
@@ -323,14 +323,6 @@ class POSO(BaseModel):
         expert_gate_hidden_dim: int = 32,
         expert_gate_scale_factor: float = 2.0,
         gate_use_softmax: bool = True,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | list[str | nn.Module] | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
         self.nums_task = len(target)
@@ -359,10 +351,6 @@ class POSO(BaseModel):
             sequence_features=sequence_features,
             target=target,
             task=resolved_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
@@ -373,12 +361,6 @@ class POSO(BaseModel):
         self.pc_sparse_feature_names = list(pc_sparse_features or [])
         self.pc_sequence_feature_names = list(pc_sequence_features or [])
 
-        if loss is None:
-            self.loss = "bce"
-        self.loss = loss
-
-        optimizer_params = optimizer_params or {}
-
         self.main_dense_features = select_features(
             self.dense_features, self.main_dense_feature_names, "main_dense_features"
         )
@@ -488,7 +470,7 @@ class POSO(BaseModel):
         else:
             self.grad_norm_shared_modules = ["embedding", "mmoe"]
         self.prediction_layer = TaskHead(
-            task_type=self.default_task,
+            task_type=self.task,
             task_dims=[1] * self.nums_task,
         )
         include_modules = (
@@ -499,12 +481,6 @@ class POSO(BaseModel):
         self.register_regularization_weights(
             embedding_attr="embedding", include_modules=include_modules
         )
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
 
     def forward(self, x):
         # Embed main and PC features separately so PC can gate hidden units

nextrec/models/multi_task/share_bottom.py

@@ -69,19 +69,9 @@ class ShareBottom(BaseModel):
         tower_params_list: list[dict],
         target: list[str],
         task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: dict | None = None,
-        loss: str | nn.Module | list[str | nn.Module] | None = "bce",
-        loss_params: dict | list[dict] | None = None,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
-        optimizer_params = optimizer_params or {}
-
         self.nums_task = len(target)
 
         resolved_task = task
@@ -102,16 +92,9 @@ class ShareBottom(BaseModel):
             sequence_features=sequence_features,
             target=target,
             task=resolved_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        self.loss = loss
-        if self.loss is None:
-            self.loss = "bce"
         # Number of tasks
         self.nums_task = len(target)
         if len(tower_params_list) != self.nums_task:
@@ -142,18 +125,12 @@ class ShareBottom(BaseModel):
             tower = MLP(input_dim=bottom_output_dim, output_layer=True, **tower_params)
             self.towers.append(tower)
         self.prediction_layer = TaskHead(
-            task_type=self.default_task, task_dims=[1] * self.nums_task
+            task_type=self.task, task_dims=[1] * self.nums_task
         )
         # Register regularization weights
         self.register_regularization_weights(
             embedding_attr="embedding", include_modules=["bottom", "towers"]
         )
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
 
     def forward(self, x):
         # Get all embeddings and flatten

nextrec/models/ranking/afm.py

@@ -61,36 +61,17 @@ class AFM(BaseModel):
         sequence_features: list[SequenceFeature] | None = None,
         attention_dim: int = 32,
         attention_dropout: float = 0.0,
-        target: list[str] | str | None = None,
-        task: str | 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,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
         dense_features = dense_features or []
         sparse_features = sparse_features or []
         sequence_features = sequence_features or []
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(AFM, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
@@ -139,8 +120,10 @@ class AFM(BaseModel):
         self.attention_linear = nn.Linear(self.embedding_dim, attention_dim)
         self.attention_p = nn.Linear(attention_dim, 1, bias=False)
         self.attention_dropout = nn.Dropout(attention_dropout)
+
         self.output_projection = nn.Linear(self.embedding_dim, 1, bias=False)
-        self.prediction_layer = TaskHead(task_type=self.default_task)
+
+        self.prediction_layer = TaskHead(task_type=self.task)
         self.input_mask = InputMask()
 
         # Register regularization weights
@@ -158,13 +141,6 @@ class AFM(BaseModel):
             emb.weight for emb in self.first_order_embeddings.values()
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         field_emb = self.embedding(
             x=x, features=self.fm_features, squeeze_dim=False

nextrec/models/ranking/autoint.py

@@ -82,16 +82,6 @@ class AutoInt(BaseModel):
         att_head_num: int = 2,
         att_dropout: float = 0.0,
         att_use_residual: bool = True,
-        target: list[str] | None = None,
-        task: str | 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,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
@@ -99,21 +89,12 @@ class AutoInt(BaseModel):
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        if target is None:
-            target = []
-        if optimizer_params is None:
-            optimizer_params = {}
-        if loss is None:
-            loss = "bce"
+        dense_features = dense_features or []
+        sparse_features = sparse_features or []
+        sequence_features = sequence_features or []
 
         self.att_layer_num = att_layer_num
         self.att_embedding_dim = att_embedding_dim
@@ -123,12 +104,7 @@ class AutoInt(BaseModel):
         # if you want to follow the paper strictly, set dense_features=[]
         # or modify the code accordingly
         self.interaction_features = dense_features + sparse_features + sequence_features
-
-        # All features for embedding
-        self.all_features = dense_features + sparse_features + sequence_features
-
-        # Embedding layer
-        self.embedding = EmbeddingLayer(features=self.all_features)
+        self.embedding = EmbeddingLayer(features=self.interaction_features)
 
         # Project embeddings to attention embedding dimension
         num_fields = len(self.interaction_features)
@@ -159,23 +135,14 @@ class AutoInt(BaseModel):
             ]
         )
 
-        # Final prediction layer
         self.fc = nn.Linear(num_fields * att_embedding_dim, 1)
-        self.prediction_layer = TaskHead(task_type=self.default_task)
+        self.prediction_layer = TaskHead(task_type=self.task)
 
-        # Register regularization weights
         self.register_regularization_weights(
             embedding_attr="embedding",
             include_modules=["projection_layers", "attention_layers", "fc"],
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         # Get embeddings field-by-field so mixed dimensions can be projected safely
         field_embeddings = []

nextrec/models/ranking/dcn.py

@@ -96,36 +96,18 @@ class DCN(BaseModel):
         sequence_features: list[SequenceFeature] | None = None,
         cross_num: int = 3,
         mlp_params: dict | None = None,
-        target: list[str] | str | None = None,
-        task: str | 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,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
         dense_features = dense_features or []
         sparse_features = sparse_features or []
         sequence_features = sequence_features or []
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
+        mlp_params = mlp_params or {}
 
         super(DCN, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
@@ -173,13 +155,6 @@ class DCN(BaseModel):
             include_modules=["cross_network", "mlp", "final_layer"],
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         # Get all embeddings and flatten
         input_flat = self.embedding(x=x, features=self.all_features, squeeze_dim=True)

nextrec/models/ranking/dcn_v2.py

@@ -45,7 +45,7 @@ DCN v2 在原始 DCN 基础上，将标量交叉权重升级为向量/矩阵参
 
 import torch
 import torch.nn as nn
-
+from typing import Literal
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import MLP, EmbeddingLayer
 from nextrec.basic.heads import TaskHead
@@ -193,53 +193,32 @@ class DCNv2(BaseModel):
         sparse_features: list[SparseFeature] | None = None,
         sequence_features: list[SequenceFeature] | None = None,
         cross_num: int = 3,
-        cross_type: str = "matrix",
-        architecture: str = "parallel",
+        cross_type: Literal["matrix", "mix", "low_rank"] = "matrix",
+        architecture: Literal["parallel", "stacked"] = "parallel",
         low_rank: int = 32,
         num_experts: int = 4,
         mlp_params: dict | None = None,
-        target: list[str] | str | None = None,
-        task: str | 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,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
         dense_features = dense_features or []
         sparse_features = sparse_features or []
         sequence_features = sequence_features or []
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
+        mlp_params = mlp_params or {}
 
         super(DCNv2, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        self.all_features = dense_features + sparse_features + sequence_features
         self.embedding = EmbeddingLayer(features=self.all_features)
         input_dim = self.embedding.input_dim
 
-        architecture = architecture.lower()
         if architecture not in {"parallel", "stacked"}:
             raise ValueError("architecture must be 'parallel' or 'stacked'.")
         self.architecture = architecture
 
-        cross_type = cross_type.lower()
         if cross_type == "matrix":
             self.cross_network = CrossNetV2(input_dim=input_dim, num_layers=cross_num)
         elif cross_type in {"mix", "low_rank"}:
@@ -271,20 +250,13 @@ class DCNv2(BaseModel):
             final_input_dim = input_dim
 
         self.final_layer = nn.Linear(final_input_dim, 1)
-        self.prediction_layer = TaskHead(task_type=self.default_task)
+        self.prediction_layer = TaskHead(task_type=self.task)
 
         self.register_regularization_weights(
             embedding_attr="embedding",
             include_modules=["cross_network", "mlp", "final_layer"],
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x) -> torch.Tensor:
         input_flat = self.embedding(x=x, features=self.all_features, squeeze_dim=True)
         cross_out = self.cross_network(input_flat)

nextrec/models/ranking/deepfm.py

@@ -42,8 +42,6 @@ embedding，无需手工构造交叉特征即可端到端训练，常用于 CTR/
 - CTR/CVR 任务的常用强基线
 """
 
-import torch.nn as nn
-
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import FM, LR, MLP, EmbeddingLayer
 from nextrec.basic.heads import TaskHead
@@ -65,16 +63,6 @@ class DeepFM(BaseModel):
         sparse_features: list[SparseFeature] | None = None,
         sequence_features: list[SequenceFeature] | None = None,
         mlp_params: dict | None = None,
-        target: list[str] | str | None = None,
-        task: str | 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,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
@@ -82,24 +70,14 @@ class DeepFM(BaseModel):
         sparse_features = sparse_features or []
         sequence_features = sequence_features or []
         mlp_params = mlp_params or {}
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(DeepFM, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        self.loss = loss
         self.fm_features = sparse_features + sequence_features
         self.deep_features = dense_features + sparse_features + sequence_features
         self.embedding = EmbeddingLayer(features=self.deep_features)
@@ -110,18 +88,13 @@ class DeepFM(BaseModel):
         self.linear = LR(fm_emb_dim_total)
         self.fm = FM(reduce_sum=True)
         self.mlp = MLP(input_dim=mlp_input_dim, **mlp_params)
-        self.prediction_layer = TaskHead(task_type=self.default_task)
+
+        self.prediction_layer = TaskHead(task_type=self.task)
 
         # Register regularization weights
         self.register_regularization_weights(
             embedding_attr="embedding", include_modules=["linear", "mlp"]
         )
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
 
     def forward(self, x):
         input_deep = self.embedding(x=x, features=self.deep_features, squeeze_dim=True)

nextrec/models/ranking/dien.py

@@ -58,6 +58,7 @@ from nextrec.basic.layers import (
 )
 from nextrec.basic.heads import TaskHead
 from nextrec.basic.model import BaseModel
+from nextrec.utils.types import ActivationName
 
 
 class AUGRU(nn.Module):
@@ -211,19 +212,9 @@ class DIEN(BaseModel):
         mlp_params: dict | None = None,
         gru_hidden_size: int = 64,
         attention_hidden_units: list[int] | None = None,
-        attention_activation: str = "sigmoid",
+        attention_activation: ActivationName = "sigmoid",
         use_negsampling: bool = False,
         aux_loss_weight: float = 1.0,
-        target: list[str] | str | None = None,
-        task: str | 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,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
@@ -232,24 +223,14 @@ class DIEN(BaseModel):
         sequence_features = sequence_features or []
         mlp_params = mlp_params or {}
         attention_hidden_units = attention_hidden_units or [80, 40]
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(DIEN, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
-        self.loss = loss
         self.use_negsampling = use_negsampling
         self.aux_loss_weight = float(aux_loss_weight)
         self.auxiliary_cache = None
@@ -361,13 +342,6 @@ class DIEN(BaseModel):
             ],
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         self.auxiliary_cache = None
         if self.candidate_feature:

nextrec/models/ranking/din.py

@@ -58,6 +58,7 @@ from nextrec.basic.layers import (
 )
 from nextrec.basic.heads import TaskHead
 from nextrec.basic.model import BaseModel
+from nextrec.utils.types import ActivationName
 
 
 class DIN(BaseModel):
@@ -78,18 +79,8 @@ class DIN(BaseModel):
         candidate_feature_name: str | None = None,
         mlp_params: dict | None = None,
         attention_hidden_units: list[int] | None = None,
-        attention_activation: str = "dice",
+        attention_activation: ActivationName = "dice",
         attention_use_softmax: bool = True,
-        target: list[str] | str | None = None,
-        task: str | 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,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **kwargs,
     ):
 
@@ -98,20 +89,11 @@ class DIN(BaseModel):
         sequence_features = sequence_features or []
         mlp_params = mlp_params or {}
         attention_hidden_units = attention_hidden_units or [80, 40]
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(DIN, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
             sequence_features=sequence_features,
-            target=target,
-            task=task or self.default_task,
-            embedding_l1_reg=embedding_l1_reg,
-            dense_l1_reg=dense_l1_reg,
-            embedding_l2_reg=embedding_l2_reg,
-            dense_l2_reg=dense_l2_reg,
             **kwargs,
         )
 
@@ -182,13 +164,6 @@ class DIN(BaseModel):
             include_modules=["attention", "mlp", "candidate_attention_proj"],
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         # Get candidate item embedding
         if self.candidate_feature is None: