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

nextrec/models/ranking/masknet.py

@@ -56,7 +56,7 @@ embedding 表示生成一个个性化的 “mask” 向量，通过逐元素的
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-
+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
@@ -167,48 +167,28 @@ class MaskNet(BaseModel):
         dense_features: list[DenseFeature] | None = None,
         sparse_features: list[SparseFeature] | None = None,
         sequence_features: list[SequenceFeature] | None = None,
-        architecture: str = "parallel",  # "serial" or "parallel"
+        architecture: Literal[
+            "serial", "parallel"
+        ] = "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] | 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 []
-        target = target or []
         mlp_params = mlp_params or {}
-        optimizer_params = optimizer_params or {}
 
         super().__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,
         )
 
-        if loss is None:
-            loss = "bce"
-        self.loss = loss
-
         self.dense_features = dense_features
         self.sparse_features = sparse_features
         self.sequence_features = sequence_features
@@ -293,12 +273,6 @@ class MaskNet(BaseModel):
             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)

nextrec/models/ranking/pnn.py

@@ -36,7 +36,7 @@ PNN 是一种 CTR 预估模型，通过将线性信号与乘积信号结合，
 
 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
@@ -59,18 +59,10 @@ class PNN(BaseModel):
         sparse_features: list[SparseFeature] | None = None,
         sequence_features: list[SequenceFeature] | None = None,
         mlp_params: dict | None = None,
-        product_type: str = "inner",  # "inner" (IPNN), "outer" (OPNN), "both" (PNN*)
+        product_type: Literal[
+            "inner", "outer", "both"
+        ] = "inner",  # "inner" (IPNN), "outer" (OPNN), "both" (PNN*)
         outer_product_dim: int | 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,
     ):
 
@@ -80,20 +72,11 @@ class PNN(BaseModel):
         mlp_params = mlp_params or {}
         if outer_product_dim is not None and outer_product_dim <= 0:
             raise ValueError("outer_product_dim must be a positive integer.")
-        optimizer_params = optimizer_params or {}
-        if loss is None:
-            loss = "bce"
 
         super(PNN, 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,
         )
 
@@ -144,13 +127,6 @@ class PNN(BaseModel):
             embedding_attr="embedding", include_modules=modules
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def compute_inner_products(self, field_emb: torch.Tensor) -> torch.Tensor:
         interactions = []
         for i in range(self.num_fields - 1):

nextrec/models/ranking/widedeep.py

@@ -38,8 +38,6 @@ Wide & Deep 同时使用宽线性部分（记忆共现/手工交叉）与深网
 - 共享特征空间，减少工程开销
 """
 
-import torch.nn as nn
-
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import LR, MLP, EmbeddingLayer
 from nextrec.basic.heads import TaskHead
@@ -61,40 +59,16 @@ class WideDeep(BaseModel):
         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,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **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,
             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
-
         # Wide part: use all features for linear model
         self.wide_features = sparse_features + sequence_features
         # Deep part: use all features
@@ -117,12 +91,6 @@ class WideDeep(BaseModel):
         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

nextrec/models/ranking/xdeepfm.py

@@ -121,41 +121,18 @@ class xDeepFM(BaseModel):
         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,
-        embedding_l1_reg=0.0,
-        dense_l1_reg=0.0,
-        embedding_l2_reg=0.0,
-        dense_l2_reg=0.0,
         **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,
             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
-
         # Linear part and CIN part: use sparse and sequence features
         self.linear_features = sparse_features + sequence_features
 
@@ -195,13 +172,6 @@ class xDeepFM(BaseModel):
             embedding_attr="embedding", include_modules=["linear", "cin", "mlp"]
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def forward(self, x):
         # Get embeddings for linear and CIN (sparse features only)
         input_linear = self.embedding(

nextrec/models/retrieval/dssm.py

@@ -10,7 +10,6 @@ Reference:
 from typing import Literal
 
 import torch
-import torch.nn as nn
 
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import MLP, EmbeddingLayer
@@ -54,17 +53,6 @@ class DSSM(BaseMatchModel):
         dense_l1_reg=0.0,
         embedding_l2_reg=0.0,
         dense_l2_reg=0.0,
-        optimizer: str | torch.optim.Optimizer = "adam",
-        optimizer_params: dict | None = None,
-        scheduler: (
-            str
-            | torch.optim.lr_scheduler._LRScheduler
-            | type[torch.optim.lr_scheduler._LRScheduler]
-            | None
-        ) = None,
-        scheduler_params: dict | None = None,
-        loss: str | nn.Module | list[str | nn.Module] | None = "bce",
-        loss_params: dict | list[dict] | None = None,
         **kwargs,
     ):
 
@@ -159,18 +147,6 @@ class DSSM(BaseMatchModel):
             embedding_attr="item_embedding", include_modules=["item_dnn"]
         )
 
-        if optimizer_params is None:
-            optimizer_params = {"lr": 1e-3, "weight_decay": 1e-5}
-
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            scheduler=scheduler,
-            scheduler_params=scheduler_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def user_tower(self, user_input: dict) -> torch.Tensor:
         """
         User tower encodes user features into embeddings.

nextrec/models/retrieval/dssm_v2.py

@@ -9,7 +9,6 @@ DSSM v2 - DSSM with pairwise training using BPR loss
 from typing import Literal
 
 import torch
-import torch.nn as nn
 
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import MLP, EmbeddingLayer
@@ -50,17 +49,6 @@ class DSSM_v2(BaseMatchModel):
         dense_l1_reg: float = 0.0,
         embedding_l2_reg: float = 0.0,
         dense_l2_reg: float = 0.0,
-        optimizer: str | torch.optim.Optimizer = "adam",
-        optimizer_params: dict | None = None,
-        scheduler: (
-            str
-            | torch.optim.lr_scheduler._LRScheduler
-            | type[torch.optim.lr_scheduler._LRScheduler]
-            | None
-        ) = None,
-        scheduler_params: dict | None = None,
-        loss: str | nn.Module | list[str | nn.Module] | None = "bce",
-        loss_params: dict | list[dict] | None = None,
         **kwargs,
     ):
 
@@ -151,18 +139,6 @@ class DSSM_v2(BaseMatchModel):
             embedding_attr="item_embedding", include_modules=["item_dnn"]
         )
 
-        if optimizer_params is None:
-            optimizer_params = {"lr": 1e-3, "weight_decay": 1e-5}
-
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            scheduler=scheduler,
-            scheduler_params=scheduler_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def user_tower(self, user_input: dict) -> torch.Tensor:
         """User tower"""
         all_user_features = (

nextrec/models/retrieval/mind.py

@@ -206,17 +206,6 @@ class MIND(BaseMatchModel):
         dense_l1_reg=0.0,
         embedding_l2_reg=0.0,
         dense_l2_reg=0.0,
-        optimizer: str | torch.optim.Optimizer = "adam",
-        optimizer_params: dict | None = None,
-        scheduler: (
-            str
-            | torch.optim.lr_scheduler._LRScheduler
-            | type[torch.optim.lr_scheduler._LRScheduler]
-            | None
-        ) = None,
-        scheduler_params: dict | None = None,
-        loss: str | nn.Module | list[str | nn.Module] | None = "bce",
-        loss_params: dict | list[dict] | None = None,
         **kwargs,
     ):
 
@@ -322,15 +311,6 @@ class MIND(BaseMatchModel):
             include_modules=["item_dnn"] if self.item_dnn else [],
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            scheduler=scheduler,
-            scheduler_params=scheduler_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def user_tower(self, user_input: dict) -> torch.Tensor:
         """
         User tower with multi-interest extraction

nextrec/models/retrieval/sdm.py

@@ -53,17 +53,6 @@ class SDM(BaseMatchModel):
         dense_l1_reg=0.0,
         embedding_l2_reg=0.0,
         dense_l2_reg=0.0,
-        optimizer: str | torch.optim.Optimizer = "adam",
-        optimizer_params: dict | None = None,
-        scheduler: (
-            str
-            | torch.optim.lr_scheduler._LRScheduler
-            | type[torch.optim.lr_scheduler._LRScheduler]
-            | None
-        ) = None,
-        scheduler_params: dict | None = None,
-        loss: str | nn.Module | list[str | nn.Module] | None = "bce",
-        loss_params: dict | list[dict] | None = None,
         **kwargs,
     ):
 
@@ -189,15 +178,6 @@ class SDM(BaseMatchModel):
             include_modules=["item_dnn"] if self.item_dnn else [],
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            scheduler=scheduler,
-            scheduler_params=scheduler_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def user_tower(self, user_input: dict) -> torch.Tensor:
         seq_feature = self.user_sequence_features[0]
         seq_input = user_input[seq_feature.name]

nextrec/models/retrieval/youtube_dnn.py

@@ -10,7 +10,6 @@ Reference:
 from typing import Literal
 
 import torch
-import torch.nn as nn
 
 from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 from nextrec.basic.layers import MLP, EmbeddingLayer
@@ -54,17 +53,6 @@ class YoutubeDNN(BaseMatchModel):
         dense_l1_reg=0.0,
         embedding_l2_reg=0.0,
         dense_l2_reg=0.0,
-        optimizer: str | torch.optim.Optimizer = "adam",
-        optimizer_params: dict | None = None,
-        scheduler: (
-            str
-            | torch.optim.lr_scheduler._LRScheduler
-            | type[torch.optim.lr_scheduler._LRScheduler]
-            | None
-        ) = None,
-        scheduler_params: dict | None = None,
-        loss: str | nn.Module | list[str | nn.Module] | None = "bce",
-        loss_params: dict | list[dict] | None = None,
         **kwargs,
     ):
 
@@ -156,15 +144,6 @@ class YoutubeDNN(BaseMatchModel):
             embedding_attr="item_embedding", include_modules=["item_dnn"]
         )
 
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            scheduler=scheduler,
-            scheduler_params=scheduler_params,
-            loss=loss,
-            loss_params=loss_params,
-        )
-
     def user_tower(self, user_input: dict) -> torch.Tensor:
         """
         User tower to encode historical behavior sequences and user features.

nextrec/models/sequential/hstu.py

@@ -323,11 +323,6 @@ class HSTU(BaseModel):
         tie_embeddings: bool = True,
         target: Optional[list[str] | str] = None,
         task: str | list[str] | None = None,
-        optimizer: str = "adam",
-        optimizer_params: Optional[dict] = None,
-        scheduler: Optional[str] = None,
-        scheduler_params: Optional[dict] = None,
-        loss_params: Optional[dict] = None,
         embedding_l1_reg: float = 0.0,
         dense_l1_reg: float = 0.0,
         embedding_l2_reg: float = 0.0,
@@ -426,19 +421,6 @@ class HSTU(BaseModel):
         self.register_buffer("causal_mask", torch.empty(0), persistent=False)
         self.ignore_index = self.padding_idx if self.padding_idx is not None else -100
 
-        optimizer_params = optimizer_params or {}
-        scheduler_params = scheduler_params or {}
-        loss_params = loss_params or {}
-        loss_params.setdefault("ignore_index", self.ignore_index)
-
-        self.compile(
-            optimizer=optimizer,
-            optimizer_params=optimizer_params,
-            scheduler=scheduler,
-            scheduler_params=scheduler_params,
-            loss="crossentropy",
-            loss_params=loss_params,
-        )
         self.register_regularization_weights(
             embedding_attr="token_embedding",
             include_modules=["layers", "lm_head", "context_proj"],

nextrec/utils/model.py

@@ -2,7 +2,7 @@
 Model-related utilities for NextRec
 
 Date: create on 03/12/2025
-Checkpoint: edit on 24/12/2025
+Checkpoint: edit on 29/12/2025
 Author: Yang Zhou, zyaztec@gmail.com
 """
 
@@ -72,6 +72,84 @@ def compute_pair_scores(model, data, batch_size: int = 512):
     return scores.detach().cpu().numpy()
 
 
+def get_training_modes(
+    training_mode,
+    nums_task: int,
+    valid_modes: set[str] | None = None,
+) -> list:
+    valid_modes = valid_modes or {"pointwise", "pairwise", "listwise"}
+    if isinstance(training_mode, list):
+        training_modes = list(training_mode)
+        if len(training_modes) != nums_task:
+            raise ValueError(
+                "[BaseModel-init Error] training_mode list length must match number of tasks."
+            )
+    else:
+        training_modes = [training_mode] * nums_task
+    if any(mode not in valid_modes for mode in training_modes):
+        raise ValueError(
+            "[BaseModel-init Error] training_mode must be one of {'pointwise', 'pairwise', 'listwise'}."
+        )
+    return training_modes
+
+
+def get_loss_list(
+    loss,
+    training_modes: list[str],
+    nums_task: int,
+    default_losses: dict[str, str],
+):
+    effective_loss = loss
+    if effective_loss is None:
+        loss_list = [default_losses[mode] for mode in training_modes]
+    elif isinstance(effective_loss, list):
+        if not effective_loss:
+            loss_list = [default_losses[mode] for mode in training_modes]
+        else:
+            if len(effective_loss) != nums_task:
+                raise ValueError(
+                    f"[BaseModel-compile Error] Number of loss functions ({len(effective_loss)}) must match number of tasks ({nums_task})."
+                )
+            loss_list = list(effective_loss)
+    else:
+        loss_list = [effective_loss] * nums_task
+
+    for idx, mode in enumerate(training_modes):
+        if isinstance(loss_list[idx], str) and loss_list[idx] in {
+            "bce",
+            "binary_crossentropy",
+        }:
+            if mode in {"pairwise", "listwise"}:
+                loss_list[idx] = default_losses[mode]
+    return loss_list
+
+
+def resolve_loss_weights(loss_weights, nums_task: int):
+    if loss_weights is None:
+        return None
+    if nums_task == 1:
+        if isinstance(loss_weights, (list, tuple)):
+            if len(loss_weights) != 1:
+                raise ValueError(
+                    "[BaseModel-compile Error] loss_weights list must have exactly one element for single-task setup."
+                )
+            loss_weights = loss_weights[0]
+        return [float(loss_weights)]
+    if isinstance(loss_weights, (int, float)):
+        weights = [float(loss_weights)] * nums_task
+    elif isinstance(loss_weights, (list, tuple)):
+        weights = [float(w) for w in loss_weights]
+        if len(weights) != nums_task:
+            raise ValueError(
+                f"[BaseModel-compile Error] Number of loss_weights ({len(weights)}) must match number of tasks ({nums_task})."
+            )
+    else:
+        raise TypeError(
+            f"[BaseModel-compile Error] loss_weights must be int, float, list or tuple, got {type(loss_weights)}"
+        )
+    return weights
+
+
 def prepare_ranking_targets(
     y_pred: torch.Tensor, y_true: torch.Tensor
 ) -> tuple[torch.Tensor, torch.Tensor]:

nextrec/utils/types.py

@@ -61,3 +61,38 @@ ActivationName = Literal[
 TrainingModeName = Literal["pointwise", "pairwise", "listwise"]
 
 TaskTypeName = Literal["binary", "regression"]
+
+MetricsName = Literal[
+    "auc",
+    "gauc",
+    "ks",
+    "logloss",
+    "accuracy",
+    "acc",
+    "precision",
+    "recall",
+    "f1",
+    "micro_f1",
+    "macro_f1",
+    "mse",
+    "mae",
+    "rmse",
+    "r2",
+    "mape",
+    "msle",
+    "auc",
+    "gauc",
+    "precision@10",
+    "hitrate@10",
+    "map@10",
+    "cosine",
+    "recall@5",
+    "recall@10",
+    "recall@20",
+    "ndcg@5",
+    "ndcg@10",
+    "ndcg@20",
+    "mrr@5",
+    "mrr@10",
+    "mrr@20",
+]

{nextrec-0.4.22.dist-info → nextrec-0.4.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrec
-Version: 0.4.22
+Version: 0.4.23
 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
@@ -69,7 +69,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.22-orange.svg)
+![Version](https://img.shields.io/badge/Version-0.4.23-orange.svg)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/zerolovesea/NextRec)
 
 中文文档 | [English Version](README_en.md)
@@ -191,6 +191,8 @@ model = DIN(
     dense_features=dense_features,
     sparse_features=sparse_features,
     sequence_features=sequence_features,
+    behavior_feature_name="sequence_0",
+    candidate_feature_name="item_id",
     mlp_params=mlp_params,
     attention_hidden_units=[80, 40],
     attention_activation='sigmoid',
@@ -204,7 +206,7 @@ model = DIN(
     session_id="din_tutorial",                            # 实验id，用于存放训练日志
 )
 
-# 编译模型，设置优化器和损失函数
+# 编译模型，优化器/损失/学习率调度器统一在 compile 中设置
 model.compile(
             optimizer = "adam",
             optimizer_params = {"lr": 1e-3, "weight_decay": 1e-5},
@@ -247,11 +249,11 @@ nextrec --mode=predict --predict_config=path/to/predict_config.yaml
 
 预测结果固定保存到 `{checkpoint_path}/predictions/{name}.{save_data_format}`。
 
-> 截止当前版本0.4.22，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
+> 截止当前版本0.4.23，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
 
 ## 兼容平台
 
-当前最新版本为0.4.22，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
+当前最新版本为0.4.23，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
 
 | 平台 | 配置 | 
 |------|------|