nextrec 0.4.10__py3-none-any.whl → 0.4.12__py3-none-any.whl

nextrec/models/ranking/eulernet.py

@@ -41,7 +41,8 @@ from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import LR, EmbeddingLayer, PredictionLayer
 from nextrec.basic.model import BaseModel
 
-class EulerInteractionLayerPaper(nn.Module):
+
+class EulerInteractionLayer(nn.Module):
     """
     Paper-aligned Euler Interaction Layer.
 
@@ -102,24 +103,32 @@ class EulerInteractionLayerPaper(nn.Module):
             self.bn = None
             self.ln = None
 
-    def forward(self, r: torch.Tensor, p: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    def forward(
+        self, r: torch.Tensor, p: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         """
         r, p: [B, m, d]
         return r_out, p_out: [B, n, d]
         """
         B, m, d = r.shape
-        assert m == self.m and d == self.d, f"Expected [B,{self.m},{self.d}] got {r.shape}"
+        assert (
+            m == self.m and d == self.d
+        ), f"Expected [B,{self.m},{self.d}] got {r.shape}"
 
         # Euler Transformation: rectangular -> polar
-        lam = torch.sqrt(r * r + p * p + self.eps)         # [B,m,d]
-        theta = torch.atan2(p, r)              # [B,m,d]
-        log_lam = torch.log(lam + self.eps)               # [B,m,d]
+        lam = torch.sqrt(r * r + p * p + self.eps)  # [B,m,d]
+        theta = torch.atan2(p, r)  # [B,m,d]
+        log_lam = torch.log(lam + self.eps)  # [B,m,d]
 
         # Generalized Multi-order Transformation
         # psi_k = sum_j alpha_{k,j} * theta_j + delta_k
         # l_k   = exp(sum_j alpha_{k,j} * log(lam_j) + delta'_k)
-        psi = torch.einsum("bmd,nmd->bnd", theta, self.alpha) + self.delta_phase  # [B,n,d]
-        log_l = torch.einsum("bmd,nmd->bnd", log_lam, self.alpha) + self.delta_logmod  # [B,n,d]
+        psi = (
+            torch.einsum("bmd,nmd->bnd", theta, self.alpha) + self.delta_phase
+        )  # [B,n,d]
+        log_l = (
+            torch.einsum("bmd,nmd->bnd", log_lam, self.alpha) + self.delta_logmod
+        )  # [B,n,d]
         l = torch.exp(log_l)  # [B,n,d]
 
         # Inverse Euler Transformation
@@ -153,7 +162,7 @@ class EulerInteractionLayerPaper(nn.Module):
         return r_out, p_out
 
 
-class ComplexSpaceMappingPaper(nn.Module):
+class ComplexSpaceMapping(nn.Module):
     """
     Map real embeddings e_j to complex features via Euler's formula (Eq.6-7).
     For each field j:
@@ -174,63 +183,6 @@ class ComplexSpaceMappingPaper(nn.Module):
         r = mu * torch.cos(e)
         p = mu * torch.sin(e)
         return r, p
-    
-class EulerNetPaper(nn.Module):
-    """
-    Paper-aligned EulerNet core (embedding -> mapping -> L Euler layers -> linear regression).
-    """
-
-    def __init__(
-        self,
-        *,
-        embedding_dim: int,
-        num_fields: int,
-        num_layers: int = 2,
-        num_orders: int = 8,      # n in paper
-        use_implicit: bool = True,
-        norm: str | None = "ln",  # None | "bn" | "ln"
-    ):
-        super().__init__()
-        self.d = embedding_dim
-        self.m = num_fields
-        self.L = num_layers
-        self.n = num_orders
-
-        self.mapping = ComplexSpaceMappingPaper(embedding_dim, num_fields)
-
-        self.layers = nn.ModuleList([
-            EulerInteractionLayerPaper(
-                embedding_dim=embedding_dim,
-                num_fields=(num_fields if i == 0 else num_orders),  # stack: m -> n -> n ...
-                num_orders=num_orders,
-                use_implicit=use_implicit,
-                norm=norm,
-            )
-            for i in range(num_layers)
-        ])
-
-        # Output regression (Eq.16-17)
-        # After last layer: r,p are [B,n,d]. Concatenate to [B, n*d] each, then regress.
-        self.w = nn.Linear(self.n * self.d, 1, bias=False)  # for real
-        self.w_im = nn.Linear(self.n * self.d, 1, bias=False)  # for imag
-
-    def forward(self, field_emb: torch.Tensor) -> torch.Tensor:
-        """
-        field_emb: [B, m, d] real embeddings e_j
-        return: logits, shape [B,1]
-        """
-        r, p = self.mapping(field_emb)  # [B,m,d]
-
-        # stack Euler interaction layers
-        for layer in self.layers:
-            r, p = layer(r, p)  # -> [B,n,d]
-
-        r_flat = r.reshape(r.size(0), self.n * self.d)
-        p_flat = p.reshape(p.size(0), self.n * self.d)
-
-        z_re = self.w(r_flat)
-        z_im = self.w_im(p_flat)
-        return z_re + z_im  # Eq.17 logits
 
 
 class EulerNet(BaseModel):
@@ -313,14 +265,23 @@ class EulerNet(BaseModel):
                 "All interaction features must share the same embedding_dim in EulerNet."
             )
 
-        self.euler = EulerNetPaper(
-            embedding_dim=self.embedding_dim,
-            num_fields=self.num_fields,
-            num_layers=num_layers,
-            num_orders=num_orders,
-            use_implicit=use_implicit,
-            norm=norm,
+        self.num_layers = num_layers
+        self.num_orders = num_orders
+        self.mapping = ComplexSpaceMapping(self.embedding_dim, self.num_fields)
+        self.layers = nn.ModuleList(
+            [
+                EulerInteractionLayer(
+                    embedding_dim=self.embedding_dim,
+                    num_fields=(self.num_fields if i == 0 else self.num_orders),
+                    num_orders=self.num_orders,
+                    use_implicit=use_implicit,
+                    norm=norm,
+                )
+                for i in range(self.num_layers)
+            ]
         )
+        self.w = nn.Linear(self.num_orders * self.embedding_dim, 1, bias=False)
+        self.w_im = nn.Linear(self.num_orders * self.embedding_dim, 1, bias=False)
 
         if self.use_linear:
             if len(self.linear_features) == 0:
@@ -336,7 +297,7 @@ class EulerNet(BaseModel):
 
         self.prediction_layer = PredictionLayer(task_type=self.task)
 
-        modules = ["euler"]
+        modules = ["mapping", "layers", "w", "w_im"]
         if self.use_linear:
             modules.append("linear")
         self.register_regularization_weights(
@@ -354,7 +315,7 @@ class EulerNet(BaseModel):
         field_emb = self.embedding(
             x=x, features=self.interaction_features, squeeze_dim=False
         )
-        y_euler = self.euler(field_emb)
+        y_euler = self.euler_forward(field_emb)
 
         if self.use_linear and self.linear is not None:
             linear_input = self.embedding(
@@ -363,3 +324,11 @@ class EulerNet(BaseModel):
             y_euler = y_euler + self.linear(linear_input)
 
         return self.prediction_layer(y_euler)
+
+    def euler_forward(self, field_emb: torch.Tensor) -> torch.Tensor:
+        r, p = self.mapping(field_emb)
+        for layer in self.layers:
+            r, p = layer(r, p)
+        r_flat = r.reshape(r.size(0), self.num_orders * self.embedding_dim)
+        p_flat = p.reshape(p.size(0), self.num_orders * self.embedding_dim)
+        return self.w(r_flat) + self.w_im(p_flat)

nextrec/models/ranking/ffm.py

@@ -0,0 +1,275 @@
+"""
+Date: create on 19/12/2025
+Checkpoint: edit on 19/12/2025
+Author: Yang Zhou, zyaztec@gmail.com
+Reference:
+[1] Juan Y, Zhuang Y, Chin W-S, et al. Field-aware Factorization Machines for CTR
+Prediction[C]//RecSys. 2016: 43-50.
+
+Field-aware Factorization Machines (FFM) extend FM by learning a distinct
+embedding of each feature for every target field. For a pair of fields (i, j),
+FFM uses v_{i,f_j} · v_{j,f_i} instead of a shared embedding, enabling richer
+context-aware interactions and stronger CTR performance on sparse categorical
+data.
+
+Pipeline:
+  (1) Build field-aware embeddings v_{i,f} for each feature i toward every field f
+  (2) Compute first-order linear terms for sparse/sequence (and optional dense) fields
+  (3) For each field pair (i, j), compute v_{i,f_j} · v_{j,f_i}
+  (4) Sum linear + field-aware interaction logits and output prediction
+
+Key Advantages:
+- Field-aware embeddings capture asymmetric interactions between fields
+- Improves CTR accuracy on sparse categorical features
+- Retains interpretable second-order structure
+
+FFM 在 FM 基础上引入字段感知机制：每个特征在不同目标字段下拥有不同的 embedding。
+对于字段对 (i, j)，模型使用 v_{i,f_j} 与 v_{j,f_i} 的内积，从而更细粒度地建模
+跨字段交互，在稀疏高维 CTR 场景中表现更优。
+
+处理流程：
+  (1) 为每个特征 i 构造面向每个字段 f 的嵌入 v_{i,f}
+  (2) 计算一阶线性项（稀疏/序列特征，及可选的稠密特征）
+  (3) 对每一对字段 (i, j) 计算 v_{i,f_j} · v_{j,f_i}
+  (4) 将线性项与交互项相加得到最终预测
+
+主要优点：
+- 字段感知嵌入可捕捉非对称交互
+- 稀疏类别特征下预测更准确
+- 保持二阶结构的可解释性
+"""
+
+import torch
+import torch.nn as nn
+
+from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
+from nextrec.basic.layers import AveragePooling, InputMask, PredictionLayer, SumPooling
+from nextrec.basic.model import BaseModel
+from nextrec.utils.torch_utils import get_initializer
+
+
+class FFM(BaseModel):
+    @property
+    def model_name(self):
+        return "FFM"
+
+    @property
+    def default_task(self):
+        return "binary"
+
+    def __init__(
+        self,
+        dense_features: list[DenseFeature] | None = None,
+        sparse_features: list[SparseFeature] | None = None,
+        sequence_features: list[SequenceFeature] | 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,
+        device: str = "cpu",
+        embedding_l1_reg=1e-6,
+        dense_l1_reg=1e-5,
+        embedding_l2_reg=1e-5,
+        dense_l2_reg=1e-4,
+        **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(FFM, self).__init__(
+            dense_features=dense_features,
+            sparse_features=sparse_features,
+            sequence_features=sequence_features,
+            target=target,
+            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,
+            **kwargs,
+        )
+
+        self.fm_features = sparse_features + sequence_features
+        if len(self.fm_features) < 2:
+            raise ValueError(
+                "FFM requires at least two sparse/sequence features to build field-aware interactions."
+            )
+
+        self.embedding_dim = self.fm_features[0].embedding_dim
+        if any(f.embedding_dim != self.embedding_dim for f in self.fm_features):
+            raise ValueError(
+                "All FFM features must share the same embedding_dim for field-aware interactions."
+            )
+        for feature in self.fm_features:
+            if isinstance(feature, SequenceFeature) and feature.combiner == "concat":
+                raise ValueError(
+                    "FFM does not support SequenceFeature with combiner='concat' because it breaks shared embedding_dim."
+                )
+
+        self.field_aware_embeddings = nn.ModuleDict()
+        for src_feature in self.fm_features:
+            for target_field in self.fm_features:
+                key = self.field_aware_key(src_feature, target_field)
+                if key in self.field_aware_embeddings:
+                    continue
+                self.field_aware_embeddings[key] = self.build_embedding(src_feature)
+
+        # First-order terms for sparse/sequence features: one hot
+        self.first_order_embeddings = nn.ModuleDict()
+        for feature in self.fm_features:
+            if feature.embedding_name in self.first_order_embeddings:
+                continue
+            emb = nn.Embedding(
+                num_embeddings=feature.vocab_size,
+                embedding_dim=1,
+                padding_idx=feature.padding_idx,
+            )
+            self.first_order_embeddings[feature.embedding_name] = emb
+
+        # Optional dense linear term
+        self.dense_features = list(dense_features)
+        dense_input_dim = sum([f.input_dim for f in self.dense_features])
+        self.linear_dense = (
+            nn.Linear(dense_input_dim, 1, bias=True) if dense_input_dim > 0 else None
+        )
+
+        self.prediction_layer = PredictionLayer(task_type=self.task)
+        self.input_mask = InputMask()
+        self.mean_pool = AveragePooling()
+        self.sum_pool = SumPooling()
+
+        self.embedding_params.extend(
+            emb.weight for emb in self.field_aware_embeddings.values()
+        )
+        self.embedding_params.extend(
+            emb.weight for emb in self.first_order_embeddings.values()
+        )
+        self.register_regularization_weights(
+            embedding_attr="field_aware_embeddings", include_modules=["linear_dense"]
+        )
+
+        self.compile(
+            optimizer=optimizer,
+            optimizer_params=optimizer_params,
+            loss=loss,
+            loss_params=loss_params,
+        )
+
+    def field_aware_key(
+        self, src_feature: SparseFeature | SequenceFeature, target_field
+    ) -> str:
+        return f"{src_feature.embedding_name}__to__{target_field.name}"
+
+    def build_embedding(self, feature: SparseFeature | SequenceFeature) -> nn.Embedding:
+        if getattr(feature, "pretrained_weight", None) is not None:
+            weight = feature.pretrained_weight
+            if weight is None:
+                raise ValueError(
+                    f"[FFM Error]: Pretrained weight for '{feature.embedding_name}' is None."
+                )
+            if weight.shape != (feature.vocab_size, feature.embedding_dim):
+                raise ValueError(
+                    f"[FFM Error]: Pretrained weight for '{feature.embedding_name}' has shape {weight.shape}, expected ({feature.vocab_size}, {feature.embedding_dim})."
+                )
+            embedding = nn.Embedding.from_pretrained(
+                embeddings=weight,
+                freeze=feature.freeze_pretrained,
+                padding_idx=feature.padding_idx,
+            )
+            embedding.weight.requires_grad = (
+                feature.trainable and not feature.freeze_pretrained
+            )
+        else:
+            embedding = nn.Embedding(
+                num_embeddings=feature.vocab_size,
+                embedding_dim=feature.embedding_dim,
+                padding_idx=feature.padding_idx,
+            )
+            embedding.weight.requires_grad = feature.trainable
+            initialization = get_initializer(
+                init_type=feature.init_type,
+                activation="linear",
+                param=feature.init_params,
+            )
+            initialization(embedding.weight)
+        return embedding
+
+    def embed_for_field(
+        self,
+        feature: SparseFeature | SequenceFeature,
+        target_field,
+        x: dict[str, torch.Tensor],
+    ) -> torch.Tensor:
+        key = self.field_aware_key(feature, target_field)
+        emb = self.field_aware_embeddings[key]
+        if isinstance(feature, SparseFeature):
+            return emb(x[feature.name].long())
+
+        seq_input = x[feature.name].long()
+        if feature.max_len is not None and seq_input.size(1) > feature.max_len:
+            seq_input = seq_input[:, -feature.max_len :]
+        seq_emb = emb(seq_input)  # [B, L, D]
+        mask = self.input_mask(x, feature, seq_input)
+        if feature.combiner == "mean":
+            return self.mean_pool(seq_emb, mask)
+        if feature.combiner == "sum":
+            return self.sum_pool(seq_emb, mask)
+        raise ValueError(
+            f"[FFM Error]: Unsupported combiner '{feature.combiner}' for sequence feature '{feature.name}'."
+        )
+
+    def forward(self, x):
+        batch_size = x[self.fm_features[0].name].size(0)
+        device = x[self.fm_features[0].name].device
+        y_linear = torch.zeros(batch_size, 1, device=device)
+
+        # First-order dense part
+        if self.linear_dense is not None:
+            dense_inputs = [
+                x[f.name].float().view(batch_size, -1) for f in self.dense_features
+            ]
+            dense_stack = torch.cat(dense_inputs, dim=1) if dense_inputs else None
+            if dense_stack is not None:
+                y_linear = y_linear + self.linear_dense(dense_stack)
+
+        # First-order sparse/sequence part
+        first_order_terms = []
+        for feature in self.fm_features:
+            emb = self.first_order_embeddings[feature.embedding_name]
+            if isinstance(feature, SparseFeature):
+                term = emb(x[feature.name].long())  # [B, 1]
+            else:
+                seq_input = x[feature.name].long()
+                if feature.max_len is not None and seq_input.size(1) > feature.max_len:
+                    seq_input = seq_input[:, -feature.max_len :]
+                mask = self.input_mask(x, feature, seq_input).squeeze(1)  # [B, L]
+                seq_weight = emb(seq_input).squeeze(-1)  # [B, L]
+                term = (seq_weight * mask).sum(dim=1, keepdim=True)  # [B, 1]
+            first_order_terms.append(term)
+        if first_order_terms:
+            y_linear = y_linear + torch.sum(
+                torch.stack(first_order_terms, dim=1), dim=1
+            )
+
+        # Field-aware interactions
+        y_interaction = torch.zeros(batch_size, 1, device=device)
+        num_fields = len(self.fm_features)
+        for i in range(num_fields - 1):
+            feature_i = self.fm_features[i]
+            for j in range(i + 1, num_fields):
+                feature_j = self.fm_features[j]
+                v_i_fj = self.embed_for_field(feature_i, feature_j, x)
+                v_j_fi = self.embed_for_field(feature_j, feature_i, x)
+                y_interaction = y_interaction + torch.sum(
+                    v_i_fj * v_j_fi, dim=1, keepdim=True
+                )
+
+        y = y_linear + y_interaction
+        return self.prediction_layer(y)

nextrec/models/ranking/lr.py

@@ -113,8 +113,6 @@ class LR(BaseModel):
         )
 
     def forward(self, x):
-        input_linear = self.embedding(
-            x=x, features=self.all_features, squeeze_dim=True
-        )
+        input_linear = self.embedding(x=x, features=self.all_features, squeeze_dim=True)
         y = self.linear(input_linear)
         return self.prediction_layer(y)

nextrec/utils/__init__.py

@@ -36,7 +36,7 @@ from .data import (
 )
 from .embedding import get_auto_embedding_dim
 from .feature import normalize_to_list
-from .model import get_mlp_output_dim, merge_features
+from .model import compute_pair_scores, get_mlp_output_dim, merge_features
 from .torch_utils import (
     add_distributed_sampler,
     concat_tensors,
@@ -88,6 +88,7 @@ __all__ = [
     # Model utilities
     "merge_features",
     "get_mlp_output_dim",
+    "compute_pair_scores",
     # Feature utilities
     "normalize_to_list",
     # Config utilities

nextrec/utils/console.py

@@ -4,7 +4,7 @@ Console and CLI utilities for NextRec.
 This module centralizes CLI logging helpers, progress display, and metric tables.
 
 Date: create on 19/12/2025
-Checkpoint: edit on 19/12/2025
+Checkpoint: edit on 20/12/2025
 Author: Yang Zhou, zyaztec@gmail.com
 """
 
@@ -242,6 +242,14 @@ def display_metrics_table(
                 normalized_order.append(name)
         task_order = normalized_order
 
+    if not task_order and not grouped and not metrics:
+        if isinstance(loss, numbers.Number):
+            msg = f"Epoch {epoch}/{epochs} - {split} (loss={float(loss):.4f})"
+            if colorize is not None:
+                msg = colorize(msg)
+            logging.info(msg)
+        return
+
     if Console is None or Table is None or box is None:
         prefix = f"Epoch {epoch}/{epochs} - {split}:"
         segments: list[str] = []

nextrec/utils/model.py

@@ -7,6 +7,8 @@ Author: Yang Zhou, zyaztec@gmail.com
 
 from collections import OrderedDict
 
+import torch
+
 
 def merge_features(primary, secondary) -> list:
     merged: OrderedDict[str, object] = OrderedDict()
@@ -42,3 +44,15 @@ def select_features(
         )
 
     return [feature_map[name] for name in names]
+
+
+def compute_pair_scores(model, data, batch_size: int = 512):
+    user_emb = model.encode_user(data, batch_size=batch_size)
+    item_emb = model.encode_item(data, batch_size=batch_size)
+    with torch.no_grad():
+        user_tensor = torch.as_tensor(user_emb, device=model.device)
+        item_tensor = torch.as_tensor(item_emb, device=model.device)
+        scores = model.compute_similarity(user_tensor, item_tensor)
+        if model.training_mode == "pointwise":
+            scores = torch.sigmoid(scores)
+    return scores.detach().cpu().numpy()

{nextrec-0.4.10.dist-info → nextrec-0.4.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrec
-Version: 0.4.10
+Version: 0.4.12
 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
@@ -66,7 +66,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.4.10-orange.svg)
+![Version](https://img.shields.io/badge/Version-0.4.12-orange.svg)
 
 中文文档 | [English Version](README_en.md)
 
@@ -99,7 +99,7 @@ NextRec是一个基于PyTorch的现代推荐系统框架，旨在为研究工程
 
 ## NextRec近期进展
 
-- **12/12/2025** 在v0.4.10中加入了[RQ-VAE](/nextrec/models/representation/rqvae.py)模块。配套的[数据集](/dataset/ecommerce_task.csv)和[代码](tutorials/notebooks/zh/使用RQ-VAE构建语义ID.ipynb)已经同步在仓库中
+- **12/12/2025** 在v0.4.12中加入了[RQ-VAE](/nextrec/models/representation/rqvae.py)模块。配套的[数据集](/dataset/ecommerce_task.csv)和[代码](tutorials/notebooks/zh/使用RQ-VAE构建语义ID.ipynb)已经同步在仓库中
 - **07/12/2025** 发布了NextRec CLI命令行工具，它允许用户根据配置文件进行一键训练和推理，我们提供了相关的[教程](/nextrec_cli_preset/NextRec-CLI_zh.md)和[教学代码](/nextrec_cli_preset)
 - **03/12/2025** NextRec获得了100颗🌟！感谢大家的支持
 - **06/12/2025** 在v0.4.1中支持了单机多卡的分布式DDP训练，并且提供了配套的[代码](tutorials/distributed)
@@ -240,11 +240,11 @@ nextrec --mode=train --train_config=path/to/train_config.yaml
 nextrec --mode=predict --predict_config=path/to/predict_config.yaml
 ```
 
-> 截止当前版本0.4.10，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
+> 截止当前版本0.4.12，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
 
 ## 兼容平台
 
-当前最新版本为0.4.10，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
+当前最新版本为0.4.12，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
 
 | 平台 | 配置 | 
 |------|------|
@@ -260,7 +260,9 @@ nextrec --mode=predict --predict_config=path/to/predict_config.yaml
 | 模型 | 论文 | 年份 | 状态 |
 |------|------|------|------|
 | [FM](nextrec/models/ranking/fm.py) | Factorization Machines | ICDM 2010 | 已支持 |
+| [LR](nextrec/models/ranking/lr.py) | Logistic Regression | - | 已支持 |
 | [AFM](nextrec/models/ranking/afm.py) | Attentional Factorization Machines: Learning the Weight of Feature Interactions via Attention Networks | IJCAI 2017 | 已支持 |
+| [FFM](nextrec/models/ranking/ffm.py) | Field-aware Factorization Machines | RecSys 2016 | 已支持 |
 | [DeepFM](nextrec/models/ranking/deepfm.py) | DeepFM: A Factorization-Machine based Neural Network for CTR Prediction | IJCAI 2017 | 已支持 |
 | [Wide&Deep](nextrec/models/ranking/widedeep.py) | Wide & Deep Learning for Recommender Systems | DLRS 2016 | 已支持 |
 | [xDeepFM](nextrec/models/ranking/xdeepfm.py) | xDeepFM: Combining Explicit and Implicit Feature Interactions | KDD 2018 | 已支持 |
@@ -272,16 +274,24 @@ nextrec --mode=predict --predict_config=path/to/predict_config.yaml
 | [DIN](nextrec/models/ranking/din.py) | Deep Interest Network for Click-Through Rate Prediction | KDD 2018 | 已支持 |
 | [DIEN](nextrec/models/ranking/dien.py) | Deep Interest Evolution Network for Click-Through Rate Prediction | AAAI 2019 | 已支持 |
 | [MaskNet](nextrec/models/ranking/masknet.py) | MaskNet: Introducing Feature-wise Gating Blocks for High-dimensional Sparse Recommendation Data | 2020 | 已支持 |
+| [EulerNet](nextrec/models/ranking/eulernet.py) | EulerNet: Efficient and Effective Feature Interaction Modeling with Euler's Formula | SIGIR 2021 | 已支持 |
 
 ### 召回模型
 
 | 模型 | 论文 | 年份 | 状态 |
 |------|------|------|------|
-| [DSSM](nextrec/models/match/dssm.py) | Learning Deep Structured Semantic Models | CIKM 2013 | 已支持 |
-| [DSSM v2](nextrec/models/match/dssm_v2.py) | DSSM with pairwise BPR-style optimization | - | 已支持 |
-| [YouTube DNN](nextrec/models/match/youtube_dnn.py) | Deep Neural Networks for YouTube Recommendations | RecSys 2016 | 已支持 |
-| [MIND](nextrec/models/match/mind.py) | Multi-Interest Network with Dynamic Routing | CIKM 2019 | 已支持 |
-| [SDM](nextrec/models/match/sdm.py) | Sequential Deep Matching Model | - | 已支持 |
+| [DSSM](nextrec/models/retrieval/dssm.py) | Learning Deep Structured Semantic Models | CIKM 2013 | 已支持 |
+| [DSSM v2](nextrec/models/retrieval/dssm_v2.py) | DSSM with pairwise BPR-style optimization | - | 已支持 |
+| [YouTube DNN](nextrec/models/retrieval/youtube_dnn.py) | Deep Neural Networks for YouTube Recommendations | RecSys 2016 | 已支持 |
+| [MIND](nextrec/models/retrieval/mind.py) | Multi-Interest Network with Dynamic Routing | CIKM 2019 | 已支持 |
+| [SDM](nextrec/models/retrieval/sdm.py) | Sequential Deep Matching Model | - | 已支持 |
+
+### 序列推荐模型
+
+| 模型 | 论文 | 年份 | 状态 |
+|------|------|------|------|
+| [SASRec](nextrec/models/sequential/sasrec.py) | Self-Attentive Sequential Recommendation | KDD 2018 | 开发中 |
+| [HSTU](nextrec/models/sequential/hstu.py) | Actions speak louder than words: Trillion-parameter sequential transducers for generative recommendations | arXiv 2024 | 已支持 |
 
 ### 多任务模型
 
@@ -298,7 +308,18 @@ nextrec --mode=predict --predict_config=path/to/predict_config.yaml
 | 模型 | 论文 | 年份 | 状态 |
 |------|------|------|------|
 | [TIGER](nextrec/models/generative/tiger.py) | Recommender Systems with Generative Retrieval | NeurIPS 2023 | 开发中 |
-| [HSTU](nextrec/models/generative/hstu.py) | Hierarchical Sequential Transduction Units | - | 已支持 |
+
+### 表征模型
+
+| 模型 | 论文 | 年份 | 状态 |
+|------|------|------|------|
+| [RQ-VAE](nextrec/models/representation/rqvae.py) | RQ-VAE: RQVAE for Generative Retrieval | - | 已支持 |
+| [BPR](nextrec/models/representation/bpr.py) | Bayesian Personalized Ranking | UAI 2009 | 开发中 |
+| [MF](nextrec/models/representation/mf.py) | Matrix Factorization Techniques for Recommender Systems | - | 开发中 |
+| [AutoRec](nextrec/models/representation/autorec.py) | AutoRec: Autoencoders Meet Collaborative Filtering | WWW 2015 | 开发中 |
+| [LightGCN](nextrec/models/representation/lightgcn.py) | LightGCN: Simplifying and Powering Graph Convolution Network for Recommendation | SIGIR 2020 | 开发中 |
+| [S3Rec](nextrec/models/representation/s3rec.py) | S3-Rec: Self-Supervised Learning for Sequential Recommendation | CIKM 2020 | 开发中 |
+| [CL4SRec](nextrec/models/representation/cl4srec.py) | CL4SRec: Contrastive Learning for Sequential Recommendation | 2021 | 开发中 |
 
 ---