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

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.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrec
-Version: 0.4.8
+Version: 0.4.10
 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.10-orange.svg)
 
 中文文档 | [English Version](README_en.md)
 
@@ -99,11 +99,10 @@ 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.10中加入了[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)
-- **23/11/2025** 在v0.2.2中对basemodel进行了逻辑上的大幅重构和流程统一，并且对listwise/pairwise/pointwise损失进行了统一
 - **11/11/2025** NextRec v0.1.0发布，我们提供了10余种Ranking模型，4种多任务模型和4种召回模型，以及统一的训练/日志/指标管理系统
 
 ## 架构
@@ -241,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.8，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
+> 截止当前版本0.4.10，NextRec CLI支持单机训练，分布式训练相关功能尚在开发中。
 
 ## 兼容平台
 
-当前最新版本为0.4.8，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
+当前最新版本为0.4.10，所有模型和测试代码均已在以下平台通过验证，如果开发者在使用中遇到兼容问题，请在issue区提出错误报告及系统版本：
 
 | 平台 | 配置 | 
 |------|------|

nextrec-0.4.10.dist-info/RECORD

@@ -0,0 +1,70 @@
+nextrec/__init__.py,sha256=_M3oUqyuvQ5k8Th_3wId6hQ_caclh7M5ad51XN09m98,235
+nextrec/__version__.py,sha256=N_k8mdXQaZTz0YYxAgWi2g6nf_GP6B5r8Q49Om9EynA,23
+nextrec/cli.py,sha256=PXRNXMRm_a_1u6StnjsHefq0rKqsc6Mzx3mZmc9553g,23803
+nextrec/basic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nextrec/basic/activation.py,sha256=uzTWfCOtBSkbu_Gk9XBNTj8__s241CaYLJk6l8nGX9I,2885
+nextrec/basic/callback.py,sha256=a6gg7r3x1v0xaOSya9PteLql7I14nepY7gX8tDYtins,14679
+nextrec/basic/features.py,sha256=Wnbzr7UMotgv1Vzeg0o9Po-KKIvYUSYIghoVDfMPx_g,4340
+nextrec/basic/layers.py,sha256=GJH2Tx3IkZrYGb7-ET976iHCC28Ubck_NO9-iyY4mDI,28911
+nextrec/basic/loggers.py,sha256=JnQiFvmsVgZ63gqBLR2ZFWrVPzkxRbzWhTdeoiJKcos,6526
+nextrec/basic/metrics.py,sha256=8RswR_3MGvIBkT_n6fnmON2eYH-hfD7kIKVnyJJjL3o,23131
+nextrec/basic/model.py,sha256=OCcV9nTAZukurRISzPGCQM5yJ0Fpph3vOMKb2CPkI68,98685
+nextrec/basic/session.py,sha256=UOG_-EgCOxvqZwCkiEd8sgNV2G1sm_HbzKYVQw8yYDI,4483
+nextrec/data/__init__.py,sha256=YZQjpty1pDCM7q_YNmiA2sa5kbujUw26ObLHWjMPjKY,1194
+nextrec/data/batch_utils.py,sha256=0bYGVX7RlhnHv_ZBaUngjDIpBNw-igCk98DgOsF7T6o,2879
+nextrec/data/data_processing.py,sha256=lKXDBszrO5fJMAQetgSPr2mSQuzOluuz1eHV4jp0TDU,5538
+nextrec/data/data_utils.py,sha256=0Ls1cnG9lBz0ovtyedw5vwp7WegGK_iF-F8e_3DEddo,880
+nextrec/data/dataloader.py,sha256=xTORNbaQVa20sk2S3kyV0SSngscvq8bNqHr0AmYjFqM,18768
+nextrec/data/preprocessor.py,sha256=wNjivq2N-iDzBropkp3YfSkN0jSA4l4h81C-ECa6k4c,44643
+nextrec/loss/__init__.py,sha256=-sibZK8QXLblVNWqdqjrPPzMCDyIXSq7yd2eZ57p9Nw,810
+nextrec/loss/listwise.py,sha256=UT9vJCOTOQLogVwaeTV7Z5uxIYnngGdxk-p9e97MGkU,5744
+nextrec/loss/loss_utils.py,sha256=Eg_EKm47onSCLhgs2q7IkB7TV9TwV1Dz4QgVR2yh-gc,4610
+nextrec/loss/pairwise.py,sha256=X9yg-8pcPt2IWU0AiUhWAt3_4W_3wIF0uSdDYTdoPFY,3398
+nextrec/loss/pointwise.py,sha256=o9J3OznY0hlbDsUXqn3k-BBzYiuUH5dopz8QBFqS_kQ,7343
+nextrec/models/generative/__init__.py,sha256=QtfMCu0-R7jg_HgjrUTP8ShWzXjQnPCpQjqpGwbMzp4,176
+nextrec/models/generative/hstu.py,sha256=P2Kl7HEL3afwiCApGKQ6UbUNO9eNXXrB10H7iiF8cI0,19735
+nextrec/models/generative/tiger.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nextrec/models/multi_task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nextrec/models/multi_task/esmm.py,sha256=3QQePhSkOcM4t472S4E5xU9_KiLiSwHb9CfdkEgmqqk,6491
+nextrec/models/multi_task/mmoe.py,sha256=uFTbc0MiFBDTCIt8mTW6xs0oyOn1EesIHHZo81HR35k,8583
+nextrec/models/multi_task/ple.py,sha256=z32etizNlTLwwR7CYKxy8u9owAbtiRh492Fje_y64hQ,13016
+nextrec/models/multi_task/poso.py,sha256=foH7XDUz0XN0s0zoyHLuTmrcs3QOT8-x4YGxLX1Lxxg,19016
+nextrec/models/multi_task/share_bottom.py,sha256=rmEnsX3LA3pNsLKfG1ir5WDLdkSY-imO_ASiclirJiA,6519
+nextrec/models/ranking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nextrec/models/ranking/afm.py,sha256=96jGUPL4yTWobMIVBjHpOxl9AtAzCAGR8yw7Sy2JmdQ,10125
+nextrec/models/ranking/autoint.py,sha256=S6Cxnp1q2OErSYqmIix5P-b4qLWR-0dY6TMStuU6WLg,8109
+nextrec/models/ranking/dcn.py,sha256=whkjiKEuadl6oSP-NJdSOCOqvWZGX4EsId9oqlfVpa8,7299
+nextrec/models/ranking/dcn_v2.py,sha256=QnqQbJsrtQp4mtvnBXFUVefKyr4dw-gHNWrCbO26oHw,11163
+nextrec/models/ranking/deepfm.py,sha256=aXoK59e2KaaPe5vfyFW4YiHbX4E2iG3gxFCxmWo8RHk,5200
+nextrec/models/ranking/dien.py,sha256=c7Zs85vxhOgKHg5s0QcSLCn1xXCCSD177TMERgM_v8g,18958
+nextrec/models/ranking/din.py,sha256=gdUhuKiKXBNOALbK8fGhlbSeuDT8agcEdNSrC_wveHc,9422
+nextrec/models/ranking/eulernet.py,sha256=mZTrD8rKbGbWMEeWpTl8mVimytLFJTLM5-LS_I3U6cw,13115
+nextrec/models/ranking/ffm.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nextrec/models/ranking/fibinet.py,sha256=_eroddVHooJcaGT8MqS4mUrtv5j4pnTmfI3FoAKOZhs,7919
+nextrec/models/ranking/fm.py,sha256=SsrSKK3y4xg5Lv-t3JLnZan55Hzze2AxAiVPuscy0bk,4536
+nextrec/models/ranking/lr.py,sha256=Qf8RozgWlsKjHGVbo-94d2Z_4kMfCXHmvwkYu3WVZjQ,4030
+nextrec/models/ranking/masknet.py,sha256=tY1y2lO0iq82oylPN0SBnL5Bikc8weinFXpURyVT1hE,12373
+nextrec/models/ranking/pnn.py,sha256=FcNIFAw5J0ORGSR6L8ZK7NeXlJPpojwe_SpsxMQqCFw,8174
+nextrec/models/ranking/widedeep.py,sha256=-ghKfe_0puvlI9fBQr8lK3gXkfVvslGwP40AJTGqc7w,5077
+nextrec/models/ranking/xdeepfm.py,sha256=FMtl_zYO1Ty_2d9VWRsz6Jo-Xjw8vikpIQPZCDVavVY,8156
+nextrec/models/representation/__init__.py,sha256=O3QHMMXBszwM-mTl7bA3wawNZvDGet-QIv6Ys5GHGJ8,190
+nextrec/models/representation/rqvae.py,sha256=JyZxVY9CibcdBGk97TxjG5O3WQC10_60tHNcP_qtegs,29290
+nextrec/models/retrieval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nextrec/models/retrieval/dssm.py,sha256=yMTu9msn6WgPqpM_zaJ0Z8R3uAYPzuJY_NS0xjJGSx0,8043
+nextrec/models/retrieval/dssm_v2.py,sha256=IJzCT78Ra1DeSpR85KF1Awqnywu_6kDko3XDPbcup5s,7075
+nextrec/models/retrieval/mind.py,sha256=ktNXwZxhnH1DV08c0gdsbodo4QJQL4UQGeyOqpmGwVM,15090
+nextrec/models/retrieval/sdm.py,sha256=LhkCZSfGhxOxziEkUtjr_hnqcyciJ2qpMoBSFBVW9lQ,10558
+nextrec/models/retrieval/youtube_dnn.py,sha256=xtGPV6_5LeSZBKkrTaU1CmtxlhgYLvZmjpwYaXYIaEA,7403
+nextrec/utils/__init__.py,sha256=5ss2XQq8QZ2Ko5eiQ7oIig5cIZNrYGIptaarYEeO7Fk,2550
+nextrec/utils/config.py,sha256=0HOeMyTlx8g6BZVpXzo2lEOkb-mzNwhbigQuUomsYnY,19934
+nextrec/utils/console.py,sha256=D2Vax9_b7bgvAAOyk-Q2oUhSk1B-OngY5buS9Gb9-I0,11398
+nextrec/utils/data.py,sha256=alruiWZFbmwy3kO12q42VXmtHmXFFjVULpHa43fx_mI,21098
+nextrec/utils/embedding.py,sha256=akAEc062MG2cD7VIOllHaqtwzAirQR2gq5iW7oKpGAU,1449
+nextrec/utils/feature.py,sha256=rsUAv3ELyDpehVw8nPEEsLCCIjuKGTJJZuFaWB_wrPk,633
+nextrec/utils/model.py,sha256=dYl1XfIZt6aVjNyV2AAhcArwFRMcEAKrjG_pr8AVHs0,1163
+nextrec/utils/torch_utils.py,sha256=AKfYbSOJjEw874xsDB5IO3Ote4X7vnqzt_E0jJny0o8,13468
+nextrec-0.4.10.dist-info/METADATA,sha256=b7ILFNk7WRZCg_2ZCx7_SWdU_d3mzN2b5IWTCnB0mbg,19318
+nextrec-0.4.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nextrec-0.4.10.dist-info/entry_points.txt,sha256=NN-dNSdfMRTv86bNXM7d3ZEPW2BQC6bRi7QP7i9cIps,45
+nextrec-0.4.10.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
+nextrec-0.4.10.dist-info/RECORD,,

nextrec/utils/cli_utils.py

@@ -1,58 +0,0 @@
-"""
-CLI utilities for NextRec.
-
-This module provides small helpers used by command-line entrypoints, such as
-printing startup banners and resolving the installed package version.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import platform
-import sys
-from datetime import datetime
-
-
-def get_nextrec_version() -> str:
-    """
-    Best-effort version resolver for NextRec.
-
-    Prefer in-repo `nextrec.__version__`, fall back to installed package metadata.
-    """
-    try:
-        from nextrec import __version__  # type: ignore
-
-        if __version__:
-            return str(__version__)
-    except Exception:
-        pass
-
-    try:
-        from importlib.metadata import version
-
-        return version("nextrec")
-    except Exception:
-        return "unknown"
-
-
-def log_startup_info(
-    logger: logging.Logger, *, mode: str, config_path: str | None
-) -> None:
-    """Log a short, user-friendly startup banner."""
-    version = get_nextrec_version()
-    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-    lines = [
-        "NextRec CLI",
-        f"- Version: {version}",
-        f"- Time: {now}",
-        f"- Mode: {mode}",
-        f"- Config: {config_path or '(not set)'}",
-        f"- Python: {platform.python_version()} ({sys.executable})",
-        f"- Platform: {platform.system()} {platform.release()} ({platform.machine()})",
-        f"- Workdir: {os.getcwd()}",
-        f"- Command: {' '.join(sys.argv)}",
-    ]
-    for line in lines:
-        logger.info(line)

nextrec/utils/device.py

@@ -1,78 +0,0 @@
-"""
-Device management utilities for NextRec
-
-Date: create on 03/12/2025
-Checkpoint: edit on 06/12/2025
-Author: Yang Zhou, zyaztec@gmail.com
-"""
-
-import torch
-import platform
-import logging
-
-
-def resolve_device() -> str:
-    if torch.cuda.is_available():
-        return "cuda"
-    if torch.backends.mps.is_available():
-        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")
-        else:
-            return torch.device("cpu")
-    return device