layerdepth_stratified/dataset_loader.py

"""High-level API: load stratified metadata + LayeredDepth-Syn rows."""

from __future__ import annotations

from pathlib import Path
from typing import Dict, Iterator, List, Optional, Sequence

from .preprocess import DEFAULT_LAYER_IDS, preprocess_sample
from .stratified_sampling import build_epoch_order, load_manifest, split_order_by_rank

BASE_DATASET = "princeton-vl/LayeredDepth-Syn"


def load_metadata(repo_id: str, *, split: str = "train", token: str | None = None):
    from datasets import load_dataset

    return load_dataset(repo_id, split=split, token=token)


def load_base_dataset(*, split: str = "train", cache_dir: str | None = None, streaming: bool = False):
    from datasets import load_dataset

    kwargs = {"split": split, "streaming": streaming}
    if cache_dir:
        kwargs["cache_dir"] = cache_dir
    return load_dataset(BASE_DATASET, **kwargs)


def iter_stratified_epoch(
    *,
    manifest_path: str | Path,
    cache_dir: str | None = None,
    seed: int = 42,
    epoch: int = 0,
    rank: int = 0,
    world_size: int = 1,
    layer_ids: Sequence[int] = DEFAULT_LAYER_IDS,
    selected_layer_ids: Sequence[int] | None = None,
) -> Iterator[dict]:
    """Yield preprocessed samples in stratified epoch order."""
    buckets, batch_mix = load_manifest(manifest_path)
    order = build_epoch_order(buckets, batch_mix, seed=seed, epoch=epoch)
    order = split_order_by_rank(order, rank, world_size)

    base = load_base_dataset(split="train", cache_dir=cache_dir, streaming=False)
    for row_index in order:
        row = base[int(row_index)]
        sample = preprocess_sample(
            row,
            layer_ids=layer_ids,
            selected_layer_ids=selected_layer_ids,
        )
        sample["row_index"] = int(row_index)
        sample["epoch"] = int(epoch)
        yield sample


def iter_from_hub_metadata(
    repo_id: str,
    *,
    cache_dir: str | None = None,
    seed: int = 42,
    epoch: int = 0,
    rank: int = 0,
    world_size: int = 1,
    token: str | None = None,
) -> Iterator[dict]:
    """Load metadata from HF hub repo, then stream preprocessed base rows."""
    meta = load_metadata(repo_id, token=token)
    buckets: Dict[str, List[int]] = {str(i): [] for i in range(1, 5)}
    for row in meta:
        buckets[str(row["bucket"])].append(int(row["row_index"]))

    batch_mix = None
    manifest_file = Path(__file__).resolve().parents[1] / "metadata" / "bucket_manifest.json"
    if manifest_file.is_file():
        _, batch_mix = load_manifest(manifest_file)

    order = build_epoch_order(buckets, batch_mix, seed=seed, epoch=epoch)
    order = split_order_by_rank(order, rank, world_size)
    base = load_base_dataset(split="train", cache_dir=cache_dir, streaming=False)

    for row_index in order:
        sample = preprocess_sample(base[int(row_index)])
        sample["row_index"] = int(row_index)
        sample["epoch"] = int(epoch)
        yield sample