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

nextrec/models/ranking/masknet.py

@@ -69,12 +69,13 @@ class InstanceGuidedMask(nn.Module):
         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] 
+        # 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,
@@ -86,20 +87,28 @@ class MaskBlockOnEmbedding(nn.Module):
         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.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.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:
+    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]
+        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)
 
@@ -123,15 +132,21 @@ class MaskBlockOnHidden(nn.Module):
         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.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)  
+    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)  
+        v_masked_hid = v_mask * norm_hidden
+        out = self.ffn(v_masked_hid)
         out = self.ln_output(out)
         out = F.relu(out)
         return out
@@ -143,8 +158,7 @@ class MaskNet(BaseModel):
         return "MaskNet"
 
     @property
-    def task_type(self):
-        # Align with PredictionLayer supported task types
+    def default_task(self):
         return "binary"
 
     def __init__(
@@ -152,13 +166,14 @@ class MaskNet(BaseModel):
         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"
+        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,
+        task: str | list[str] | None = None,
         optimizer: str = "adam",
         optimizer_params: dict | None = None,
         loss: str | nn.Module | None = "bce",
@@ -182,13 +197,12 @@ class MaskNet(BaseModel):
             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,
         )
 
@@ -200,50 +214,97 @@ class MaskNet(BaseModel):
         self.sparse_features = sparse_features
         self.sequence_features = sequence_features
         self.mask_features = self.all_features  # use all features for masking
-        assert len(self.mask_features) > 0, "MaskNet requires at least one feature for masking."
+        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 = getattr(self.mask_features[0], "embedding_dim", None)
-        assert self.embedding_dim is not None, "MaskNet requires mask_features to have 'embedding_dim' defined."
+        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, but got {edim} for feature {getattr(f, 'name', type(f))}.")
+                raise ValueError(
+                    f"MaskNet expects identical embedding_dim across all mask_features, 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'."
+        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()
+        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.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)])
+                [
+                    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.final_mlp = MLP(input_dim=self.num_blocks * block_hidden_dim, **mlp_params)
+            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.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.prediction_layer = PredictionLayer(task_type=self.task)
 
         if self.model_type == "serial":
-            self.register_regularization_weights(embedding_attr="embedding", include_modules=["mask_blocks", "output_layer"],)
+            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, optimizer_params=optimizer_params, loss=loss, loss_params=loss_params)
+            self.register_regularization_weights(
+                embedding_attr="embedding", include_modules=["mask_blocks", "final_mlp"]
+            )
+        self.compile(
+            optimizer=optimizer,
+            optimizer_params=optimizer_params,
+            loss=loss,
+            loss_params=loss_params,
+        )
 
     def forward(self, x: dict[str, torch.Tensor]) -> torch.Tensor:
         field_emb = self.embedding(x=x, features=self.mask_features, squeeze_dim=False)
         B = field_emb.size(0)
-        v_emb_flat = field_emb.view(B, -1)  # flattened embeddings 
+        v_emb_flat = field_emb.view(B, -1)  # flattened embeddings
 
         if self.model_type == "parallel":
             block_outputs = []
@@ -254,7 +315,7 @@ class MaskNet(BaseModel):
             concat_hidden = torch.cat(block_outputs, dim=-1)
             logit = self.final_mlp(concat_hidden)  # [B, 1]
         # serial
-        else: 
+        else:
             hidden = self.first_block(field_emb, v_emb_flat)
             hidden = self.block_dropout(hidden)
             for block in self.hidden_blocks:

nextrec/models/ranking/pnn.py

@@ -20,47 +20,49 @@ class PNN(BaseModel):
         return "PNN"
 
     @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 = {},
-                 product_type: str = "inner",
-                 outer_product_dim: int | None = None,
-                 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 = {},
+        product_type: str = "inner",
+        outer_product_dim: int | None = None,
+        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(PNN, 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.field_features = sparse_features + sequence_features
         if len(self.field_features) < 2:
             raise ValueError("PNN requires at least two sparse/sequence features.")
@@ -69,7 +71,9 @@ class PNN(BaseModel):
         self.num_fields = len(self.field_features)
         self.embedding_dim = self.field_features[0].embedding_dim
         if any(f.embedding_dim != self.embedding_dim for f in self.field_features):
-            raise ValueError("All field features must share the same embedding_dim for PNN.")
+            raise ValueError(
+                "All field features must share the same embedding_dim for PNN."
+            )
 
         self.product_type = product_type.lower()
         if self.product_type not in {"inner", "outer"}:
@@ -86,14 +90,13 @@ class PNN(BaseModel):
 
         linear_dim = self.num_fields * self.embedding_dim
         self.mlp = MLP(input_dim=linear_dim + product_dim, **mlp_params)
-        self.prediction_layer = PredictionLayer(task_type=self.task_type)
+        self.prediction_layer = PredictionLayer(task_type=self.task)
 
-        modules = ['mlp']
+        modules = ["mlp"]
         if self.product_type == "outer":
-            modules.append('kernel')
+            modules.append("kernel")
         self.register_regularization_weights(
-            embedding_attr='embedding',
-            include_modules=modules
+            embedding_attr="embedding", include_modules=modules
         )
 
         self.compile(

nextrec/models/ranking/widedeep.py

@@ -39,7 +39,6 @@ Wide & Deep 同时使用宽线性部分（记忆共现/手工交叉）与深网
 - 共享特征空间，减少工程开销
 """
 
-import torch
 import torch.nn as nn
 
 from nextrec.basic.model import BaseModel
@@ -53,45 +52,47 @@ class WideDeep(BaseModel):
         return "WideDeep"
 
     @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,
-                 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,
+        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(WideDeep, 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"
-            
+
         # Wide part: use all features for linear model
         self.wide_features = sparse_features + sequence_features
         # Deep part: use all features
@@ -103,22 +104,29 @@ class WideDeep(BaseModel):
         # Wide part: Linear layer
         wide_dim = sum([f.embedding_dim for f in self.wide_features])
         self.linear = LR(wide_dim)
-        
+
         # Deep part: MLP
         input_dim = self.embedding.input_dim
         # deep_emb_dim_total = sum([f.embedding_dim for f in self.deep_features if not isinstance(f, DenseFeature)])
         # dense_input_dim = sum([getattr(f, "embedding_dim", 1) or 1 for f in dense_features])
         self.mlp = MLP(input_dim=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=['linear', 'mlp'])
-        self.compile(optimizer=optimizer, optimizer_params=optimizer_params, loss=loss, loss_params=loss_params)
+        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):
         # Deep part
         input_deep = self.embedding(x=x, features=self.deep_features, squeeze_dim=True)
         y_deep = self.mlp(input_deep)  # [B, 1]
-        
+
         # Wide part
         input_wide = self.embedding(x=x, features=self.wide_features, squeeze_dim=True)
         y_wide = self.linear(input_wide)

nextrec/models/ranking/xdeepfm.py

@@ -3,8 +3,8 @@ Date: create on 09/11/2025
 Author:
     Yang Zhou,zyaztec@gmail.com
 Reference:
-    [1] Lian J, Zhou X, Zhang F, et al. xdeepfm: Combining explicit and implicit feature interactions 
-        for recommender systems[C]//Proceedings of the 24th ACM SIGKDD international conference on 
+    [1] Lian J, Zhou X, Zhang F, et al. xdeepfm: Combining explicit and implicit feature interactions
+        for recommender systems[C]//Proceedings of the 24th ACM SIGKDD international conference on
         knowledge discovery & data mining. 2018: 1754-1763.
         (https://arxiv.org/abs/1803.05170)
 """
@@ -17,6 +17,7 @@ from nextrec.basic.model import BaseModel
 from nextrec.basic.layers import LR, EmbeddingLayer, MLP, PredictionLayer
 from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature
 
+
 class CIN(nn.Module):
     """Compressed Interaction Network from xDeepFM (Lian et al., 2018)."""
 
@@ -28,7 +29,16 @@ class CIN(nn.Module):
         prev_dim, fc_input_dim = input_dim, 0
         for i in range(self.num_layers):
             cross_layer_size = cin_size[i]
-            self.conv_layers.append(torch.nn.Conv1d(input_dim * prev_dim, cross_layer_size, 1, stride=1, dilation=1, bias=True))
+            self.conv_layers.append(
+                torch.nn.Conv1d(
+                    input_dim * prev_dim,
+                    cross_layer_size,
+                    1,
+                    stride=1,
+                    dilation=1,
+                    bias=True,
+                )
+            )
             if self.split_half and i != self.num_layers - 1:
                 cross_layer_size //= 2
             prev_dim = cross_layer_size
@@ -49,57 +59,60 @@ class CIN(nn.Module):
                 h = x
             xs.append(x)
         return self.fc(torch.sum(torch.cat(xs, dim=1), 2))
-    
+
+
 class xDeepFM(BaseModel):
     @property
     def model_name(self):
         return "xDeepFM"
 
     @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,
-                 cin_size: list[int] = [128, 128],
-                 split_half: 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,
+        cin_size: list[int] = [128, 128],
+        split_half: 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(xDeepFM, 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"
-            
+
         # Linear part and CIN part: use sparse and sequence features
         self.linear_features = sparse_features + sequence_features
-        
+
         # Deep part: use all features
         self.deep_features = dense_features + sparse_features + sequence_features
 
@@ -109,21 +122,28 @@ class xDeepFM(BaseModel):
         # Linear part
         linear_dim = sum([f.embedding_dim for f in self.linear_features])
         self.linear = LR(linear_dim)
-        
+
         # CIN part: Compressed Interaction Network
         num_fields = len(self.linear_features)
         self.cin = CIN(input_dim=num_fields, cin_size=cin_size, split_half=split_half)
-        
+
         # Deep part: DNN
-        deep_emb_dim_total = sum([f.embedding_dim for f in self.deep_features if not isinstance(f, DenseFeature)])
-        dense_input_dim = sum([getattr(f, "embedding_dim", 1) or 1 for f in dense_features])
+        deep_emb_dim_total = sum(
+            [
+                f.embedding_dim
+                for f in self.deep_features
+                if not isinstance(f, DenseFeature)
+            ]
+        )
+        dense_input_dim = sum(
+            [getattr(f, "embedding_dim", 1) or 1 for f in dense_features]
+        )
         self.mlp = MLP(input_dim=deep_emb_dim_total + dense_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=['linear', 'cin', 'mlp']
+            embedding_attr="embedding", include_modules=["linear", "cin", "mlp"]
         )
 
         self.compile(
@@ -135,14 +155,16 @@ class xDeepFM(BaseModel):
 
     def forward(self, x):
         # Get embeddings for linear and CIN (sparse features only)
-        input_linear = self.embedding(x=x, features=self.linear_features, squeeze_dim=False)
-        
+        input_linear = self.embedding(
+            x=x, features=self.linear_features, squeeze_dim=False
+        )
+
         # Linear part
         y_linear = self.linear(input_linear.flatten(start_dim=1))
-        
+
         # CIN part
         y_cin = self.cin(input_linear)  # [B, 1]
-        
+
         # Deep part
         input_deep = self.embedding(x=x, features=self.deep_features, squeeze_dim=True)
         y_deep = self.mlp(input_deep)  # [B, 1]