Upload 4 files

format_detector.py

@@ -0,0 +1,258 @@
+"""
+format_detector.py
+==================
+Auto-detects:
+  - File format  (parquet, tar/webdataset, zip, arrow, jsonl, image folder)
+  - Image field  (image, img, jpeg, png, pixel_values, …)
+  - Caption field (caption, text, prompt, label, description, …)
+
+Used by ingest_universal.py — import and call detect().
+"""
+
+import os
+import io
+import json
+import tarfile
+import zipfile
+import struct
+from pathlib import Path
+from typing import Optional
+
+from PIL import Image
+
+
+# ── Known field names ─────────────────────────────────────────────────────────
+IMAGE_FIELDS   = ["image", "img", "jpeg", "png", "gif", "webp",
+                  "pixel_values", "image_bytes", "image_data",
+                  "bytes", "data", "photo", "thumbnail"]
+
+CAPTION_FIELDS = ["caption", "text", "prompt", "label", "description",
+                  "title", "alt", "alt_text", "sentence", "query",
+                  "blip_caption", "llava_caption", "cogvlm_caption",
+                  "tag", "tags", "keyword", "keywords"]
+
+
+# ── Format signatures ─────────────────────────────────────────────────────────
+MAGIC = {
+    b"\x50\x4b\x03\x04": "zip",
+    b"\x1f\x8b":         "tar.gz",
+    b"PAR1":             "parquet",
+    b"\x41\x52\x52\x4f": "arrow",   # ARROW1
+}
+
+
+def sniff_bytes(path: str) -> Optional[str]:
+    with open(path, "rb") as f:
+        header = f.read(8)
+    for magic, fmt in MAGIC.items():
+        if header[:len(magic)] == magic:
+            return fmt
+    # Bare tar (no gzip)
+    if tarfile.is_tarfile(path):
+        return "tar"
+    return None
+
+
+# ── Per-format sample readers ─────────────────────────────────────────────────
+def _sample_parquet(path: str) -> dict:
+    import pyarrow.parquet as pq
+    tbl = pq.read_table(path, memory_map=True).slice(0, 1)
+    row = {col: tbl.column(col)[0].as_py() for col in tbl.schema.names}
+    return row
+
+
+def _sample_arrow(path: str) -> dict:
+    import pyarrow as pa
+    with pa.memory_map(path, "r") as src:
+        reader = pa.ipc.open_file(src)
+        batch  = reader.get_batch(0)
+    row = {col: batch.column(col)[0].as_py() for col in batch.schema.names}
+    return row
+
+
+def _sample_tar(path: str) -> dict:
+    """
+    WebDataset tars group files by key:
+      000000.jpg  000000.txt  000000.json …
+    We read enough members to reconstruct one sample dict.
+    """
+    sample = {}
+    current_key = None
+    with tarfile.open(path, "r:*") as tf:
+        for member in tf:
+            if member.isdir():
+                continue
+            stem, ext = os.path.splitext(os.path.basename(member.name))
+            ext = ext.lstrip(".").lower()
+            if current_key is None:
+                current_key = stem
+            if stem != current_key:
+                break          # moved to next sample
+            fobj = tf.extractfile(member)
+            if fobj is None:
+                continue
+            raw = fobj.read()
+            if ext in ("jpg", "jpeg", "png", "gif", "webp", "bmp"):
+                sample["__image_bytes__"] = raw
+                sample["image"] = Image.open(io.BytesIO(raw))
+            elif ext in ("txt",):
+                sample["caption"] = raw.decode("utf-8", errors="replace").strip()
+            elif ext in ("json",):
+                try:
+                    d = json.loads(raw)
+                    sample.update(d)
+                except Exception:
+                    pass
+            else:
+                sample[ext] = raw
+    return sample
+
+
+def _sample_zip(path: str) -> dict:
+    sample = {}
+    with zipfile.ZipFile(path) as zf:
+        names = zf.namelist()
+        # Find first image file
+        for name in names:
+            ext = Path(name).suffix.lower().lstrip(".")
+            if ext in ("jpg", "jpeg", "png", "gif", "webp"):
+                raw = zf.read(name)
+                sample["image"] = Image.open(io.BytesIO(raw))
+                # Look for sibling caption file
+                stem = Path(name).stem
+                for cap_ext in ("txt", "caption"):
+                    cap_name = f"{stem}.{cap_ext}"
+                    if cap_name in names:
+                        sample["caption"] = zf.read(cap_name).decode("utf-8", errors="replace").strip()
+                # Also check for a metadata JSON
+                for json_name in (f"{stem}.json", "metadata.json", "captions.json"):
+                    if json_name in names:
+                        try:
+                            d = json.loads(zf.read(json_name))
+                            sample.update(d)
+                        except Exception:
+                            pass
+                break
+    return sample
+
+
+def _sample_jsonl(path: str) -> dict:
+    with open(path) as f:
+        line = f.readline()
+    return json.loads(line)
+
+
+def _sample_image_folder(path: str) -> dict:
+    """path is a directory; find first image + sibling txt."""
+    for root, _, files in os.walk(path):
+        for fname in sorted(files):
+            ext = Path(fname).suffix.lower().lstrip(".")
+            if ext in ("jpg", "jpeg", "png", "gif", "webp"):
+                img_path = os.path.join(root, fname)
+                sample = {"image": Image.open(img_path)}
+                txt = os.path.join(root, Path(fname).stem + ".txt")
+                if os.path.exists(txt):
+                    sample["caption"] = open(txt).read().strip()
+                return sample
+    return {}
+
+
+# ── Field detection ───────────────────────────────────────────────────────────
+def _is_image_value(v) -> bool:
+    if isinstance(v, Image.Image):
+        return True
+    if isinstance(v, bytes):
+        try:
+            Image.open(io.BytesIO(v))
+            return True
+        except Exception:
+            return False
+    if isinstance(v, dict) and "bytes" in v:
+        return _is_image_value(v["bytes"])
+    return False
+
+
+def detect_fields(sample: dict) -> tuple[Optional[str], Optional[str]]:
+    """Return (image_field, caption_field) from a sample dict."""
+    image_field   = None
+    caption_field = None
+
+    # Priority: known names first, then any field whose value looks like an image
+    for name in IMAGE_FIELDS:
+        if name in sample and _is_image_value(sample[name]):
+            image_field = name
+            break
+    if image_field is None:
+        for k, v in sample.items():
+            if _is_image_value(v):
+                image_field = k
+                break
+
+    for name in CAPTION_FIELDS:
+        if name in sample and isinstance(sample[name], str):
+            caption_field = name
+            break
+    if caption_field is None:
+        for k, v in sample.items():
+            if k != image_field and isinstance(v, str) and len(v) > 1:
+                caption_field = k
+                break
+
+    return image_field, caption_field
+
+
+# ── Main entry ────────────────────────────────────────────────────────────────
+class DatasetInfo:
+    def __init__(self, fmt, image_field, caption_field, sample):
+        self.fmt           = fmt            # "parquet" | "tar" | "zip" | "arrow" | "jsonl" | "folder" | "hf_streaming"
+        self.image_field   = image_field
+        self.caption_field = caption_field
+        self.sample        = sample
+
+    def __repr__(self):
+        return (f"DatasetInfo(fmt={self.fmt!r}, "
+                f"image_field={self.image_field!r}, "
+                f"caption_field={self.caption_field!r})")
+
+
+def detect(path: str) -> DatasetInfo:
+    """
+    Detect format + fields for a single file or directory.
+    Returns a DatasetInfo object.
+    """
+    if os.path.isdir(path):
+        fmt    = "folder"
+        sample = _sample_image_folder(path)
+    else:
+        ext = Path(path).suffix.lower()
+        sniffed = sniff_bytes(path)
+        fmt = sniffed or ext.lstrip(".")
+
+        if fmt == "parquet":
+            sample = _sample_parquet(path)
+        elif fmt in ("tar", "tar.gz"):
+            sample = _sample_tar(path)
+        elif fmt == "zip":
+            sample = _sample_zip(path)
+        elif fmt == "arrow":
+            sample = _sample_arrow(path)
+        elif ext in (".jsonl", ".json"):
+            fmt    = "jsonl"
+            sample = _sample_jsonl(path)
+        else:
+            # Unknown — try HF datasets as last resort
+            fmt    = "hf_streaming"
+            sample = {}
+
+    img_f, cap_f = detect_fields(sample)
+    return DatasetInfo(fmt, img_f, cap_f, sample)
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python format_detector.py <file_or_dir>")
+        sys.exit(1)
+    info = detect(sys.argv[1])
+    print(info)
+    print(f"  Fields in sample: {list(info.sample.keys())}")

ingest_universal.py

@@ -0,0 +1,622 @@
+"""
+ingest_universal.py
+===================
+Universal shard worker — handles ANY HuggingFace image dataset format:
+
+  ✓ Parquet          (.parquet)
+  ✓ WebDataset tar   (.tar, .tar.gz, .tgz)
+  ✓ ZIP archives     (.zip)
+  ✓ Arrow IPC        (.arrow)
+  ✓ JSON Lines       (.jsonl, .json)
+  ✓ Image folder     (directory of jpg/png + txt sibling files)
+  ✓ HF Streaming     (fallback for anything else via datasets library)
+
+Auto-detects image field and caption field from the first sample.
+Can be overridden via --image-field and --caption-field flags.
+
+Usage
+-----
+    # Auto-detect everything
+    python ingest_universal.py --shard-file train-00001.parquet --shard-idx 1
+
+    # WebDataset tar
+    python ingest_universal.py --shard-file 00001.tar --shard-idx 1
+
+    # ZIP archive
+    python ingest_universal.py --shard-file images.zip --shard-idx 0
+
+    # HF streaming fallback
+    python ingest_universal.py --hf-dataset laion/laion400m --shard-idx 0
+
+    # Override detected fields
+    python ingest_universal.py --shard-file f.parquet --image-field pixel_values --caption-field blip_caption
+"""
+
+import os
+import io
+import json
+import time
+import fcntl
+import tarfile
+import zipfile
+import argparse
+import traceback
+from pathlib import Path
+from typing import Iterator, Optional
+
+import torch
+import torchvision.transforms as T
+from PIL import Image
+from tqdm import tqdm
+from diffusers import AutoencoderKL
+
+from format_detector import detect, DatasetInfo, IMAGE_FIELDS, CAPTION_FIELDS
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+def parse_args():
+    p = argparse.ArgumentParser(description="Universal HF image dataset ingest worker")
+
+    src = p.add_mutually_exclusive_group(required=True)
+    src.add_argument("--shard-file",   help="Path to local shard file or directory")
+    src.add_argument("--hf-dataset",   help="HuggingFace dataset name (streaming fallback)")
+
+    p.add_argument("--hf-split",       default="train")
+    p.add_argument("--shard-idx",      type=int, default=0)
+    p.add_argument("--total-shards",   type=int, default=1)
+    p.add_argument("--base-dir",       default="/workspace/hem/dataset_output")
+    p.add_argument("--vae-model",      default="stabilityai/sd-vae-ft-ema")
+    p.add_argument("--resolutions",    type=int, nargs="+", default=[256, 512])
+    p.add_argument("--shard-size",     type=int, default=1000)
+    p.add_argument("--no-latents",     action="store_true")
+    p.add_argument("--no-originals",   action="store_true")
+    p.add_argument("--max-samples",    type=int, default=None)
+    p.add_argument("--flush-every",    type=int, default=200)
+    p.add_argument("--cuda-device",    type=int, default=0)
+    p.add_argument("--image-field",    default=None, help="Override auto-detected image field")
+    p.add_argument("--caption-field",  default=None, help="Override auto-detected caption field")
+    p.add_argument("--detect-only",    action="store_true", help="Print detected format/fields and exit")
+    return p.parse_args()
+
+
+# ── Path helpers ──────────────────────────────────────────────────────────────
+class Paths:
+    def __init__(self, base_dir, resolutions):
+        self.base   = base_dir
+        self.resols = resolutions
+
+    def img_dir(self, res):   return os.path.join(self.base, "images", f"{res}x{res}")
+    def orig_dir(self):       return os.path.join(self.base, "images", "original")
+    def lat_dir(self, res):   return os.path.join(self.base, "latents", f"sd-vae-{res}")
+    def captions_file(self):  return os.path.join(self.base, "captions", "captions.json")
+    def shards_dir(self):     return os.path.join(self.base, "captions", "shards")
+    def meta_file(self):      return os.path.join(self.base, "metadata", "dataset_info.json")
+    def logs_dir(self):       return os.path.join(self.base, "metadata", "processing_logs")
+
+    def failed_file(self, idx):
+        return os.path.join(self.logs_dir(), f"failed_shard_{idx:06d}.json")
+
+    def worker_caps_file(self, idx):
+        return os.path.join(self.logs_dir(), f"captions_shard_{idx:06d}.json")
+
+    @staticmethod
+    def bucket(stem): return stem[:3]
+
+    def img_path(self, res, stem):
+        return os.path.join(self.img_dir(res), self.bucket(stem), f"{stem}.jpg")
+
+    def orig_path(self, stem):
+        return os.path.join(self.orig_dir(), self.bucket(stem), f"{stem}.jpg")
+
+    def lat_path(self, res, stem):
+        return os.path.join(self.lat_dir(res), self.bucket(stem), f"{stem}.pt")
+
+    def ensure_dirs(self, stem):
+        b = self.bucket(stem)
+        for res in self.resols:
+            os.makedirs(os.path.join(self.img_dir(res), b), exist_ok=True)
+            os.makedirs(os.path.join(self.lat_dir(res), b), exist_ok=True)
+        os.makedirs(os.path.join(self.orig_dir(), b), exist_ok=True)
+
+    def ensure_global_dirs(self):
+        os.makedirs(os.path.join(self.base, "captions", "shards"), exist_ok=True)
+        os.makedirs(os.path.join(self.base, "metadata", "processing_logs"), exist_ok=True)
+        for res in self.resols:
+            os.makedirs(self.img_dir(res), exist_ok=True)
+            os.makedirs(self.lat_dir(res), exist_ok=True)
+        os.makedirs(self.orig_dir(), exist_ok=True)
+
+
+# ── State helpers ─────────────────────────────────────────────────────────────
+def load_global_done(paths):
+    cf = paths.captions_file()
+    if os.path.exists(cf) and os.path.getsize(cf) > 2:
+        with open(cf) as f:
+            return set(json.load(f).keys())
+    return set()
+
+
+def load_worker_state(paths, idx):
+    wf = paths.worker_caps_file(idx)
+    ff = paths.failed_file(idx)
+    caps = {}
+    if os.path.exists(wf) and os.path.getsize(wf) > 2:
+        with open(wf) as f:
+            caps = json.load(f)
+    failed = set()
+    if os.path.exists(ff) and os.path.getsize(ff) > 2:
+        with open(ff) as f:
+            failed = set(json.load(f))
+    return caps, failed
+
+
+def flush_worker(paths, idx, caps, failed):
+    with open(paths.worker_caps_file(idx), "w") as f:
+        json.dump(caps, f, ensure_ascii=False)
+    with open(paths.failed_file(idx), "w") as f:
+        json.dump(sorted(failed), f, indent=2)
+
+
+def merge_to_global(paths, idx):
+    wf = paths.worker_caps_file(idx)
+    if not os.path.exists(wf):
+        return
+    with open(wf) as f:
+        worker = json.load(f)
+    cf   = paths.captions_file()
+    lock = cf + ".lock"
+    with open(lock, "w") as lk:
+        fcntl.flock(lk, fcntl.LOCK_EX)
+        try:
+            g = {}
+            if os.path.exists(cf) and os.path.getsize(cf) > 2:
+                with open(cf) as f:
+                    g = json.load(f)
+            g.update(worker)
+            tmp = cf + ".tmp"
+            with open(tmp, "w") as f:
+                json.dump(g, f, ensure_ascii=False)
+            os.replace(tmp, cf)
+        finally:
+            fcntl.flock(lk, fcntl.LOCK_UN)
+    print(f"[shard {idx:06d}] Merged {len(worker):,} captions → global file")
+
+
+def save_subshard(paths, idx, sub_idx, data):
+    p = os.path.join(paths.shards_dir(), f"shard_{idx:06d}_{sub_idx:04d}.json")
+    with open(p, "w") as f:
+        json.dump(data, f, ensure_ascii=False)
+
+
+def update_meta(paths, processed, errors):
+    mf   = paths.meta_file()
+    lock = mf + ".lock"
+    os.makedirs(os.path.dirname(mf), exist_ok=True)
+    with open(lock, "w") as lk:
+        fcntl.flock(lk, fcntl.LOCK_EX)
+        try:
+            info = {}
+            if os.path.exists(mf) and os.path.getsize(mf) > 2:
+                with open(mf) as f:
+                    info = json.load(f)
+            info["processed_count"] = info.get("processed_count", 0) + processed
+            info["failed_count"]    = info.get("failed_count",    0) + errors
+            info["last_run"]        = time.strftime("%Y-%m-%dT%H:%M:%S")
+            with open(mf, "w") as f:
+                json.dump(info, f, indent=2)
+        finally:
+            fcntl.flock(lk, fcntl.LOCK_UN)
+
+
+# ── Image helpers ─────────────────────────────────────────────────────────────
+def build_vae_transforms(resolutions):
+    return {
+        res: T.Compose([
+            T.Resize((res, res), interpolation=T.InterpolationMode.LANCZOS),
+            T.ToTensor(),
+            T.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
+        ])
+        for res in resolutions
+    }
+
+
+@torch.inference_mode()
+def encode_latent(vae, tensor):
+    latent = vae.encode(tensor).latent_dist.sample()
+    return (latent * 0.18215).cpu()
+
+
+def coerce_image(v) -> Optional[Image.Image]:
+    """Convert any image-like value to a PIL RGB image."""
+    try:
+        if isinstance(v, Image.Image):
+            return v.convert("RGB")
+        if isinstance(v, bytes):
+            return Image.open(io.BytesIO(v)).convert("RGB")
+        if isinstance(v, dict):
+            raw = v.get("bytes") or v.get("data") or v.get("image")
+            if raw:
+                return coerce_image(raw)
+        if isinstance(v, str) and os.path.exists(v):
+            return Image.open(v).convert("RGB")
+    except Exception:
+        pass
+    return None
+
+
+def extract_caption(sample, field):
+    if field and field in sample:
+        v = sample[field]
+        if isinstance(v, list):
+            return " ".join(str(x) for x in v)
+        return str(v)
+    # Fallback: try all known caption fields
+    for f in CAPTION_FIELDS:
+        if f in sample and isinstance(sample[f], str):
+            return sample[f]
+    return ""
+
+
+# ── Format-specific iterators ──��──────────────────────────────────────────────
+def iter_parquet(path: str) -> Iterator[dict]:
+    import pyarrow.parquet as pq
+    from datasets import Dataset
+    ds = Dataset(pq.read_table(path))
+    yield from ds
+
+
+def iter_arrow(path: str) -> Iterator[dict]:
+    import pyarrow as pa
+    with pa.memory_map(path, "r") as src:
+        reader = pa.ipc.open_file(src)
+        for i in range(reader.num_record_batches):
+            batch = reader.get_batch(i)
+            for row_idx in range(batch.num_rows):
+                yield {col: batch.column(col)[row_idx].as_py()
+                       for col in batch.schema.names}
+
+
+def iter_webdataset(path: str) -> Iterator[dict]:
+    """
+    Iterate a WebDataset tar shard.
+    Groups consecutive tar members by stem into one sample dict.
+    """
+    current_key  = None
+    current_samp = {}
+
+    def emit(s):
+        return s if s else None
+
+    with tarfile.open(path, "r:*") as tf:
+        for member in tf:
+            if member.isdir() or member.size == 0:
+                continue
+            name = os.path.basename(member.name)
+            stem, ext = os.path.splitext(name)
+            ext = ext.lstrip(".").lower()
+
+            if current_key is None:
+                current_key = stem
+
+            if stem != current_key:
+                if current_samp:
+                    yield current_samp
+                current_key  = stem
+                current_samp = {}
+
+            fobj = tf.extractfile(member)
+            if fobj is None:
+                continue
+            raw = fobj.read()
+
+            if ext in ("jpg", "jpeg", "png", "gif", "webp", "bmp"):
+                try:
+                    current_samp["image"] = Image.open(io.BytesIO(raw)).convert("RGB")
+                    current_samp["__img_bytes__"] = raw
+                except Exception:
+                    pass
+            elif ext == "txt":
+                current_samp["caption"] = raw.decode("utf-8", errors="replace").strip()
+            elif ext == "json":
+                try:
+                    current_samp.update(json.loads(raw))
+                except Exception:
+                    pass
+            elif ext == "cls":
+                try:
+                    current_samp["label"] = raw.decode().strip()
+                except Exception:
+                    pass
+            else:
+                current_samp[ext] = raw
+
+        if current_samp:
+            yield current_samp
+
+
+def iter_zip(path: str) -> Iterator[dict]:
+    """
+    Iterate a ZIP file.
+    Groups image files with their sibling caption files by stem.
+    """
+    with zipfile.ZipFile(path, "r") as zf:
+        names   = set(zf.namelist())
+        img_ext = {"jpg", "jpeg", "png", "gif", "webp", "bmp"}
+
+        for name in sorted(names):
+            ext = Path(name).suffix.lower().lstrip(".")
+            if ext not in img_ext:
+                continue
+            stem   = Path(name).stem
+            sample = {}
+
+            try:
+                raw = zf.read(name)
+                sample["image"] = Image.open(io.BytesIO(raw)).convert("RGB")
+            except Exception:
+                continue
+
+            # Sibling caption
+            for cap_ext in ("txt", "caption"):
+                sib = str(Path(name).with_suffix(f".{cap_ext}"))
+                if sib in names:
+                    try:
+                        sample["caption"] = zf.read(sib).decode("utf-8", errors="replace").strip()
+                    except Exception:
+                        pass
+
+            # Sibling JSON metadata
+            sib_json = str(Path(name).with_suffix(".json"))
+            if sib_json in names:
+                try:
+                    sample.update(json.loads(zf.read(sib_json)))
+                except Exception:
+                    pass
+
+            yield sample
+
+
+def iter_jsonl(path: str) -> Iterator[dict]:
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                yield json.loads(line)
+            except Exception:
+                continue
+
+
+def iter_image_folder(path: str) -> Iterator[dict]:
+    img_ext = {".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"}
+    for root, _, files in os.walk(path):
+        for fname in sorted(files):
+            if Path(fname).suffix.lower() not in img_ext:
+                continue
+            img_path = os.path.join(root, fname)
+            sample   = {}
+            try:
+                sample["image"] = Image.open(img_path).convert("RGB")
+            except Exception:
+                continue
+            txt_path = os.path.join(root, Path(fname).stem + ".txt")
+            if os.path.exists(txt_path):
+                sample["caption"] = open(txt_path).read().strip()
+            json_path = os.path.join(root, Path(fname).stem + ".json")
+            if os.path.exists(json_path):
+                try:
+                    sample.update(json.loads(open(json_path).read()))
+                except Exception:
+                    pass
+            yield sample
+
+
+def iter_hf_streaming(dataset_name: str, split: str) -> Iterator[dict]:
+    from datasets import load_dataset
+    ds = load_dataset(dataset_name, split=split, streaming=True)
+    yield from ds
+
+
+def get_iterator(args, info: DatasetInfo) -> Iterator[dict]:
+    """Return the right iterator based on detected format."""
+    if args.shard_file:
+        fmt = info.fmt
+        p   = args.shard_file
+        if fmt == "parquet":
+            return iter_parquet(p)
+        elif fmt in ("tar", "tar.gz"):
+            return iter_webdataset(p)
+        elif fmt == "zip":
+            return iter_zip(p)
+        elif fmt == "arrow":
+            return iter_arrow(p)
+        elif fmt == "jsonl":
+            return iter_jsonl(p)
+        elif fmt == "folder":
+            return iter_image_folder(p)
+        else:
+            print(f"[warn] Unknown format '{fmt}', trying HF datasets as fallback...")
+            from datasets import load_dataset
+            ds = load_dataset("parquet", data_files={"train": p}, split="train")
+            return iter(ds)
+    else:
+        return iter_hf_streaming(args.hf_dataset, args.hf_split)
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+def main():
+    args = parse_args()
+
+    # ── Detect format + fields ────────────────────────────────────────────────
+    src = args.shard_file or args.hf_dataset
+    print(f"[shard {args.shard_idx:06d}] Detecting format: {src}")
+
+    if args.shard_file:
+        info = detect(args.shard_file)
+    else:
+        # HF streaming: create a minimal info stub
+        info = DatasetInfo("hf_streaming", None, None, {})
+
+    # Allow CLI overrides
+    if args.image_field:
+        info.image_field = args.image_field
+    if args.caption_field:
+        info.caption_field = args.caption_field
+
+    print(f"[shard {args.shard_idx:06d}] {info}")
+
+    if args.detect_only:
+        print(f"Sample keys: {list(info.sample.keys())}")
+        return
+
+    # ── Setup ─────────────────────────────────────────────────────────────────
+    device_str = f"cuda:{args.cuda_device}" if torch.cuda.is_available() else "cpu"
+    device     = torch.device(device_str)
+    print(f"[shard {args.shard_idx:06d}] Device: {device_str}")
+
+    paths = Paths(args.base_dir, args.resolutions)
+    paths.ensure_global_dirs()
+
+    already_done_global = load_global_done(paths)
+    worker_caps, failed = load_worker_state(paths, args.shard_idx)
+    already_done = already_done_global | set(worker_caps.keys())
+    print(f"[shard {args.shard_idx:06d}] Already done: {len(already_done):,}  Failed: {len(failed):,}")
+
+    # ── Load VAE ──────────────────────────────────────────────────────────────
+    vae        = None
+    vae_xforms = {}
+    if not args.no_latents:
+        print(f"[shard {args.shard_idx:06d}] Loading VAE: {args.vae_model}")
+        vae = AutoencoderKL.from_pretrained(args.vae_model).to(device)
+        vae.eval()
+        vae_xforms = build_vae_transforms(args.resolutions)
+
+    # ── Iterator ──────────────────────────────────────────────────────────────
+    data_iter  = get_iterator(args, info)
+    new_caps   = {}
+    sub_data   = {}
+    sub_idx    = 0
+    dirs_seen  = set()
+    processed  = 0
+    skipped    = 0
+    errors     = 0
+    t0         = time.time()
+
+    pbar = tqdm(
+        total=args.max_samples,
+        unit="img",
+        dynamic_ncols=True,
+        desc=f"shard {args.shard_idx:03d}/{args.total_shards:03d} [{info.fmt}]",
+    )
+
+    for local_idx, sample in enumerate(data_iter):
+        if args.max_samples and local_idx >= args.max_samples:
+            break
+
+        global_idx = args.shard_idx * 1_000_000 + local_idx
+        stem       = f"{global_idx:012d}"
+
+        # ── Resume ────────────────────────────────────────────────────────────
+        if stem in already_done:
+            skipped += 1
+            pbar.update(1)
+            continue
+
+        # ── Extract image ──────────────────────────────────────────────────────
+        try:
+            raw_img = sample.get(info.image_field) if info.image_field else None
+            # Fallback: try all known image fields
+            if raw_img is None:
+                for f in IMAGE_FIELDS:
+                    if f in sample:
+                        raw_img = sample[f]
+                        break
+            if raw_img is None:
+                raise ValueError(f"No image field found. Keys: {list(sample.keys())}")
+
+            pil_img = coerce_image(raw_img)
+            if pil_img is None:
+                raise ValueError(f"Could not coerce image from field '{info.image_field}'")
+
+            caption = extract_caption(sample, info.caption_field)
+
+        except Exception as e:
+            failed.add(stem)
+            errors += 1
+            pbar.update(1)
+            continue
+
+        # ── Ensure dirs ────────────────────────────────────────────────────────
+        bucket = paths.bucket(stem)
+        if bucket not in dirs_seen:
+            paths.ensure_dirs(stem)
+            dirs_seen.add(bucket)
+
+        # ── Save ───────────────────────────────────────────────────────────────
+        try:
+            if not args.no_originals:
+                pil_img.save(paths.orig_path(stem), format="JPEG", quality=95)
+
+            for res in args.resolutions:
+                resized = pil_img.resize((res, res), Image.LANCZOS)
+                resized.save(paths.img_path(res, stem), format="JPEG", quality=90)
+
+                if vae is not None:
+                    tensor = vae_xforms[res](pil_img).unsqueeze(0).to(device)
+                    lat    = encode_latent(vae, tensor)
+                    torch.save(lat, paths.lat_path(res, stem))
+
+            worker_caps[stem] = caption
+            new_caps[stem]    = caption
+            sub_data[stem]    = caption
+            already_done.add(stem)
+
+            if len(sub_data) >= args.shard_size:
+                save_subshard(paths, args.shard_idx, sub_idx, sub_data)
+                sub_idx  += 1
+                sub_data  = {}
+
+            processed += 1
+
+        except Exception:
+            failed.add(stem)
+            errors += 1
+            traceback.print_exc()
+
+        pbar.update(1)
+        elapsed = time.time() - t0 + 1e-6
+        pbar.set_postfix(
+            ok=processed, skip=skipped, err=errors,
+            fps=f"{processed/elapsed:.1f}",
+        )
+
+        # ── Periodic flush ────────────────────────────────────────────────────
+        if processed % args.flush_every == 0 and new_caps:
+            flush_worker(paths, args.shard_idx, worker_caps, failed)
+            new_caps = {}
+
+    pbar.close()
+
+    # ── Final flush ────────────────────────────────────────────────────────────
+    flush_worker(paths, args.shard_idx, worker_caps, failed)
+    if sub_data:
+        save_subshard(paths, args.shard_idx, sub_idx, sub_data)
+
+    merge_to_global(paths, args.shard_idx)
+    update_meta(paths, processed, errors)
+
+    elapsed = time.time() - t0
+    print(
+        f"\n[shard {args.shard_idx:06d}] Done in {elapsed/60:.1f} min\n"
+        f"  Format    : {info.fmt}\n"
+        f"  Img field : {info.image_field}\n"
+        f"  Cap field : {info.caption_field}\n"
+        f"  Processed : {processed:,}\n"
+        f"  Skipped   : {skipped:,}\n"
+        f"  Errors    : {errors:,}\n"
+    )
+
+
+if __name__ == "__main__":
+    main()

run_pipeline_universal.sh

@@ -0,0 +1,387 @@
+#!/usr/bin/env bash
+# =============================================================================
+# run_pipeline_universal.sh
+# Universal pipeline: download ANY HuggingFace image dataset + process in parallel
+#
+# Supported formats (auto-detected):
+#   .parquet  .tar  .tar.gz  .tgz  .zip  .arrow  .jsonl  image folders
+#
+# Usage
+# -----
+#   HF_DATASET=laion/laion400m bash run_pipeline_universal.sh
+#   HF_DATASET=poloclub/diffusiondb JOBS=8 CUDA_DEVICES="0,1" bash run_pipeline_universal.sh
+#   HF_DATASET=timbrooks/instructpix2pix-clip-filtered bash run_pipeline_universal.sh
+#
+# Environment variables
+# ----------------------
+#   HF_DATASET       REQUIRED — HuggingFace dataset name (org/repo)
+#   HF_SPLIT         Dataset split to use           [default: train]
+#   BASE_DIR         Output base directory           [default: /workspace/hem/dataset_output]
+#   JOBS             Parallel worker count           [default: 4]
+#   CUDA_DEVICES     GPU indices, comma-separated    [default: 0]
+#   RESOLUTIONS      Space-separated px sizes        [default: "256 512"]
+#   NO_LATENTS       Set to 1 to skip VAE encoding   [default: 0]
+#   NO_ORIGINALS     Set to 1 to skip original imgs  [default: 0]
+#   MAX_SHARDS       Limit shard count (testing)     [default: all]
+#   MAX_SAMPLES      Limit rows per shard (testing)  [default: all]
+#   IMAGE_FIELD      Override auto-detected field     [default: auto]
+#   CAPTION_FIELD    Override auto-detected field     [default: auto]
+#   DOWNLOAD_ONLY    Set to 1 — download then stop   [default: 0]
+#   PROCESS_ONLY     Set to 1 — skip download        [default: 0]
+#   DRY_RUN          Set to 1 — print, don't run     [default: 0]
+#   ARIA2_CONNS      aria2 parallel connections       [default: 16]
+#   ARIA2_SPLITS     aria2 splits per file            [default: 5]
+#   PYTHON           Python interpreter path          [default: python3]
+# =============================================================================
+
+set -euo pipefail
+
+# ── Defaults ──────────────────────────────────────────────────────────────────
+: "${HF_DATASET:?ERROR: HF_DATASET is required. Example: HF_DATASET=laion/laion400m}"
+: "${HF_SPLIT:=train}"
+: "${BASE_DIR:=/workspace/hem/dataset_output}"
+: "${JOBS:=4}"
+: "${CUDA_DEVICES:=0}"
+: "${RESOLUTIONS:=256 512}"
+: "${NO_LATENTS:=0}"
+: "${NO_ORIGINALS:=0}"
+: "${MAX_SHARDS:=}"
+: "${MAX_SAMPLES:=}"
+: "${IMAGE_FIELD:=}"
+: "${CAPTION_FIELD:=}"
+: "${DOWNLOAD_ONLY:=0}"
+: "${PROCESS_ONLY:=0}"
+: "${DRY_RUN:=0}"
+: "${ARIA2_CONNS:=16}"
+: "${ARIA2_SPLITS:=5}"
+: "${PYTHON:=python3}"
+
+RAW_DIR="${BASE_DIR}/raw_shards"
+LOG_DIR="${BASE_DIR}/metadata/processing_logs"
+PARALLEL_LOG="${LOG_DIR}/parallel_jobs.log"
+ARIA2_LOG="${LOG_DIR}/aria2.log"
+URL_FILE="${LOG_DIR}/hf_shard_urls.txt"
+SHARD_LIST="${LOG_DIR}/shard_list.tsv"
+WORKER_LOG_DIR="${LOG_DIR}/worker_logs"
+
+# ── Colors ────────────────────────────────────────────────────────────────────
+GRN='\033[0;32m'; YLW='\033[1;33m'; RED='\033[0;31m'; CYN='\033[0;36m'; NC='\033[0m'
+log()  { echo -e "${GRN}[pipeline]${NC} $*"; }
+warn() { echo -e "${YLW}[pipeline]${NC} $*"; }
+info() { echo -e "${CYN}[pipeline]${NC} $*"; }
+die()  { echo -e "${RED}[pipeline] FATAL${NC} $*" >&2; exit 1; }
+run()  { [[ "$DRY_RUN" == "1" ]] && echo "[DRY-RUN] $*" || eval "$*"; }
+
+# ── Dependency check ──────────────────────────────────────────────────────────
+check_deps() {
+    log "Checking dependencies..."
+    local miss=()
+    command -v aria2c   &>/dev/null || miss+=("aria2c  → sudo apt install aria2")
+    command -v parallel &>/dev/null || miss+=("parallel → sudo apt install parallel")
+    command -v "$PYTHON" &>/dev/null || miss+=("$PYTHON")
+    "$PYTHON" -c "import datasets, diffusers, torch, torchvision, pyarrow, PIL" 2>/dev/null \
+        || miss+=("Python packages → bash setup_universal.sh")
+    [[ ${#miss[@]} -gt 0 ]] && die "Missing:\n$(printf '  • %s\n' "${miss[@]}")"
+    log "OK"
+}
+
+# ── HuggingFace token ─────────────────────────────────────────────────────────
+get_hf_token() {
+    local tok_file="$HOME/.cache/huggingface/token"
+    if [[ -f "$tok_file" ]]; then
+        cat "$tok_file"
+    else
+        echo ""
+    fi
+}
+
+# ── Phase 0: Probe dataset (detect format, list files) ───────────────────────
+phase_probe() {
+    log "=== Phase 0: Probe dataset $HF_DATASET ==="
+    mkdir -p "$RAW_DIR" "$LOG_DIR" "$WORKER_LOG_DIR"
+
+    "$PYTHON" - <<PYEOF
+import sys, os, json
+from huggingface_hub import HfFileSystem, hf_hub_download
+from huggingface_hub.utils import EntryNotFoundError
+
+fs     = HfFileSystem()
+repo   = "datasets/${HF_DATASET}"
+base   = "https://huggingface.co/datasets/${HF_DATASET}/resolve/main"
+token  = open(os.path.expanduser("~/.cache/huggingface/token")).read().strip() \
+         if os.path.exists(os.path.expanduser("~/.cache/huggingface/token")) else None
+
+# List all files in the repo
+try:
+    all_files = fs.ls(repo, detail=False, recursive=True)
+except Exception as e:
+    print(f"ERROR listing repo: {e}", file=sys.stderr)
+    sys.exit(1)
+
+# Supported shard extensions (in preference order)
+SHARD_EXTS = {".parquet", ".tar", ".tar.gz", ".tgz", ".zip", ".arrow", ".jsonl", ".json"}
+
+shard_files = [f for f in sorted(all_files)
+               if any(f.endswith(ext) for ext in SHARD_EXTS)
+               and not f.endswith("metadata.json")
+               and not f.endswith(".gitattributes")]
+
+if not shard_files:
+    # Maybe it's an image folder dataset — list image files
+    img_exts = {".jpg", ".jpeg", ".png", ".gif", ".webp"}
+    shard_files = [f for f in sorted(all_files)
+                   if any(f.endswith(e) for e in img_exts)]
+    is_folder = True
+else:
+    is_folder = False
+
+print(f"Found {len(shard_files)} shard files (folder_mode={is_folder})", file=sys.stderr)
+
+# Write aria2 input file
+with open("${URL_FILE}", "w") as out:
+    for p in shard_files:
+        rel = p.split("${HF_DATASET}/")[-1]
+        out.write(f"{base}/{rel}\n")
+        out.write(f"  dir=${RAW_DIR}\n")
+        fname = rel.replace("/", "__")   # flatten subdirs into filename
+        out.write(f"  out={fname}\n")
+
+# Write metadata about what we found
+meta = {
+    "hf_dataset": "${HF_DATASET}",
+    "hf_split": "${HF_SPLIT}",
+    "shard_count": len(shard_files),
+    "is_folder_dataset": is_folder,
+    "sample_files": shard_files[:5],
+}
+with open("${LOG_DIR}/probe_result.json", "w") as f:
+    json.dump(meta, f, indent=2)
+
+print(json.dumps(meta, indent=2))
+PYEOF
+
+    log "Probe complete. URL file: $URL_FILE"
+}
+
+# ── Phase 1: Download with aria2 ─────────────────────────────────────────────
+phase_download() {
+    log "=== Phase 1: Download shards ==="
+
+    [[ -s "$URL_FILE" ]] || die "URL file missing or empty. Run probe first."
+
+    SHARD_COUNT=$(grep -c "^https" "$URL_FILE" || true)
+    log "Downloading $SHARD_COUNT files with aria2 ($ARIA2_CONNS connections, $ARIA2_SPLITS splits/file)..."
+
+    HF_TOKEN="$(get_hf_token)"
+    AUTH=""
+    [[ -n "$HF_TOKEN" ]] && AUTH="--header=Authorization: Bearer ${HF_TOKEN}"
+
+    run aria2c \
+        --input-file="$URL_FILE" \
+        ${AUTH:+"$AUTH"} \
+        --max-concurrent-downloads="$ARIA2_CONNS" \
+        --split="$ARIA2_SPLITS" \
+        --min-split-size=10M \
+        --continue=true \
+        --retry-wait=5 \
+        --max-tries=10 \
+        --file-allocation=none \
+        --console-log-level=warn \
+        --log="$ARIA2_LOG" \
+        --log-level=notice \
+        --summary-interval=30
+
+    log "Download complete → $RAW_DIR"
+    ls -lh "$RAW_DIR" | tail -5
+}
+
+# ── Phase 2: Detect shard format and build worker args ────────────────────────
+phase_build_shard_list() {
+    log "=== Phase 2a: Build shard list ==="
+
+    mapfile -t RAW_FILES < <(find "$RAW_DIR" -type f | sort)
+    TOTAL="${#RAW_FILES[@]}"
+
+    if [[ "$TOTAL" -eq 0 ]]; then
+        die "No files in $RAW_DIR — run download phase first."
+    fi
+
+    # Probe first file to detect format
+    FIRST="${RAW_FILES[0]}"
+    info "Probing format of: $FIRST"
+    "$PYTHON" - "$FIRST" <<'PYEOF'
+import sys
+from format_detector import detect
+info = detect(sys.argv[1])
+print(f"  Format: {info.fmt}")
+print(f"  Image field: {info.image_field}")
+print(f"  Caption field: {info.caption_field}")
+PYEOF
+
+    # Apply MAX_SHARDS cap
+    if [[ -n "$MAX_SHARDS" && "$MAX_SHARDS" -lt "$TOTAL" ]]; then
+        warn "Capping to $MAX_SHARDS of $TOTAL shards"
+        RAW_FILES=("${RAW_FILES[@]:0:$MAX_SHARDS}")
+        TOTAL="$MAX_SHARDS"
+    fi
+
+    # Write shard list: idx TAB filepath
+    > "$SHARD_LIST"
+    for i in "${!RAW_FILES[@]}"; do
+        echo -e "${i}\t${RAW_FILES[$i]}" >> "$SHARD_LIST"
+    done
+
+    log "Shard list written: $SHARD_LIST ($TOTAL entries)"
+}
+
+# ── Phase 3: Process with GNU Parallel ───────────────────────────────────────
+phase_process() {
+    log "=== Phase 2b: Process $TOTAL shards with $JOBS workers ==="
+
+    # Build GPU array
+    IFS=',' read -ra GPU_ARR <<< "$CUDA_DEVICES"
+    GPU_COUNT="${#GPU_ARR[@]}"
+
+    # Build optional flags
+    EXTRA_FLAGS=""
+    [[ "$NO_LATENTS"   == "1" ]] && EXTRA_FLAGS+=" --no-latents"
+    [[ "$NO_ORIGINALS" == "1" ]] && EXTRA_FLAGS+=" --no-originals"
+    [[ -n "$IMAGE_FIELD"   ]]   && EXTRA_FLAGS+=" --image-field $IMAGE_FIELD"
+    [[ -n "$CAPTION_FIELD" ]]   && EXTRA_FLAGS+=" --caption-field $CAPTION_FIELD"
+    [[ -n "$MAX_SAMPLES"   ]]   && EXTRA_FLAGS+=" --max-samples $MAX_SAMPLES"
+
+    RES_FLAGS="--resolutions $RESOLUTIONS"
+
+    # Per-job command
+    # GNU Parallel substitutions: {1}=shard_idx  {2}=shard_file  {%}=slot
+    read -r -d '' WORKER_CMD <<CMD || true
+shard_idx={1}
+shard_file={2}
+slot={%}
+gpu_idx=\${GPU_ARR[\$(( (slot-1) % GPU_COUNT ))]}
+
+log_file="${WORKER_LOG_DIR}/shard_\$(printf '%06d' \$shard_idx).log"
+
+echo "[slot \$slot | gpu \$gpu_idx] shard \$shard_idx → \$shard_file" >&2
+
+CUDA_VISIBLE_DEVICES=\$gpu_idx \\
+$PYTHON ingest_universal.py \\
+    --shard-file   "\$shard_file" \\
+    --shard-idx    \$shard_idx \\
+    --total-shards $TOTAL \\
+    --base-dir     "$BASE_DIR" \\
+    --cuda-device  0 \\
+    $RES_FLAGS \\
+    $EXTRA_FLAGS \\
+    > "\$log_file" 2>&1
+
+ec=\$?
+[[ \$ec -ne 0 ]] && echo "[FAILED shard \$shard_idx] exit=\$ec  log: \$log_file" >&2
+exit \$ec
+CMD
+
+    # Export GPU array for subshell
+    export GPU_ARR GPU_COUNT
+
+    if [[ "$DRY_RUN" == "1" ]]; then
+        warn "[DRY-RUN] Would run GNU Parallel over $TOTAL shards"
+        warn "[DRY-RUN] Worker command:"
+        echo "$WORKER_CMD"
+        return
+    fi
+
+    parallel \
+        --jobs "$JOBS" \
+        --colsep '\t' \
+        --progress \
+        --eta \
+        --bar \
+        --joblog "$PARALLEL_LOG" \
+        --resume-failed \
+        --halt soon,fail=20 \
+        bash -c "$WORKER_CMD" \
+        :::: "$SHARD_LIST"
+
+    log "All workers finished."
+}
+
+# ── Phase 4: Report ───────────────────────────────────────────────────────────
+phase_report() {
+    log "=== Pipeline Report ==="
+
+    echo ""
+    info "Dataset    : $HF_DATASET"
+    info "Output dir : $BASE_DIR"
+    echo ""
+
+    # Count captions
+    CAPS=$("$PYTHON" -c "
+import json, os
+f = '${BASE_DIR}/captions/captions.json'
+print(len(json.load(open(f))) if os.path.exists(f) and os.path.getsize(f) > 2 else 0)
+" 2>/dev/null || echo "?")
+
+    # Count failed across all shards
+    FAILED=$( ls "${LOG_DIR}"/failed_shard_*.json 2>/dev/null \
+        | xargs -I{} "$PYTHON" -c "import json; d=json.load(open('{}'));print(len(d))" 2>/dev/null \
+        | paste -sd+ | bc 2>/dev/null || echo "?" )
+
+    # Disk usage
+    DISK=$(du -sh "$BASE_DIR" 2>/dev/null | cut -f1 || echo "?")
+
+    info "Captions processed : $CAPS"
+    info "Total failed IDs   : $FAILED"
+    info "Disk used          : $DISK"
+    info "Worker logs        : $WORKER_LOG_DIR/"
+    info "Parallel job log   : $PARALLEL_LOG"
+    echo ""
+
+    # Show any failed shards from GNU Parallel log
+    if [[ -f "$PARALLEL_LOG" ]]; then
+        FAILED_JOBS=$(awk -F'\t' 'NR>1 && $7!=0 {print $0}' "$PARALLEL_LOG" | wc -l)
+        if [[ "$FAILED_JOBS" -gt 0 ]]; then
+            warn "$FAILED_JOBS shards had errors. To retry:"
+            warn "  PROCESS_ONLY=1 bash run_pipeline_universal.sh"
+        else
+            log "All shards completed successfully."
+        fi
+    fi
+}
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+main() {
+    echo ""
+    log "╔══════════════════════════════════════════════════════╗"
+    log "║   Universal HF Image Dataset Pipeline               ║"
+    log "╚══════════════════════════════════════════════════════╝"
+    echo ""
+    log "Dataset  : $HF_DATASET ($HF_SPLIT)"
+    log "Output   : $BASE_DIR"
+    log "Workers  : $JOBS  |  GPUs: $CUDA_DEVICES"
+    log "Res      : $RESOLUTIONS  |  Latents: $([ "$NO_LATENTS" = "1" ] && echo NO || echo YES)"
+    [[ -n "$MAX_SHARDS"  ]] && warn "MAX_SHARDS=$MAX_SHARDS (testing mode)"
+    [[ -n "$MAX_SAMPLES" ]] && warn "MAX_SAMPLES=$MAX_SAMPLES (testing mode)"
+    [[ "$DRY_RUN" == "1" ]] && warn "DRY_RUN=1 — no files will be written"
+    echo ""
+
+    check_deps
+
+    if [[ "$PROCESS_ONLY" != "1" ]]; then
+        phase_probe
+        phase_download
+    else
+        log "Skipping download (PROCESS_ONLY=1)"
+    fi
+
+    if [[ "$DOWNLOAD_ONLY" != "1" ]]; then
+        phase_build_shard_list
+        phase_process
+    else
+        log "Skipping processing (DOWNLOAD_ONLY=1)"
+    fi
+
+    phase_report
+    log "Pipeline done."
+}
+
+main "$@"

setup_universal.sh

@@ -0,0 +1,110 @@
+#!/usr/bin/env bash
+# =============================================================================
+# setup_universal.sh — Install all dependencies for the universal pipeline
+# =============================================================================
+set -euo pipefail
+
+GRN='\033[0;32m'; NC='\033[0m'
+log() { echo -e "${GRN}[setup]${NC} $*"; }
+
+# ── System packages ───────────────────────────────────────────────────────────
+log "Installing system packages..."
+sudo apt-get update -qq
+sudo apt-get install -y --no-install-recommends \
+    aria2 \
+    parallel \
+    pigz \
+    pv \
+    jq \
+    bc \
+    curl wget ca-certificates \
+    libgl1 libglib2.0-0          # needed by Pillow on headless servers
+
+# Silence GNU Parallel citation nag
+mkdir -p ~/.parallel && touch ~/.parallel/will-cite
+
+# ── Python packages ───────────────────────────────────────────────────────────
+log "Installing Python packages..."
+pip install --upgrade pip --quiet
+
+pip install --quiet \
+    datasets \
+    diffusers \
+    transformers \
+    accelerate \
+    torch torchvision \
+    pyarrow \
+    Pillow \
+    tqdm \
+    huggingface_hub \
+    safetensors \
+    webdataset \
+    pyarrow \
+    orjson \
+    requests
+
+# ── HuggingFace login ─────────────────────────────────────────────────────────
+HF_TOKEN_FILE="$HOME/.cache/huggingface/token"
+if [[ ! -f "$HF_TOKEN_FILE" ]]; then
+    log "No HuggingFace token found. Run: huggingface-cli login"
+else
+    log "HuggingFace token found ✓"
+fi
+
+# ── Directory scaffold ────────────────────────────────────────────────────────
+BASE_DIR="${BASE_DIR:-/workspace/hem/dataset_output}"
+log "Creating base directory structure: $BASE_DIR"
+
+mkdir -p \
+    "${BASE_DIR}/images/original" \
+    "${BASE_DIR}/captions/shards" \
+    "${BASE_DIR}/metadata/processing_logs/worker_logs" \
+    "${BASE_DIR}/raw_shards" \
+    "${BASE_DIR}/logs"
+
+for res in 256 512 1024; do
+    mkdir -p "${BASE_DIR}/images/${res}x${res}"
+    mkdir -p "${BASE_DIR}/latents/sd-vae-${res}"
+done
+
+# Seed empty files
+CAPS="${BASE_DIR}/captions/captions.json"
+[[ -f "$CAPS" ]] || echo '{}' > "$CAPS"
+
+META="${BASE_DIR}/metadata/dataset_info.json"
+if [[ ! -f "$META" ]]; then
+    cat > "$META" <<JSON
+{
+  "hf_dataset": null,
+  "hf_split": "train",
+  "resolutions": [256, 512],
+  "vae_model": "stabilityai/sd-vae-ft-ema",
+  "processed_count": 0,
+  "failed_count": 0,
+  "last_run": null
+}
+JSON
+fi
+
+# ── Verify format_detector is importable ──────────────────────────────────────
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [[ -f "$SCRIPT_DIR/format_detector.py" ]]; then
+    log "Verifying format_detector.py..."
+    python3 -c "from format_detector import detect; print('  format_detector OK')" \
+        || echo "  [warn] Could not import format_detector — ensure it is in the same folder"
+fi
+
+log ""
+log "Setup complete ✓"
+log ""
+log "Quick start:"
+log "  huggingface-cli login"
+log "  HF_DATASET=LLAAMM/text2image1m bash run_pipeline_universal.sh"
+log ""
+log "Other examples:"
+log "  HF_DATASET=laion/laion400m JOBS=8 CUDA_DEVICES=0,1,2,3 bash run_pipeline_universal.sh"
+log "  HF_DATASET=poloclub/diffusiondb RESOLUTIONS='256' NO_LATENTS=1 bash run_pipeline_universal.sh"
+log "  HF_DATASET=timbrooks/instructpix2pix-clip-filtered bash run_pipeline_universal.sh"
+log ""
+log "Test run (3 shards, 100 samples each, no VAE):"
+log "  HF_DATASET=your/dataset MAX_SHARDS=3 MAX_SAMPLES=100 NO_LATENTS=1 bash run_pipeline_universal.sh"