| """Extract images from ULVR_all parquet files into Monet training layout.""" |
| import argparse |
| import json |
| import multiprocessing as mp |
| import os |
|
|
| import pyarrow.parquet as pq |
|
|
|
|
| def build_mapping(jsonl_path: str) -> dict: |
| mapping = {} |
| with open(jsonl_path) as f: |
| for line in f: |
| d = json.loads(line) |
| sid = d["metadata"]["sample_id"] |
| input_path = None |
| inter_paths = [] |
| for msg in d["data"]: |
| if msg["role"] == "user": |
| for c in msg["content"]: |
| if c["type"] == "image": |
| input_path = c["image"] |
| elif msg["role"] == "assistant": |
| for c in msg["content"]: |
| if c["type"] == "image": |
| inter_paths.append(c["image"]) |
| mapping[sid] = (input_path, inter_paths) |
| return mapping |
|
|
|
|
| def process_parquet(args): |
| parq_path, mapping = args |
| written = 0 |
| skipped = 0 |
| out_root = process_parquet.out_root |
| f = pq.ParquetFile(parq_path) |
| cols = [ |
| "id", |
| "input_image", |
| "intermediate_image_1", |
| "intermediate_image_2", |
| "intermediate_image_3", |
| ] |
| for batch in f.iter_batches(batch_size=256, columns=cols): |
| df = batch.to_pandas() |
| for _, row in df.iterrows(): |
| sid = row["id"] |
| if sid not in mapping: |
| skipped += 1 |
| continue |
| input_path, inter_paths = mapping[sid] |
| img = row["input_image"] |
| if img is not None and img.get("bytes"): |
| out = os.path.join(out_root, input_path) |
| os.makedirs(os.path.dirname(out), exist_ok=True) |
| if not os.path.exists(out) or os.path.getsize(out) != len(img["bytes"]): |
| with open(out, "wb") as fp: |
| fp.write(img["bytes"]) |
| written += 1 |
| for i, inter_path in enumerate(inter_paths, start=1): |
| col = f"intermediate_image_{i}" |
| img = row.get(col) |
| if img is None or not hasattr(img, "get"): |
| continue |
| b = img.get("bytes") |
| if not b: |
| continue |
| out = os.path.join(out_root, inter_path) |
| os.makedirs(os.path.dirname(out), exist_ok=True) |
| if not os.path.exists(out) or os.path.getsize(out) != len(b): |
| with open(out, "wb") as fp: |
| fp.write(b) |
| written += 1 |
| return parq_path, written, skipped |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--jsonl", required=True) |
| parser.add_argument("--parquet-dir", required=True) |
| parser.add_argument("--out-root", required=True) |
| parser.add_argument("--workers", type=int, default=8) |
| args = parser.parse_args() |
|
|
| mapping = build_mapping(args.jsonl) |
| print(f"Need to extract images for {len(mapping)} samples", flush=True) |
|
|
| files = sorted( |
| os.path.join(args.parquet_dir, f) |
| for f in os.listdir(args.parquet_dir) |
| if f.endswith(".parquet") |
| ) |
| if len(files) != 26: |
| print(f"WARNING: expected 26 parquet shards, found {len(files)}", flush=True) |
| print(f"{len(files)} parquet files", flush=True) |
|
|
| process_parquet.out_root = args.out_root |
| pool_args = [(p, mapping) for p in files] |
| nproc = min(args.workers, len(files)) |
| with mp.Pool(nproc) as pool: |
| for parq_path, written, skipped in pool.imap_unordered(process_parquet, pool_args): |
| print( |
| f" done {os.path.basename(parq_path)}: written={written}, skipped={skipped}", |
| flush=True, |
| ) |
| print("All done.", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
