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

nextrec-0.4.9.dist-info/RECORD

@@ -0,0 +1,70 @@
+nextrec/__init__.py,sha256=_M3oUqyuvQ5k8Th_3wId6hQ_caclh7M5ad51XN09m98,235
+nextrec/__version__.py,sha256=LdxLMJM_JXsCQBeSvnxCNyGWmINE0yWfna3DQaT41Vs,22
+nextrec/cli.py,sha256=vumtNQww-FXgGa6I90IhEjngL1Y-e0GSuSK442s4M40,19209
+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=bQPRRIOGB_0PNJv3Zr-8mruUMBC7N2dmPWy7r3L45M4,98649
+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=D2QZDxc9Ic7zkSoaJQBxrjmbHWyJ8d3k0QF3IqLZxfk,18793
+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=EMAGhPCjJHmxpkoTWaioVgNt2yVB0PzGJpDc8cQlczs,5224
+nextrec/models/ranking/dien.py,sha256=c7Zs85vxhOgKHg5s0QcSLCn1xXCCSD177TMERgM_v8g,18958
+nextrec/models/ranking/din.py,sha256=gdUhuKiKXBNOALbK8fGhlbSeuDT8agcEdNSrC_wveHc,9422
+nextrec/models/ranking/eulernet.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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.9.dist-info/METADATA,sha256=FnndUmBNuNT6Odd_8XTlnW71NmqZ_Wr5lFNmxVwha1k,19463
+nextrec-0.4.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nextrec-0.4.9.dist-info/entry_points.txt,sha256=NN-dNSdfMRTv86bNXM7d3ZEPW2BQC6bRi7QP7i9cIps,45
+nextrec-0.4.9.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
+nextrec-0.4.9.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

nextrec/utils/distributed.py

@@ -1,141 +0,0 @@
-"""
-Distributed utilities for NextRec.
-
-Date: create on 04/12/2025
-Checkpoint: edit on 05/12/2025
-Author: Yang Zhou,zyaztec@gmail.com
-"""
-
-import logging
-import numpy as np
-import torch
-import torch.distributed as dist
-
-from torch.utils.data import DataLoader, IterableDataset
-from torch.utils.data.distributed import DistributedSampler
-from nextrec.basic.loggers import colorize
-
-
-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/utils/file.py

@@ -1,92 +0,0 @@
-"""
-File I/O utilities for NextRec
-
-Date: create on 03/12/2025
-Checkpoint: edit on 06/12/2025
-Author: Yang Zhou, zyaztec@gmail.com
-"""
-
-import yaml
-import pandas as pd
-import pyarrow.parquet as pq
-
-from pathlib import Path
-from typing import Generator
-
-
-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 {}

nextrec/utils/initializer.py

@@ -1,79 +0,0 @@
-"""
-Initialization utilities for NextRec
-
-Date: create on 13/11/2025
-Author: Yang Zhou, zyaztec@gmail.com
-"""
-
-from typing import Any, Dict, Set
-
-import torch.nn as nn
-
-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):
-    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

nextrec/utils/optimizer.py

@@ -1,75 +0,0 @@
-"""
-Optimizer and Scheduler utilities for NextRec
-
-Date: create on 13/11/2025
-Author: Yang Zhou, zyaztec@gmail.com
-"""
-
-import torch
-from typing import Iterable
-
-
-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

nextrec/utils/tensor.py

@@ -1,72 +0,0 @@
-"""
-Tensor manipulation utilities for NextRec
-
-Date: create on 03/12/2025
-Author: Yang Zhou, zyaztec@gmail.com
-"""
-
-import torch
-from typing import Any
-
-
-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