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

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

nextrec-0.4.8.dist-info/RECORD

@@ -1,71 +0,0 @@
-nextrec/__init__.py,sha256=_M3oUqyuvQ5k8Th_3wId6hQ_caclh7M5ad51XN09m98,235
-nextrec/__version__.py,sha256=40-PUZPRIakJU2yYWQcwTYvSJA6iewqiG8XylhxuAQk,22
-nextrec/cli.py,sha256=ItikUEFDju7c_3tDhYQuNPbhvFK6jij9zAujR_MYYK8,19388
-nextrec/basic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nextrec/basic/activation.py,sha256=uzTWfCOtBSkbu_Gk9XBNTj8__s241CaYLJk6l8nGX9I,2885
-nextrec/basic/callback.py,sha256=lELZhkB1TlAT_5My7Ce41u7Rox73rbyaulykWCk-svo,14108
-nextrec/basic/features.py,sha256=kfgU3gCORjYD7ylmKJDrWIrRIL97GcKWCDWeULU5N7g,4339
-nextrec/basic/layers.py,sha256=jDT6nnpCxdgzKMdhU-apxPgjHm-AHujRxjgBum4mBm0,29017
-nextrec/basic/loggers.py,sha256=p9wNmLuRYyvHsOzP0eNOYSlV3hrTDjrt6ggrH_r4RE0,6243
-nextrec/basic/metrics.py,sha256=EicHCyyr2j45J-emHf5KifQN6fnb6IV6gqEBu7ioANQ,26066
-nextrec/basic/model.py,sha256=tYpQAbeW99aXTrsmryoWe9sA8ihG8pHNytRcU_49-pQ,100764
-nextrec/basic/session.py,sha256=UOG_-EgCOxvqZwCkiEd8sgNV2G1sm_HbzKYVQw8yYDI,4483
-nextrec/data/__init__.py,sha256=auT_PkbgU9pUCt7KQl6H2ajcUorRhSyHa8NG3wExcG8,1197
-nextrec/data/batch_utils.py,sha256=FAJiweuDyAIzX7rICVmcxMofdFs2-7RLinovwB-lAYM,2878
-nextrec/data/data_processing.py,sha256=lnpJWqa5KwxxtlDPJ5PsVtO9uKke0u4OaJJvgudjRXI,5302
-nextrec/data/data_utils.py,sha256=LaVNXATcqu0ARPV-6WESQz6JXi3g-zq4uKjcoqBFlqI,1219
-nextrec/data/dataloader.py,sha256=L4VBpWUZrxozFBV54nhJAAC-ZX5Hg6zFwIwpGnguJ9c,18789
-nextrec/data/preprocessor.py,sha256=BxoD6GHEre86i-TbxPi58Uwmg_G7oLkiER6f7VfmVHo,41583
-nextrec/loss/__init__.py,sha256=mO5t417BneZ8Ysa51GyjDaffjWyjzFgPXIQrrggasaQ,827
-nextrec/loss/listwise.py,sha256=UT9vJCOTOQLogVwaeTV7Z5uxIYnngGdxk-p9e97MGkU,5744
-nextrec/loss/loss_utils.py,sha256=8lGJpiJ7GYplUdQqJL5XzHIiQr98g5pRb2cTYdS5VLA,4646
-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=RU4DRibbfK802rzSXIgf3mSwYsSsYLKJiPzcXqprbvY,350
-nextrec/models/generative/hstu.py,sha256=ro0ifzvlS0SQaS1PMVDjvGDBgql5RnWEPGCu_iRtMrQ,19605
-nextrec/models/generative/rqvae.py,sha256=yxZ9KNEjRu0yxBjeNtCa2Y0ElB97diV_Z92CS9hbhzE,29255
-nextrec/models/generative/tiger.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nextrec/models/match/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nextrec/models/match/dssm.py,sha256=W6oBOEMGT-xYvhd-qzmGpYqxm9B-fwIQaXE7nEw2gfI,7923
-nextrec/models/match/dssm_v2.py,sha256=I2eWWyzFd7nIiShOB7VPxNMLoqST5IY98WxjDyvAGa8,6955
-nextrec/models/match/mind.py,sha256=semg4EEThD4l7K8fW1wuRF3i9Ex-smJVI4CNORVajvA,15089
-nextrec/models/match/sdm.py,sha256=kwDjDkFpoTmicfKScXjhJLe500upbg8eDXICQLMW03k,10557
-nextrec/models/match/youtube_dnn.py,sha256=-XuaM7lh02qkLCwJF3KgWxOQGn61p92MnYA100LWG4o,7283
-nextrec/models/multi_task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nextrec/models/multi_task/esmm.py,sha256=tQg_jE51VDTyc-F0auviyP8CI9uzYQ_KjybbCAXWp1s,6491
-nextrec/models/multi_task/mmoe.py,sha256=qFWKdCE_VSGpVrMgx0NOO-HtLRNGdVxCWdkMfoEgjLA,8583
-nextrec/models/multi_task/ple.py,sha256=SMTgKqz8huXzmyMwACVG8yisHvd3GFGshYl7LOpnJXs,13016
-nextrec/models/multi_task/poso.py,sha256=JkNlMcqjMuE4PTGM6HeGcJTxhbLklXpusfyY8A1BjTQ,19017
-nextrec/models/multi_task/share_bottom.py,sha256=mkWaGHimUqp-2dmPHXjb5ffxX7ixv1BF0gQXTbx9kBo,6519
-nextrec/models/ranking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nextrec/models/ranking/afm.py,sha256=XaiUYm36-pVNzB31lEtMstjg42-shn94khja0LMQB3s,10125
-nextrec/models/ranking/autoint.py,sha256=CyHnYyHJiQIOiPGI-j_16nCpECDQJ3FlVZ4nq3qu-l8,8109
-nextrec/models/ranking/dcn.py,sha256=vxbrDu9RxXznXNpXVeYJR4wdxoc4Vo0ygML6fFArY18,7299
-nextrec/models/ranking/dcn_v2.py,sha256=VNMiHf6BeBOxnoommjGZfF-9t_B88niiVEgmPVcGjQM,11163
-nextrec/models/ranking/deepfm.py,sha256=D9RPM40QAhogw8_RAOfE3JD1gnGf4F3-gXR40EZq-RU,5224
-nextrec/models/ranking/dien.py,sha256=G1W_pj8XyGBPgZo_86I3LgfHzQvR-xvR-PGNJZdRdAM,18958
-nextrec/models/ranking/din.py,sha256=gcibKTxK6nQCCxYMymO9ttu3UG2MSrOWRNBPCmJgMEM,9422
-nextrec/models/ranking/fibinet.py,sha256=OuE4MoG7rHycyRRQtKOvxHbuf7C6zoJFxGFerXmmn9U,7919
-nextrec/models/ranking/fm.py,sha256=ko_Eao9UfklakEk_TVEFZSyVAojmtclo1uIMBhL4FLU,4525
-nextrec/models/ranking/masknet.py,sha256=JqBSW1Wh_-P2OoEPss4FBhFdsBfTJYBsj9RR0Eoy6pk,12373
-nextrec/models/ranking/pnn.py,sha256=twwixy26mfAVaI9AqNnMLdwOG-WtDga60xsNiyJrFjI,8174
-nextrec/models/ranking/widedeep.py,sha256=Xm2klmKBOoSKWCBQN7FhwLStu0BHSTOgAJ9kwLmtiFY,5077
-nextrec/models/ranking/xdeepfm.py,sha256=kcPLoNC1940YxRMgWZS4mSxIXlwtc_HfNDIae_uYrsU,8156
-nextrec/utils/__init__.py,sha256=zqU9vjRUpVzJepcvdbxboik68K5jnMR40kdVjr6tpXY,2599
-nextrec/utils/cli_utils.py,sha256=mOI2yKZwCE3lVH5RCKs3WnIKyXYiLI08vHFT8duBRrQ,1497
-nextrec/utils/config.py,sha256=wx2Y-oxQqWhwOlW6DdG6ExLXDf-QDRnj8EQYDjrVhuY,19903
-nextrec/utils/device.py,sha256=DtgmrJnVJQKtgtVUbm0SW0vZ5Le0R9HU8TsvqPnRLZc,2453
-nextrec/utils/distributed.py,sha256=tIkgUjzEjR_FHOm9ckyM8KddkCfxNSogP-rdHcVGhuk,4782
-nextrec/utils/embedding.py,sha256=akAEc062MG2cD7VIOllHaqtwzAirQR2gq5iW7oKpGAU,1449
-nextrec/utils/feature.py,sha256=LcXaWP98zMZhJTKL92VVHX8mqOE5Q0MyVq3hw5Z9kxs,300
-nextrec/utils/file.py,sha256=s2cO1LRbU7xPeAbVoOA6XOoV6wvLrW6oy6p9fVSz9pc,3024
-nextrec/utils/initializer.py,sha256=sEkP5DUQ4x2Cydc2h5MoGzBhLr-4tt6x6bqTO2f0TyE,2206
-nextrec/utils/model.py,sha256=dYl1XfIZt6aVjNyV2AAhcArwFRMcEAKrjG_pr8AVHs0,1163
-nextrec/utils/optimizer.py,sha256=eX8baIvWOpwDTGninbyp6pQfzdHbIL62GTi4ldpYcfM,2337
-nextrec/utils/synthetic_data.py,sha256=V6lxEQCU-yJXMBCoCAeKZZWBMYXpZhvbyfiI8jCmvqs,18112
-nextrec/utils/tensor.py,sha256=Z6MBpSuQpHw4kGjeKxG0cXZMpRBCM45zTKhk9WolyiM,2220
-nextrec-0.4.8.dist-info/METADATA,sha256=25dlzG2TNFZCvm_V6ZAnqaMTL6qwNNt7xMSRsmaQ_Nk,19460
-nextrec-0.4.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nextrec-0.4.8.dist-info/entry_points.txt,sha256=NN-dNSdfMRTv86bNXM7d3ZEPW2BQC6bRi7QP7i9cIps,45
-nextrec-0.4.8.dist-info/licenses/LICENSE,sha256=2fQfVKeafywkni7MYHyClC6RGGC3laLTXCNBx-ubtp0,1064
-nextrec-0.4.8.dist-info/RECORD,,