#!/usr/bin/env python3 """ EyePACS adapter — augmented_resized_V2 (143k DR-graded 600x600 fundus images). Inputs: {input_root}/augmented_resized_V2/{train,val,test}/{0,1,2,3,4}/*.jpg Subdir name = DR grade. Filenames like 005b95c28852-600.jpg. Outputs (under {output_root}): extracted/public_eyepacs_combo_dr_aug/{hash[:2]}/{hash}/ fundus_color.jpg (copied as-is — already 600x600) meta.json manifest/public_eyepacs_combo_dr_aug_images.parquet captions/public_eyepacs_combo_dr_aug_captions.parquet 143k images → multiprocessed. study_hash basename includes split to avoid hash collisions if the same id_code appears across splits (it should not, but be defensive). """ import argparse import json import shutil from concurrent.futures import ProcessPoolExecutor, as_completed from pathlib import Path import pandas as pd from PIL import Image, ImageFile ImageFile.LOAD_TRUNCATED_IMAGES = True from public_common import ( IMAGE_SCHEMA_COLUMNS, CAPTION_SCHEMA_COLUMNS, study_hash_for, default_base_fields, caption_l1_public, caption_l3_public, study_dir_for, rel_file_path, write_meta, coerce_image_row, ) COHORT = "public_eyepacs_combo_dr_aug" COHORT_PHRASE = "EyePACS combined diabetic retinopathy screening dataset (augmented 600x600 v2)" DR_SEVERITY = {0: "none", 1: "mild", 2: "moderate", 3: "severe", 4: "proliferative"} def process_one(args): image_path_str, split, dr_grade, out_root_str, force = args image_path = Path(image_path_str) out_root = Path(out_root_str) basename = f"{split}_{image_path.stem}" # e.g. train_005b95c28852-600 sh = study_hash_for(COHORT, basename) sdir = study_dir_for(out_root, COHORT, sh) sdir.mkdir(parents=True, exist_ok=True) meta_p = sdir / "meta.json" if meta_p.exists() and not force: try: meta = json.loads(meta_p.read_text()) if meta.get("status") == "ok": return _row_and_caps(meta) except Exception: pass dst_img = sdir / "fundus_color.jpg" try: if not dst_img.exists() or force: shutil.copyfile(image_path, dst_img) # Verify the copy is a readable image (catches truncated / non-JPG bytes) with Image.open(dst_img) as im: im.verify() with Image.open(dst_img) as im: w, h = im.size except Exception as e: # Delete the partial copy so a future run can re-attempt try: dst_img.unlink(missing_ok=True) except Exception: pass return ("FAIL", basename, type(e).__name__, str(e)[:200]) meta = { "status": "ok", "cohort": COHORT, "study_hash": sh, "source_basename": basename, "split": split, "image_height_px": int(h), "image_width_px": int(w), "eye": "unknown", "dr_grade": int(dr_grade), } write_meta(sdir, meta) return _row_and_caps(meta) def _row_and_caps(meta: dict): sh = meta["study_hash"] image_id = f"{COHORT}_{sh}_fundus_color" row = default_base_fields(COHORT, sh, eye=meta["eye"]) dr = meta["dr_grade"] row["diagnosis_group"] = ["DR"] if dr > 0 else [] row["severity"] = DR_SEVERITY[dr] row["diagnosis_source"] = "screening_label" row["label_confidence"] = "single_reader" row.update({ "image_id": image_id, "file_path": rel_file_path(COHORT, sh, "fundus_color.jpg"), "file_format": "jpg", "modality": "fundus_color", "anatomy": "macula", "device_technology": "fundus_camera", "scan_protocol": "single_shot", "image_height_px": meta["image_height_px"], "image_width_px": meta["image_width_px"], "has_segmentation": False, "n_layers_visible": 0, "is_valid": True, }) caps = caption_l1_public(image_id, COHORT_PHRASE, "fundus_color", meta["eye"]) l3 = (f"A color fundus photograph from the EyePACS combined DR screening dataset " f"({meta['split']} split, augmented 600x600), " f"diabetic retinopathy grade {dr} ({DR_SEVERITY[dr]}).") caps.append(caption_l3_public(image_id, l3, "manifest_fields+screening_label")) return row, caps def _enumerate_inputs(in_root: Path): base = in_root / "augmented_resized_V2" for split in ("train", "val", "test"): for grade in range(5): d = base / split / str(grade) if not d.exists(): continue for ip in d.glob("*.jpg"): yield (str(ip), split, grade) def main(): ap = argparse.ArgumentParser() ap.add_argument("--input-root", required=True, help="Path to .../Generation/EyePACS (contains augmented_resized_V2/)") ap.add_argument("--output-root", required=True) ap.add_argument("--num-workers", type=int, default=8) ap.add_argument("--force", action="store_true") ap.add_argument("--limit", type=int, default=None) args = ap.parse_args() in_root = Path(args.input_root) out_root = Path(args.output_root) inputs = list(_enumerate_inputs(in_root)) print(f"[{COHORT}] enumerated {len(inputs)} images") if args.limit: inputs = inputs[:args.limit] job_args = [(p, s, g, str(out_root), args.force) for (p, s, g) in inputs] rows, caps = [], [] failures = [] with ProcessPoolExecutor(max_workers=args.num_workers) as ex: futs = [ex.submit(process_one, a) for a in job_args] for i, fut in enumerate(as_completed(futs), 1): try: result = fut.result() except Exception as e: failures.append(("worker", type(e).__name__, str(e)[:200])) continue if isinstance(result, tuple) and len(result) == 4 and result[0] == "FAIL": failures.append(result[1:]) continue row, cap = result rows.append(row) caps.extend(cap) if i % 5000 == 0: print(f" ... {i}/{len(futs)} ({len(failures)} failed so far)") if failures: print(f"[{COHORT}] {len(failures)} images FAILED to extract:") for f in failures[:30]: print(f" {f}") mdir = out_root / "manifest"; cdir = out_root / "captions" mdir.mkdir(parents=True, exist_ok=True); cdir.mkdir(parents=True, exist_ok=True) imgs_df = pd.DataFrame([coerce_image_row(r) for r in rows])[IMAGE_SCHEMA_COLUMNS] imgs_df.to_parquet(mdir / f"{COHORT}_images.parquet", index=False) caps_df = pd.DataFrame(caps)[CAPTION_SCHEMA_COLUMNS] caps_df.to_parquet(cdir / f"{COHORT}_captions.parquet", index=False) print(f"[{COHORT}] wrote {len(imgs_df)} images, {len(caps_df)} captions") print(imgs_df.groupby(["severity"]).size().to_string()) if __name__ == "__main__": main()