nextrec 0.4.8__py3-none-any.whl → 0.4.9__py3-none-any.whl

nextrec/utils/{synthetic_data.py → data.py}

@@ -1,17 +1,101 @@
 """
-Synthetic Data Generation Utilities
+Data utilities for NextRec.
 
-This module provides utilities for generating synthetic datasets for testing
-and tutorial purposes in the NextRec framework.
+This module provides file I/O helpers and synthetic data generation.
 
-Date: create on 06/12/2025
+Date: create on 19/12/2025
+Checkpoint: edit on 19/12/2025
 Author: Yang Zhou, zyaztec@gmail.com
 """
 
-import torch
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Generator, List, Optional, Tuple
+
 import numpy as np
 import pandas as pd
-from typing import Optional, Dict, List, Tuple
+import pyarrow.parquet as pq
+import torch
+import yaml
+
+
+def resolve_file_paths(path: str) -> tuple[list[str], str]:
+    """
+    Resolve file or directory path into a sorted list of files and file type.
+
+    Args: path: Path to a file or directory
+    Returns: tuple: (list of file paths, file type)
+    """
+    path_obj = Path(path)
+
+    if path_obj.is_file():
+        file_type = path_obj.suffix.lower().lstrip(".")
+        assert file_type in [
+            "csv",
+            "parquet",
+        ], f"Unsupported file extension: {file_type}"
+        return [str(path_obj)], file_type
+
+    if path_obj.is_dir():
+        collected_files = [p for p in path_obj.iterdir() if p.is_file()]
+        csv_files = [str(p) for p in collected_files if p.suffix.lower() == ".csv"]
+        parquet_files = [
+            str(p) for p in collected_files if p.suffix.lower() == ".parquet"
+        ]
+
+        if csv_files and parquet_files:
+            raise ValueError(
+                "Directory contains both CSV and Parquet files. Please keep a single format."
+            )
+        file_paths = csv_files if csv_files else parquet_files
+        if not file_paths:
+            raise ValueError(f"No CSV or Parquet files found in directory: {path}")
+        file_paths.sort()
+        file_type = "csv" if csv_files else "parquet"
+        return file_paths, file_type
+
+    raise ValueError(f"Invalid path: {path}")
+
+
+def read_table(path: str | Path, data_format: str | None = None) -> pd.DataFrame:
+    data_path = Path(path)
+    fmt = data_format.lower() if data_format else data_path.suffix.lower().lstrip(".")
+    if data_path.is_dir() and not fmt:
+        fmt = "parquet"
+    if fmt in {"parquet", ""}:
+        return pd.read_parquet(data_path)
+    if fmt in {"csv", "txt"}:
+        # Use low_memory=False to avoid mixed-type DtypeWarning on wide CSVs
+        return pd.read_csv(data_path, low_memory=False)
+    raise ValueError(f"Unsupported data format: {data_path}")
+
+
+def load_dataframes(file_paths: list[str], file_type: str) -> list[pd.DataFrame]:
+    return [read_table(fp, file_type) for fp in file_paths]
+
+
+def iter_file_chunks(
+    file_path: str, file_type: str, chunk_size: int
+) -> Generator[pd.DataFrame, None, None]:
+    if file_type == "csv":
+        yield from pd.read_csv(file_path, chunksize=chunk_size)
+        return
+    parquet_file = pq.ParquetFile(file_path)
+    for batch in parquet_file.iter_batches(batch_size=chunk_size):
+        yield batch.to_pandas()
+
+
+def default_output_dir(path: str) -> Path:
+    path_obj = Path(path)
+    if path_obj.is_file():
+        return path_obj.parent / f"{path_obj.stem}_preprocessed"
+    return path_obj.with_name(f"{path_obj.name}_preprocessed")
+
+
+def read_yaml(path: str | Path):
+    with open(path, "r", encoding="utf-8") as file:
+        return yaml.safe_load(file) or {}
 
 
 def generate_ranking_data(
@@ -90,13 +174,14 @@ def generate_ranking_data(
         sequence_vocabs.append(seq_vocab)
 
     if "gender" in data and "dense_0" in data:
+        dense_1 = data.get("dense_1", 0)
         # Complex label generation with feature correlation
         label_probs = 1 / (
             1
             + np.exp(
                 -(
                     data["dense_0"] * 0.3
-                    + data["dense_1"] * 0.2
+                    + dense_1 * 0.2
                     + (data["gender"] - 0.5) * 0.5
                     + np.random.randn(n_samples) * 0.1
                 )
@@ -112,7 +197,7 @@ def generate_ranking_data(
         print(f"Positive rate: {data['label'].mean():.4f}")
 
     # Import here to avoid circular import
-    from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature
+    from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 
     # Create feature definitions
     # Use input_dim for dense features to be compatible with both simple and complex scenarios
@@ -273,7 +358,7 @@ def generate_match_data(
     print(f"Positive rate: {data['label'].mean():.4f}")
 
     # Import here to avoid circular import
-    from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature
+    from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 
     # User dense features
     user_dense_features = [DenseFeature(name="user_age", input_dim=1)]
@@ -413,15 +498,17 @@ def generate_multitask_data(
 
     # Generate multi-task labels with correlation
     # CTR (click) is relatively easier to predict
-    ctr_logits = (
-        data["dense_0"] * 0.3 + data["dense_1"] * 0.2 + np.random.randn(n_samples) * 0.5
-    )
+    dense_0 = data.get("dense_0", 0)
+    dense_1 = data.get("dense_1", 0)
+    dense_2 = data.get("dense_2", 0)
+    dense_3 = data.get("dense_3", 0)
+    ctr_logits = dense_0 * 0.3 + dense_1 * 0.2 + np.random.randn(n_samples) * 0.5
     data["click"] = (1 / (1 + np.exp(-ctr_logits)) > 0.5).astype(np.float32)
 
     # CVR (conversion) depends on click and is harder
     cvr_logits = (
-        data["dense_2"] * 0.2
-        + data["dense_3"] * 0.15
+        dense_2 * 0.2
+        + dense_3 * 0.15
         + data["click"] * 1.5  # Strong dependency on click
         + np.random.randn(n_samples) * 0.8
     )
@@ -441,7 +528,7 @@ def generate_multitask_data(
     print(f"CTCVR rate: {data['ctcvr'].mean():.4f}")
 
     # Import here to avoid circular import
-    from nextrec.basic.features import DenseFeature, SparseFeature, SequenceFeature
+    from nextrec.basic.features import DenseFeature, SequenceFeature, SparseFeature
 
     # Create feature definitions
     dense_features = [

nextrec/utils/feature.py

@@ -2,9 +2,13 @@
 Feature processing utilities for NextRec
 
 Date: create on 03/12/2025
+Checkpoint: edit on 19/12/2025
 Author: Yang Zhou, zyaztec@gmail.com
 """
 
+import numbers
+from typing import Any
+
 
 def normalize_to_list(value: str | list[str] | None) -> list[str]:
     if value is None:
@@ -12,3 +16,14 @@ def normalize_to_list(value: str | list[str] | None) -> list[str]:
     if isinstance(value, str):
         return [value]
     return list(value)
+
+
+def as_float(value: Any) -> float | None:
+    if isinstance(value, numbers.Number):
+        return float(value)
+    if hasattr(value, "item"):
+        try:
+            return float(value.item())
+        except Exception:
+            return None
+    return None

nextrec/utils/torch_utils.py

@@ -0,0 +1,411 @@
+"""
+PyTorch-related utilities for NextRec.
+
+This module groups device setup, distributed helpers, optimizers/schedulers,
+initialization, and tensor helpers.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Iterable, Set
+
+import numpy as np
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from torch.utils.data import DataLoader, IterableDataset
+from torch.utils.data.distributed import DistributedSampler
+
+from nextrec.basic.loggers import colorize
+
+KNOWN_NONLINEARITIES: Set[str] = {
+    "linear",
+    "conv1d",
+    "conv2d",
+    "conv3d",
+    "conv_transpose1d",
+    "conv_transpose2d",
+    "conv_transpose3d",
+    "sigmoid",
+    "tanh",
+    "relu",
+    "leaky_relu",
+    "selu",
+    "gelu",
+}
+
+
+def resolve_nonlinearity(activation: str) -> str:
+    if activation in KNOWN_NONLINEARITIES:
+        return activation
+    return "linear"
+
+
+def resolve_gain(activation: str, param: Dict[str, Any]) -> float:
+    if "gain" in param:
+        return param["gain"]
+    nonlinearity = resolve_nonlinearity(activation)
+    try:
+        return nn.init.calculate_gain(nonlinearity, param.get("param"))  # type: ignore
+    except ValueError:
+        return 1.0
+
+
+def get_initializer(
+    init_type: str = "normal",
+    activation: str = "linear",
+    param: Dict[str, Any] | None = None,
+):
+    param = param or {}
+    nonlinearity = resolve_nonlinearity(activation)
+    gain = resolve_gain(activation, param)
+
+    def initializer_fn(tensor):
+        if init_type == "xavier_uniform":
+            nn.init.xavier_uniform_(tensor, gain=gain)
+        elif init_type == "xavier_normal":
+            nn.init.xavier_normal_(tensor, gain=gain)
+        elif init_type == "kaiming_uniform":
+            nn.init.kaiming_uniform_(
+                tensor, a=param.get("a", 0), nonlinearity=nonlinearity  # type: ignore
+            )
+        elif init_type == "kaiming_normal":
+            nn.init.kaiming_normal_(
+                tensor, a=param.get("a", 0), nonlinearity=nonlinearity  # type: ignore
+            )
+        elif init_type == "orthogonal":
+            nn.init.orthogonal_(tensor, gain=gain)
+        elif init_type == "normal":
+            nn.init.normal_(
+                tensor, mean=param.get("mean", 0.0), std=param.get("std", 0.0001)
+            )
+        elif init_type == "uniform":
+            nn.init.uniform_(tensor, a=param.get("a", -0.05), b=param.get("b", 0.05))
+        else:
+            raise ValueError(f"Unknown init_type: {init_type}")
+        return tensor
+
+    return initializer_fn
+
+
+def resolve_device() -> str:
+    if torch.cuda.is_available():
+        return "cuda"
+    if torch.backends.mps.is_available():
+        import platform
+
+        mac_ver = platform.mac_ver()[0]
+        try:
+            major, _ = (int(x) for x in mac_ver.split(".")[:2])
+        except Exception:
+            major, _ = 0, 0
+        if major >= 14:
+            return "mps"
+    return "cpu"
+
+
+def get_device_info() -> dict:
+    info = {
+        "cuda_available": torch.cuda.is_available(),
+        "cuda_device_count": (
+            torch.cuda.device_count() if torch.cuda.is_available() else 0
+        ),
+        "mps_available": torch.backends.mps.is_available(),
+        "current_device": resolve_device(),
+    }
+
+    if torch.cuda.is_available():
+        info["cuda_device_name"] = torch.cuda.get_device_name(0)
+        info["cuda_capability"] = torch.cuda.get_device_capability(0)
+
+    return info
+
+
+def configure_device(
+    distributed: bool, local_rank: int, base_device: torch.device | str = "cpu"
+) -> torch.device:
+    try:
+        device = torch.device(base_device)
+    except Exception:
+        logging.warning(
+            "[configure_device Warning] Invalid base_device, falling back to CPU."
+        )
+        return torch.device("cpu")
+
+    if distributed:
+        if device.type == "cuda":
+            if not torch.cuda.is_available():
+                logging.warning(
+                    "[Distributed Warning] CUDA requested but unavailable. Falling back to CPU."
+                )
+                return torch.device("cpu")
+            if not (0 <= local_rank < torch.cuda.device_count()):
+                logging.warning(
+                    f"[Distributed Warning] local_rank {local_rank} is invalid for available CUDA devices. Falling back to CPU."
+                )
+                return torch.device("cpu")
+            try:
+                torch.cuda.set_device(local_rank)
+                return torch.device(f"cuda:{local_rank}")
+            except Exception as exc:
+                logging.warning(
+                    f"[Distributed Warning] Failed to set CUDA device for local_rank {local_rank}: {exc}. Falling back to CPU."
+                )
+                return torch.device("cpu")
+        return torch.device("cpu")
+    return device
+
+
+def get_optimizer(
+    optimizer: str | torch.optim.Optimizer = "adam",
+    params: Iterable[torch.nn.Parameter] | None = None,
+    **optimizer_params,
+):
+    if params is None:
+        raise ValueError("params cannot be None. Please provide model parameters.")
+
+    if "lr" not in optimizer_params:
+        optimizer_params["lr"] = 1e-3
+    if isinstance(optimizer, str):
+        opt_name = optimizer.lower()
+        if opt_name == "adam":
+            opt_class = torch.optim.Adam
+        elif opt_name == "sgd":
+            opt_class = torch.optim.SGD
+        elif opt_name == "adamw":
+            opt_class = torch.optim.AdamW
+        elif opt_name == "adagrad":
+            opt_class = torch.optim.Adagrad
+        elif opt_name == "rmsprop":
+            opt_class = torch.optim.RMSprop
+        else:
+            raise NotImplementedError(f"Unsupported optimizer: {optimizer}")
+        optimizer_fn = opt_class(params=params, **optimizer_params)
+    elif isinstance(optimizer, torch.optim.Optimizer):
+        optimizer_fn = optimizer
+    else:
+        raise TypeError(f"Invalid optimizer type: {type(optimizer)}")
+    return optimizer_fn
+
+
+def get_scheduler(
+    scheduler: (
+        str
+        | torch.optim.lr_scheduler._LRScheduler
+        | torch.optim.lr_scheduler.LRScheduler
+        | type[torch.optim.lr_scheduler._LRScheduler]
+        | type[torch.optim.lr_scheduler.LRScheduler]
+        | None
+    ),
+    optimizer,
+    **scheduler_params,
+):
+    if isinstance(scheduler, str):
+        if scheduler == "step":
+            scheduler_fn = torch.optim.lr_scheduler.StepLR(
+                optimizer, **scheduler_params
+            )
+        elif scheduler == "cosine":
+            scheduler_fn = torch.optim.lr_scheduler.CosineAnnealingLR(
+                optimizer, **scheduler_params
+            )
+        else:
+            raise NotImplementedError(f"Unsupported scheduler: {scheduler}")
+    elif isinstance(
+        scheduler,
+        (torch.optim.lr_scheduler._LRScheduler, torch.optim.lr_scheduler.LRScheduler),
+    ):
+        scheduler_fn = scheduler
+    else:
+        raise TypeError(f"Invalid scheduler type: {type(scheduler)}")
+
+    return scheduler_fn
+
+
+def to_tensor(
+    value: Any, dtype: torch.dtype, device: torch.device | str | None = None
+) -> torch.Tensor:
+    if value is None:
+        raise ValueError("[Tensor Utils Error] Cannot convert None to tensor.")
+    tensor = value if isinstance(value, torch.Tensor) else torch.as_tensor(value)
+    if tensor.dtype != dtype:
+        tensor = tensor.to(dtype=dtype)
+
+    if device is not None:
+        target_device = (
+            device if isinstance(device, torch.device) else torch.device(device)
+        )
+        if tensor.device != target_device:
+            tensor = tensor.to(target_device)
+    return tensor
+
+
+def stack_tensors(tensors: list[torch.Tensor], dim: int = 0) -> torch.Tensor:
+    if not tensors:
+        raise ValueError("[Tensor Utils Error] Cannot stack empty list of tensors.")
+    return torch.stack(tensors, dim=dim)
+
+
+def concat_tensors(tensors: list[torch.Tensor], dim: int = 0) -> torch.Tensor:
+    if not tensors:
+        raise ValueError(
+            "[Tensor Utils Error] Cannot concatenate empty list of tensors."
+        )
+    return torch.cat(tensors, dim=dim)
+
+
+def pad_sequence_tensors(
+    tensors: list[torch.Tensor],
+    max_len: int | None = None,
+    padding_value: float = 0.0,
+    padding_side: str = "right",
+) -> torch.Tensor:
+    if not tensors:
+        raise ValueError("[Tensor Utils Error] Cannot pad empty list of tensors.")
+    if max_len is None:
+        max_len = max(t.size(0) for t in tensors)
+    batch_size = len(tensors)
+    padded = torch.full(
+        (batch_size, max_len),
+        padding_value,
+        dtype=tensors[0].dtype,
+        device=tensors[0].device,
+    )
+
+    for i, tensor in enumerate(tensors):
+        length = min(tensor.size(0), max_len)
+        if padding_side == "right":
+            padded[i, :length] = tensor[:length]
+        elif padding_side == "left":
+            padded[i, -length:] = tensor[:length]
+        else:
+            raise ValueError(
+                f"[Tensor Utils Error] padding_side must be 'right' or 'left', got {padding_side}"
+            )
+    return padded
+
+
+def init_process_group(
+    distributed: bool, rank: int, world_size: int, device_id: int | None = None
+) -> None:
+    """
+    initialize distributed process group for multi-GPU training.
+
+    Args:
+        distributed: whether to enable distributed training
+        rank: global rank of the current process
+        world_size: total number of processes
+    """
+    if (not distributed) or (not dist.is_available()) or dist.is_initialized():
+        return
+    backend = "nccl" if device_id is not None else "gloo"
+    if backend == "nccl":
+        torch.cuda.set_device(device_id)
+    dist.init_process_group(
+        backend=backend, init_method="env://", rank=rank, world_size=world_size
+    )
+
+
+def gather_numpy(self, array: np.ndarray | None) -> np.ndarray | None:
+    """
+    Gather numpy arrays (or None) across ranks. Uses all_gather_object to avoid
+    shape mismatches and ensures every rank participates even when local data is empty.
+    """
+    if not (self.distributed and dist.is_available() and dist.is_initialized()):
+        return array
+
+    world_size = dist.get_world_size()
+    gathered: list[np.ndarray | None] = [None for _ in range(world_size)]
+    dist.all_gather_object(gathered, array)
+    pieces: list[np.ndarray] = []
+    for item in gathered:
+        if item is None:
+            continue
+        item_np = np.asarray(item)
+        if item_np.size > 0:
+            pieces.append(item_np)
+    if not pieces:
+        return None
+    return np.concatenate(pieces, axis=0)
+
+
+def add_distributed_sampler(
+    loader: DataLoader,
+    distributed: bool,
+    world_size: int,
+    rank: int,
+    shuffle: bool,
+    drop_last: bool,
+    default_batch_size: int,
+    is_main_process: bool = False,
+) -> tuple[DataLoader, DistributedSampler | None]:
+    """
+    add distributedsampler to a dataloader, this for distributed training
+    when each device has its own dataloader
+    """
+    # early return if not distributed
+    if not (distributed and dist.is_available() and dist.is_initialized()):
+        return loader, None
+    # return if already has DistributedSampler
+    if isinstance(loader.sampler, DistributedSampler):
+        return loader, loader.sampler
+    dataset = getattr(loader, "dataset", None)
+    if dataset is None:
+        return loader, None
+    if isinstance(dataset, IterableDataset):
+        if is_main_process:
+            logging.info(
+                colorize(
+                    "[Distributed Info] Iterable/streaming DataLoader provided; DistributedSampler is skipped. Ensure dataset handles sharding per rank.",
+                    color="yellow",
+                )
+            )
+        return loader, None
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=world_size,
+        rank=rank,
+        shuffle=shuffle,
+        drop_last=drop_last,
+    )
+    loader_kwargs = {
+        "batch_size": (
+            loader.batch_size if loader.batch_size is not None else default_batch_size
+        ),
+        "shuffle": False,
+        "sampler": sampler,
+        "num_workers": loader.num_workers,
+        "collate_fn": loader.collate_fn,
+        "drop_last": drop_last,
+    }
+    if getattr(loader, "pin_memory", False):
+        loader_kwargs["pin_memory"] = True
+    pin_memory_device = getattr(loader, "pin_memory_device", None)
+    if pin_memory_device:
+        loader_kwargs["pin_memory_device"] = pin_memory_device
+    timeout = getattr(loader, "timeout", None)
+    if timeout:
+        loader_kwargs["timeout"] = timeout
+    worker_init_fn = getattr(loader, "worker_init_fn", None)
+    if worker_init_fn is not None:
+        loader_kwargs["worker_init_fn"] = worker_init_fn
+    generator = getattr(loader, "generator", None)
+    if generator is not None:
+        loader_kwargs["generator"] = generator
+    if loader.num_workers > 0:
+        loader_kwargs["persistent_workers"] = getattr(
+            loader, "persistent_workers", False
+        )
+        prefetch_factor = getattr(loader, "prefetch_factor", None)
+        if prefetch_factor is not None:
+            loader_kwargs["prefetch_factor"] = prefetch_factor
+    distributed_loader = DataLoader(dataset, **loader_kwargs)
+    if is_main_process:
+        logging.info(
+            colorize(
+                "[Distributed Info] Attached DistributedSampler to provided DataLoader",
+                color="cyan",
+            )
+        )
+    return distributed_loader, sampler

{nextrec-0.4.8.dist-info → nextrec-0.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrec
-Version: 0.4.8
+Version: 0.4.9
 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
@@ -33,6 +33,7 @@ Requires-Dist: pyarrow<15.0.0,>=12.0.0; sys_platform == 'win32'
 Requires-Dist: pyarrow>=12.0.0; sys_platform == 'darwin'
 Requires-Dist: pyarrow>=16.0.0; sys_platform == 'linux' and python_version >= '3.12'
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7.0
 Requires-Dist: scikit-learn<2.0,>=1.2; sys_platform == 'linux' and python_version < '3.12'
 Requires-Dist: scikit-learn>=1.3.0; sys_platform == 'darwin'
 Requires-Dist: scikit-learn>=1.3.0; sys_platform == 'linux' and python_version >= '3.12'
@@ -43,7 +44,6 @@ Requires-Dist: scipy>=1.10.0; sys_platform == 'win32'
 Requires-Dist: scipy>=1.11.0; sys_platform == 'linux' and python_version >= '3.12'
 Requires-Dist: torch>=2.0.0
 Requires-Dist: torchvision>=0.15.0
-Requires-Dist: tqdm>=4.65.0
 Requires-Dist: transformers>=4.38.0
 Provides-Extra: dev
 Requires-Dist: jupyter>=1.0.0; extra == 'dev'
@@ -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.8-orange.svg)
+![Version](https://img.shields.io/badge/Version-0.4.9-orange.svg)
 
 中文文档 | [English Version](README_en.md)
 
@@ -99,7 +99,7 @@ NextRec是一个基于PyTorch的现代推荐系统框架，旨在为研究工程
 
 ## NextRec近期进展
 
-- **12/12/2025** 在v0.4.8中加入了[RQ-VAE](/nextrec/models/generative/rqvae.py)模块。配套的[数据集](/dataset/ecommerce_task.csv)和[代码](tutorials/notebooks/zh/使用RQ-VAE构建语义ID.ipynby)已经同步在仓库中
+- **12/12/2025** 在v0.4.9中加入了[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)
@@ -241,11 +241,11 @@ nextrec --mode=train --train_config=path/to/train_config.yaml
 nextrec --mode=predict --predict_config=path/to/predict_config.yaml
 ```
 
-> 截止当前版本0.4.8，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
+> 截止当前版本0.4.9，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
 
 ## 兼容平台
 
-当前最新版本为0.4.8，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
+当前最新版本为0.4.9，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
 
 | 平台 | 配置 | 
 |------|------|