code/pack_for_hf.py

#!/usr/bin/env python3
"""
pack_for_hf.py — 把 extracted/ + manifest + masks 转成 HuggingFace parquet shard。

每 row 包含:
  - 全部 41 列 manifest 字段
  - image: bytes (PNG/JPG raw)
  - 各 cohort 对应的 mask column (bytes, 可为 None)

Sharding: 按 cohort 分组,每 cohort 切多 shard, 命名 {cohort}-{i:05d}-of-{N:05d}.parquet,
shard size 目标 ~600 MB。

Usage:
  python pack_for_hf.py \\
      --manifest /path/to/oct_public_images_v1.parquet \\
      --extracted-root /path/to/extracted \\
      --output-dir hf_staging/data/public_oct \\
      [--cohort public_oct_kermany]   # filter
      [--shard-size-mb 600]
      [--num-workers 4]
"""
import argparse
import io
import json
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq


# 每 cohort 的 mask 列名 → 文件名模板 (study_dir 内相对)
# {bscan_index:03d} 会按 row.bscan_index 替换
MASK_RESOLVERS = {
    # ----- Public fundus -----
    "public_drive_vessel": {
        "vessel_mask": "vessel_mask.png",
        "fov_mask": "fov_mask.png",
    },
    "public_idrid": {
        "lesion_microaneurysms_mask": "lesion_microaneurysms.png",
        "lesion_haemorrhages_mask": "lesion_haemorrhages.png",
        "lesion_hard_exudates_mask": "lesion_hard_exudates.png",
        "lesion_soft_exudates_mask": "lesion_soft_exudates.png",
        "optic_disc_mask": "optic_disc_mask.png",
    },
    "public_refuge2_disc_cup": {"disc_cup_mask": "disc_cup_mask.png"},
    "public_gamma_multimodal": {"disc_cup_mask": "disc_cup_mask.png"},
    # ----- Public OCT -----
    "public_oct_oimhs": {"layer_mask": "layer_mask.png"},
    "public_oct_aroi": {"layer_mask": "layer_mask.png"},
    "public_oct_retouch": {"fluid_mask": "fluid_mask.png"},
    "public_oct_amd_sd": {"lesion_mask": "lesion_mask.png"},
    "public_oct_chiu_dme_2015": {"layer_mask": "layer_mask.png"},
    "public_oct_glaucoma": {"layer_mask": "layer_mask.png"},
    "public_oct_octa500": {"mask": "mask_{bscan_index:03d}.png"},
    # ----- Private Topcon -----
    # segmentation.npz (10-layer ALL bscans in one file) — 留给 v2 处理
    # 当前 v1 不嵌入 npz, 仅 manifest 有 has_segmentation 字段
}


def resolve_mask_bytes(row, study_dir: Path) -> dict:
    """读取该 row 对应的所有 mask 文件 bytes (缺失为 None)."""
    cohort = row.cohort
    masks = {}
    for col_name, pat in MASK_RESOLVERS.get(cohort, {}).items():
        if "{bscan_index" in pat:
            idx = row.bscan_index
            if idx is None:
                masks[col_name] = None
                continue
            fname = pat.format(bscan_index=int(idx))
        else:
            fname = pat
        p = study_dir / fname
        masks[col_name] = p.read_bytes() if p.exists() else None
    return masks


def get_study_dir(file_path_str: str, extracted_root: Path) -> Path:
    """从 row.file_path 推 study 目录 (含 bscan/masks 的目录)."""
    abs_p = extracted_root / file_path_str
    return abs_p.parent


def process_row(row, extracted_root, all_mask_columns):
    """读 image bytes + mask bytes, 返回一个 dict (parquet row)."""
    file_path = row["file_path"]
    abs_p = extracted_root / file_path
    if not abs_p.exists():
        return None  # 文件缺失,跳过
    try:
        img_bytes = abs_p.read_bytes()
    except Exception:
        return None
    if len(img_bytes) == 0:
        return None  # 0 KB 文件,跳过

    study_dir = abs_p.parent
    mask_data = resolve_mask_bytes(row, study_dir)

    # 完整 row dict: 全 manifest 列 + image + 所有 mask 列 (本 cohort 没有的 mask 列填 None)
    out = {k: row[k] for k in row.index}
    out["image"] = img_bytes
    for col in all_mask_columns:
        out[col] = mask_data.get(col)
    return out


def write_shards(rows_iter, output_dir: Path, cohort: str,
                 shard_size_bytes: int):
    """
    将 rows_iter 中的 dict 写到多个 parquet shard。
    Shard 命名: {cohort}-{idx:05d}-of-{total}.parquet (total 先写 NNNNN 占位,最后 rename)。
    返回最终 shard 数。
    """
    shard_idx = 0
    cur_buf = []
    cur_bytes = 0
    written_shards = []

    def flush():
        nonlocal shard_idx, cur_buf, cur_bytes
        if not cur_buf:
            return
        tmp_path = output_dir / f"{cohort}-{shard_idx:05d}-tmp.parquet"
        tbl = pa.Table.from_pylist(cur_buf)
        pq.write_table(tbl, tmp_path, compression="zstd")
        written_shards.append(tmp_path)
        shard_idx += 1
        cur_buf = []
        cur_bytes = 0

    for r in rows_iter:
        if r is None:
            continue
        # rough size estimate: image bytes + mask bytes + ~500 metadata
        sz = len(r["image"]) + 500
        for k, v in r.items():
            if k.endswith("_mask") and v is not None:
                sz += len(v)
        if cur_bytes + sz > shard_size_bytes and cur_buf:
            flush()
        cur_buf.append(r)
        cur_bytes += sz
    flush()

    # Rename with final shard count
    n = len(written_shards)
    for tmp in written_shards:
        idx_part = tmp.name.split("-")[1]
        final = output_dir / f"{cohort}-{idx_part}-of-{n:05d}.parquet"
        tmp.rename(final)
    return n


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--manifest", required=True)
    ap.add_argument("--extracted-root", required=True)
    ap.add_argument("--output-dir", required=True)
    ap.add_argument("--cohort", default=None, help="只处理指定 cohort")
    ap.add_argument("--shard-size-mb", type=int, default=600)
    ap.add_argument("--num-workers", type=int, default=4)
    ap.add_argument("--limit-per-cohort", type=int, default=None,
                    help="测试用: 每 cohort 只 pack 前 N 行")
    args = ap.parse_args()

    extracted_root = Path(args.extracted_root)
    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    shard_size_bytes = args.shard_size_mb * 1024 * 1024

    df = pd.read_parquet(args.manifest)
    if args.cohort:
        df = df[df.cohort == args.cohort]
    print(f"Loaded {len(df)} rows from {args.manifest}")
    print(f"Cohorts to pack: {df.cohort.unique().tolist()}")
    print()

    # 所有出现在本 manifest 中的 cohort 的 mask 列名 union
    cohorts_in_df = set(df.cohort.unique())
    all_mask_columns = sorted({
        c for ck, cols in MASK_RESOLVERS.items() if ck in cohorts_in_df
        for c in cols
    })
    print(f"Mask columns union: {all_mask_columns}")
    print()

    total_shards = 0
    total_rows = 0
    for cohort, sub in df.groupby("cohort"):
        if args.limit_per_cohort:
            sub = sub.head(args.limit_per_cohort)
        n = len(sub)
        print(f"[{cohort}] packing {n} rows ...")

        # 并行读 image+mask bytes, 然后串行写 parquet
        with ThreadPoolExecutor(max_workers=args.num_workers) as ex:
            futs = [ex.submit(process_row, r, extracted_root, all_mask_columns)
                    for r in sub.to_dict(orient="records")]
            results = []
            for i, f in enumerate(futs, 1):
                results.append(f.result())
                if i % 5000 == 0:
                    n_ok = sum(1 for r in results if r is not None)
                    print(f"  read {i}/{n} ({n_ok} ok)")

        n_ok = sum(1 for r in results if r is not None)
        n_skip = n - n_ok
        n_shards = write_shards(results, output_dir, cohort, shard_size_bytes)
        print(f"  → {n_ok} rows written, {n_skip} skipped (missing/0KB), {n_shards} shards")
        total_shards += n_shards
        total_rows += n_ok

    print(f"\n[done] {total_rows} rows in {total_shards} shards under {output_dir}")


if __name__ == "__main__":
    main()