nextrec 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

nextrec/models/ranking/widedeep.py

@@ -39,7 +39,6 @@ Wide & Deep 同时使用宽线性部分（记忆共现/手工交叉）与深网
 - 共享特征空间，减少工程开销
 """
 
-import torch
 import torch.nn as nn
 
 from nextrec.basic.model import BaseModel
@@ -55,25 +54,33 @@ class WideDeep(BaseModel):
     @property
     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] = [],
-                 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):
-        
+
+    def __init__(
+        self,
+        dense_features: list[DenseFeature],
+        sparse_features: list[SparseFeature],
+        sequence_features: list[SequenceFeature],
+        mlp_params: dict,
+        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,
+        device: str = "cpu",
+        embedding_l1_reg=1e-6,
+        dense_l1_reg=1e-5,
+        embedding_l2_reg=1e-5,
+        dense_l2_reg=1e-4,
+        **kwargs,
+    ):
+
+        if target is None:
+            target = []
+        optimizer_params = optimizer_params or {}
+        if loss is None:
+            loss = "bce"
+
         super(WideDeep, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
@@ -85,13 +92,11 @@ class WideDeep(BaseModel):
             dense_l1_reg=dense_l1_reg,
             embedding_l2_reg=embedding_l2_reg,
             dense_l2_reg=dense_l2_reg,
-            **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,7 +108,7 @@ 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)])
@@ -111,14 +116,21 @@ class WideDeep(BaseModel):
         self.mlp = MLP(input_dim=input_dim, **mlp_params)
         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,7 +59,8 @@ 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):
@@ -58,27 +69,36 @@ class xDeepFM(BaseModel):
     @property
     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] = [],
-                 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):
-        
+
+    def __init__(
+        self,
+        dense_features: list[DenseFeature],
+        sparse_features: list[SparseFeature],
+        sequence_features: list[SequenceFeature],
+        mlp_params: dict,
+        cin_size: list[int] | None = None,
+        split_half: 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,
+        device: str = "cpu",
+        embedding_l1_reg=1e-6,
+        dense_l1_reg=1e-5,
+        embedding_l2_reg=1e-5,
+        dense_l2_reg=1e-4,
+        **kwargs,
+    ):
+
+        cin_size = cin_size or [128, 128]
+        if target is None:
+            target = []
+        optimizer_params = optimizer_params or {}
+        if loss is None:
+            loss = "bce"
+
         super(xDeepFM, self).__init__(
             dense_features=dense_features,
             sparse_features=sparse_features,
@@ -90,16 +110,14 @@ class xDeepFM(BaseModel):
             dense_l1_reg=dense_l1_reg,
             embedding_l2_reg=embedding_l2_reg,
             dense_l2_reg=dense_l2_reg,
-            **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 +127,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)
 
         # 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 +160,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]

nextrec/utils/__init__.py

@@ -10,63 +10,88 @@ This package provides various utility functions organized by category:
 - file_utils: File I/O operations
 - model_utils: Model-related utilities
 - feature_utils: Feature processing utilities
+- config_utils: Configuration loading and processing utilities
 
 Date: create on 13/11/2025
 Last update: 06/12/2025
 Author: Yang Zhou, zyaztec@gmail.com
 """
+
 from . import optimizer, initializer, embedding
 from .optimizer import get_optimizer, get_scheduler
 from .initializer import get_initializer
 from .embedding import get_auto_embedding_dim
 from .device import resolve_device, get_device_info
 from .tensor import to_tensor, stack_tensors, concat_tensors, pad_sequence_tensors
-from .file import resolve_file_paths, read_table, load_dataframes, iter_file_chunks, default_output_dir
+from .file import (
+    resolve_file_paths,
+    read_table,
+    load_dataframes,
+    iter_file_chunks,
+    default_output_dir,
+    read_yaml,
+)
 from .model import merge_features, get_mlp_output_dim
 from .feature import normalize_to_list
-from .synthetic_data import generate_ranking_data, generate_distributed_ranking_data, generate_match_data, generate_multitask_data
+from .synthetic_data import (
+    generate_match_data,
+    generate_ranking_data,
+    generate_multitask_data,
+    generate_distributed_ranking_data,
+)
+from .config import (
+    resolve_path,
+    select_features,
+    register_processor_features,
+    build_feature_objects,
+    extract_feature_groups,
+    load_model_class,
+    build_model_instance,
+)
 
 __all__ = [
     # Optimizer & Scheduler
-    'get_optimizer',
-    'get_scheduler',
-    
+    "get_optimizer",
+    "get_scheduler",
     # Initializer
-    'get_initializer',
-    
+    "get_initializer",
     # Embedding
-    'get_auto_embedding_dim',
-    
+    "get_auto_embedding_dim",
     # Device utilities
-    'resolve_device',
-    'get_device_info',
-    
+    "resolve_device",
+    "get_device_info",
     # Tensor utilities
-    'to_tensor',
-    'stack_tensors',
-    'concat_tensors',
-    'pad_sequence_tensors',
-    
+    "to_tensor",
+    "stack_tensors",
+    "concat_tensors",
+    "pad_sequence_tensors",
     # File utilities
-    'resolve_file_paths',
-    'read_table',
-    'load_dataframes',
-    'iter_file_chunks',
-    'default_output_dir',
-    
+    "resolve_file_paths",
+    "read_table",
+    "read_yaml",
+    "load_dataframes",
+    "iter_file_chunks",
+    "default_output_dir",
     # Model utilities
-    'merge_features',
-    'get_mlp_output_dim',
-    
+    "merge_features",
+    "get_mlp_output_dim",
     # Feature utilities
-    'normalize_to_list',
-    
+    "normalize_to_list",
+    # Config utilities
+    "resolve_path",
+    "select_features",
+    "register_processor_features",
+    "build_feature_objects",
+    "extract_feature_groups",
+    "load_model_class",
+    "build_model_instance",
     # Synthetic data utilities
-    'generate_ranking_data',
-    'generate_distributed_ranking_data',
-    
+    "generate_ranking_data",
+    "generate_match_data",
+    "generate_multitask_data",
+    "generate_distributed_ranking_data",
     # Module exports
-    'optimizer',
-    'initializer',
-    'embedding',
+    "optimizer",
+    "initializer",
+    "embedding",
 ]