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

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,
     ):
 
@@ -115,8 +103,8 @@ class DSSM(BaseMatchModel):
             user_dnn_units = user_dnn_hidden_units + [embedding_dim]
             self.user_dnn = MLP(
                 input_dim=user_input_dim,
-                dims=user_dnn_units,
-                output_layer=False,
+                hidden_dims=user_dnn_units,
+                output_dim=None,
                 dropout=dnn_dropout,
                 activation=dnn_activation,
             )
@@ -146,8 +134,8 @@ class DSSM(BaseMatchModel):
             item_dnn_units = item_dnn_hidden_units + [embedding_dim]
             self.item_dnn = MLP(
                 input_dim=item_input_dim,
-                dims=item_dnn_units,
-                output_layer=False,
+                hidden_dims=item_dnn_units,
+                output_dim=None,
                 dropout=dnn_dropout,
                 activation=dnn_activation,
             )
@@ -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,
     ):
 
@@ -109,8 +97,8 @@ class DSSM_v2(BaseMatchModel):
             user_dnn_units = user_dnn_hidden_units + [embedding_dim]
             self.user_dnn = MLP(
                 input_dim=user_input_dim,
-                dims=user_dnn_units,
-                output_layer=False,
+                hidden_dims=user_dnn_units,
+                output_dim=None,
                 dropout=dnn_dropout,
                 activation=dnn_activation,
             )
@@ -138,8 +126,8 @@ class DSSM_v2(BaseMatchModel):
             item_dnn_units = item_dnn_hidden_units + [embedding_dim]
             self.item_dnn = MLP(
                 input_dim=item_input_dim,
-                dims=item_dnn_units,
-                output_layer=False,
+                hidden_dims=item_dnn_units,
+                output_dim=None,
                 dropout=dnn_dropout,
                 activation=dnn_activation,
             )
@@ -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,
     ):
 
@@ -306,8 +295,8 @@ class MIND(BaseMatchModel):
                 item_dnn_units = item_dnn_hidden_units + [embedding_dim]
                 self.item_dnn = MLP(
                     input_dim=item_input_dim,
-                    dims=item_dnn_units,
-                    output_layer=False,
+                    hidden_dims=item_dnn_units,
+                    output_dim=None,
                     dropout=dnn_dropout,
                     activation=dnn_activation,
                 )
@@ -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,
     ):
 
@@ -142,8 +131,8 @@ class SDM(BaseMatchModel):
             # User DNN to final embedding
             self.user_dnn = MLP(
                 input_dim=user_final_dim,
-                dims=[rnn_hidden_size * 2, embedding_dim],
-                output_layer=False,
+                hidden_dims=[rnn_hidden_size * 2, embedding_dim],
+                output_dim=None,
                 dropout=dnn_dropout,
                 activation=dnn_activation,
             )
@@ -173,8 +162,8 @@ class SDM(BaseMatchModel):
                 item_dnn_units = item_dnn_hidden_units + [embedding_dim]
                 self.item_dnn = MLP(
                     input_dim=item_input_dim,
-                    dims=item_dnn_units,
-                    output_layer=False,
+                    hidden_dims=item_dnn_units,
+                    output_dim=None,
                     dropout=dnn_dropout,
                     activation=dnn_activation,
                 )
@@ -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,
     ):
 
@@ -114,8 +102,8 @@ class YoutubeDNN(BaseMatchModel):
             user_dnn_units = user_dnn_hidden_units + [embedding_dim]
             self.user_dnn = MLP(
                 input_dim=user_input_dim,
-                dims=user_dnn_units,
-                output_layer=False,
+                hidden_dims=user_dnn_units,
+                output_dim=None,
                 dropout=dnn_dropout,
                 activation=dnn_activation,
             )
@@ -143,8 +131,8 @@ class YoutubeDNN(BaseMatchModel):
             item_dnn_units = item_dnn_hidden_units + [embedding_dim]
             self.item_dnn = MLP(
                 input_dim=item_input_dim,
-                dims=item_dnn_units,
-                output_layer=False,
+                hidden_dims=item_dnn_units,
+                output_dim=None,
                 dropout=dnn_dropout,
                 activation=dnn_activation,
             )
@@ -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,13 +2,14 @@
 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
 """
 
 from collections import OrderedDict
 
 import torch
+from torch import nn
 
 from nextrec.loss import (
     ApproxNDCGLoss,
@@ -19,6 +20,14 @@ from nextrec.loss import (
     SampledSoftmaxLoss,
     TripletLoss,
 )
+from nextrec.utils.types import (
+    LossName,
+    OptimizerName,
+    SchedulerName,
+    TrainingModeName,
+    TaskTypeName,
+    MetricsName,
+)
 
 
 def merge_features(primary, secondary) -> list:
@@ -29,9 +38,9 @@ def merge_features(primary, secondary) -> list:
 
 
 def get_mlp_output_dim(params: dict, fallback: int) -> int:
-    dims = params.get("dims")
-    if dims:
-        return dims[-1]
+    hidden_dims = params.get("hidden_dims")
+    if hidden_dims:
+        return hidden_dims[-1]
     return fallback
 
 
@@ -72,6 +81,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.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrec
-Version: 0.4.22
+Version: 0.4.24
 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.24-orange.svg)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/zerolovesea/NextRec)
 
 中文文档 | [English Version](README_en.md)
@@ -182,7 +182,7 @@ sequence_features = [
     SequenceFeature(name='sequence_1', vocab_size=int(df['sequence_1'].apply(lambda x: max(x)).max() + 1), embedding_dim=16, padding_idx=0, embedding_name='sparse_0_emb'),]
 
 mlp_params = {
-    "dims": [256, 128, 64],
+    "hidden_dims": [256, 128, 64],
     "activation": "relu",
     "dropout": 0.3,
 }
@@ -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.24，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
 
 ## 兼容平台
 
-当前最新版本为0.4.22，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
+当前最新版本为0.4.24，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
 
 | 平台 | 配置 | 
 |------|------|