parquet_to_raw.py

"""
Convert a parquet-format HuggingFace dataset back to raw image files.

Input:  a local directory of .parquet shards  OR  an HF repo ID
Output: GSD-S/{split}/{images,masks,segs,segs_colored}/<image_id>.{jpg,png}
"""
import argparse
from pathlib import Path

from datasets import load_dataset, load_from_disk

# split -> (has_segs, has_segs_colored)
SPLITS = {
    "train": (True, True),
    "test":  (True, True),
}


def save_split(ds, split: str, has_segs: bool, has_segs_colored: bool, out_dir: Path):
    split_dir = out_dir / split
    img_dir         = split_dir / "images";      img_dir.mkdir(parents=True, exist_ok=True)
    mask_dir        = split_dir / "masks";       mask_dir.mkdir(parents=True, exist_ok=True)
    seg_dir         = split_dir / "segs"         if has_segs         else None
    seg_colored_dir = split_dir / "segs_colored" if has_segs_colored else None
    if seg_dir:         seg_dir.mkdir(parents=True, exist_ok=True)
    if seg_colored_dir: seg_colored_dir.mkdir(parents=True, exist_ok=True)

    for i, sample in enumerate(ds):
        stem = sample.get("image_id") or f"{i:06d}"

        sample["image"].save(img_dir  / f"{stem}.jpg")
        sample["mask"].save(mask_dir  / f"{stem}.png")

        if has_segs and sample.get("seg") is not None:
            sample["seg"].save(seg_dir / f"{stem}.png")
        if has_segs_colored and sample.get("seg_colored") is not None:
            sample["seg_colored"].save(seg_colored_dir / f"{stem}.png")

        if (i + 1) % 100 == 0:
            print(f"  {i + 1}/{len(ds)}")

    print(f"  saved {len(ds)} samples -> {split_dir}")


def main():
    parser = argparse.ArgumentParser(description="Convert parquet dataset to raw images")
    src = parser.add_mutually_exclusive_group(required=True)
    src.add_argument("--repo",  help="HuggingFace repo ID, e.g. garrying/GSD-S")
    src.add_argument("--local", help="Path to a directory saved with save_to_disk()")
    parser.add_argument("--out", default="GSD-S", help="Output root directory (default: ./GSD-S)")
    parser.add_argument("--splits", nargs="+", choices=list(SPLITS), default=list(SPLITS),
                        help="Which splits to convert (default: all)")
    args = parser.parse_args()

    out_dir = Path(args.out)
    out_dir.mkdir(parents=True, exist_ok=True)

    for split in args.splits:
        has_segs, has_segs_colored = SPLITS[split]
        print(f"\nLoading {split}...")

        if args.repo:
            ds = load_dataset(args.repo, split=split)
        else:
            ds = load_from_disk(str(Path(args.local) / split))

        print(f"  {len(ds)} samples — saving images...")
        save_split(ds, split, has_segs, has_segs_colored, out_dir)

    print(f"\nDone!  Raw files in: {out_dir.resolve()}")


if __name__ == "__main__":
    main()