Add data processing, de-identification & quality control toolkit

tools/data_processing/README.md

@@ -0,0 +1,36 @@
+# Ophthalmic Data Processing, De-identification & Quality Control Toolkit
+
+This toolkit gathers validated, production-tested scripts written by team members for preprocessing, de-identifying, quality filtering, and structuring raw multi-center ophthalmic datasets.
+
+## 1. Directory Layout & Key Modules
+
+- deidentification/: Privacy redaction & image sanitization
+  - audit_fundus_corner_pii.py: Optical OCR & pixel-density corner PII audit
+  - deidentify_trial.py: Core algorithms (fundus circular mask, frame blackout, OCR regex)
+  - deidentify_batch.py: High-throughput batch de-identification pipeline
+  - fundus_pii_trial.py: Visual inspection harness for burned-in text
+  - test_deidentify_trial.py: Automated regression tests for geometric masking
+  - crop_fundus_images.py: Automatic contour extraction & fundus border cropping
+
+- quality_control/: Multi-stage image & metadata QA
+  - build_quality_risk_review.py: Audits aspect ratios, corrupted headers, and outlier samples
+  - filter_prompt_artifacts.py: Sanitizes prompt formatting noise and deduplicates tags
+  - prompt_qc.py: Validates clinical prompt consistency and anatomical hierarchies
+  - resize_mode_qc.py: Aspect ratio and resolution distribution verification
+  - asrm_preprocess.py: ASRMNet-based fundus quality evaluation preprocessor
+  - clean_excel.py: Cross-references image files against diagnosis tables
+
+- report_parsing/: Clinical report extraction & multimodal matching
+  - materialize_newdata_prompts.py: Generates unified 41-column structured manifests
+  - attach_labels.py: Merges free-text clinical reports with image records
+  - batch_retrieve_reports.py: RoBERTa-SigLIP zero-shot image-to-report cross-modal retrieval
+  - cohorts.py: Master registry of all multi-center hospital datasets
+
+- taxonomy/: Clinical taxonomy & bilingual standardizations
+  - build_mixed_v5_taxonomy.py: Disease category crosswalk mapping
+  - build_mixed_v6_taxonomy.py: 95-disease hierarchical taxonomy builder (ICD/SNOMED aligned)
+  - test_build_mixed_v6_taxonomy.py: Taxonomy integrity tests
+  - test_taxonomy_sampling.py: Category-balanced sampling evaluation
+
+## 2. Provenance & Attribution
+Developed by ZJU & Multimodal Ophthalmology Lab contributors (Lisicheng, Zhanghuan, Huchengwei, Lizekun).

tools/data_processing/deidentification/audit_fundus_corner_pii.py

@@ -0,0 +1,291 @@
+"""Audit fundus-like cohorts for residual top-left burned-in PII.
+
+This script samples images from a prompt-adapter manifest, computes a fast
+top-left white-text proxy, optionally runs OCR on top candidates, and writes a
+review HTML. It never modifies source images and never stores raw OCR text.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import io
+import json
+import math
+import tarfile
+from pathlib import Path
+from typing import Any
+
+import cv2
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+
+DEFAULT_MANIFEST = Path(
+    "/data/team/lisicheng/new_data_manifest/"
+    "prompt_adapter_mixed_v6_exclude_octbuckets_octa/adapter_manifest_mixed_v6.parquet"
+)
+DEFAULT_OUT = Path("/data/team/lisicheng/Code/OCTFlow/pilot/path1/audit/fundus_corner_pii_audit_20260709")
+DEFAULT_COHORTS = [
+    "tongren_fundus",
+    "tongren_95disease_fundus",
+    "fundus90wer",
+    "fq_rawfundus",
+    "fq_testfundus",
+    "tongren_external_fundus",
+    "eryuan_t17_fundus",
+    "hcw_fundus",
+    "eyfrd6_fundus",
+]
+
+
+class ImageOpener:
+    def __init__(self) -> None:
+        self._tar_cache: dict[str, tarfile.TarFile] = {}
+
+    def close(self) -> None:
+        for tf in self._tar_cache.values():
+            tf.close()
+        self._tar_cache.clear()
+
+    def open(self, path: str) -> Image.Image:
+        if "::" not in path:
+            return Image.open(path).convert("RGB")
+        tar_path, member = path.split("::", 1)
+        tf = self._tar_cache.get(tar_path)
+        if tf is None:
+            tf = tarfile.open(tar_path, "r:*")
+            self._tar_cache[tar_path] = tf
+        fh = tf.extractfile(member)
+        if fh is None:
+            raise FileNotFoundError(member)
+        return Image.open(io.BytesIO(fh.read())).convert("RGB")
+
+
+def top_left_text_proxy(im: Image.Image, top_ratio: float, left_ratio: float) -> dict[str, float]:
+    arr = np.asarray(im.convert("RGB"), dtype=np.float32)
+    h, w = arr.shape[:2]
+    crop = arr[: max(1, int(h * top_ratio)), : max(1, int(w * left_ratio))]
+    gray = crop.mean(axis=2)
+    white = (crop[..., 0] > 180) & (crop[..., 1] > 180) & (crop[..., 2] > 180)
+    dx = np.abs(np.diff(gray, axis=1))
+    dy = np.abs(np.diff(gray, axis=0)) if gray.shape[0] > 1 else np.zeros_like(dx)
+    edge_density = float(((dx > 18).mean() + (dy > 18).mean()) / 2.0)
+    white_fraction = float(white.mean())
+    return {
+        "corner_white_fraction": round(white_fraction, 6),
+        "corner_edge_density": round(edge_density, 6),
+        "corner_gray_std": round(float(gray.std()), 4),
+        "corner_text_score": round(float(white_fraction * 100.0 + edge_density * 10.0), 6),
+    }
+
+
+def likely_text(stats: dict[str, float]) -> bool:
+    return (
+        stats["corner_white_fraction"] >= 0.01
+        and stats["corner_edge_density"] >= 0.006
+        and stats["corner_gray_std"] >= 15.0
+    )
+
+
+def load_ocr_reader(enable: bool) -> object | None:
+    if not enable:
+        return None
+    import easyocr
+
+    return easyocr.Reader(["ch_sim", "en"], gpu=True)
+
+
+def run_ocr(reader: object | None, im: Image.Image, top_ratio: float, left_ratio: float) -> dict[str, Any]:
+    if reader is None:
+        return {
+            "ocr_checked": False,
+            "ocr_box_count": 0,
+            "ocr_has_age": False,
+            "ocr_has_sex": False,
+            "ocr_has_chinese": False,
+            "ocr_has_any_text": False,
+        }
+    arr = np.asarray(im.convert("RGB"))
+    h, w = arr.shape[:2]
+    crop = arr[: max(1, int(h * top_ratio)), : max(1, int(w * left_ratio))]
+    results = reader.readtext(crop, detail=1)
+    detected_text = " ".join(str(item[1]) for item in results if len(item) >= 2)
+    return {
+        "ocr_checked": True,
+        "ocr_box_count": int(len(results)),
+        "ocr_has_age": bool(("岁" in detected_text) or any(str(i) in detected_text for i in range(1, 100))),
+        "ocr_has_sex": bool(("男" in detected_text) or ("女" in detected_text)),
+        "ocr_has_chinese": bool(any("\u4e00" <= ch <= "\u9fff" for ch in detected_text)),
+        "ocr_has_any_text": bool(detected_text.strip()),
+    }
+
+
+def thumb_data(im: Image.Image, size: int) -> str:
+    thumb = im.copy()
+    thumb.thumbnail((size, size), Image.Resampling.LANCZOS)
+    canvas = Image.new("RGB", (size, size), (0, 0, 0))
+    canvas.paste(thumb, ((size - thumb.width) // 2, (size - thumb.height) // 2))
+    buf = io.BytesIO()
+    canvas.save(buf, format="JPEG", quality=86)
+    return "data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode("ascii")
+
+
+def json_safe(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {str(k): json_safe(v) for k, v in value.items()}
+    if isinstance(value, list | tuple):
+        return [json_safe(v) for v in value]
+    if isinstance(value, np.integer):
+        return int(value)
+    if isinstance(value, np.floating):
+        value = float(value)
+    if isinstance(value, float):
+        return value if math.isfinite(value) else None
+    try:
+        if pd.isna(value):
+            return None
+    except (TypeError, ValueError):
+        pass
+    return value
+
+
+def audit(args: argparse.Namespace) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    df = pd.read_parquet(
+        args.manifest,
+        columns=["image_id", "cohort", "modality", "modality_subtype", "file_path"],
+    )
+    df = df[df["cohort"].astype(str).isin(args.cohorts)].copy()
+    sampled = []
+    for cohort, group in df.groupby("cohort", sort=True):
+        sampled.append(group.sample(n=min(args.per_cohort, len(group)), random_state=args.seed))
+    sample = pd.concat(sampled, ignore_index=True) if sampled else df.head(0)
+
+    opener = ImageOpener()
+    rows: list[dict[str, Any]] = []
+    try:
+        for i, row in enumerate(sample.to_dict("records"), start=1):
+            rec = {k: row.get(k) for k in row}
+            rec["decode_error"] = ""
+            try:
+                im = opener.open(str(row["file_path"]))
+                rec.update(top_left_text_proxy(im, args.top_ratio, args.left_ratio))
+                rec["likely_corner_text"] = likely_text(rec)
+                rec["_image"] = im
+            except Exception as exc:
+                rec["decode_error"] = repr(exc)
+                rec["likely_corner_text"] = False
+                rec["corner_white_fraction"] = None
+                rec["corner_edge_density"] = None
+                rec["corner_gray_std"] = None
+                rec["corner_text_score"] = None
+                rec["_image"] = None
+            rows.append(rec)
+            if i % 200 == 0:
+                print(f"[scan] {i}/{len(sample)}", flush=True)
+    finally:
+        opener.close()
+
+    rows.sort(key=lambda r: (str(r.get("cohort")), -(r.get("corner_text_score") or 0.0)))
+    ocr_targets: list[dict[str, Any]] = []
+    for _, group in pd.DataFrame([{k: v for k, v in r.items() if k != "_image"} for r in rows]).groupby("cohort", sort=True):
+        ids = set(group.sort_values("corner_text_score", ascending=False).head(args.ocr_top_per_cohort)["image_id"].astype(str))
+        ocr_targets.extend([r for r in rows if str(r["image_id"]) in ids])
+
+    reader = load_ocr_reader(args.ocr)
+    target_ids = {str(r["image_id"]) for r in ocr_targets}
+    for rec in rows:
+        if str(rec["image_id"]) in target_ids and rec.get("_image") is not None:
+            rec.update(run_ocr(reader, rec["_image"], args.top_ratio, args.left_ratio))
+        else:
+            rec.update(run_ocr(None, None, args.top_ratio, args.left_ratio))
+
+    html_records = []
+    for _, group in pd.DataFrame([{k: v for k, v in r.items() if k != "_image"} for r in rows]).groupby("cohort", sort=True):
+        ids = set(group.sort_values("corner_text_score", ascending=False).head(args.html_top_per_cohort)["image_id"].astype(str))
+        html_records.extend([r for r in rows if str(r["image_id"]) in ids])
+    for rec in html_records:
+        im = rec.get("_image")
+        rec["thumb_data"] = thumb_data(im, args.thumb_size) if im is not None else ""
+
+    clean_rows = [{k: v for k, v in r.items() if k != "_image"} for r in rows]
+    clean_html = [{k: v for k, v in r.items() if k != "_image"} for r in html_records]
+    data = pd.DataFrame(clean_rows)
+    summary = {
+        "manifest": str(args.manifest),
+        "rows_sampled": int(len(clean_rows)),
+        "per_cohort": int(args.per_cohort),
+        "likely_corner_text_total": int(data["likely_corner_text"].sum()) if len(data) else 0,
+        "decode_errors": int(data["decode_error"].fillna("").astype(str).ne("").sum()) if len(data) else 0,
+        "by_cohort": data.groupby("cohort").agg(
+            sampled=("image_id", "count"),
+            likely_corner_text=("likely_corner_text", "sum"),
+            mean_corner_text_score=("corner_text_score", "mean"),
+            max_corner_text_score=("corner_text_score", "max"),
+            ocr_checked=("ocr_checked", "sum"),
+            ocr_has_any_text=("ocr_has_any_text", "sum"),
+            ocr_has_chinese=("ocr_has_chinese", "sum"),
+            ocr_has_age=("ocr_has_age", "sum"),
+            ocr_has_sex=("ocr_has_sex", "sum"),
+        ).reset_index().to_dict("records")
+        if len(data)
+        else [],
+    }
+    return clean_rows, {"summary": summary, "html_records": clean_html}
+
+
+def write_html(records: list[dict[str, Any]], out: Path) -> None:
+    rows_json = json.dumps(json_safe(records), ensure_ascii=False, allow_nan=False).replace("</", "<\\/")
+    css = """:root{--bg:#f5f6f8;--panel:#fff;--line:#d8dee8;--text:#1f2937;--muted:#667085;--blue:#0f62fe}*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--text);font-family:Arial,"Noto Sans CJK SC","Microsoft YaHei",sans-serif}header{position:sticky;top:0;background:#fff;border-bottom:1px solid var(--line);padding:12px 16px}.viewer{display:grid;grid-template-columns:minmax(440px,52vw) 1fr;gap:14px;padding:14px}.panel{background:#fff;border:1px solid var(--line);border-radius:6px;padding:12px}.imgbox{height:min(68vh,720px);min-height:420px;background:#050505;display:flex;align-items:center;justify-content:center;overflow:hidden}.imgbox img{max-width:100%;max-height:100%;object-fit:contain}.badge{display:inline-block;border-radius:999px;padding:3px 8px;margin:0 5px 6px 0;font-size:12px;background:#edf2ff;color:#173b8f}.bad{background:#ffecec;color:#9b1c1c}.meta{font-size:13px;line-height:1.5;word-break:break-word}.path{font-family:monospace;font-size:12px;color:#334155}button,input{font-size:13px;border:1px solid #b8c0cc;border-radius:4px;background:#fff;padding:7px 9px}button.primary{background:var(--blue);border-color:var(--blue);color:#fff}"""
+    js = """
+const rows = JSON.parse(document.getElementById('rows-data').textContent);
+let idx = 0;
+function esc(v) { return String(v ?? '').replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c])); }
+function go(delta) { idx=Math.max(0, Math.min(rows.length-1, idx+delta)); render(); }
+function gotoIndex(v) { const n=Number(v); if (Number.isFinite(n)) { idx=Math.max(0, Math.min(rows.length-1, n-1)); render(); } }
+function render() {
+  if (!rows.length) { document.getElementById('root').innerHTML='<div class=viewer><div class=panel>没有样本。</div></div>'; return; }
+  const r=rows[idx];
+  document.getElementById('progress').textContent=`第 ${idx+1} / ${rows.length} 张`;
+  document.getElementById('jump').value=idx+1;
+  document.getElementById('root').innerHTML=`<section class="viewer"><div class="panel"><div class="imgbox"><img src="${esc(r.thumb_data)}"></div></div><div class="panel"><div><span class="badge ${r.likely_corner_text ? 'bad' : ''}">likely_corner_text=${esc(r.likely_corner_text)}</span><span class="badge">score=${esc(r.corner_text_score)}</span><span class="badge">${esc(r.cohort)}</span></div><div class="meta"><b>image_id</b>: ${esc(r.image_id)}<br><b>modality</b>: ${esc(r.modality_subtype)}<br><b>corner white</b>: ${esc(r.corner_white_fraction)}; <b>edge</b>: ${esc(r.corner_edge_density)}; <b>std</b>: ${esc(r.corner_gray_std)}<br><b>OCR checked</b>: ${esc(r.ocr_checked)}; <b>any</b>: ${esc(r.ocr_has_any_text)}; <b>Chinese</b>: ${esc(r.ocr_has_chinese)}; <b>age</b>: ${esc(r.ocr_has_age)}; <b>sex</b>: ${esc(r.ocr_has_sex)}<br><b>path</b>: <span class="path">${esc(r.file_path)}</span></div></div></section>`;
+}
+document.addEventListener('keydown', ev => { if (ev.key === 'ArrowRight') go(1); else if (ev.key === 'ArrowLeft') go(-1); });
+render();
+"""
+    doc = f"""<!doctype html><html><head><meta charset="utf-8"><title>Fundus corner PII audit</title><style>{css}</style></head><body><header><h1>Fundus corner PII audit</h1><span id="progress"></span> <button onclick="go(-1)">上一张</button> <button class="primary" onclick="go(1)">下一张</button> <label>跳转 <input id="jump" type="number" min="1" max="{len(records)}" onchange="gotoIndex(this.value)" style="width:80px"></label></header><main id="root"></main><script type="application/json" id="rows-data">{rows_json}</script><script>{js}</script></body></html>"""
+    out.write_text(doc, encoding="utf-8")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    parser.add_argument("--cohorts", nargs="+", default=DEFAULT_COHORTS)
+    parser.add_argument("--per-cohort", type=int, default=400)
+    parser.add_argument("--ocr-top-per-cohort", type=int, default=20)
+    parser.add_argument("--html-top-per-cohort", type=int, default=30)
+    parser.add_argument("--top-ratio", type=float, default=0.18)
+    parser.add_argument("--left-ratio", type=float, default=0.20)
+    parser.add_argument("--thumb-size", type=int, default=512)
+    parser.add_argument("--seed", type=int, default=20260709)
+    parser.add_argument("--ocr", action=argparse.BooleanOptionalAction, default=True)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+    rows, payload = audit(args)
+    pd.DataFrame(rows).to_csv(args.out / "corner_pii_sample_stats.csv", index=False)
+    (args.out / "summary.json").write_text(
+        json.dumps(json_safe(payload["summary"]), ensure_ascii=False, indent=2, allow_nan=False),
+        encoding="utf-8",
+    )
+    write_html(payload["html_records"], args.out / "OPEN_THIS_FUNDUS_CORNER_PII_AUDIT.html")
+    print(json.dumps(json_safe(payload["summary"]), ensure_ascii=False), flush=True)
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/deidentification/crop_fundus_images.py

@@ -0,0 +1,120 @@
+import cv2
+import numpy as np
+import os
+import argparse
+from tqdm import tqdm
+import csv
+
+def crop_and_save_image(input_path, output_path, padding=10):
+    """
+    Crop a single fundus image to remove black background and save to the specified path.
+
+    Returns:
+        dict: A dictionary containing cropping information, used for writing to CSV.
+    """
+    try:
+        image = cv2.imread(input_path)
+        if image is None:
+            print(f"Warning: Unable to read image {input_path}, skipped.")
+            return None
+
+        original_h, original_w = image.shape[:2]
+
+        # Convert to grayscale for thresholding
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        _, thresh = cv2.threshold(gray, 10, 255, cv2.THRESH_BINARY)
+
+        # Find contours
+        contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        if not contours:
+            print(f"Warning: No contours found in image {input_path}, skipped.")
+            return None
+
+        # Find the largest contour (main fundus region)
+        main_contour = max(contours, key=cv2.contourArea)
+        x, y, w, h = cv2.boundingRect(main_contour)
+
+        img_h, img_w = original_h, original_w
+        x1 = max(0, x - padding)
+        y1 = max(0, y - padding)
+        x2 = min(img_w, x + w + padding)
+        y2 = min(img_h, y + h + padding)
+
+        cropped_image = image[y1:y2, x1:x2]
+
+        # Replace white spots in black background with black
+        white_mask = np.all(cropped_image == [255, 255, 255], axis=-1)
+        cropped_image[white_mask] = [0, 0, 0]
+
+        cv2.imwrite(output_path, cropped_image)
+
+        # Calculate cropped pixels (left, top, right, bottom)
+        left_crop = x1
+        top_crop = y1
+        right_crop = img_w - x2
+        bottom_crop = img_h - y2
+
+        return {
+            "filename": os.path.basename(input_path),
+            "original_width": original_w,
+            "original_height": original_h,
+            "left_crop": left_crop,
+            "top_crop": top_crop,
+            "right_crop": right_crop,
+            "bottom_crop": bottom_crop
+        }
+
+    except Exception as e:
+        print(f"Error processing file {input_path}: {e}")
+        return None
+
+def main():
+    parser = argparse.ArgumentParser(description="Automatically crop fundus images to remove black background.")
+    parser.add_argument('-i', '--input_dir', help="Input directory containing original images.", default="csdi_datasets/original_images")
+    parser.add_argument('-o', '--output_dir', help="Output directory for saving cropped images.", default="csdi_datasets/croped_images")
+    parser.add_argument('-p', '--padding', type=int, default=0, help="Extra pixel padding around the crop boundary, default 0.")
+    parser.add_argument('-c', '--csv_path', type=str, default="crop_info.csv", help="CSV file path to save cropping information, default 'crop_info.csv'.")
+
+    args = parser.parse_args()
+    input_dir = args.input_dir
+    output_dir = args.output_dir
+    padding = args.padding
+    csv_path = args.csv_path
+
+    if not os.path.isdir(input_dir):
+        print(f"Error: Input directory '{input_dir}' does not exist.")
+        return
+
+    os.makedirs(output_dir, exist_ok=True)
+    print(f"Cropped images will be saved to: '{output_dir}'")
+
+    supported_formats = ('.png', '.jpg', '.jpeg', '.bmp', '.tif', '.tiff')
+    image_files = [f for f in os.listdir(input_dir) if f.lower().endswith(supported_formats)]
+
+    if not image_files:
+        print(f"No supported image files found in directory '{input_dir}'.")
+        return
+
+    crop_records = []
+
+    print(f"Found {len(image_files)} images, starting processing...")
+    for filename in tqdm(image_files, desc="Processing progress"):
+        input_image_path = os.path.join(input_dir, filename)
+        output_image_path = os.path.join(output_dir, filename)
+
+        record = crop_and_save_image(input_image_path, output_image_path, padding)
+        if record:
+            crop_records.append(record)
+
+    # Write CSV file
+    with open(csv_path, 'w', newline='', encoding='utf-8') as csvfile:
+        fieldnames = ["filename", "original_width", "original_height", "left_crop", "top_crop", "right_crop", "bottom_crop"]
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+        for rec in crop_records:
+            writer.writerow(rec)
+
+    print(f"All images processed! Cropping information saved to '{csv_path}'.")
+
+if __name__ == '__main__':
+    main()

tools/data_processing/deidentification/deidentify_batch.py

@@ -0,0 +1,501 @@
+"""Batch de-identification for cohorts with confirmed pixel-level PII.
+
+Original images are read-only. Processed images are written as opaque-ID JPEGs
+under /data/team/lisicheng/new_data_deid and the manifest is updated to use
+train_path for the affected cohorts.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import tarfile
+from pathlib import Path
+from typing import Any
+
+import cv2
+import numpy as np
+
+from deidentify_trial import (
+    blackout_frame,
+    deidentify_fundus_circle,
+    deidentify_fundus_left_outside_circle,
+    load_easyocr_reader,
+    maybe_ocr_metadata,
+    make_sheet,
+    read_image,
+    write_image,
+)
+
+
+DEFAULT_MANIFEST = Path(
+    "/data/team/lisicheng/new_data_manifest/"
+    "new_data_manifest_dedup_split_labeled_with_wds.parquet"
+)
+DEFAULT_OUT_ROOT = Path("/data/team/lisicheng/new_data_deid")
+DEFAULT_TONGREN_METADATA = Path("/data/team/lisicheng/Dataser/tongren_metadata.csv")
+DEID_COHORTS = (
+    "tongren_95disease_fundus",
+    "fundus90wer",
+    "eryuan_fundus",
+    "xiangya_bscan",
+    "tongren_fundus",
+    "tongren_external_fundus",
+    "fq_testfundus",
+    "fq_rawfundus",
+    "fq_validfundus",
+)
+LEFT_ONLY_FUNDUS_COHORTS = {
+    "tongren_fundus",
+    "tongren_external_fundus",
+    "fq_testfundus",
+    "fq_rawfundus",
+    "fq_validfundus",
+}
+FULL_CIRCLE_FUNDUS_COHORTS = {
+    "tongren_95disease_fundus",
+    "fundus90wer",
+    "eryuan_fundus",
+}
+
+
+def main() -> None:
+    args = parse_args()
+    if args.command == "prepare":
+        prepare_inputs(args)
+    elif args.command == "process":
+        process_inputs(args)
+    elif args.command == "finalize":
+        finalize_manifest(args)
+    elif args.command == "qc":
+        build_qc(args)
+    else:
+        raise ValueError(f"unknown command: {args.command}")
+
+
+def prepare_inputs(args: argparse.Namespace) -> None:
+    import pandas as pd
+
+    args.out_root.mkdir(parents=True, exist_ok=True)
+    meta_dir = args.out_root / "metadata"
+    meta_dir.mkdir(parents=True, exist_ok=True)
+    out_jsonl = args.input_jsonl or meta_dir / "deid_inputs.jsonl"
+
+    df = pd.read_parquet(args.manifest)
+    cohorts = tuple(args.cohorts or DEID_COHORTS)
+    subset = df[df["cohort"].isin(cohorts)].copy()
+    if args.limit:
+        subset = subset.groupby("cohort", group_keys=False).head(args.limit)
+
+    fields = ["image_id", "cohort", "file_path", "train_path", "rel_path", "modality"]
+    missing = [field for field in fields if field not in subset.columns]
+    if missing:
+        raise KeyError(f"manifest missing columns: {missing}")
+
+    tongren_meta = load_tongren_metadata(args.tongren_metadata)
+    with out_jsonl.open("w", encoding="utf-8") as f:
+        for row in subset[fields].to_dict("records"):
+            meta = metadata_for_row(row, tongren_meta)
+            row.update({f"ocr_{key}": value for key, value in meta.items()})
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+    counts = subset.groupby("cohort").size().to_dict()
+    print(json.dumps({"input_jsonl": str(out_jsonl), "counts": counts}, ensure_ascii=False))
+
+
+def process_inputs(args: argparse.Namespace) -> None:
+    meta_dir = args.out_root / "metadata"
+    meta_dir.mkdir(parents=True, exist_ok=True)
+    shard_name = f"{args.run_name}_shard{args.shard_index:03d}-of-{args.num_shards:03d}.jsonl"
+    metadata_path = args.metadata_jsonl or meta_dir / shard_name
+    if metadata_path.exists() and not args.overwrite_metadata:
+        raise FileExistsError(f"metadata exists; use --overwrite-metadata: {metadata_path}")
+
+    done_ids = load_done_ids(args.skip_done_metadata_dir, args.skip_done_metadata_glob)
+    if done_ids:
+        print(f"[resume] loaded {len(done_ids)} completed image_ids")
+
+    reader = load_easyocr_reader(args.ocr)
+    n_seen = 0
+    n_skip = 0
+    n_done = 0
+    n_error = 0
+    with args.input_jsonl.open("r", encoding="utf-8") as src, metadata_path.open(
+        "w", encoding="utf-8"
+    ) as meta_out:
+        for idx, line in enumerate(src):
+            if idx % args.num_shards != args.shard_index:
+                continue
+            if args.limit and n_seen >= args.limit:
+                break
+            n_seen += 1
+            row = json.loads(line)
+            if row.get("image_id") in done_ids:
+                n_skip += 1
+                continue
+            try:
+                result = process_one(row, args, reader)
+                n_done += 1
+            except Exception as exc:
+                n_error += 1
+                result = {
+                    "image_id": row.get("image_id"),
+                    "cohort": row.get("cohort"),
+                    "ok": False,
+                    "error": repr(exc),
+                }
+            meta_out.write(json.dumps(result, ensure_ascii=False) + "\n")
+            if n_seen % args.log_every == 0:
+                print(
+                    f"[{args.shard_index}/{args.num_shards}] "
+                    f"seen={n_seen} skip={n_skip} done={n_done} err={n_error}"
+                )
+    print(
+        json.dumps(
+            {
+                "metadata_jsonl": str(metadata_path),
+                "seen": n_seen,
+                "skip": n_skip,
+                "done": n_done,
+                "error": n_error,
+            },
+            ensure_ascii=False,
+        )
+    )
+
+
+def process_one(row: dict[str, Any], args: argparse.Namespace, reader: object | None) -> dict[str, Any]:
+    cohort = row["cohort"]
+    src_path = str(row.get("train_path") or row["file_path"])
+    image_id = row["image_id"]
+    out_path = args.out_root / "images" / cohort / f"{image_id}.jpg"
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    img = read_image_any(src_path)
+    ocr_meta: dict[str, int | str] = existing_ocr_meta(row)
+    circle_ok: bool | None = None
+    circle_info: dict[str, Any] | None = None
+
+    if cohort in FULL_CIRCLE_FUNDUS_COHORTS:
+        if reader is not None and not ocr_meta:
+            ocr_meta = maybe_ocr_metadata(img, reader)
+        out_img, circle_ok, circle_info = deidentify_fundus_circle(
+            img,
+            radius_ratio=args.fundus_radius_ratio,
+            threshold=args.fundus_threshold,
+            open_kernel=args.fundus_open_kernel,
+        )
+        method = "fundus_circle_mask"
+    elif cohort in LEFT_ONLY_FUNDUS_COHORTS:
+        if reader is not None and not ocr_meta:
+            ocr_meta = maybe_ocr_metadata(img, reader)
+        out_img, circle_ok, circle_info = deidentify_fundus_left_outside_circle(
+            img,
+            radius_ratio=args.left_fundus_radius_ratio,
+            left_ratio=args.left_fundus_ratio,
+            threshold=args.fundus_threshold,
+            open_kernel=args.fundus_open_kernel,
+        )
+        method = "fundus_left_outside_circle_mask_r0985_l055"
+    elif cohort == "xiangya_bscan":
+        out_img = blackout_frame(
+            img,
+            top=args.bscan_top,
+            bottom=args.bscan_bottom,
+            right=args.bscan_right,
+        )
+        method = "bscan_blackout_top10_bottom5_right2"
+    else:
+        raise ValueError(f"unsupported cohort: {cohort}")
+
+    if not out_path.exists() or args.overwrite_images:
+        write_image(out_path, out_img, quality=args.jpeg_quality)
+
+    return {
+        "image_id": image_id,
+        "cohort": cohort,
+        "ok": True,
+        "source_path": src_path,
+        "deid_path": str(out_path),
+        "deid_method": method,
+        "pii_masked": True,
+        "ocr_age": ocr_meta.get("age"),
+        "ocr_sex": ocr_meta.get("sex"),
+        "ocr_eye": ocr_meta.get("eye"),
+        "circle_ok": circle_ok,
+        "circle_info": circle_info,
+    }
+
+
+def finalize_manifest(args: argparse.Namespace) -> None:
+    import pandas as pd
+
+    meta_files = sorted(args.metadata_dir.glob(args.metadata_glob))
+    if not meta_files:
+        raise FileNotFoundError(f"no metadata files match {args.metadata_dir}/{args.metadata_glob}")
+
+    rows: list[dict[str, Any]] = []
+    failed_rows: list[dict[str, Any]] = []
+    for path in meta_files:
+        with path.open("r", encoding="utf-8") as f:
+            for line in f:
+                try:
+                    row = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if row.get("ok"):
+                    rows.append(row)
+                elif row.get("image_id"):
+                    failed_rows.append(row)
+    meta = pd.DataFrame(rows)
+    if meta.empty:
+        raise ValueError("no successful deid metadata rows found")
+    meta = meta.drop_duplicates("image_id", keep="last")
+
+    df = pd.read_parquet(args.manifest)
+    df = df.copy()
+    if "train_path" not in df.columns:
+        df["train_path"] = df["file_path"]
+    else:
+        df["train_path"] = df["train_path"].where(df["train_path"].notna(), df["file_path"])
+    for col, default in [
+        ("deid_path", None),
+        ("pii_masked", False),
+        ("deid_method", None),
+        ("ocr_age", None),
+        ("ocr_sex", None),
+        ("ocr_eye", None),
+    ]:
+        if col not in df.columns:
+            df[col] = default
+
+    cols = ["image_id", "deid_path", "deid_method", "ocr_age", "ocr_sex", "ocr_eye"]
+    merged = df.merge(meta[cols], on="image_id", how="left", suffixes=("", "_new"))
+    has_deid = merged["deid_path_new"].notna()
+    nullable_cols = [
+        "deid_path",
+        "deid_path_new",
+        "deid_method",
+        "deid_method_new",
+        "ocr_age",
+        "ocr_age_new",
+        "ocr_sex",
+        "ocr_sex_new",
+        "ocr_eye",
+        "ocr_eye_new",
+    ]
+    for col in nullable_cols:
+        if col in merged.columns:
+            merged[col] = merged[col].astype("object")
+    merged.loc[has_deid, "train_path"] = merged.loc[has_deid, "deid_path_new"]
+    merged.loc[has_deid, "deid_path"] = merged.loc[has_deid, "deid_path_new"]
+    merged.loc[has_deid, "pii_masked"] = True
+    for col in ["deid_method", "ocr_age", "ocr_sex", "ocr_eye"]:
+        merged.loc[has_deid, col] = merged.loc[has_deid, f"{col}_new"]
+    merged = merged.drop(columns=[f"{col}_new" for col in cols if col != "image_id"])
+
+    required_cohorts = tuple(args.cohorts or DEID_COHORTS)
+    missing_deid = merged["cohort"].isin(required_cohorts) & ~merged["pii_masked"]
+    dropped_missing_deid = int(missing_deid.sum())
+    if dropped_missing_deid:
+        missing_path = args.out_manifest.with_suffix(".missing_deid.jsonl")
+        missing_records = merged.loc[
+            missing_deid, ["image_id", "cohort", "file_path", "rel_path"]
+        ].to_dict("records")
+        failure_by_id = {row.get("image_id"): row for row in failed_rows}
+        with missing_path.open("w", encoding="utf-8") as f:
+            for row in missing_records:
+                failure = failure_by_id.get(row["image_id"])
+                if failure:
+                    row["error"] = failure.get("error")
+                f.write(json.dumps(row, ensure_ascii=False) + "\n")
+        if args.drop_missing_deid:
+            merged = merged.loc[~missing_deid].copy()
+
+    args.out_manifest.parent.mkdir(parents=True, exist_ok=True)
+    merged.to_parquet(args.out_manifest, index=False)
+    print(
+        json.dumps(
+            {
+                "out_manifest": str(args.out_manifest),
+                "rows": int(len(merged)),
+                "pii_masked": int(merged["pii_masked"].sum()),
+                "by_cohort": merged[merged["pii_masked"]].groupby("cohort").size().to_dict(),
+                "dropped_missing_deid": dropped_missing_deid if args.drop_missing_deid else 0,
+            },
+            ensure_ascii=False,
+        )
+    )
+
+
+def build_qc(args: argparse.Namespace) -> None:
+    rows = []
+    with args.metadata_jsonl.open("r", encoding="utf-8") as f:
+        for line in f:
+            row = json.loads(line)
+            if args.cohort and row.get("cohort") != args.cohort:
+                continue
+            if row.get("ok"):
+                rows.append(row)
+    rows = rows[: args.n]
+    groups = []
+    for row in rows:
+        src = read_image_any(str(row["source_path"]))
+        deid = read_image(Path(row["deid_path"]))
+        groups.append([src, deid])
+    make_sheet(groups, ["source", "deid"], args.out, cell=args.cell)
+    print(f"DONE -> {args.out}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("prepare")
+    p.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    p.add_argument("--out-root", type=Path, default=DEFAULT_OUT_ROOT)
+    p.add_argument("--input-jsonl", type=Path, default=None)
+    p.add_argument("--cohorts", nargs="+", default=list(DEID_COHORTS))
+    p.add_argument("--tongren-metadata", type=Path, default=DEFAULT_TONGREN_METADATA)
+    p.add_argument("--limit", type=int, default=None)
+
+    p = sub.add_parser("process")
+    p.add_argument("--input-jsonl", type=Path, required=True)
+    p.add_argument("--out-root", type=Path, default=DEFAULT_OUT_ROOT)
+    p.add_argument("--run-name", default="deid")
+    p.add_argument("--metadata-jsonl", type=Path, default=None)
+    p.add_argument("--overwrite-metadata", action="store_true")
+    p.add_argument("--overwrite-images", action="store_true")
+    p.add_argument("--skip-done-metadata-dir", type=Path, default=None)
+    p.add_argument("--skip-done-metadata-glob", default="*.jsonl")
+    p.add_argument("--num-shards", type=int, default=1)
+    p.add_argument("--shard-index", type=int, default=0)
+    p.add_argument("--limit", type=int, default=None)
+    p.add_argument("--log-every", type=int, default=1000)
+    p.add_argument("--ocr", action=argparse.BooleanOptionalAction, default=True)
+    p.add_argument("--jpeg-quality", type=int, default=95)
+    p.add_argument("--fundus-radius-ratio", type=float, default=0.97)
+    p.add_argument("--left-fundus-radius-ratio", type=float, default=0.985)
+    p.add_argument("--left-fundus-ratio", type=float, default=0.55)
+    p.add_argument("--fundus-threshold", type=int, default=25)
+    p.add_argument("--fundus-open-kernel", type=int, default=25)
+    p.add_argument("--bscan-top", type=float, default=0.10)
+    p.add_argument("--bscan-bottom", type=float, default=0.05)
+    p.add_argument("--bscan-right", type=float, default=0.02)
+
+    p = sub.add_parser("finalize")
+    p.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    p.add_argument("--metadata-dir", type=Path, default=DEFAULT_OUT_ROOT / "metadata")
+    p.add_argument("--metadata-glob", default="deid_shard*.jsonl")
+    p.add_argument("--cohorts", nargs="+", default=list(DEID_COHORTS))
+    p.add_argument("--drop-missing-deid", action=argparse.BooleanOptionalAction, default=True)
+    p.add_argument(
+        "--out-manifest",
+        type=Path,
+        default=DEFAULT_MANIFEST.with_name(
+            "new_data_manifest_dedup_split_labeled_with_wds_deid.parquet"
+        ),
+    )
+
+    p = sub.add_parser("qc")
+    p.add_argument("--metadata-jsonl", type=Path, required=True)
+    p.add_argument("--out", type=Path, required=True)
+    p.add_argument("--cohort", default=None)
+    p.add_argument("--n", type=int, default=24)
+    p.add_argument("--cell", type=int, default=256)
+
+    return parser.parse_args()
+
+
+def load_done_ids(metadata_dir: Path | None, metadata_glob: str) -> set[str]:
+    if metadata_dir is None:
+        return set()
+    done: set[str] = set()
+    for path in sorted(metadata_dir.glob(metadata_glob)):
+        with path.open("r", encoding="utf-8") as f:
+            for line in f:
+                try:
+                    row = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if row.get("ok") and row.get("image_id"):
+                    done.add(row["image_id"])
+    return done
+
+
+def read_image_any(path: str) -> Any:
+    if "::" not in path:
+        return read_image(Path(path))
+
+    tar_path, member_name = path.split("::", 1)
+    with tarfile.open(tar_path, "r:*") as tf:
+        member = tf.getmember(member_name)
+        fp = tf.extractfile(member)
+        if fp is None:
+            raise FileNotFoundError(path)
+        data = fp.read()
+    arr = np.frombuffer(data, dtype=np.uint8)
+    img = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+    if img is None:
+        raise ValueError(f"failed to decode image: {path}")
+    return img
+
+
+def load_tongren_metadata(path: Path) -> dict[str, dict[str, Any]]:
+    if not path.exists():
+        return {}
+    import pandas as pd
+
+    meta = pd.read_csv(path)
+    out: dict[str, dict[str, Any]] = {}
+    for row in meta.itertuples(index=False):
+        filename = str(row.filename)
+        sex = {"男": "M", "女": "F"}.get(str(row.sex), None)
+        age = None if pd.isna(row.age) else int(row.age)
+        eye = eye_from_seq(row.eye_seq)
+        out[filename] = {k: v for k, v in {"age": age, "sex": sex, "eye": eye}.items() if v is not None}
+    return out
+
+
+def metadata_for_row(row: dict[str, Any], tongren_meta: dict[str, dict[str, Any]]) -> dict[str, Any]:
+    if row.get("cohort") != "tongren_fundus":
+        return {}
+    name = str(row.get("rel_path") or "")
+    if not name:
+        path = str(row.get("train_path") or row.get("file_path") or "")
+        name = path.split("::", 1)[1] if "::" in path else Path(path).name
+    return tongren_meta.get(name, {})
+
+
+def eye_from_seq(value: Any) -> str | None:
+    if value is None or (isinstance(value, float) and math.isnan(value)):
+        return None
+    text = str(int(value)) if isinstance(value, float) else str(value)
+    if text == "1":
+        return "OD"
+    if text == "2":
+        return "OS"
+    return None
+
+
+def existing_ocr_meta(row: dict[str, Any]) -> dict[str, int | str]:
+    meta: dict[str, int | str] = {}
+    for src_key, dst_key in [("ocr_age", "age"), ("ocr_sex", "sex"), ("ocr_eye", "eye")]:
+        value = row.get(src_key)
+        if value is None:
+            continue
+        if isinstance(value, float) and math.isnan(value):
+            continue
+        if value == "":
+            continue
+        if dst_key == "age":
+            value = int(value)
+        meta[dst_key] = value
+    return meta
+
+
+if __name__ == "__main__":
+    os.environ.setdefault("PYTHONIOENCODING", "utf-8")
+    main()

tools/data_processing/deidentification/deidentify_trial.py

@@ -0,0 +1,421 @@
+"""Small visual trial for burned-in PII handling.
+
+This script is intentionally sample-only. It never edits source images and never
+saves raw OCR text. It writes comparison sheets so the cohort-level policy can be
+chosen by eye before a full preprocessing run.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import re
+from pathlib import Path
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+import cohorts as C
+
+
+IMG_EXTS = {".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp"}
+
+
+def parse_ocr_metadata(text: str) -> dict[str, int | str]:
+    """Keep only non-identifier fields from OCR text."""
+    meta: dict[str, int | str] = {}
+
+    age_match = re.search(r"(?<!\d)(\d{1,3})\s*岁", text)
+    if age_match:
+        age = int(age_match.group(1))
+        if 0 <= age <= 120:
+            meta["age"] = age
+
+    if "男" in text:
+        meta["sex"] = "M"
+    elif "女" in text:
+        meta["sex"] = "F"
+
+    eye_match = re.search(r"\b(O[DSU])\b", text.upper())
+    if eye_match:
+        meta["eye"] = eye_match.group(1)
+
+    return meta
+
+
+def blackout_top_bar(img: np.ndarray, ratio: float) -> np.ndarray:
+    """Mask the top horizontal metadata bar while preserving image size."""
+    out = img.copy()
+    rows = _rows_from_ratio(img, ratio)
+    out[:rows, :] = 0
+    return out
+
+
+def crop_top_bar(img: np.ndarray, ratio: float) -> np.ndarray:
+    """Remove the top horizontal metadata bar."""
+    rows = _rows_from_ratio(img, ratio)
+    return img[rows:, :].copy()
+
+
+def blackout_frame(img: np.ndarray, *, top: float, bottom: float, right: float) -> np.ndarray:
+    """Mask fixed device UI bands while preserving the scan geometry."""
+    out = img.copy()
+    top_rows = _rows_from_ratio(img, top) if top > 0 else 0
+    bottom_rows = _rows_from_ratio(img, bottom) if bottom > 0 else 0
+    right_cols = _cols_from_ratio(img, right) if right > 0 else 0
+    if top_rows:
+        out[:top_rows, :] = 0
+    if bottom_rows:
+        out[-bottom_rows:, :] = 0
+    if right_cols:
+        out[:, -right_cols:] = 0
+    return out
+
+
+def deidentify_fundus_circle(
+    img: np.ndarray,
+    *,
+    radius_ratio: float = 0.97,
+    threshold: int = 25,
+    open_kernel: int = 25,
+    fallback_top_ratio: float = 0.25,
+) -> tuple[np.ndarray, bool, dict[str, float | int | str]]:
+    """Keep the detected retinal circle and black out everything outside it."""
+    circle_info = _detect_fundus_circle(img, threshold=threshold, open_kernel=open_kernel)
+    if circle_info is None:
+        return _fundus_fallback(img, fallback_top_ratio, "no_component")
+    cx, cy, radius, area = circle_info
+    h, w = img.shape[:2]
+    if area < int(h * w * 0.08):
+        return _fundus_fallback(img, fallback_top_ratio, "component_too_small")
+    radius = float(radius) * radius_ratio
+    if radius < min(h, w) * 0.20:
+        return _fundus_fallback(img, fallback_top_ratio, "radius_too_small")
+
+    circle = np.zeros((h, w), dtype=np.uint8)
+    cv2.circle(circle, (int(cx), int(cy)), int(radius), 255, -1)
+    out = np.zeros_like(img)
+    out[circle > 0] = img[circle > 0]
+    return out, True, {"cx": int(cx), "cy": int(cy), "radius": int(radius), "area": area}
+
+
+def deidentify_fundus_left_outside_circle(
+    img: np.ndarray,
+    *,
+    radius_ratio: float = 0.985,
+    left_ratio: float = 0.55,
+    threshold: int = 25,
+    open_kernel: int = 25,
+    fallback_top_ratio: float = 0.25,
+) -> tuple[np.ndarray, bool, dict[str, float | int | str]]:
+    """Black out only left-side pixels outside the detected fundus field of view."""
+    circle_info = _detect_fundus_circle(img, threshold=threshold, open_kernel=open_kernel)
+    if circle_info is None:
+        return _fundus_fallback(img, fallback_top_ratio, "no_component")
+
+    cx, cy, radius, area = circle_info
+    h, w = img.shape[:2]
+    if area < int(h * w * 0.08):
+        return _fundus_fallback(img, fallback_top_ratio, "component_too_small")
+
+    radius = float(radius) * radius_ratio
+    if radius < min(h, w) * 0.20:
+        return _fundus_fallback(img, fallback_top_ratio, "radius_too_small")
+
+    circle = np.zeros((h, w), dtype=np.uint8)
+    cv2.circle(circle, (int(cx), int(cy)), int(radius), 255, -1)
+    left_limit = max(int(cx), int(round(w * left_ratio)))
+    left_limit = min(w, max(1, left_limit))
+    left_mask = np.zeros((h, w), dtype=bool)
+    left_mask[:, :left_limit] = True
+
+    out = img.copy()
+    out[(circle == 0) & left_mask] = 0
+    return out, True, {
+        "cx": int(cx),
+        "cy": int(cy),
+        "radius": int(radius),
+        "area": area,
+        "left_limit": int(left_limit),
+    }
+
+
+def read_image(path: Path) -> np.ndarray:
+    data = np.fromfile(str(path), dtype=np.uint8)
+    img = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    if img is None:
+        raise ValueError(f"failed to decode image: {path}")
+    return img
+
+
+def write_image(path: Path, img: np.ndarray, quality: int = 92) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    ext = path.suffix.lower()
+    params = []
+    if ext in {".jpg", ".jpeg"}:
+        params = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
+    ok, data = cv2.imencode(ext, img, params)
+    if not ok:
+        raise ValueError(f"failed to encode image: {path}")
+    data.tofile(str(path))
+
+
+def sample_paths(cohort_key: str, n: int, seed: int, scan_limit: int | None) -> list[Path]:
+    cohort = _cohort(cohort_key)
+    root = Path(C.read_path(cohort))
+    exts = set(cohort.get("exts") or IMG_EXTS)
+    files: list[Path] = []
+    for path in root.rglob("*"):
+        if path.is_file() and path.suffix.lower() in exts:
+            files.append(path)
+            if scan_limit and len(files) >= scan_limit:
+                break
+    if not files:
+        raise FileNotFoundError(f"no images found for {cohort_key} under {root}")
+    rng = random.Random(seed)
+    return rng.sample(files, min(n, len(files)))
+
+
+def maybe_ocr_metadata(img: np.ndarray, reader: object | None) -> dict[str, int | str]:
+    if reader is None:
+        return {}
+    h = img.shape[0]
+    crop = img[: int(h * 0.55), :]
+    rgb = cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)
+    results = reader.readtext(rgb, detail=0)
+    return parse_ocr_metadata(" ".join(str(item) for item in results))
+
+
+def load_easyocr_reader(enable: bool) -> object | None:
+    if not enable:
+        return None
+    try:
+        import easyocr
+    except Exception as exc:  # pragma: no cover - depends on h100 environment
+        print(f"[warn] easyocr unavailable; OCR metadata disabled: {exc}")
+        return None
+    try:
+        return easyocr.Reader(["ch_sim", "en"], gpu=True)
+    except Exception as exc:  # pragma: no cover - depends on h100 environment
+        print(f"[warn] easyocr reader failed; OCR metadata disabled: {exc}")
+        return None
+
+
+def make_sheet(
+    groups: list[list[np.ndarray]],
+    labels: list[str],
+    out_path: Path,
+    *,
+    cell: int = 256,
+    header: int = 24,
+) -> None:
+    rows = len(groups)
+    cols = len(labels)
+    sheet = Image.new("RGB", (cols * cell, rows * (cell + header)), (18, 18, 18))
+    draw = ImageDraw.Draw(sheet)
+    font = ImageFont.load_default()
+    for row, imgs in enumerate(groups):
+        for col, label in enumerate(labels):
+            x = col * cell
+            y = row * (cell + header)
+            draw.text((x + 5, y + 5), label, fill=(230, 230, 230), font=font)
+            thumb = _thumb_bgr(imgs[col], cell)
+            sheet.paste(thumb, (x, y + header))
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    sheet.save(out_path, quality=92)
+
+
+def run_fundus_trial(args: argparse.Namespace, metadata_rows: list[dict[str, object]]) -> None:
+    reader = load_easyocr_reader(args.ocr)
+    paths = sample_paths(args.fundus_cohort, args.n, args.seed, args.scan_limit)
+    groups: list[list[np.ndarray]] = []
+    for i, path in enumerate(paths):
+        img = read_image(path)
+        meta = maybe_ocr_metadata(img, reader)
+        masked, ok, info = deidentify_fundus_circle(
+            img,
+            radius_ratio=args.fundus_radius_ratio,
+            threshold=args.fundus_threshold,
+            open_kernel=args.fundus_open_kernel,
+        )
+        groups.append([img, masked])
+        write_image(args.out / "fundus" / f"sample_{i:03d}_masked.jpg", masked)
+        metadata_rows.append(
+            {
+                "sample_idx": i,
+                "cohort": args.fundus_cohort,
+                "kind": "fundus",
+                "method": "circle_mask",
+                "circle_ok": ok,
+                "circle_info": info,
+                "ocr_meta": meta,
+            }
+        )
+    make_sheet(groups, ["original", "circle_mask"], args.out / "fundus_compare.jpg")
+
+
+def run_bscan_trial(args: argparse.Namespace, metadata_rows: list[dict[str, object]]) -> None:
+    paths = sample_paths(args.bscan_cohort, args.n, args.seed + 1, args.scan_limit)
+    ratios = [float(part) for part in args.bscan_ratios.split(",") if part.strip()]
+    frame_specs = _parse_frame_specs(args.bscan_frame_specs)
+
+    blackout_groups: list[list[np.ndarray]] = []
+    crop_groups: list[list[np.ndarray]] = []
+    frame_groups: list[list[np.ndarray]] = []
+    blackout_labels = ["original"] + [f"black_{int(r * 100)}pct" for r in ratios]
+    crop_labels = ["original"] + [f"crop_{int(r * 100)}pct" for r in ratios]
+    frame_labels = ["original"] + [
+        f"top{int(top * 100)}_bot{int(bottom * 100)}_right{int(right * 100)}"
+        for top, bottom, right in frame_specs
+    ]
+
+    for i, path in enumerate(paths):
+        img = read_image(path)
+        blackout_imgs = [img] + [blackout_top_bar(img, r) for r in ratios]
+        crop_imgs = [img] + [crop_top_bar(img, r) for r in ratios]
+        frame_imgs = [img] + [
+            blackout_frame(img, top=top, bottom=bottom, right=right)
+            for top, bottom, right in frame_specs
+        ]
+        blackout_groups.append(blackout_imgs)
+        crop_groups.append(crop_imgs)
+        frame_groups.append(frame_imgs)
+        for label, out_img in zip(blackout_labels[1:], blackout_imgs[1:], strict=True):
+            write_image(args.out / "bscan_blackout" / f"sample_{i:03d}_{label}.jpg", out_img)
+        for label, out_img in zip(crop_labels[1:], crop_imgs[1:], strict=True):
+            write_image(args.out / "bscan_crop" / f"sample_{i:03d}_{label}.jpg", out_img)
+        for label, out_img in zip(frame_labels[1:], frame_imgs[1:], strict=True):
+            write_image(args.out / "bscan_frame" / f"sample_{i:03d}_{label}.jpg", out_img)
+        metadata_rows.append(
+            {
+                "sample_idx": i,
+                "cohort": args.bscan_cohort,
+                "kind": "bscan",
+                "methods": {"blackout": ratios, "crop": ratios, "frame": frame_specs},
+            }
+        )
+
+    make_sheet(blackout_groups, blackout_labels, args.out / "bscan_blackout_compare.jpg")
+    make_sheet(crop_groups, crop_labels, args.out / "bscan_crop_compare.jpg")
+    make_sheet(frame_groups, frame_labels, args.out / "bscan_frame_compare.jpg")
+
+
+def main() -> None:
+    args = parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+    metadata_rows: list[dict[str, object]] = []
+
+    if args.fundus:
+        run_fundus_trial(args, metadata_rows)
+    if args.bscan:
+        run_bscan_trial(args, metadata_rows)
+
+    with (args.out / "metadata.jsonl").open("w", encoding="utf-8") as f:
+        for row in metadata_rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+    print(f"DONE -> {args.out}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--out", type=Path, default=Path("/data/team/lisicheng/deid_trial"))
+    parser.add_argument("--n", type=int, default=12)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--scan-limit", type=int, default=50000)
+    parser.add_argument("--fundus", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--bscan", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--ocr", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--fundus-cohort", default="tongren_95disease_fundus")
+    parser.add_argument("--bscan-cohort", default="xiangya_bscan")
+    parser.add_argument("--fundus-radius-ratio", type=float, default=0.97)
+    parser.add_argument("--fundus-threshold", type=int, default=25)
+    parser.add_argument("--fundus-open-kernel", type=int, default=25)
+    parser.add_argument("--bscan-ratios", default="0.06,0.08,0.10")
+    parser.add_argument("--bscan-frame-specs", default="0.08,0.05,0.02;0.10,0.05,0.02")
+    return parser.parse_args()
+
+
+def _cohort(key: str) -> dict[str, object]:
+    for cohort in C.INCLUDE:
+        if cohort["key"] == key:
+            return cohort
+    raise KeyError(f"unknown cohort: {key}")
+
+
+def _rows_from_ratio(img: np.ndarray, ratio: float) -> int:
+    if not 0 < ratio < 1:
+        raise ValueError(f"ratio must be between 0 and 1: {ratio}")
+    return max(1, min(img.shape[0] - 1, int(round(img.shape[0] * ratio))))
+
+
+def _cols_from_ratio(img: np.ndarray, ratio: float) -> int:
+    if not 0 < ratio < 1:
+        raise ValueError(f"ratio must be between 0 and 1: {ratio}")
+    return max(1, min(img.shape[1] - 1, int(round(img.shape[1] * ratio))))
+
+
+def _parse_frame_specs(raw: str) -> list[tuple[float, float, float]]:
+    specs: list[tuple[float, float, float]] = []
+    for item in raw.split(";"):
+        item = item.strip()
+        if not item:
+            continue
+        parts = [float(part) for part in item.split(",")]
+        if len(parts) != 3:
+            raise ValueError(f"frame spec must be top,bottom,right: {item}")
+        specs.append((parts[0], parts[1], parts[2]))
+    return specs
+
+
+def _to_gray(img: np.ndarray) -> np.ndarray:
+    if img.ndim == 2:
+        return img
+    return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+
+def _detect_fundus_circle(
+    img: np.ndarray, *, threshold: int, open_kernel: int
+) -> tuple[float, float, float, int] | None:
+    gray = _to_gray(img)
+    _, th = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)
+    kernel = np.ones((open_kernel, open_kernel), np.uint8)
+    th = cv2.morphologyEx(th, cv2.MORPH_OPEN, kernel)
+
+    n_labels, labels, stats, _ = cv2.connectedComponentsWithStats(th)
+    if n_labels <= 1:
+        return None
+
+    areas = stats[1:, cv2.CC_STAT_AREA]
+    largest = 1 + int(np.argmax(areas))
+    area = int(stats[largest, cv2.CC_STAT_AREA])
+    mask = (labels == largest).astype("uint8") * 255
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return None
+
+    contour = max(contours, key=cv2.contourArea)
+    (cx, cy), radius = cv2.minEnclosingCircle(contour)
+    return cx, cy, radius, area
+
+
+def _fundus_fallback(
+    img: np.ndarray, top_ratio: float, reason: str
+) -> tuple[np.ndarray, bool, dict[str, str]]:
+    return blackout_top_bar(img, top_ratio), False, {"reason": reason}
+
+
+def _thumb_bgr(img: np.ndarray, cell: int) -> Image.Image:
+    if img.ndim == 2:
+        rgb = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
+    else:
+        rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    im = Image.fromarray(rgb)
+    im.thumbnail((cell, cell), Image.Resampling.LANCZOS)
+    canvas = Image.new("RGB", (cell, cell), (0, 0, 0))
+    canvas.paste(im, ((cell - im.width) // 2, (cell - im.height) // 2))
+    return canvas
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/deidentification/fundus_pii_trial.py

@@ -0,0 +1,185 @@
+"""Small QC trial for fundus-like left-corner PII de-identification.
+
+Reads samples from the final manifest, masks the detected circular field of view, and writes
+comparison sheets plus non-identifying metadata. Source images are never modified.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import tarfile
+from pathlib import Path
+from typing import Any
+
+import cv2
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+from deidentify_trial import (
+    deidentify_fundus_circle,
+    deidentify_fundus_left_outside_circle,
+    load_easyocr_reader,
+    make_sheet,
+)
+
+
+DEFAULT_MANIFEST = Path(
+    "/data/team/lisicheng/new_data_manifest/"
+    "new_data_manifest_dedup_split_labeled_with_wds_deid.parquet"
+)
+DEFAULT_TONGREN_META = Path("/data/team/lisicheng/Dataser/tongren_metadata.csv")
+DEFAULT_OUT = Path("/data/team/lisicheng/new_data_manifest/fundus_pii_trial_20260702")
+COHORTS = [
+    "tongren_fundus",
+    "tongren_external_fundus",
+    "fq_testfundus",
+    "fq_rawfundus",
+    "fq_validfundus",
+]
+
+
+def main() -> None:
+    args = parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+    reader = load_easyocr_reader(args.ocr)
+    tongren_meta = load_tongren_metadata(args.tongren_metadata)
+    df = pd.read_parquet(
+        args.manifest,
+        columns=["image_id", "cohort", "modality", "train_path", "file_path", "rel_path"],
+    )
+    df = df[df["cohort"].isin(args.cohorts)].copy()
+    records = []
+    for cohort, group in df.groupby("cohort", sort=True):
+        sample = group.sample(n=min(args.per_cohort, len(group)), random_state=args.seed)
+        rows = []
+        for idx, row in enumerate(sample.to_dict("records")):
+            img = read_image_any(str(row.get("train_path") or row.get("file_path")))
+            meta = metadata_for_row(row, tongren_meta)
+            if not meta and reader is not None:
+                meta = ocr_metadata(img, reader)
+            masked, ok, info = deidentify_fundus_circle(
+                img,
+                radius_ratio=args.radius_ratio,
+                threshold=args.threshold,
+                open_kernel=args.open_kernel,
+            )
+            left_masked, left_ok, left_info = deidentify_fundus_left_outside_circle(
+                img,
+                radius_ratio=args.left_radius_ratio,
+                left_ratio=args.left_ratio,
+                threshold=args.threshold,
+                open_kernel=args.open_kernel,
+            )
+            rows.append([img, masked, left_masked])
+            rec = {
+                "image_id": row["image_id"],
+                "cohort": cohort,
+                "source_path": row.get("train_path") or row.get("file_path"),
+                "circle_ok": ok,
+                "circle_info": info,
+                "left_circle_ok": left_ok,
+                "left_circle_info": left_info,
+                "ocr_age": meta.get("age"),
+                "ocr_sex": meta.get("sex"),
+                "ocr_eye": meta.get("eye"),
+            }
+            records.append(rec)
+            save_rgb(args.out / "images" / f"{cohort}_{idx:02d}_masked.jpg", masked)
+            save_rgb(args.out / "images" / f"{cohort}_{idx:02d}_left_masked.jpg", left_masked)
+        make_sheet(
+            rows,
+            ["source", "full_circle", "left_only_circle"],
+            args.out / f"{cohort}_compare.jpg",
+            cell=args.cell,
+        )
+    with (args.out / "metadata.jsonl").open("w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+    print(f"DONE -> {args.out} ({len(records)} samples)")
+
+
+def load_tongren_metadata(path: Path) -> dict[str, dict[str, Any]]:
+    if not path.exists():
+        return {}
+    meta = pd.read_csv(path)
+    out: dict[str, dict[str, Any]] = {}
+    for row in meta.itertuples(index=False):
+        sex = {"男": "M", "女": "F"}.get(str(row.sex), None)
+        age = None if pd.isna(row.age) else int(row.age)
+        eye = eye_from_seq(row.eye_seq)
+        out[str(row.filename)] = {"age": age, "sex": sex, "eye": eye}
+    return out
+
+
+def eye_from_seq(value: Any) -> str | None:
+    if value is None or (isinstance(value, float) and math.isnan(value)):
+        return None
+    text = str(int(value)) if isinstance(value, float) else str(value)
+    if text == "1":
+        return "OD"
+    if text == "2":
+        return "OS"
+    return None
+
+
+def metadata_for_row(row: dict[str, Any], tongren_meta: dict[str, dict[str, Any]]) -> dict[str, Any]:
+    name = str(row.get("rel_path") or Path(str(row.get("train_path") or "")).name)
+    return {k: v for k, v in tongren_meta.get(name, {}).items() if v is not None}
+
+
+def ocr_metadata(img: np.ndarray, reader: object) -> dict[str, Any]:
+    from deidentify_trial import parse_ocr_metadata
+
+    h = img.shape[0]
+    crop = img[: int(h * 0.55), :]
+    rgb = cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)
+    results = reader.readtext(rgb, detail=0)
+    return parse_ocr_metadata(" ".join(str(item) for item in results))
+
+
+def read_image_any(path: str) -> np.ndarray:
+    if "::" in path:
+        tar_path, member = path.split("::", 1)
+        with tarfile.open(tar_path) as tf:
+            fp = tf.extractfile(member)
+            if fp is None:
+                raise FileNotFoundError(path)
+            data = fp.read()
+        arr = np.frombuffer(data, dtype=np.uint8)
+    else:
+        arr = np.fromfile(path, dtype=np.uint8)
+    img = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+    if img is None:
+        raise ValueError(f"failed to decode image: {path}")
+    return img
+
+
+def save_rgb(path: Path, img: np.ndarray) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    Image.fromarray(rgb).save(path, quality=92)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    parser.add_argument("--tongren-metadata", type=Path, default=DEFAULT_TONGREN_META)
+    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    parser.add_argument("--cohorts", nargs="+", default=COHORTS)
+    parser.add_argument("--per-cohort", type=int, default=8)
+    parser.add_argument("--seed", type=int, default=20260702)
+    parser.add_argument("--ocr", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--cell", type=int, default=320)
+    parser.add_argument("--radius-ratio", type=float, default=0.97)
+    parser.add_argument("--left-radius-ratio", type=float, default=0.985)
+    parser.add_argument("--left-ratio", type=float, default=0.55)
+    parser.add_argument("--threshold", type=int, default=25)
+    parser.add_argument("--open-kernel", type=int, default=25)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/deidentification/test_deidentify_trial.py

@@ -0,0 +1,190 @@
+import unittest
+from argparse import Namespace
+from pathlib import Path
+import sys
+import tarfile
+from tempfile import TemporaryDirectory
+
+import cv2
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from deidentify_batch import metadata_for_row, process_one
+from deidentify_trial import (
+    blackout_frame,
+    blackout_top_bar,
+    crop_top_bar,
+    deidentify_fundus_circle,
+    deidentify_fundus_left_outside_circle,
+    parse_ocr_metadata,
+)
+
+
+class DeidentifyTrialTest(unittest.TestCase):
+    def test_parse_ocr_metadata_keeps_only_non_identifier_fields(self):
+        meta = parse_ocr_metadata("张三 61岁 男 OD 2021/05/21 15:15")
+
+        self.assertEqual(meta, {"age": 61, "sex": "M", "eye": "OD"})
+
+    def test_fundus_circle_mask_blacks_corner_and_keeps_retina(self):
+        img = np.zeros((160, 160, 3), dtype=np.uint8)
+        yy, xx = np.ogrid[:160, :160]
+        circle = (xx - 80) ** 2 + (yy - 80) ** 2 <= 58**2
+        img[circle] = (90, 80, 70)
+        img[:16, :35] = (255, 255, 255)
+
+        out, ok, _ = deidentify_fundus_circle(img, radius_ratio=0.94, open_kernel=9)
+
+        self.assertTrue(ok)
+        self.assertTrue(np.all(out[4, 4] == 0))
+        self.assertTrue(np.all(out[80, 80] == img[80, 80]))
+
+    def test_left_only_circle_mask_keeps_right_outside_circle(self):
+        img = np.zeros((160, 160, 3), dtype=np.uint8)
+        yy, xx = np.ogrid[:160, :160]
+        circle = (xx - 80) ** 2 + (yy - 80) ** 2 <= 58**2
+        img[circle] = (90, 80, 70)
+        img[4, 4] = (255, 255, 255)
+        img[4, 150] = (123, 45, 67)
+
+        out, ok, _ = deidentify_fundus_left_outside_circle(
+            img, radius_ratio=0.985, left_ratio=0.55, open_kernel=9
+        )
+
+        self.assertTrue(ok)
+        self.assertTrue(np.all(out[4, 4] == 0))
+        self.assertTrue(np.all(out[80, 80] == img[80, 80]))
+        self.assertTrue(np.array_equal(out[4, 150], img[4, 150]))
+
+    def test_blackout_top_bar_preserves_shape_and_masks_top_rows(self):
+        img = np.full((100, 80, 3), 128, dtype=np.uint8)
+
+        out = blackout_top_bar(img, ratio=0.12)
+
+        self.assertEqual(out.shape, img.shape)
+        self.assertTrue(np.all(out[:12] == 0))
+        self.assertTrue(np.all(out[12:] == 128))
+
+    def test_blackout_frame_masks_top_bottom_and_right_without_resizing(self):
+        img = np.full((100, 80, 3), 128, dtype=np.uint8)
+
+        out = blackout_frame(img, top=0.08, bottom=0.05, right=0.02)
+
+        self.assertEqual(out.shape, img.shape)
+        self.assertTrue(np.all(out[:8, :] == 0))
+        self.assertTrue(np.all(out[95:, :] == 0))
+        self.assertTrue(np.all(out[:, 78:] == 0))
+        self.assertTrue(np.all(out[8:95, :78] == 128))
+
+    def test_crop_top_bar_removes_requested_fraction(self):
+        img = np.arange(100 * 80 * 3, dtype=np.uint8).reshape(100, 80, 3)
+
+        out = crop_top_bar(img, ratio=0.12)
+
+        self.assertEqual(out.shape, (88, 80, 3))
+        self.assertTrue(np.array_equal(out[0], img[12]))
+
+    def test_process_one_bscan_writes_opaque_jpeg_and_metadata(self):
+        with TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            src = tmp_path / "source.bmp"
+            img = np.full((100, 80, 3), 128, dtype=np.uint8)
+            ok, encoded = cv2.imencode(".bmp", img)
+            self.assertTrue(ok)
+            encoded.tofile(str(src))
+
+            args = Namespace(
+                out_root=tmp_path / "out",
+                bscan_top=0.10,
+                bscan_bottom=0.05,
+                bscan_right=0.02,
+                overwrite_images=False,
+                jpeg_quality=95,
+            )
+            row = {
+                "image_id": "xiangya_bscan_00000001",
+                "cohort": "xiangya_bscan",
+                "file_path": str(src),
+            }
+
+            result = process_one(row, args, reader=None)
+
+            out_path = tmp_path / "out" / "images" / "xiangya_bscan" / "xiangya_bscan_00000001.jpg"
+            self.assertTrue(out_path.exists())
+            self.assertEqual(result["deid_path"], str(out_path))
+            self.assertEqual(result["deid_method"], "bscan_blackout_top10_bottom5_right2")
+            self.assertTrue(result["pii_masked"])
+
+    def test_process_one_left_fundus_reads_tar_member(self):
+        with TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            img = np.zeros((160, 160, 3), dtype=np.uint8)
+            yy, xx = np.ogrid[:160, :160]
+            circle = (xx - 80) ** 2 + (yy - 80) ** 2 <= 58**2
+            img[circle] = (90, 80, 70)
+            img[4, 4] = (255, 255, 255)
+            ok, encoded = cv2.imencode(".png", img)
+            self.assertTrue(ok)
+
+            tar_path = tmp_path / "sample.tar"
+            png_path = tmp_path / "sample.png"
+            encoded.tofile(str(png_path))
+            with tarfile.open(tar_path, "w") as tf:
+                tf.add(png_path, arcname="sample.png")
+
+            args = Namespace(
+                out_root=tmp_path / "out",
+                overwrite_images=False,
+                jpeg_quality=95,
+                fundus_threshold=25,
+                fundus_open_kernel=9,
+                left_fundus_radius_ratio=0.985,
+                left_fundus_ratio=0.55,
+            )
+            row = {
+                "image_id": "tongren_fundus_00000001",
+                "cohort": "tongren_fundus",
+                "train_path": f"{tar_path}::sample.png",
+                "file_path": f"{tar_path}::sample.png",
+                "ocr_age": 61,
+                "ocr_sex": "F",
+                "ocr_eye": "OD",
+            }
+
+            result = process_one(row, args, reader=None)
+
+            self.assertTrue(Path(result["deid_path"]).exists())
+            self.assertEqual(result["deid_method"], "fundus_left_outside_circle_mask_r0985_l055")
+            self.assertEqual(result["ocr_age"], 61)
+            self.assertEqual(result["ocr_sex"], "F")
+
+    def test_tongren_metadata_is_not_applied_to_fq_rows(self):
+        meta = {"1005653-1.png": {"age": 63, "sex": "F", "eye": "OD"}}
+
+        self.assertEqual(
+            metadata_for_row(
+                {
+                    "cohort": "fq_rawfundus",
+                    "rel_path": "1005653-1.png",
+                    "train_path": "/nfs01/FQ_Datasets/data/rawFundus/1005653-1.png",
+                },
+                meta,
+            ),
+            {},
+        )
+        self.assertEqual(
+            metadata_for_row(
+                {
+                    "cohort": "tongren_fundus",
+                    "rel_path": "1005653-1.png",
+                    "train_path": "/data/team/lisicheng/Dataser/shards_tongren/fundus/a.tar::1005653-1.png",
+                },
+                meta,
+            ),
+            {"age": 63, "sex": "F", "eye": "OD"},
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tools/data_processing/quality_control/asrm_preprocess.py

@@ -0,0 +1,280 @@
+import os
+import cv2
+import torch
+import numpy as np
+from torch.utils.data import Dataset, DataLoader, WeightedRandomSampler
+from torchvision import transforms
+from typing import List, Tuple, Dict
+import random
+
+
+class FundusQualityDataset(Dataset):
+    """
+    Dataset for fundus quality classification
+    Combines:
+    - Labeled invalid images
+    - Labeled valid images
+    - Unlabeled raw images (optional)
+    """
+    def __init__(
+        self,
+        invalid_dir: str,
+        valid_dir: str,
+        raw_dir: str = None,
+        img_size: int = 512,
+        transform=None,
+        use_raw: bool = False,
+        raw_pseudo_label_threshold: float = 0.5
+    ):
+        self.img_size = img_size
+        self.transform = transform
+        self.use_raw = use_raw
+        self.raw_pseudo_label_threshold = raw_pseudo_label_threshold
+        
+        # Load labeled data
+        self.invalid_paths = self._load_image_paths(invalid_dir)
+        self.valid_paths = self._load_image_paths(valid_dir)
+        
+        # Load unlabeled raw data
+        self.raw_paths = []
+        if use_raw and raw_dir is not None:
+            self.raw_paths = self._load_image_paths(raw_dir)
+            
+        # Combine all paths and create labels
+        self.image_paths = []
+        self.labels = []
+        self.is_labeled = []
+        
+        # Invalid images (label=0)
+        for path in self.invalid_paths:
+            self.image_paths.append(path)
+            self.labels.append(0)
+            self.is_labeled.append(True)
+            
+        # Valid images (label=1)
+        for path in self.valid_paths:
+            self.image_paths.append(path)
+            self.labels.append(1)
+            self.is_labeled.append(True)
+            
+        # Raw images (unlabeled, label=-1 initially)
+        if use_raw:
+            for path in self.raw_paths:
+                self.image_paths.append(path)
+                self.labels.append(-1)  # Pseudo label placeholder
+                self.is_labeled.append(False)
+                
+        # Pseudo labels dict (for raw images)
+        self.pseudo_labels = {}
+        
+        print(f"Dataset loaded: {len(self.invalid_paths)} invalid, "
+              f"{len(self.valid_paths)} valid, "
+              f"{len(self.raw_paths)} raw")
+        
+    # f:\oinn\image_filter\FQ-ManifoldNet\model_ASRMNet\asrm_preprocess.py
+
+    # 修改第30行附近的 _load_image_paths 函数
+    def _load_image_paths(self, directory: str) -> List[str]:
+        """Load all image paths from directory"""
+        if not os.path.exists(directory):
+            print(f"⚠️  目录不存在: {directory}")
+            return []
+            
+        image_paths = []
+        # 支持的扩展名（包含DICOM格式）
+        valid_extensions = ('.png', '.jpg', '.jpeg', '.tif', '.tiff', '.bmp', '.dcm')
+        
+        # 列出所有文件进行调试
+        all_files = os.listdir(directory)
+        print(f"📂 {os.path.basename(directory)}: 找到 {len(all_files)} 个文件")
+        
+        # 尝试多种方式扫描
+        for filename in all_files:
+            # 方法1: 检查小写扩展名
+            if filename.lower().endswith(valid_extensions):
+                image_paths.append(os.path.join(directory, filename))
+        
+        print(f"✅ {os.path.basename(directory)}: 成功加载 {len(image_paths)} 张图像")
+        
+        # 如果还是0，尝试直接使用所有文件（跳过目录）
+        if len(image_paths) == 0:
+            print(f"🔍 {os.path.basename(directory)}: 尝试直接使用所有文件...")
+            for filename in all_files:
+                filepath = os.path.join(directory, filename)
+                if os.path.isfile(filepath):
+                    image_paths.append(filepath)
+            print(f"   第二次尝试: 加载了 {len(image_paths)} 张")
+        
+        return image_paths
+        
+    def set_pseudo_labels(self, pseudo_label_dict: Dict[str, float]):
+        """
+        Set pseudo labels for raw images
+        Args:
+            pseudo_label_dict: {image_path: quality_score} (0-1)
+        """
+        self.pseudo_labels = pseudo_label_dict
+        
+    def __len__(self) -> int:
+        return len(self.image_paths)
+        
+    def __getitem__(self, idx: int) -> Dict:
+        img_path = self.image_paths[idx]
+        
+        # Load image
+        img = cv2.imread(img_path)
+        if img is None:
+            # Return empty image if loading fails
+            img = np.zeros((self.img_size, self.img_size, 3), dtype=np.uint8)
+            
+        # Convert to RGB
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        
+        # Resize
+        img = cv2.resize(img, (self.img_size, self.img_size))
+        
+        # Apply transforms
+        if self.transform is not None:
+            img = self.transform(img)
+        
+        # Get label
+        if self.is_labeled[idx]:
+            label = self.labels[idx]
+        else:
+            # Use pseudo label if available, else return -1
+            if img_path in self.pseudo_labels:
+                score = self.pseudo_labels[img_path]
+                label = 1 if score > self.raw_pseudo_label_threshold else 0
+            else:
+                label = -1
+                
+        return {
+            'image': img,
+            'label': label,
+            'is_labeled': self.is_labeled[idx],
+            'path': img_path
+        }
+
+
+def get_train_transforms(img_size: int = 512):
+    """Training data transforms with augmentation"""
+    return transforms.Compose([
+        transforms.ToPILImage(),
+        transforms.RandomHorizontalFlip(p=0.5),
+        transforms.RandomRotation(degrees=15),
+        transforms.ColorJitter(
+            brightness=0.2,
+            contrast=0.2,
+            saturation=0.2,
+            hue=0.1
+        ),
+        transforms.ToTensor(),
+        transforms.Normalize(
+            mean=[0.485, 0.456, 0.406],
+            std=[0.229, 0.224, 0.225]
+        )
+    ])
+
+
+def get_val_transforms(img_size: int = 512):
+    """Validation/test data transforms (no augmentation)"""
+    return transforms.Compose([
+        transforms.ToPILImage(),
+        transforms.ToTensor(),
+        transforms.Normalize(
+            mean=[0.485, 0.456, 0.406],
+            std=[0.229, 0.224, 0.225]
+        )
+    ])
+
+
+def create_data_loaders(
+    invalid_dir: str,
+    valid_dir: str,
+    raw_dir: str = None,
+    img_size: int = 512,
+    batch_size: int = 32,
+    num_workers: int = 8,
+    use_raw: bool = False,
+    use_weighted_sampler: bool = True
+) -> Tuple[DataLoader, DataLoader]:
+    """
+    Create train and validation data loaders
+    Args:
+        invalid_dir: Directory with invalid fundus images
+        valid_dir: Directory with valid fundus images
+        raw_dir: Directory with raw unlabeled images (optional)
+        img_size: Target image size
+        batch_size: Batch size
+        num_workers: Number of data loading workers
+        use_raw: Whether to include raw unlabeled images
+        use_weighted_sampler: Whether to use weighted sampler for class imbalance
+    Returns:
+        (train_loader, val_loader)
+    """
+    # Create train dataset
+    train_dataset = FundusQualityDataset(
+        invalid_dir=invalid_dir,
+        valid_dir=valid_dir,
+        raw_dir=raw_dir,
+        img_size=img_size,
+        transform=get_train_transforms(img_size),
+        use_raw=use_raw
+    )
+    
+    # Split into train/val
+    dataset_size = len(train_dataset)
+    val_size = int(0.2 * dataset_size)
+    train_size = dataset_size - val_size
+    
+    from torch.utils.data import random_split
+    train_subset, val_subset = random_split(
+        train_dataset,
+        [train_size, val_size],
+        generator=torch.Generator().manual_seed(42)
+    )
+    
+    # Create samplers
+    if use_weighted_sampler:
+        # Weighted sampler to handle class imbalance
+        labeled_indices = [i for i in range(len(train_dataset)) 
+                          if train_dataset.is_labeled[i]]
+        
+        if len(labeled_indices) > 0:
+            labeled_labels = [train_dataset.labels[i] for i in labeled_indices]
+            class_counts = np.bincount(labeled_labels, minlength=2)
+            class_weights = 1.0 / (class_counts + 1e-8)
+            
+            # Create weights for all samples (unlabeled get weight 1)
+            weights = torch.ones(len(train_subset))
+            for idx_in_subset, idx_in_dataset in enumerate(train_subset.indices):
+                if train_dataset.is_labeled[idx_in_dataset]:
+                    label = train_dataset.labels[idx_in_dataset]
+                    weights[idx_in_subset] = class_weights[label]
+                    
+            sampler = WeightedRandomSampler(weights, len(weights))
+        else:
+            sampler = None
+    else:
+        sampler = None
+    
+    # Create data loaders
+    train_loader = DataLoader(
+        train_subset,
+        batch_size=batch_size,
+        sampler=sampler,
+        shuffle=(sampler is None),
+        num_workers=num_workers,
+        pin_memory=True,
+        drop_last=True
+    )
+    
+    val_loader = DataLoader(
+        val_subset,
+        batch_size=batch_size,
+        shuffle=False,
+        num_workers=num_workers,
+        pin_memory=True
+    )
+    
+    return train_loader, val_loader

tools/data_processing/quality_control/build_quality_risk_review.py

@@ -0,0 +1,385 @@
+"""Build an embedded HTML review page for high-risk training rows.
+
+This is a targeted human-QC sampler for prompt-adapter manifests. It does not
+modify source images or training manifests.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import csv
+import html
+import io
+import json
+import math
+import random
+import tarfile
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+from PIL import Image
+
+
+DEFAULT_MANIFEST = Path(
+    "/data/team/lisicheng/new_data_manifest/"
+    "prompt_adapter_mixed_v6_exclude_octbuckets_octa/adapter_manifest_mixed_v6.parquet"
+)
+DEFAULT_CAPTIONS = Path(
+    "/data/team/lisicheng/new_data_manifest/"
+    "prompt_adapter_mixed_v6_exclude_octbuckets_octa/captions_v2.parquet"
+)
+DEFAULT_OUT = Path("/data/team/lisicheng/Code/OCTFlow/pilot/path1/audit/v6_quality_risk_review_20260709")
+
+HIGH_RISK_COHORTS = [
+    "data0410_master_fundus",
+    "chengdu_shiyi_ubm",
+    "eryuan_ubm",
+    "yinhai_ubm",
+    "yinhai_bscan",
+    "xiangya_bscan",
+    "chengdu_bscan",
+    "yinhai_uwf",
+    "eryuan_ffa",
+    "eryuan_t17_fundus",
+    "hcw_fundus",
+]
+DEID_SANITY_COHORTS = [
+    "fundus90wer",
+    "tongren_fundus",
+    "tongren_95disease_fundus",
+    "tongren_external_fundus",
+    "fq_rawfundus",
+    "fq_testfundus",
+]
+RARE_OR_CONFUSABLE_SUBTYPES = [
+    "octa_enface",
+    "oct_enface",
+    "slit_lamp_anterior_segment",
+    "reflectance_slo_gray",
+    "fundus_fluorescein_angiography",
+    "uwf_color_fundus",
+    "external_anterior_segment_photo",
+    "ocular_bscan_ultrasound",
+    "ubm_anterior_segment",
+]
+
+
+class ImageOpener:
+    def __init__(self) -> None:
+        self._tar_cache: dict[str, tarfile.TarFile] = {}
+
+    def close(self) -> None:
+        for tf in self._tar_cache.values():
+            tf.close()
+        self._tar_cache.clear()
+
+    def open(self, path: str) -> Image.Image:
+        if "::" not in path:
+            return Image.open(path).convert("RGB")
+        tar_path, member = path.split("::", 1)
+        tf = self._tar_cache.get(tar_path)
+        if tf is None:
+            tf = tarfile.open(tar_path, "r:*")
+            self._tar_cache[tar_path] = tf
+        fh = tf.extractfile(member)
+        if fh is None:
+            raise FileNotFoundError(member)
+        return Image.open(io.BytesIO(fh.read())).convert("RGB")
+
+
+def clean(value: Any) -> Any:
+    if value is None:
+        return None
+    if isinstance(value, float) and math.isnan(value):
+        return None
+    return value
+
+
+def json_safe(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {str(k): json_safe(v) for k, v in value.items()}
+    if isinstance(value, list | tuple):
+        return [json_safe(v) for v in value]
+    if value is None:
+        return None
+    if isinstance(value, float):
+        return value if math.isfinite(value) else None
+    try:
+        if pd.isna(value):
+            return None
+    except (TypeError, ValueError):
+        pass
+    return value
+
+
+def sample_group(group: pd.DataFrame, n: int, seed: int) -> pd.DataFrame:
+    if len(group) <= n:
+        return group
+    return group.sample(n=n, random_state=seed)
+
+
+def add_samples(
+    selected: dict[str, dict[str, Any]],
+    frame: pd.DataFrame,
+    reason: str,
+    n: int,
+    seed: int,
+    group_col: str | None = None,
+) -> None:
+    if len(frame) == 0:
+        return
+    if group_col:
+        pieces = [sample_group(g, n, seed) for _, g in frame.groupby(group_col, sort=True)]
+        rows = pd.concat(pieces, ignore_index=True) if pieces else frame.head(0)
+    else:
+        rows = sample_group(frame, n, seed)
+    for row in rows.to_dict("records"):
+        image_id = str(row["image_id"])
+        if image_id in selected:
+            selected[image_id]["risk_reason"] += f"; {reason}"
+        else:
+            row["risk_reason"] = reason
+            selected[image_id] = row
+
+
+def build_review_rows(args: argparse.Namespace) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    cols = [
+        "image_id",
+        "cohort",
+        "hospital_domain",
+        "modality",
+        "modality_family",
+        "modality_subtype",
+        "view_or_projection",
+        "field_of_view",
+        "image_quality_band",
+        "image_quality_score",
+        "image_height_px",
+        "image_width_px",
+        "file_path",
+        "prompt_modality_phrase",
+        "diagnosis_group_clean",
+    ]
+    df = pd.read_parquet(args.manifest, columns=cols)
+    rng_seed = args.seed
+    selected: dict[str, dict[str, Any]] = {}
+
+    add_samples(
+        selected,
+        df[df["image_quality_band"].fillna("").astype(str).eq("poor")],
+        "显式 poor quality",
+        args.poor_per_modality,
+        rng_seed,
+        "modality_subtype",
+    )
+    add_samples(
+        selected,
+        df[df["cohort"].astype(str).isin(HIGH_RISK_COHORTS)],
+        "私有原始路径或水印/PII 高风险 cohort",
+        args.high_risk_per_cohort,
+        rng_seed + 1,
+        "cohort",
+    )
+    add_samples(
+        selected,
+        df[df["cohort"].astype(str).isin(DEID_SANITY_COHORTS)],
+        "已脱敏大 cohort 抽查",
+        args.deid_sanity_per_cohort,
+        rng_seed + 2,
+        "cohort",
+    )
+    add_samples(
+        selected,
+        df[df["modality_subtype"].astype(str).isin(RARE_OR_CONFUSABLE_SUBTYPES)],
+        "稀有或易混淆 subtype 抽查",
+        args.rare_per_subtype,
+        rng_seed + 3,
+        "modality_subtype",
+    )
+    top_cohorts = df["cohort"].value_counts().head(args.top_cohorts).index
+    add_samples(
+        selected,
+        df[df["cohort"].astype(str).isin(top_cohorts.astype(str))],
+        "大 cohort 随机兜底抽查",
+        args.top_per_cohort,
+        rng_seed + 4,
+        "cohort",
+    )
+
+    rows = list(selected.values())
+    random.Random(args.seed).shuffle(rows)
+    if args.max_rows and len(rows) > args.max_rows:
+        rows = rows[: args.max_rows]
+
+    ids = [str(r["image_id"]) for r in rows]
+    captions = pd.read_parquet(args.captions, columns=["image_id", "level", "prompt_text"])
+    captions["image_id"] = captions["image_id"].astype(str)
+    wide = captions[captions["image_id"].isin(ids)].pivot(index="image_id", columns="level", values="prompt_text")
+
+    opener = ImageOpener()
+    records: list[dict[str, Any]] = []
+    try:
+        for idx, row in enumerate(rows, start=1):
+            image_id = str(row["image_id"])
+            thumb, open_error = thumbnail(opener, str(row["file_path"]), args.thumb_size)
+            record = {
+                "review_seq": idx,
+                **{k: clean(v) for k, v in row.items()},
+                "short_prompt": clean(wide["short"].get(image_id)) if "short" in wide else None,
+                "medium_prompt": clean(wide["medium"].get(image_id)) if "medium" in wide else None,
+                "dense_prompt": clean(wide["dense"].get(image_id)) if "dense" in wide else None,
+                "thumb_data": thumb,
+                "open_error": open_error,
+            }
+            records.append(record)
+    finally:
+        opener.close()
+
+    summary = {
+        "manifest": str(args.manifest),
+        "captions": str(args.captions),
+        "rows_in_manifest": int(len(df)),
+        "review_rows": int(len(records)),
+        "risk_reason_counts": pd.Series([r["risk_reason"] for r in records]).value_counts().astype(int).to_dict(),
+        "review_by_cohort": pd.Series([r["cohort"] for r in records]).value_counts().astype(int).to_dict(),
+        "review_by_modality_subtype": pd.Series([r["modality_subtype"] for r in records]).value_counts().astype(int).to_dict(),
+        "poor_quality_rows": int(df["image_quality_band"].fillna("").astype(str).eq("poor").sum()),
+        "high_risk_cohort_rows": int(df["cohort"].astype(str).isin(HIGH_RISK_COHORTS).sum()),
+    }
+    return records, summary
+
+
+def thumbnail(opener: ImageOpener, path: str, size: int) -> tuple[str, str]:
+    try:
+        im = opener.open(path)
+        im.thumbnail((size, size), Image.Resampling.LANCZOS)
+        canvas = Image.new("RGB", (size, size), (0, 0, 0))
+        canvas.paste(im, ((size - im.width) // 2, (size - im.height) // 2))
+        err = ""
+    except Exception as exc:
+        canvas = Image.new("RGB", (size, size), (100, 15, 15))
+        err = repr(exc)
+    buf = io.BytesIO()
+    canvas.save(buf, format="JPEG", quality=88)
+    return "data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode("ascii"), err
+
+
+def write_csv(records: list[dict[str, Any]], out: Path) -> None:
+    cols = [
+        "review_seq",
+        "risk_reason",
+        "image_id",
+        "cohort",
+        "hospital_domain",
+        "modality",
+        "modality_family",
+        "modality_subtype",
+        "view_or_projection",
+        "field_of_view",
+        "image_quality_band",
+        "image_quality_score",
+        "image_height_px",
+        "image_width_px",
+        "prompt_modality_phrase",
+        "diagnosis_group_clean",
+        "short_prompt",
+        "medium_prompt",
+        "dense_prompt",
+        "file_path",
+        "open_error",
+    ]
+    with out.open("w", newline="", encoding="utf-8-sig") as handle:
+        writer = csv.DictWriter(handle, fieldnames=cols)
+        writer.writeheader()
+        for row in records:
+            writer.writerow({col: row.get(col) for col in cols})
+
+
+def write_html(records: list[dict[str, Any]], out: Path) -> None:
+    rows_json = json.dumps(json_safe(records), ensure_ascii=False, allow_nan=False).replace("</", "<\\/")
+    css = """:root{--bg:#f5f6f8;--panel:#fff;--line:#d8dee8;--text:#1f2937;--muted:#667085;--blue:#0f62fe;--green:#177245;--red:#b42318;--amber:#9a5b00}*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--text);font-family:Arial,"Noto Sans CJK SC","Microsoft YaHei",sans-serif}header{position:sticky;top:0;z-index:10;background:var(--panel);border-bottom:1px solid var(--line);padding:12px 16px;box-shadow:0 1px 8px rgba(15,23,42,.07)}h1{font-size:18px;margin:0 0 8px}.bar{display:flex;gap:8px;align-items:center;flex-wrap:wrap}.progress{font-size:13px;min-width:260px;color:var(--muted)}button,select,input,textarea{font-size:13px;border:1px solid #b8c0cc;border-radius:4px;background:#fff;padding:7px 9px}button{cursor:pointer}button.primary{background:var(--blue);border-color:var(--blue);color:#fff}button.ok{background:#e9f7ef;color:var(--green);border-color:#a8ddb9}button.bad{background:#fff1f0;color:var(--red);border-color:#ffccc7}button.warn{background:#fff7e6;color:var(--amber);border-color:#ffd591}.hint{font-size:12px;color:var(--muted);margin-top:6px}.viewer{display:grid;grid-template-columns:minmax(440px,52vw) 1fr;gap:14px;padding:14px}.panel{background:var(--panel);border:1px solid var(--line);border-radius:6px;padding:12px}.imgbox{height:min(68vh,720px);min-height:420px;background:#050505;display:flex;align-items:center;justify-content:center;overflow:hidden}.imgbox img{max-width:100%;max-height:100%;object-fit:contain}.badge{display:inline-block;border-radius:999px;padding:3px 8px;margin:0 5px 6px 0;font-size:12px;background:#edf2ff;color:#173b8f}.badge.warn{background:#fff7e6;color:#8a4b00}.badge.bad{background:#ffecec;color:#9b1c1c}.meta{font-size:13px;line-height:1.5;word-break:break-word}.prompt{font-size:13px;line-height:1.45;margin-top:8px;padding:8px;background:#f8fafc;border:1px solid #e2e8f0;border-radius:4px}.review{border-top:1px solid var(--line);margin-top:10px;padding-top:10px}.row{display:flex;gap:8px;align-items:center;flex-wrap:wrap;margin:8px 0}textarea{width:100%;height:72px;resize:vertical}.path{font-family:monospace;font-size:12px;color:#334155}@media(max-width:1000px){.viewer{grid-template-columns:1fr}.imgbox{height:520px}}"""
+    js = """
+const rows = JSON.parse(document.getElementById('rows-data').textContent);
+const storageKey = 'octflow_v6_quality_risk_review_20260709';
+function loadState(key, fallback) { try { return localStorage.getItem(key) ?? fallback; } catch (_) { return fallback; } }
+let idx = Number(loadState(storageKey + ':idx', '0') || 0);
+let edits = JSON.parse(loadState(storageKey, '{}') || '{}');
+idx = Math.max(0, Math.min(idx, rows.length - 1));
+function esc(v) { return String(v ?? '').replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c])); }
+function edit(id) { return edits[id] || {status:'unreviewed', issue:'', note:''}; }
+function save() { try { localStorage.setItem(storageKey, JSON.stringify(edits)); localStorage.setItem(storageKey + ':idx', String(idx)); } catch (_) {} }
+function counts() { const c={unreviewed:0,keep:0,watermark:0,pii:0,wrong_modality:0,low_quality:0,drop:0}; rows.forEach(r=>{ const s=edit(r.image_id).status || 'unreviewed'; c[s]=(c[s]||0)+1; }); return c; }
+function go(delta) { idx=Math.max(0, Math.min(rows.length-1, idx+delta)); save(); render(); }
+function gotoIndex(v) { const n=Number(v); if (Number.isFinite(n)) { idx=Math.max(0, Math.min(rows.length-1, n-1)); save(); render(); } }
+function setStatus(status, advance=true) { const r=rows[idx]; edits[r.image_id]={...edit(r.image_id),status}; save(); if (advance) go(1); else render(); }
+function updateNote(v) { const r=rows[idx]; edits[r.image_id]={...edit(r.image_id),note:v}; save(); }
+function mergedRows() { return rows.map(r=>{ const x={...r, ...edit(r.image_id)}; delete x.thumb_data; return x; }); }
+function download(name, text, type) { const blob=new Blob([text],{type}); const url=URL.createObjectURL(blob); const a=document.createElement('a'); a.href=url; a.download=name; document.body.appendChild(a); a.click(); a.remove(); URL.revokeObjectURL(url); }
+function exportCSV() { const out=mergedRows(); const cols=['review_seq','status','note','risk_reason','image_id','cohort','hospital_domain','modality','modality_family','modality_subtype','view_or_projection','field_of_view','image_quality_band','image_quality_score','prompt_modality_phrase','diagnosis_group_clean','short_prompt','file_path','open_error']; const csv=[cols.join(',')].concat(out.map(o=>cols.map(c=>'"'+String(o[c]??'').replaceAll('"','""')+'"').join(','))).join('\\n'); download('octflow_v6_quality_risk_review_edits.csv', csv, 'text/csv'); }
+function exportJSON() { download('octflow_v6_quality_risk_review_edits.json', JSON.stringify(mergedRows(), null, 2), 'application/json'); }
+function render() {
+  if (!rows.length) { document.getElementById('root').innerHTML='<div class=viewer><div class=panel>没有审核样本。</div></div>'; return; }
+  const r=rows[idx], e=edit(r.image_id), c=counts();
+  document.getElementById('progress').textContent=`第 ${idx+1} / ${rows.length} 张；保留 ${c.keep||0}，水印 ${c.watermark||0}，PII ${c.pii||0}，错模态 ${c.wrong_modality||0}，低质 ${c.low_quality||0}，丢弃 ${c.drop||0}，未看 ${c.unreviewed||0}`;
+  document.getElementById('jump').value=idx+1;
+  document.getElementById('root').innerHTML=`<section class="viewer"><div class="panel"><div class="imgbox"><img src="${esc(r.thumb_data)}" loading="eager"></div></div><div class="panel"><div><span class="badge warn">${esc(r.risk_reason)}</span><span class="badge">${esc(r.modality_subtype)}</span><span class="badge">${esc(r.cohort)}</span>${r.open_error ? '<span class="badge bad">读取错误</span>' : ''}</div><div class="meta"><b>图像 ID</b>：${esc(r.image_id)}<br><b>cohort</b>：${esc(r.cohort)}；<b>center</b>：${esc(r.hospital_domain)}<br><b>modality</b>：${esc(r.modality)}；<b>family</b>：${esc(r.modality_family)}；<b>subtype</b>：${esc(r.modality_subtype)}<br><b>view/fov</b>：${esc(r.view_or_projection)} / ${esc(r.field_of_view)}<br><b>quality</b>：${esc(r.image_quality_band)} / ${esc(r.image_quality_score)}；<b>size</b>：${esc(r.image_width_px)} x ${esc(r.image_height_px)}<br><b>diagnosis</b>：${esc(r.diagnosis_group_clean)}<br><b>路径</b>：<span class="path">${esc(r.file_path)}</span>${r.open_error ? '<br><b>读取错误</b>：'+esc(r.open_error) : ''}</div><div class="prompt"><b>短 prompt</b>：${esc(r.short_prompt)}</div><div class="prompt"><b>中 prompt</b>：${esc(r.medium_prompt)}</div><div class="review"><div class="row"><button class="ok" onclick="setStatus('keep')">1 保留</button><button class="warn" onclick="setStatus('watermark')">2 水印</button><button class="bad" onclick="setStatus('pii')">3 PII</button><button class="warn" onclick="setStatus('wrong_modality', false)">4 错模态</button><button class="warn" onclick="setStatus('low_quality')">5 低质</button><button class="bad" onclick="setStatus('drop')">6 丢弃</button><button onclick="setStatus('unreviewed', false)">清空</button></div><textarea placeholder="备注" oninput="updateNote(this.value)">${esc(e.note || '')}</textarea></div><div class="hint">快捷键：1 保留，2 水印，3 PII，4 错模态，5 低质，6 丢弃，←/→ 翻页，C 导出 CSV，J 导出 JSON。备注框内不会触发快捷键。</div></div></section>`;
+}
+document.addEventListener('keydown', ev => {
+  const tag=(ev.target && ev.target.tagName || '').toLowerCase();
+  if (tag === 'input' || tag === 'textarea' || tag === 'select') return;
+  if (ev.key === 'ArrowRight') go(1);
+  else if (ev.key === 'ArrowLeft') go(-1);
+  else if (ev.key === '1') setStatus('keep');
+  else if (ev.key === '2') setStatus('watermark');
+  else if (ev.key === '3') setStatus('pii');
+  else if (ev.key === '4') setStatus('wrong_modality', false);
+  else if (ev.key === '5') setStatus('low_quality');
+  else if (ev.key === '6') setStatus('drop');
+  else if (ev.key.toLowerCase() === 'c') exportCSV();
+  else if (ev.key.toLowerCase() === 'j') exportJSON();
+});
+render();
+"""
+    doc = f"""<!doctype html><html><head><meta charset="utf-8"><title>OCTFlow v6 风险样本审核</title><style>{css}</style></head>
+<body><header><h1>OCTFlow v6 风险样本审核</h1><div class="bar"><span id="progress" class="progress"></span><button onclick="go(-1)">上一张</button><button class="primary" onclick="go(1)">下一张</button><label>跳转 <input id="jump" type="number" min="1" max="{len(records)}" onchange="gotoIndex(this.value)" style="width:80px"></label><button onclick="exportCSV()">导出 CSV</button><button onclick="exportJSON()">导出 JSON</button></div><div class="hint">风险导向抽样：poor quality、私有原始路径/水印高风险 cohort、已脱敏大 cohort 抽查、稀有或易混淆 subtype、大 cohort 兜底抽查。这里只用于人工 QC，不修改训练数据。</div></header><main id="root"></main><script type="application/json" id="rows-data">{rows_json}</script><script>{js}</script></body></html>"""
+    out.write_text(doc, encoding="utf-8")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    parser.add_argument("--captions", type=Path, default=DEFAULT_CAPTIONS)
+    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    parser.add_argument("--seed", type=int, default=20260709)
+    parser.add_argument("--thumb-size", type=int, default=512)
+    parser.add_argument("--poor-per-modality", type=int, default=20)
+    parser.add_argument("--high-risk-per-cohort", type=int, default=6)
+    parser.add_argument("--deid-sanity-per-cohort", type=int, default=4)
+    parser.add_argument("--rare-per-subtype", type=int, default=8)
+    parser.add_argument("--top-cohorts", type=int, default=20)
+    parser.add_argument("--top-per-cohort", type=int, default=2)
+    parser.add_argument("--max-rows", type=int, default=180)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+    records, summary = build_review_rows(args)
+    write_csv(records, args.out / "risk_review_rows.csv")
+    (args.out / "risk_review_rows.json").write_text(
+        json.dumps(json_safe(records), ensure_ascii=False, indent=2, allow_nan=False),
+        encoding="utf-8",
+    )
+    (args.out / "summary.json").write_text(
+        json.dumps(summary, ensure_ascii=False, indent=2, allow_nan=False),
+        encoding="utf-8",
+    )
+    write_html(records, args.out / "OPEN_THIS_V6_QUALITY_RISK_REVIEW.html")
+    print(json.dumps({"out": str(args.out), **summary}, ensure_ascii=False), flush=True)
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/quality_control/clean_excel.py

@@ -0,0 +1,52 @@
+import os
+import pandas as pd
+
+
+def main():
+    # --- 1. 路径配置 ---
+    original_excel_path = "/data/team/huchengwei/fundus/fundus_csv/paired_fundus_image_dramdrvo.xlsx"
+    missing_log_path = "/data/team/huchengwei/fundus/fundus_csv/missing_images_dramdrvo.txt"  # 上一步脚本自动生成的缺失名单
+    # 新的干净表格保存路径
+    new_excel_path = "/data/team/huchengwei/fundus/fundus_csv/dramdrvo_cleaned.xlsx"
+
+    # --- 2. 加载缺失黑名单 ---
+    if not os.path.exists(missing_log_path):
+        raise FileNotFoundError(f"找不到 {missing_log_path}，请确认上一步脚本是否正确生成了该文件。")
+
+    with open(missing_log_path, "r", encoding="utf-8") as f:
+        # 去除换行符并存入哈希集合 (Set) 以获得 O(1) 的查询速度
+        missing_basenames = set(line.strip() for line in f if line.strip())
+
+    print(f"[*] 成功加载缺失名单，共计 {len(missing_basenames)} 个目标。")
+
+    # --- 3. 读取原始 DataFrame ---
+    print(f"[*] 正在读取原始 Excel 表格...")
+    df = pd.read_excel(original_excel_path)
+    original_len = len(df)
+
+    # --- 4. 核心清洗逻辑 ---
+    # 定义过滤条件：提取 image_name 的无后缀基础名，判断其是否在黑名单中
+    def is_valid_row(image_name):
+        basename = os.path.splitext(str(image_name))[0]
+        return basename not in missing_basenames
+
+    # 应用掩码 (Boolean Mask) 过滤
+    mask = df['image_name'].apply(is_valid_row)
+    df_cleaned = df[mask]
+
+    cleaned_len = len(df_cleaned)
+    removed_count = original_len - cleaned_len
+
+    # --- 5. 校验与保存 ---
+    print(f"[*] 清洗完成！")
+    print(f"    -> 原始数据行数: {original_len}")
+    print(f"    -> 清洗后数据行数: {cleaned_len} (正好对应你成功复制的 5505 张图)")
+    print(f"    -> 实际排除行数: {removed_count}")
+
+    # 保存新的 Excel
+    df_cleaned.to_excel(new_excel_path, index=False)
+    print(f"[*] 新的干净表格已生成并保存至:\n    {new_excel_path}")
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/quality_control/filter_prompt_artifacts.py

@@ -0,0 +1,155 @@
+"""Filter prompt-adapter manifest/caption artifacts without touching images.
+
+The script removes selected cohorts from a prompt-adapter directory and writes a
+new manifest/caption pair plus an audit summary. It is intended for quality or
+privacy exclusions after prompt construction.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import pandas as pd
+
+
+DEFAULT_IN = Path("/data/team/lisicheng/new_data_manifest/prompt_adapter_mixed_v6")
+DEFAULT_OUT = Path("/data/team/lisicheng/new_data_manifest/prompt_adapter_mixed_v6_exclude_octbuckets_octa")
+
+
+def _status_from_counts(subtype: str, counts: pd.Series) -> str:
+    count = int(counts.get(subtype, 0))
+    if count >= 2000:
+        return "formal"
+    if count >= 500:
+        return "supplemental"
+    return "tiny"
+
+
+def _count_dict(frame: pd.DataFrame, column: str) -> dict[str, int]:
+    if column not in frame.columns:
+        return {}
+    return frame[column].fillna("unknown").astype(str).value_counts().astype(int).to_dict()
+
+
+def _write_readme(out: Path, summary: dict) -> None:
+    excluded = ", ".join(summary["excluded_cohorts"])
+    text = f"""# Prompt Adapter Filtered Artifacts
+
+Source: `{summary["input_dir"]}`
+
+Output: `{summary["out_dir"]}`
+
+Excluded cohorts: `{excluded}`
+
+Reason: manual review found pervasive watermark/low-quality/ambiguous images in
+the excluded cohort, so the whole cohort is removed from training artifacts.
+
+Manifest rows:
+
+- before: {summary["manifest_rows_before"]}
+- excluded: {summary["manifest_rows_excluded"]}
+- after: {summary["manifest_rows_after"]}
+
+Caption rows:
+
+- before: {summary["caption_rows_before"]}
+- excluded: {summary["caption_rows_excluded"]}
+- after: {summary["caption_rows_after"]}
+
+Files:
+
+- `adapter_manifest_mixed_v6.parquet`: filtered training manifest
+- `captions_v2.parquet`: filtered prompts/captions
+- `excluded_rows.parquet`: removed manifest rows
+- `excluded_image_ids.txt`: removed image IDs, one per line
+- `summary.json`: counts and distribution checks
+"""
+    (out / "README.md").write_text(text, encoding="utf-8")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", type=Path, default=DEFAULT_IN)
+    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    parser.add_argument("--manifest-name", default="adapter_manifest_mixed_v6.parquet")
+    parser.add_argument("--captions-name", default="captions_v2.parquet")
+    parser.add_argument("--exclude-cohort", action="append", default=["octbuckets_octa"])
+    parser.add_argument("--overwrite", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+    manifest_out = args.out / args.manifest_name
+    captions_out = args.out / args.captions_name
+    if not args.overwrite:
+        for path in [manifest_out, captions_out]:
+            if path.exists():
+                raise FileExistsError(f"{path} exists; pass --overwrite")
+
+    manifest_in = args.input / args.manifest_name
+    captions_in = args.input / args.captions_name
+    manifest = pd.read_parquet(manifest_in)
+    captions = pd.read_parquet(captions_in)
+    exclude_cohorts = set(args.exclude_cohort)
+
+    if "cohort" not in manifest.columns:
+        raise KeyError("manifest must contain a 'cohort' column")
+    if "image_id" not in manifest.columns:
+        raise KeyError("manifest must contain an 'image_id' column")
+    if "image_id" not in captions.columns:
+        raise KeyError("captions must contain an 'image_id' column")
+
+    cohort_values = manifest["cohort"].fillna("").astype(str)
+    excluded_mask = cohort_values.isin(exclude_cohorts)
+    excluded = manifest.loc[excluded_mask].copy()
+    kept = manifest.loc[~excluded_mask].copy()
+
+    if "modality_subtype" in kept.columns and "subtype_sample_status" in kept.columns:
+        subtype_counts = kept["modality_subtype"].fillna("unknown").astype(str).value_counts()
+        kept["subtype_sample_status"] = [
+            _status_from_counts(subtype, subtype_counts)
+            for subtype in kept["modality_subtype"].fillna("unknown").astype(str)
+        ]
+
+    keep_ids = set(kept["image_id"].astype(str))
+    caption_image_ids = captions["image_id"].astype(str)
+    kept_captions = captions.loc[caption_image_ids.isin(keep_ids)].copy()
+    excluded_caption_rows = int(len(captions) - len(kept_captions))
+
+    kept.to_parquet(manifest_out, index=False, compression="zstd")
+    kept_captions.to_parquet(captions_out, index=False, compression="zstd")
+    excluded.to_parquet(args.out / "excluded_rows.parquet", index=False, compression="zstd")
+    (args.out / "excluded_image_ids.txt").write_text(
+        "\n".join(excluded["image_id"].astype(str).tolist()) + ("\n" if len(excluded) else ""),
+        encoding="utf-8",
+    )
+
+    summary = {
+        "input_dir": str(args.input),
+        "out_dir": str(args.out),
+        "excluded_cohorts": sorted(exclude_cohorts),
+        "manifest_rows_before": int(len(manifest)),
+        "manifest_rows_excluded": int(len(excluded)),
+        "manifest_rows_after": int(len(kept)),
+        "caption_rows_before": int(len(captions)),
+        "caption_rows_excluded": excluded_caption_rows,
+        "caption_rows_after": int(len(kept_captions)),
+        "excluded_by_modality": _count_dict(excluded, "modality"),
+        "excluded_by_modality_family": _count_dict(excluded, "modality_family"),
+        "excluded_by_modality_subtype": _count_dict(excluded, "modality_subtype"),
+        "after_by_modality": _count_dict(kept, "modality"),
+        "after_by_modality_family": _count_dict(kept, "modality_family"),
+        "after_by_modality_subtype": _count_dict(kept, "modality_subtype"),
+        "after_by_subtype_sample_status": _count_dict(kept, "subtype_sample_status"),
+    }
+    (args.out / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+    _write_readme(args.out, summary)
+    print(json.dumps(summary, ensure_ascii=False), flush=True)
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/quality_control/prompt_qc.py

@@ -0,0 +1,462 @@
+"""Build prompt QC samples for the de-identified new-data manifest."""
+
+from __future__ import annotations
+
+import argparse
+import html
+import io
+import math
+import re
+import tarfile
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+from PIL import Image, ImageOps
+
+
+DEFAULT_MANIFEST = Path(
+    "/data/team/lisicheng/new_data_manifest/"
+    "new_data_manifest_dedup_split_labeled_with_wds_deid.parquet"
+)
+DEFAULT_OUT = Path("/data/team/lisicheng/new_data_manifest/prompt_qc")
+
+MODALITY_TEXT = {
+    "fundus_color": "color fundus photograph",
+    "oct_bscan": "OCT B-scan",
+    "octa": "optical coherence tomography angiography image",
+    "ffa": "fluorescein fundus angiography image",
+    "bscan_us": "ocular B-scan ultrasound image",
+    "ubm": "ultrasound biomicroscopy image",
+    "uwf": "ultra-widefield fundus photograph",
+}
+
+BANNED_PROMPT_TERMS = {
+    "tongren",
+    "xiangya",
+    "yinhai",
+    "chengdu",
+    "eryuan",
+    "handan",
+    "data0410",
+    "hcw",
+    "fq_unlabeled",
+    "mixed_unlabeled",
+    "octbuckets",
+    "train",
+    "test",
+    "internal_test",
+    "external_test",
+    "unlabeled",
+}
+
+DIAG_MAP = {
+    "amd": "age-related macular degeneration",
+    "年龄相关性黄斑变性": "age-related macular degeneration",
+    "老年性黄斑变性": "age-related macular degeneration",
+    "dr": "diabetic retinopathy",
+    "糖尿病视网膜病变": "diabetic retinopathy",
+    "糖网": "diabetic retinopathy",
+    "normal": "normal",
+    "正常": "normal",
+    "rvo": "retinal vein occlusion",
+    "视网膜静脉阻塞": "retinal vein occlusion",
+    "csc": "central serous chorioretinopathy",
+    "中心性浆液性脉络膜视网膜病变": "central serous chorioretinopathy",
+    "中浆": "central serous chorioretinopathy",
+    "erm": "epiretinal membrane",
+    "黄斑前膜": "epiretinal membrane",
+    "mh": "macular hole",
+    "黄斑裂孔": "macular hole",
+    "rao": "retinal artery occlusion",
+    "视网膜动脉阻塞": "retinal artery occlusion",
+    "rd": "retinal detachment",
+    "视网膜脱离": "retinal detachment",
+    "vkh": "Vogt-Koyanagi-Harada disease",
+    "葡萄膜炎": "uveitis",
+    "青光眼": "glaucoma",
+    "白内障": "cataract",
+}
+
+FINDING_RULES = [
+    (re.compile(r"玻璃体混浊|中低回声光点|中低回声光斑"), "vitreous opacity"),
+    (re.compile(r"玻璃体积血"), "vitreous hemorrhage"),
+    (re.compile(r"玻璃体后脱离"), "posterior vitreous detachment"),
+    (re.compile(r"后巩膜葡萄肿"), "posterior staphyloma"),
+    (re.compile(r"视网膜脱离"), "retinal detachment"),
+    (re.compile(r"视网膜裂孔"), "retinal tear"),
+    (re.compile(r"眼内占位|占位性病变"), "intraocular mass"),
+    (re.compile(r"脉络膜黑色素瘤"), "choroidal melanoma"),
+    (re.compile(r"硅油眼"), "silicone oil eye"),
+    (re.compile(r"黄斑囊样水肿|黄斑水肿|囊样水肿"), "macular edema"),
+    (re.compile(r"黄斑前膜"), "epiretinal membrane"),
+    (re.compile(r"黄斑裂孔"), "macular hole"),
+    (re.compile(r"分支静脉阻塞"), "branch retinal vein occlusion"),
+    (re.compile(r"视网膜静脉阻塞|静脉阻塞"), "retinal vein occlusion"),
+    (re.compile(r"视网膜动脉阻塞|动脉阻塞"), "retinal artery occlusion"),
+    (re.compile(r"糖尿病视网膜病变|糖网"), "diabetic retinopathy"),
+    (re.compile(r"高血压视网膜病变"), "hypertensive retinopathy"),
+    (re.compile(r"新生血管|CNV", re.I), "neovascularization"),
+    (re.compile(r"荧光渗漏|渗漏"), "fluorescein leakage"),
+    (re.compile(r"无灌注"), "capillary nonperfusion"),
+    (re.compile(r"微动脉瘤"), "microaneurysms"),
+    (re.compile(r"硬性渗出|硬渗"), "hard exudates"),
+    (re.compile(r"棉絮斑"), "cotton-wool spots"),
+    (re.compile(r"出血"), "retinal hemorrhage"),
+    (re.compile(r"视盘.*高荧光|视盘.*渗漏"), "optic disc leakage"),
+    (re.compile(r"房角开放"), "open anterior chamber angle"),
+    (re.compile(r"房角偏窄|窄房角|房角狭窄"), "narrow anterior chamber angle"),
+    (re.compile(r"虹膜平坦"), "flat iris configuration"),
+    (re.compile(r"睫状体.*囊|囊样暗区|囊样无回声区"), "ciliary body cyst"),
+    (re.compile(r"晶体内回声增强"), "lens opacity"),
+    (re.compile(r"前房.*浅"), "shallow anterior chamber"),
+]
+
+PII_PATTERNS = [
+    re.compile(r"(姓名|患者姓名|病人姓名|name)\s*[:：]?\s*[\u4e00-\u9fffA-Za-z·]{1,8}", re.I),
+    re.compile(r"(ID号|\bID\b|编号|住院号|门诊号|检查号|patient\s*id)\s*[:：]?\s*[A-Za-z0-9_-]+", re.I),
+    re.compile(r"(检查日期|出生日期|DOB)\s*[:：]?\s*\d{4}[-/.年]\d{1,2}[-/.月]\d{1,2}(?:日)?", re.I),
+    re.compile(r"\b\d{4}[-/.年]\d{1,2}[-/.月]\d{1,2}(?:日)?(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?\b"),
+    re.compile(r"\b\d{8,}\b"),
+]
+
+
+def clean_text(text: Any) -> str:
+    if text is None:
+        return ""
+    if isinstance(text, float) and math.isnan(text):
+        return ""
+    out = str(text)
+    for pattern in PII_PATTERNS:
+        out = pattern.sub("", out)
+    out = re.sub(r"(医师签名|医生签名|签名|建议门诊|门诊时间).*", "", out, flags=re.I)
+    out = re.sub(r"(待删|删除)", "", out)
+    out = re.sub(r"\s+", " ", out)
+    out = re.sub(r"[，。；;,\s]+$", "", out)
+    return out.strip(" ，。；;,")
+
+
+def build_prompts(row: dict[str, Any]) -> dict[str, str]:
+    modality = str(row.get("modality") or "")
+    base = base_prompt(row, modality)
+    descriptors = _clinical_descriptors(row)
+    demographics = _demographics(row)
+
+    short_parts = [base]
+    medium_parts = [base] + demographics + descriptors[:3]
+    dense_parts = [base] + demographics + descriptors[:8]
+
+    return {
+        "short": _join(short_parts),
+        "medium": _join(medium_parts),
+        "dense": _join(dense_parts),
+    }
+
+
+def base_prompt(row: dict[str, Any], modality: str) -> str:
+    if str(row.get("cohort") or "") == "tongren_external_fundus":
+        return "anterior segment photograph"
+    return MODALITY_TEXT.get(modality, f"{modality.replace('_', ' ')} ophthalmic image")
+
+
+def main() -> None:
+    args = parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+    (args.out / "imgs").mkdir(exist_ok=True)
+
+    df = pd.read_parquet(args.manifest)
+    df = df[df.get("split", "train") == "train"].copy() if "split" in df.columns else df.copy()
+    for col in ["center", "modality"]:
+        if col not in df.columns:
+            raise KeyError(f"manifest missing {col!r}")
+
+    samples = sample_by_center_modality(df, args.per_group, args.seed)
+    records = []
+    caption_rows = []
+    for idx, row in enumerate(samples.to_dict("records")):
+        prompts = build_prompts(row)
+        for level, prompt in prompts.items():
+            caption_rows.append(
+                {"image_id": row["image_id"], "level": level, "prompt_text": prompt}
+            )
+        image_rel = render_thumb(row, args.out / "imgs", idx, args.thumb)
+        record = {
+            "idx": idx,
+            "image_rel": image_rel,
+            "prompts": prompts,
+            **{k: row.get(k) for k in [
+                "image_id",
+                "center",
+                "modality",
+                "cohort",
+                "diagnosis_raw",
+                "group_raw",
+                "diagnosis_group",
+                "caption",
+                "train_path",
+                "pii_masked",
+                "ocr_age",
+                "ocr_sex",
+                "ocr_eye",
+            ]},
+        }
+        records.append(record)
+
+    caps = pd.DataFrame(caption_rows)
+    caps.to_parquet(args.out / "prompt_qc_captions.parquet", index=False)
+    caps.to_csv(args.out / "prompt_qc_captions.csv", index=False)
+    write_html(records, args.out / "prompt_qc.html")
+    write_design(args.out / "prompt_design.md")
+    print(f"DONE -> {args.out / 'prompt_qc.html'} ({len(records)} samples)")
+
+
+def sample_by_center_modality(df: pd.DataFrame, n: int, seed: int) -> pd.DataFrame:
+    groups = []
+    for (_, _), group in df.groupby(["center", "modality"], dropna=False):
+        groups.append(group.sample(n=min(n, len(group)), random_state=seed))
+    out = pd.concat(groups, ignore_index=True)
+    return out.sort_values(["modality", "center", "cohort", "image_id"]).reset_index(drop=True)
+
+
+def render_thumb(row: dict[str, Any], img_dir: Path, idx: int, size: int) -> str:
+    path = str(row.get("train_path") or row.get("file_path"))
+    name = f"{idx:04d}_{safe_name(row.get('modality'))}_{safe_name(row.get('center'))}.jpg"
+    out = img_dir / name
+    try:
+        if "::" in path:
+            im = open_wds_member(path).convert("RGB")
+        else:
+            im = Image.open(path).convert("RGB")
+        im.thumbnail((size, size), Image.Resampling.LANCZOS)
+        canvas = Image.new("RGB", (size, size), (0, 0, 0))
+        canvas.paste(im, ((size - im.width) // 2, (size - im.height) // 2))
+        im = canvas
+        im.save(out, quality=90)
+    except Exception:
+        im = Image.new("RGB", (size, size), (80, 20, 20))
+        im = ImageOps.expand(im, border=2, fill=(255, 0, 0))
+        im.save(out, quality=90)
+    return f"imgs/{name}"
+
+
+def open_wds_member(path: str) -> Image.Image:
+    tar_path, member_name = path.split("::", 1)
+    with tarfile.open(tar_path, "r:*") as tf:
+        member = tf.getmember(member_name)
+        fp = tf.extractfile(member)
+        if fp is None:
+            raise FileNotFoundError(path)
+        data = fp.read()
+    return Image.open(io.BytesIO(data))
+
+
+def write_html(records: list[dict[str, Any]], out: Path) -> None:
+    css = """
+body{font-family:Arial,sans-serif;margin:20px;background:#f7f7f7;color:#222}
+.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(460px,1fr));gap:14px}
+.card{background:white;border:1px solid #ddd;border-radius:6px;padding:12px}
+img{width:180px;height:180px;object-fit:contain;background:#000;float:left;margin-right:12px}
+.meta{font-size:12px;color:#555;line-height:1.35}
+.prompt{font-size:13px;margin:6px 0}.level{font-weight:bold;color:#333}
+.caption{clear:both;font-size:12px;color:#555;border-top:1px solid #eee;margin-top:10px;padding-top:8px}
+h1{margin-bottom:4px}.note{color:#555;margin-bottom:18px}
+"""
+    parts = [
+        "<!doctype html><html><head><meta charset='utf-8'>",
+        f"<style>{css}</style></head><body>",
+        "<h1>New-data prompt QC</h1>",
+        "<div class='note'>Grouped by center × modality, sampled 5 rows per group. "
+        "Prompts intentionally exclude center/cohort names and raw identifiers.</div>",
+        "<div class='grid'>",
+    ]
+    for r in records:
+        parts.append("<div class='card'>")
+        parts.append(f"<img src='{html.escape(r['image_rel'])}'>")
+        parts.append("<div class='meta'>")
+        for k in ["image_id", "modality", "center", "cohort", "pii_masked", "ocr_age", "ocr_sex", "ocr_eye"]:
+            parts.append(f"<b>{k}</b>: {html.escape(str(r.get(k)))}<br>")
+        parts.append(f"<b>train_path</b>: {html.escape(str(r.get('train_path'))[:180])}</div>")
+        for level in ["short", "medium", "dense"]:
+            parts.append(
+                f"<div class='prompt'><span class='level'>{level}</span>: "
+                f"{html.escape(r['prompts'][level])}</div>"
+            )
+        parts.append("<div class='caption'>")
+        for k in ["diagnosis_raw", "group_raw", "diagnosis_group", "caption"]:
+            v = r.get(k)
+            if v is not None and not (isinstance(v, float) and math.isnan(v)):
+                parts.append(f"<b>{k}</b>: {html.escape(str(v)[:400])}<br>")
+        parts.append("</div></div>")
+    parts.append("</div></body></html>")
+    out.write_text("\n".join(parts), encoding="utf-8")
+
+
+def write_design(out: Path) -> None:
+    text = """# Prompt design logic
+
+The training prompt space follows the previous private-data SD3 logic: each image has
+multiple candidate prompts (`short`, `medium`, `dense`), and training samples one
+prompt level at random per step.
+
+Prompt levels:
+- `short`: modality phrase only, matching the old private-data minimal prompt style.
+- `medium`: modality phrase plus age/sex/eye if available and up to three English labels.
+- `dense`: modality phrase plus age/sex/eye if available and up to eight English labels.
+
+Modality phrases:
+- `fundus_color`: color fundus photograph
+- `tongren_external_fundus`: anterior segment photograph, overriding the
+  `fundus_color` modality phrase because these images are external/anterior-eye photos.
+- `uwf`: ultra-widefield fundus photograph
+- `ffa`: fluorescein fundus angiography image
+- `octa`: optical coherence tomography angiography image
+- `bscan_us`: ocular B-scan ultrasound image
+- `ubm`: ultrasound biomicroscopy image
+
+Safety rules:
+- Never include center, hospital, cohort, dataset name, file name, ID, exact date, DOB, or raw OCR text.
+- Store only non-identifying OCR-derived attributes: age, sex, eye laterality.
+- Rows without labels still receive a modality-only prompt.
+- Long free-text reports are never copied into prompts; they are reduced to English finding labels.
+"""
+    out.write_text(text, encoding="utf-8")
+
+
+def _clinical_descriptors(row: dict[str, Any]) -> list[str]:
+    desc: list[str] = []
+    for key in ["diagnosis_raw", "diagnosis_group", "group_raw"]:
+        val = clean_text(row.get(key))
+        val = translate_diag(val)
+        candidates = [val] if _is_prompt_ready_label(val) else extract_finding_tags(val)
+        _extend_unique(desc, candidates)
+    cap = clean_text(row.get("caption"))
+    _extend_unique(desc, extract_finding_tags(cap))
+    return desc
+
+
+def extract_finding_tags(text: str) -> list[str]:
+    if not text:
+        return []
+    tags = [label for pattern, label in FINDING_RULES if pattern.search(text)]
+    return _unique(tags)
+
+
+def _extend_unique(out: list[str], values: list[str]) -> None:
+    seen = {v.lower() for v in out}
+    for value in values:
+        if _allowed_descriptor(value) and value.lower() not in seen:
+            out.append(value)
+            seen.add(value.lower())
+
+
+def _unique(values: list[str]) -> list[str]:
+    out = []
+    seen = set()
+    for value in values:
+        key = value.lower()
+        if key not in seen:
+            out.append(value)
+            seen.add(key)
+    return out
+
+
+def _is_prompt_ready_label(text: str) -> bool:
+    if not _allowed_descriptor(text):
+        return False
+    if re.search(r"[\u4e00-\u9fff]", text):
+        return False
+    return _is_concise_label(text)
+
+
+def _allowed_descriptor(text: str) -> bool:
+    if not text:
+        return False
+    lowered = text.lower().strip()
+    if lowered in BANNED_PROMPT_TERMS:
+        return False
+    if "_" in text or re.match(r"^group\d+\b", lowered):
+        return False
+    return not any(term in lowered for term in BANNED_PROMPT_TERMS)
+
+
+def _is_concise_label(text: str) -> bool:
+    if len(text) > 80:
+        return False
+    return not re.search(r"[。；;]|提示|所��|检查", text)
+
+
+def _clip_text(text: str, max_chars: int) -> str:
+    if len(text) <= max_chars:
+        return text
+    return text[: max_chars - 3].rstrip(" ，。；;,") + "..."
+
+
+def _demographics(row: dict[str, Any]) -> list[str]:
+    out: list[str] = []
+    age = row.get("ocr_age")
+    if age is not None and not (isinstance(age, float) and math.isnan(age)):
+        bucket = age_bucket(age)
+        if bucket:
+            out.append(bucket)
+    sex = str(row.get("ocr_sex") or "").upper()
+    if sex == "M":
+        out.append("male")
+    elif sex == "F":
+        out.append("female")
+    eye = str(row.get("ocr_eye") or "").upper()
+    if eye == "OD":
+        out.append("right eye")
+    elif eye == "OS":
+        out.append("left eye")
+    elif eye == "OU":
+        out.append("both eyes")
+    if len(out) >= 2 and out[1] in {"male", "female"}:
+        out = [f"{out[1]} patient {out[0]}"] + out[2:]
+    return out
+
+
+def age_bucket(age: Any) -> str:
+    try:
+        value = int(age)
+    except (TypeError, ValueError):
+        return ""
+    if value < 0 or value > 120:
+        return ""
+    if value < 2:
+        return "infant"
+    if value < 13:
+        return "child"
+    if value < 20:
+        return "teenage patient"
+    decade = min((value // 10) * 10, 90)
+    return f"in their {decade}s"
+
+
+def _join(parts: list[str]) -> str:
+    clean = [p for p in (clean_text(part) for part in parts) if p]
+    return ", ".join(clean)
+
+
+def translate_diag(text: str) -> str:
+    if not text:
+        return ""
+    key = text.strip().lower()
+    return DIAG_MAP.get(key, text.strip())
+
+
+def safe_name(value: Any) -> str:
+    return re.sub(r"[^A-Za-z0-9_.-]+", "_", str(value or "na"))[:80]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    parser.add_argument("--per-group", type=int, default=5)
+    parser.add_argument("--seed", type=int, default=20260701)
+    parser.add_argument("--thumb", type=int, default=320)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/quality_control/resize_mode_qc.py

@@ -0,0 +1,107 @@
+"""Build a visual QC sheet comparing center-crop vs aspect-preserving padding."""
+
+from __future__ import annotations
+
+import argparse
+import io
+import tarfile
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+from PIL import Image, ImageDraw, ImageFont
+
+import sys
+import types
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "src"))
+omegaconf_stub = types.ModuleType("omegaconf")
+omegaconf_stub.DictConfig = object
+sys.modules.setdefault("omegaconf", omegaconf_stub)
+from utils.train_utils import center_crop_arr, resize_pad_arr
+
+
+DEFAULT_MANIFEST = Path(
+    "/data/team/lisicheng/new_data_manifest/"
+    "new_data_manifest_dedup_split_labeled_with_wds_deid.parquet"
+)
+DEFAULT_OUT = Path("/data/team/lisicheng/new_data_manifest/resize_mode_qc_20260702")
+
+
+def main() -> None:
+    args = parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+    df = pd.read_parquet(args.manifest, columns=["image_id", "cohort", "modality", "train_path", "file_path"])
+    samples = []
+    for (_, _), group in df.groupby(["modality", "cohort"], sort=True):
+        samples.append(group.sample(n=min(args.per_group, len(group)), random_state=args.seed))
+    sample = pd.concat(samples, ignore_index=True).sort_values(["modality", "cohort", "image_id"])
+
+    rows = []
+    records = []
+    for row in sample.to_dict("records"):
+        path = str(row.get("train_path") or row.get("file_path"))
+        try:
+            im = open_image(path).convert("RGB")
+            crop = center_crop_arr(im, args.size)
+            pad = resize_pad_arr(im, args.size)
+            rows.append((row, im, crop, pad))
+            records.append({**row, "width": im.width, "height": im.height})
+        except Exception as exc:
+            records.append({**row, "error": repr(exc)})
+    write_sheet(rows, args.out / "resize_mode_qc.jpg", args.size)
+    pd.DataFrame(records).to_csv(args.out / "resize_mode_qc.csv", index=False)
+    print(f"DONE -> {args.out / 'resize_mode_qc.jpg'} ({len(rows)} images)")
+
+
+def open_image(path: str) -> Image.Image:
+    if "::" in path:
+        tar_path, member = path.split("::", 1)
+        with tarfile.open(tar_path) as tf:
+            fp = tf.extractfile(member)
+            if fp is None:
+                raise FileNotFoundError(path)
+            data = fp.read()
+        return Image.open(io.BytesIO(data))
+    return Image.open(path)
+
+
+def write_sheet(rows: list[tuple[dict[str, Any], Image.Image, Image.Image, Image.Image]], out: Path, cell: int) -> None:
+    header = 52
+    cols = 3
+    sheet = Image.new("RGB", (cols * cell, len(rows) * (cell + header)), (20, 20, 20))
+    draw = ImageDraw.Draw(sheet)
+    font = ImageFont.load_default()
+    for r, (meta, original, crop, pad) in enumerate(rows):
+        y = r * (cell + header)
+        label = f"{meta.get('modality')} | {meta.get('cohort')} | {meta.get('image_id')}"
+        draw.text((6, y + 4), label[:140], fill=(235, 235, 235), font=font)
+        for c, (name, im) in enumerate([("original", original), ("center_crop", crop), ("resize_pad", pad)]):
+            x = c * cell
+            draw.text((x + 6, y + 22), name, fill=(210, 210, 210), font=font)
+            thumb = fit_thumb(im, cell)
+            sheet.paste(thumb, (x, y + header))
+    out.parent.mkdir(parents=True, exist_ok=True)
+    sheet.save(out, quality=92)
+
+
+def fit_thumb(im: Image.Image, cell: int) -> Image.Image:
+    im = im.copy()
+    im.thumbnail((cell, cell), Image.Resampling.LANCZOS)
+    canvas = Image.new("RGB", (cell, cell), (0, 0, 0))
+    canvas.paste(im, ((cell - im.width) // 2, (cell - im.height) // 2))
+    return canvas
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    parser.add_argument("--per-group", type=int, default=2)
+    parser.add_argument("--seed", type=int, default=20260702)
+    parser.add_argument("--size", type=int, default=320)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/report_parsing/attach_labels.py

@@ -0,0 +1,163 @@
+"""Attach clinical captions / dx to the manifest for FILE-labeled cohorts (json/jsonl/xlsx).
+Folder-labeled cohorts (eryuan/eryuan_t17/tongren_95disease/dual/eyfrd6) are already labeled by
+build_manifest (diagnosis_raw=parent dir). Join keys verified by the 2026-06-30 label-schema recon.
+
+PII discipline: ONLY clinical findings/impression/dx text -> caption. Names/IDs/DOB/exam-dates/
+doctor-signatures are NEVER read into caption (separate fields, dropped); embedded scheduling/
+signature/boilerplate tails in free text are stripped by clean_caption().
+
+All joins are STUDY/scan-level except data0410 (image-level 1:1) and hcw (image-level) -> a scan's
+caption is fanned out to all its frames.
+
+Output: adds `caption` + `diagnosis_group` columns -> <manifest>_labeled.parquet
+Usage: /data/team/lisicheng/octdata_venv/bin/python attach_labels.py --manifest .../new_data_manifest.parquet [--only k1,k2]
+"""
+import argparse, json, re, os
+from collections import Counter
+from pathlib import Path
+import pandas as pd
+import cohorts as C
+
+NFS = "/nfs01/datasetsBackup"
+LBL = {
+    "handan":       f"{NFS}/ffa/handan_ffa/data.json",
+    "chengdu_ffa":  f"{NFS}/ffa/chengdu_ffa/visionoph4.jsonl",
+    "yinhai_ffa":   f"{NFS}/ffa/yinhai_ffa/output2.jsonl",
+    "yinhai_bscan": f"{NFS}/pretrainNewDS/BUltrasound/YinhaiBscan/YinhaiBscan.json",       # RAW (has findings)
+    "xiangya_bscan":f"{NFS}/pretrainNewDS/BUltrasound/XiangyaBscan/xiangyaBUltrasound_cleanedv3.json",
+    "chengdu_ubm":  f"{NFS}/pretrainNewDS/ubm/ChengduShiyiUBM/ChengdushiyiUBM_cleanedv3.json",
+    "yinhai_ubm":   f"{NFS}/pretrainNewDS/ubm/YinhaiUBM/YinHaiUBM_cleanedv3.json",
+}
+
+_TAIL = re.compile(r'(建议[:：]|门诊时间[:：]|医[师生]签[名字]|签[名字][:：]|医师[:：]|检查者|报告医[师生]|TOPCON|Corporation).*$', re.S)
+def clean_caption(t):
+    if t is None: return None
+    t = str(t).strip()
+    if not t or t == "18": return None                      # chengdu_ubm degenerate
+    t = _TAIL.split(t)[0]                                    # drop scheduling/signature tail (PII)
+    t = re.sub(r'请结合临床[。.]?\s*$', '', t)                 # UBM boilerplate
+    t = t.replace("&&", " ").replace("\n", " ")             # yinhai_ubm per-eye joiner / newlines
+    t = re.sub(r'\s+', ' ', t).strip(" >]")
+    return t or None
+
+def _basename(p): return os.path.basename(str(p))
+def _stem(p): return Path(str(p)).stem
+def _load_array(path, tolerant=False):
+    s = open(path, encoding="utf-8", errors="replace").read()
+    if tolerant: s = re.sub(r',(\s*[}\]])', r'\1', s)       # xiangya malformed trailing commas
+    return json.loads(s)
+
+# each builder returns (lookup_dict, key_fn) ; lookup value = caption_str OR (caption, dx)
+def b_handan():
+    recs = json.load(open(LBL["handan"]))["data"]
+    dup = {k for k, c in Counter(r.get("ID号", "").strip() for r in recs if r.get("ID号", "").strip()).items() if c > 1}
+    m = {}
+    for r in recs:
+        i = r.get("ID号", "").strip()
+        if not i or i in dup: continue                       # drop ambiguous/empty
+        m[i] = clean_caption(" ".join(x for x in [r.get("影像所见"), r.get("印象")] if x))
+    def key(p):
+        idp = _basename(p).rsplit("_", 1)[0]
+        return idp if idp in m else re.sub(r'\D+$', '', idp)  # strip trailing non-digit (e.g. 1809243Coats)
+    return m, key
+
+def b_chengdu_ffa():
+    m = {}
+    for r in _load_array(LBL["chengdu_ffa"]):
+        cap = clean_caption(r.get("description"))
+        dx = ";".join(dict.fromkeys(d for d in (r.get("diagnosis") or []) if d)) or None
+        for im in r.get("images", []):
+            b = re.split(r'[\\/]', im.get("image_path", ""))[-1]   # basename, NO cleanup (mangled names are real)
+            if b and b not in m: m[b] = (cap, dx)
+    return m, _basename
+
+def b_yinhai_ffa():
+    recs = [json.loads(l) for l in open(LBL["yinhai_ffa"]) if l.strip()]
+    m = {}
+    for r in recs:
+        f = r.get("file", ""); stem = f[:-4] if f.endswith(".csv") else f
+        if stem: m[stem] = clean_caption(r.get("second_column2"))
+    return m, lambda p: _basename(p).rsplit("-", 1)[0]          # <stem>-<frame>.bmp
+
+def b_by_images(path, tolerant=False, ubm_clean=False):
+    m = {}
+    for r in _load_array(path, tolerant=tolerant):
+        cap = r.get("description")
+        if ubm_clean and cap and not (cap[:1].isdigit() or ("一" <= cap[:1] <= "鿿")):
+            cap = cap[1:]                                       # strip 1 leading junk char (chengdu_ubm)
+        cap = clean_caption(cap)
+        for im in r.get("images", []):
+            b = _basename(re.split(r'[\\/]', im.get("image_path", ""))[-1])
+            if b and b not in m: m[b] = cap
+    return m, _basename
+
+def b_hcw():
+    rp = Path(C.EXTRACT_ROOT) / "hcw_fundus" / "fundus" / "fundus_csv"
+    frames = [pd.read_excel(rp / x) for x in ["dramdrvo_cleaned.xlsx", "glaucoma_cleaned.xlsx"] if (rp / x).exists()]
+    if not frames: print("  [hcw] xlsx missing -> run extract.sh (needs fundus_csv glob)"); return {}, _stem
+    lab = pd.concat(frames, ignore_index=True)
+    lab["stem"] = lab["image_name"].map(_stem)
+    m = {}
+    for stem, g in lab.groupby("stem"):
+        prim = g[g["is_primary"] == "是"]
+        names = ";".join(dict.fromkeys(g["diag_name"].dropna().astype(str)))
+        main = (prim.iloc[0] if len(prim) else g.iloc[0]).get("diag_name")
+        m[stem] = (clean_caption(names), str(main) if pd.notna(main) else None)
+    return m, _stem
+
+def b_data0410():
+    fp = Path(C.EXTRACT_ROOT) / "data0410_master_fundus" / "data" / "reports_2020_2025_cleaned.xlsx"
+    if not fp.exists(): print("  [data0410] xlsx missing -> run extract.sh"); return {}, _basename
+    df = pd.read_excel(fp)
+    return {str(n): clean_caption(c) for n, c in zip(df["ImageName"], df["Notes_clean"])}, _basename
+
+BUILDERS = {
+    "handan_fundus": b_handan, "handan_ffa": b_handan,
+    "chengdu_ffa": b_chengdu_ffa, "yinhai_ffa": b_yinhai_ffa,
+    "yinhai_bscan": lambda: b_by_images(LBL["yinhai_bscan"]),
+    "xiangya_bscan": lambda: b_by_images(LBL["xiangya_bscan"], tolerant=True),
+    "chengdu_shiyi_ubm": lambda: b_by_images(LBL["chengdu_ubm"], ubm_clean=True),
+    "yinhai_ubm": lambda: b_by_images(LBL["yinhai_ubm"], ubm_clean=True),
+    "hcw_fundus": b_hcw, "data0410_master_fundus": b_data0410,
+}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--manifest", required=True)
+    ap.add_argument("--only", default=None)
+    args = ap.parse_args()
+    df = pd.read_parquet(args.manifest)
+    for col in ("caption", "diagnosis_group"):
+        if col not in df: df[col] = None
+    only = set(args.only.split(",")) if args.only else None
+
+    for cohort, builder in BUILDERS.items():
+        if only and cohort not in only: continue
+        sub = df[df["cohort"] == cohort]
+        if not len(sub): continue
+        try:
+            lookup, key_fn = builder()
+        except Exception as e:
+            print(f"[{cohort}] builder FAILED: {e}"); continue
+        # vectorized: build aligned Series on sub.index (preserves df index) -> O(N), not O(N^2)
+        caps, dxs = [], []
+        for k in sub["file_path"].map(key_fn):
+            v = lookup.get(k)
+            if v is None: caps.append(None); dxs.append(None); continue
+            c, d = v if isinstance(v, tuple) else (v, None)
+            caps.append(c); dxs.append(d)
+        caps = pd.Series(caps, index=sub.index); dxs = pd.Series(dxs, index=sub.index)
+        df.loc[sub.index, "caption"] = caps
+        df.loc[sub.index, "diagnosis_group"] = dxs
+        nhit = int((caps.notna() | dxs.notna()).sum())
+        print(f"[{cohort}] {len(sub)} imgs -> {nhit} captioned ({100*nhit/max(1,len(sub)):.0f}%)")
+
+    outp = args.manifest.replace(".parquet", "_labeled.parquet")
+    df.to_parquet(outp, index=False)
+    cov = df["caption"].notna().sum()
+    print(f"\n=== {len(df)} rows, {cov} with caption -> {outp} ===")
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/report_parsing/batch_retrieve_reports.py

@@ -0,0 +1,470 @@
+import argparse
+import json
+import math
+import sys
+from collections import Counter
+from pathlib import Path
+
+import pandas as pd
+import torch
+import torch.nn.functional as F
+import yaml
+from PIL import Image
+from torch.utils.data import DataLoader, Dataset
+from torchvision import transforms
+from tqdm import tqdm
+from transformers import BertTokenizer
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[3]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from siglip.model import OcularRoBERTaSigLIP, clean_state_dict
+
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".bmp", ".tif", ".tiff", ".webp"}
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description=(
+            "Retrieve the most compatible report texts for a folder of OCT images. "
+            "This model ranks existing reports; it does not generate new text."
+        )
+    )
+    parser.add_argument("--image-dir", required=True, help="Directory containing OCT images")
+    parser.add_argument(
+        "--config",
+        default=str(PROJECT_ROOT / "siglip" / "train_config.yaml"),
+        help="Phase 2 training config",
+    )
+    parser.add_argument("--checkpoint", default=None, help="Phase 2 checkpoint")
+    parser.add_argument(
+        "--ijepa-path",
+        default=None,
+        help="Optional Phase 1 initialization; normally omit for a complete Phase 2 checkpoint",
+    )
+    parser.add_argument("--report-bank", default=None, help="XLSX/CSV containing candidate report texts")
+    parser.add_argument("--text-column", default=None)
+    parser.add_argument("--image-column", default=None)
+    parser.add_argument("--text-model-name", default=None)
+    parser.add_argument("--hf-cache-dir", default=None)
+    parser.add_argument("--local-files-only", action="store_true", default=None)
+    parser.add_argument("--allow-download", action="store_true")
+    parser.add_argument("--output-dir", default="phase2_retrieval_results")
+    parser.add_argument("--top-k", type=int, default=5)
+    parser.add_argument("--image-batch-size", type=int, default=64)
+    parser.add_argument("--text-batch-size", type=int, default=256)
+    parser.add_argument("--retrieval-chunk-size", type=int, default=16384)
+    parser.add_argument("--num-workers", type=int, default=8)
+    parser.add_argument("--precision", choices=["bf16", "fp16", "fp32"], default="bf16")
+    parser.add_argument("--device", default=None)
+    parser.add_argument("--num-images", type=int, default=0, help="0 uses every image")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--non-recursive", action="store_true")
+    parser.add_argument("--write-text-files", action="store_true")
+    parser.add_argument("--rebuild-text-cache", action="store_true")
+    return parser.parse_args()
+
+
+def load_config(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+
+def resolve_args(args, config):
+    data_cfg = config.get("data", {})
+    model_cfg = config.get("model", {})
+    checkpoint_cfg = config.get("checkpoint", {})
+
+    output_root = Path(checkpoint_cfg.get("output_dir", PROJECT_ROOT / "BioCliFM"))
+    run_name = checkpoint_cfg.get("run_name", "phase2")
+    default_checkpoint = output_root / "checkpoints" / run_name / "siglip_best.pth"
+
+    args.checkpoint = args.checkpoint or str(default_checkpoint)
+    args.report_bank = args.report_bank or data_cfg.get("excel_path")
+    args.text_column = args.text_column or data_cfg.get("text_col", "Notes_clean")
+    args.image_column = args.image_column or data_cfg.get("image_col", "ImageName")
+    args.text_model_name = args.text_model_name or model_cfg.get(
+        "text_model_name", "hfl/chinese-roberta-wwm-ext-large"
+    )
+    args.hf_cache_dir = args.hf_cache_dir or model_cfg.get("hf_cache_dir")
+    if args.allow_download:
+        args.local_files_only = False
+    elif args.local_files_only is None:
+        args.local_files_only = model_cfg.get("local_files_only", False)
+    args.embed_dim = model_cfg.get("embed_dim", 512)
+    args.max_length = data_cfg.get("max_length", 256)
+    args.input_size = data_cfg.get("input_size", 224)
+
+    required_paths = {
+        "image directory": args.image_dir,
+        "Phase 2 checkpoint": args.checkpoint,
+        "report bank": args.report_bank,
+    }
+    for label, value in required_paths.items():
+        if not value or not Path(value).expanduser().exists():
+            raise FileNotFoundError(f"{label} does not exist: {value}")
+
+    if args.ijepa_path and not Path(args.ijepa_path).expanduser().exists():
+        raise FileNotFoundError(f"Phase 1 checkpoint does not exist: {args.ijepa_path}")
+    if args.top_k <= 0:
+        raise ValueError("--top-k must be greater than zero")
+    return args
+
+
+def read_table(path, columns=None, nrows=None):
+    path = Path(path)
+    if path.suffix.lower() == ".csv":
+        return pd.read_csv(path, usecols=columns, nrows=nrows)
+    return pd.read_excel(path, usecols=columns, nrows=nrows)
+
+
+def load_report_bank(path, text_column, image_column):
+    header = read_table(path, columns=None, nrows=0).columns
+    if text_column not in header:
+        raise KeyError(f"Text column '{text_column}' not found. Available columns: {list(header)}")
+
+    columns = [text_column]
+    has_image_column = image_column in header
+    if has_image_column:
+        columns.append(image_column)
+    df = read_table(path, columns=columns)
+
+    texts = []
+    text_to_index = {}
+    ground_truth = {}
+    skipped = 0
+
+    for _, row in df.iterrows():
+        raw_text = row.get(text_column)
+        if pd.isna(raw_text):
+            skipped += 1
+            continue
+        text = str(raw_text).strip()
+        if not text:
+            skipped += 1
+            continue
+        if text not in text_to_index:
+            text_to_index[text] = len(texts)
+            texts.append(text)
+
+        if has_image_column:
+            raw_image = row.get(image_column)
+            if not pd.isna(raw_image):
+                image_key = Path(str(raw_image).strip()).name
+                if image_key:
+                    ground_truth.setdefault(image_key, set()).add(text)
+
+    if not texts:
+        raise RuntimeError(f"No valid reports found in {path}")
+    print(f"[Info] Report bank: rows={len(df)}, unique_reports={len(texts)}, skipped={skipped}")
+    if has_image_column:
+        print(f"[Info] Ground-truth image names available: {len(ground_truth)}")
+    return texts, ground_truth
+
+
+def discover_images(image_dir, recursive, num_images, seed):
+    image_dir = Path(image_dir).expanduser().resolve()
+    iterator = image_dir.rglob("*") if recursive else image_dir.glob("*")
+    paths = sorted(path for path in iterator if path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS)
+    if not paths:
+        raise RuntimeError(f"No supported images found under {image_dir}")
+    if num_images > 0 and len(paths) > num_images:
+        generator = torch.Generator().manual_seed(seed)
+        indices = torch.randperm(len(paths), generator=generator)[:num_images].tolist()
+        paths = [paths[index] for index in sorted(indices)]
+    print(f"[Info] OCT images selected: {len(paths)}")
+    return image_dir, paths
+
+
+class OCTImageDataset(Dataset):
+    def __init__(self, image_root, image_paths, transform):
+        self.image_root = image_root
+        self.image_paths = image_paths
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.image_paths)
+
+    def __getitem__(self, index):
+        path = self.image_paths[index]
+        try:
+            with Image.open(path) as image:
+                tensor = self.transform(image.convert("RGB"))
+        except Exception as exc:
+            raise RuntimeError(f"Failed to read image: {path}") from exc
+        return tensor, str(path.relative_to(self.image_root)), path.name
+
+
+def autocast_context(device, precision):
+    enabled = device.type == "cuda" and precision != "fp32"
+    dtype = torch.bfloat16 if precision == "bf16" else torch.float16
+    return torch.amp.autocast(device_type=device.type, dtype=dtype, enabled=enabled)
+
+
+def checkpoint_signature(path):
+    path = Path(path).expanduser().resolve()
+    stat = path.stat()
+    return {"path": str(path), "size": stat.st_size, "mtime_ns": stat.st_mtime_ns}
+
+
+def load_phase2_model(args, device):
+    checkpoint = torch.load(args.checkpoint, map_location="cpu")
+    state_dict = clean_state_dict(checkpoint.get("model_state_dict", checkpoint))
+    projection_weight = state_dict.get("visual_projection.weight")
+    embed_dim = projection_weight.shape[0] if projection_weight is not None else args.embed_dim
+
+    model = OcularRoBERTaSigLIP(
+        ijepa_ckpt_path=args.ijepa_path,
+        ijepa_encoder_source="target",
+        text_model_name=args.text_model_name,
+        embed_dim=embed_dim,
+        hf_cache_dir=args.hf_cache_dir,
+        local_files_only=args.local_files_only,
+    )
+    incompatible = model.load_state_dict(state_dict, strict=True)
+    if incompatible.missing_keys or incompatible.unexpected_keys:
+        raise RuntimeError(
+            f"Checkpoint mismatch: missing={incompatible.missing_keys}, "
+            f"unexpected={incompatible.unexpected_keys}"
+        )
+    model.to(device).eval()
+    epoch = checkpoint.get("epoch", "unknown")
+    loss = checkpoint.get("loss", "unknown")
+    print(f"[Info] Loaded Phase 2 checkpoint: epoch={epoch}, loss={loss}, embed_dim={embed_dim}")
+    if args.ijepa_path is None:
+        print("[Info] Phase 1 is already incorporated in the complete Phase 2 vision tower.")
+    return model
+
+
+def encode_text_bank(model, tokenizer, texts, args, device, output_dir):
+    cache_path = output_dir / "text_bank_embeddings.pt"
+    expected_meta = {
+        "checkpoint": checkpoint_signature(args.checkpoint),
+        "report_bank": str(Path(args.report_bank).expanduser().resolve()),
+        "text_column": args.text_column,
+        "text_model_name": args.text_model_name,
+        "max_length": args.max_length,
+        "num_texts": len(texts),
+    }
+    if cache_path.exists() and not args.rebuild_text_cache:
+        cache = torch.load(cache_path, map_location="cpu")
+        if cache.get("metadata") == expected_meta and cache.get("texts") == texts:
+            print(f"[Info] Reusing text embedding cache: {cache_path}")
+            return cache["embeddings"].float()
+        print("[Info] Text embedding cache is stale; rebuilding it.")
+
+    chunks = []
+    for start in tqdm(range(0, len(texts), args.text_batch_size), desc="Encoding report bank"):
+        batch_texts = texts[start:start + args.text_batch_size]
+        inputs = tokenizer(
+            batch_texts,
+            padding=True,
+            truncation=True,
+            max_length=args.max_length,
+            return_tensors="pt",
+        ).to(device)
+        with torch.inference_mode(), autocast_context(device, args.precision):
+            embeddings = F.normalize(
+                model.encode_text(inputs["input_ids"], inputs["attention_mask"]), dim=-1
+            )
+        chunks.append(embeddings.float().cpu())
+
+    embeddings = torch.cat(chunks, dim=0)
+    torch.save({"metadata": expected_meta, "texts": texts, "embeddings": embeddings}, cache_path)
+    print(f"[Info] Saved text embedding cache: {cache_path}")
+    return embeddings
+
+
+def chunked_topk(image_embeddings, text_embeddings, top_k, chunk_size, device):
+    batch_size = image_embeddings.shape[0]
+    best_scores = torch.full((batch_size, top_k), -math.inf, device=device)
+    best_indices = torch.full((batch_size, top_k), -1, dtype=torch.long, device=device)
+
+    for start in range(0, text_embeddings.shape[0], chunk_size):
+        text_chunk = text_embeddings[start:start + chunk_size].to(device, non_blocking=True)
+        scores = image_embeddings @ text_chunk.t()
+        local_k = min(top_k, scores.shape[1])
+        chunk_scores, chunk_indices = scores.topk(local_k, dim=1)
+        chunk_indices += start
+
+        combined_scores = torch.cat([best_scores, chunk_scores], dim=1)
+        combined_indices = torch.cat([best_indices, chunk_indices], dim=1)
+        best_scores, positions = combined_scores.topk(top_k, dim=1)
+        best_indices = combined_indices.gather(1, positions)
+
+    return best_scores.float().cpu(), best_indices.cpu()
+
+
+def retrieve_reports(model, image_loader, text_embeddings, texts, ground_truth, args, device):
+    results = []
+    scale = model.criterion.t_prime.detach().exp().clamp(max=model.criterion.max_temperature).float().cpu()
+    bias = model.criterion.b.detach().float().cpu()
+    top_k = min(args.top_k, len(texts))
+
+    for images, relative_paths, basenames in tqdm(image_loader, desc="Retrieving reports"):
+        images = images.to(device, non_blocking=True)
+        with torch.inference_mode(), autocast_context(device, args.precision):
+            image_embeddings = F.normalize(model.encode_image(images), dim=-1)
+        cosine_scores, indices = chunked_topk(
+            image_embeddings.float(), text_embeddings, top_k, args.retrieval_chunk_size, device
+        )
+
+        for row_index, (relative_path, basename) in enumerate(zip(relative_paths, basenames)):
+            candidates = []
+            for rank in range(top_k):
+                text_index = indices[row_index, rank].item()
+                cosine = cosine_scores[row_index, rank].item()
+                logit = cosine * scale.item() + bias.item()
+                candidates.append({
+                    "rank": rank + 1,
+                    "report": texts[text_index],
+                    "cosine_similarity": cosine,
+                    "siglip_logit": logit,
+                    "sigmoid_score": torch.sigmoid(torch.tensor(logit)).item(),
+                })
+
+            expected = ground_truth.get(basename, set())
+            expected_rank = next(
+                (candidate["rank"] for candidate in candidates if candidate["report"] in expected),
+                None,
+            )
+            results.append({
+                "image_path": relative_path,
+                "image_name": basename,
+                "retrieved_report": candidates[0]["report"],
+                "top1_cosine": candidates[0]["cosine_similarity"],
+                "top1_siglip_logit": candidates[0]["siglip_logit"],
+                "top1_sigmoid_score": candidates[0]["sigmoid_score"],
+                "top1_top2_margin": (
+                    candidates[0]["cosine_similarity"] - candidates[1]["cosine_similarity"]
+                    if len(candidates) > 1 else None
+                ),
+                "ground_truth_reports": sorted(expected),
+                "ground_truth_rank_at_k": expected_rank,
+                "candidates": candidates,
+            })
+    return results
+
+
+def save_results(results, output_dir, top_k, write_text_files):
+    jsonl_path = output_dir / "retrieval_results.jsonl"
+    with open(jsonl_path, "w", encoding="utf-8") as f:
+        for result in results:
+            f.write(json.dumps(result, ensure_ascii=False) + "\n")
+
+    rows = []
+    for result in results:
+        row = {
+            "image_path": result["image_path"],
+            "image_name": result["image_name"],
+            "retrieved_report": result["retrieved_report"],
+            "top1_cosine": result["top1_cosine"],
+            "top1_siglip_logit": result["top1_siglip_logit"],
+            "top1_sigmoid_score": result["top1_sigmoid_score"],
+            "top1_top2_margin": result["top1_top2_margin"],
+            "ground_truth_report": " || ".join(result["ground_truth_reports"]),
+            "ground_truth_rank_at_k": result["ground_truth_rank_at_k"],
+        }
+        for candidate in result["candidates"][:top_k]:
+            rank = candidate["rank"]
+            row[f"report_{rank}"] = candidate["report"]
+            row[f"cosine_{rank}"] = candidate["cosine_similarity"]
+            row[f"sigmoid_score_{rank}"] = candidate["sigmoid_score"]
+        rows.append(row)
+
+    csv_path = output_dir / "retrieval_results.csv"
+    pd.DataFrame(rows).to_csv(csv_path, index=False, encoding="utf-8-sig")
+
+    if write_text_files:
+        reports_dir = output_dir / "reports"
+        reports_dir.mkdir(parents=True, exist_ok=True)
+        for index, result in enumerate(results, start=1):
+            safe_stem = Path(result["image_name"]).stem.replace("/", "_").replace("\\", "_")
+            report_path = reports_dir / f"{index:04d}_{safe_stem}.txt"
+            report_path.write_text(result["retrieved_report"] + "\n", encoding="utf-8")
+
+    return csv_path, jsonl_path
+
+
+def print_summary(results, top_k):
+    top1_scores = torch.tensor([item["top1_cosine"] for item in results])
+    margins = [item["top1_top2_margin"] for item in results if item["top1_top2_margin"] is not None]
+    evaluated = [item for item in results if item["ground_truth_reports"]]
+    report_counts = Counter(item["retrieved_report"] for item in results)
+    most_common_report, most_common_count = report_counts.most_common(1)[0]
+
+    print("\n=== Phase 1 + Phase 2 OCT Report Retrieval Summary ===")
+    print(f"Images: {len(results)}")
+    print(
+        "Top-1 cosine mean/min/max: "
+        f"{top1_scores.mean().item():.4f} / {top1_scores.min().item():.4f} / {top1_scores.max().item():.4f}"
+    )
+    if margins:
+        print(f"Top-1/Top-2 cosine margin mean: {sum(margins) / len(margins):.4f}")
+    print(f"Unique Top-1 reports: {len(report_counts)}/{len(results)}")
+    print(
+        "Most frequent Top-1 report share: "
+        f"{most_common_count}/{len(results)} ({most_common_count / len(results):.2%})"
+    )
+    print(f"Most frequent Top-1 report: {most_common_report}")
+    if evaluated:
+        recall1 = sum(item["ground_truth_rank_at_k"] == 1 for item in evaluated) / len(evaluated)
+        recallk = sum(item["ground_truth_rank_at_k"] is not None for item in evaluated) / len(evaluated)
+        reciprocal_ranks = [
+            1.0 / item["ground_truth_rank_at_k"] if item["ground_truth_rank_at_k"] else 0.0
+            for item in evaluated
+        ]
+        print(f"Ground-truth matched images: {len(evaluated)}/{len(results)}")
+        print(f"Recall@1: {recall1:.4f}")
+        print(f"Recall@{top_k}: {recallk:.4f}")
+        print(f"MRR@{top_k}: {sum(reciprocal_ranks) / len(reciprocal_ranks):.4f}")
+    else:
+        print("Ground-truth metrics: unavailable (image names were not found in the report table).")
+
+
+def main():
+    args = parse_args()
+    args = resolve_args(args, load_config(args.config))
+    device = torch.device(args.device or ("cuda:0" if torch.cuda.is_available() else "cpu"))
+    output_dir = Path(args.output_dir).expanduser().resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print("[Info] Mode: report retrieval/ranking, not free-text generation")
+    print(f"[Info] Device={device}, precision={args.precision}, local_files_only={args.local_files_only}")
+    texts, ground_truth = load_report_bank(args.report_bank, args.text_column, args.image_column)
+    image_root, image_paths = discover_images(
+        args.image_dir, not args.non_recursive, args.num_images, args.seed
+    )
+
+    model = load_phase2_model(args, device)
+    tokenizer = BertTokenizer.from_pretrained(
+        args.text_model_name,
+        cache_dir=args.hf_cache_dir,
+        local_files_only=args.local_files_only,
+    )
+    text_embeddings = encode_text_bank(model, tokenizer, texts, args, device, output_dir)
+
+    transform = transforms.Compose([
+        transforms.Resize((args.input_size, args.input_size)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+    ])
+    image_loader = DataLoader(
+        OCTImageDataset(image_root, image_paths, transform),
+        batch_size=args.image_batch_size,
+        shuffle=False,
+        num_workers=args.num_workers,
+        pin_memory=device.type == "cuda",
+    )
+    results = retrieve_reports(model, image_loader, text_embeddings, texts, ground_truth, args, device)
+    csv_path, jsonl_path = save_results(results, output_dir, args.top_k, args.write_text_files)
+    print_summary(results, min(args.top_k, len(texts)))
+    print(f"[Info] CSV: {csv_path}")
+    print(f"[Info] JSONL: {jsonl_path}")
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/report_parsing/cohorts.py

@@ -0,0 +1,183 @@
+"""Verified cohort registry for the h100 cross-center new-data consolidation (2026-06-30).
+
+Single source of truth, encoding the 11-agent read-only recon (see memory reference_h100_newdata).
+HARD RULES baked in: originals on /nfs01 are READ-ONLY and NEVER modified/deleted. Archives
+extract ONLY to EXTRACT_ROOT (work dir on /data). Already-extracted dirs are read in place.
+Dedup/skip is done at MANIFEST level (drop rows), never by touching files.
+
+Each cohort dict:
+  key        unique cohort id (also the manifest `cohort` namespace)
+  modality   fundus_color | octa | ffa | bscan_us | ubm | uwf
+  center     hospital/source (for multi-center splits)
+  src        path to the extracted dir OR the archive
+  comp       none | zip | targz | rar5 | 7z   (archive type if not extracted)
+  extracted  True  -> read `src` in place (0 disk);  False -> extract to EXTRACT_ROOT/key
+  extract_glob  optional member filter for selective extraction (e.g. images only)
+  exts       image extensions to enumerate
+  label_kind folder | json | jsonl | xlsx | none
+  label_path label file (abs), or None  (folder labels come from dir names)
+  pii        none | low | t1   (t1 = must strip identifiers before any export; see register)
+  dedup_group  cohorts sharing a group are cross-checked for duplicates
+  role       train | external_test         (external_test = held out, never trained)
+  note
+"""
+import os
+
+EXTRACT_ROOT = "/data/team/lisicheng/new_data_extracted"   # all extraction lands here (/data, 2.9T free); /nfs01 is read-only
+WORK = "/data/team/lisicheng"
+NFS_BACKUP = "/nfs01/datasetsBackup"
+NFS_FQ = "/nfs01/FQ_Datasets/data"
+DATASETS = "/data/datasets"
+UNRAR = "/data/team/lisicheng/miniconda3/envs/ocr/bin/unrar"   # not on PATH; full path
+
+IMG_EXTS = (".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp")
+
+
+def read_path(c):
+    """Where images are actually read from."""
+    return c["src"] if c.get("extracted") else os.path.join(EXTRACT_ROOT, c["key"])
+
+
+# ----------------------------------------------------------------------------- COHORTS
+COHORTS = [
+    # ===================== FUNDUS (color fundus photography) =====================
+    dict(key="fundus90wer", modality="fundus_color", center="mixed_unlabeled",
+         src=f"{DATASETS}/fundus90wER", comp="none", extracted=True, exts=(".png", ".jpg"),
+         label_kind="none", label_path=None, pii="t1", dedup_group="fundus_pool", role="train",
+         note="899,266 (verified). Chinese names in filenames -> t1 (filename PII only, not in pixels). md5 in cleaning_report usable as dedup key."),
+    dict(key="fq_rawfundus", modality="fundus_color", center="fq_unlabeled",
+         src=f"{NFS_FQ}/rawFundus", comp="none", extracted=True, exts=(".png",),
+         label_kind="none", label_path=None, pii="low", dedup_group="fq_tongren_idname", role="train",
+         note="208,138 (verified). <id>-<n>.png. SKIP rawFundus_predicted (same imgs, quality-resorted)."),
+    dict(key="fq_testfundus", modality="fundus_color", center="fq_unlabeled",
+         src=f"{NFS_FQ}/testFundus", comp="none", extracted=True, exts=(".png",),
+         label_kind="none", label_path=None, pii="low", dedup_group="fq_tongren_idname", role="train",
+         note="52,034 (verified). SKIP testFundus_predicted."),
+    dict(key="fq_validfundus", modality="fundus_color", center="fq_unlabeled",
+         src=f"{NFS_FQ}/validFundus", comp="none", extracted=True, exts=(".png",),
+         label_kind="folder", label_path=None, pii="low", dedup_group="fq_tongren_idname", role="train",
+         note="4,000 (verified). quality=gradable (whole-dir tag)."),
+    dict(key="eryuan_t17_fundus", modality="fundus_color", center="eryuan",
+         src=f"{NFS_FQ}/eryuanFundusT17RDCls", comp="none", extracted=True, exts=(".tif",),
+         label_kind="folder", label_path=None, pii="low", dedup_group="eryuan_pool", role="train",
+         note="31,621 (verified). 17 disease classes; has train/val/test -> reserve its test split as INTERNAL test. class = immediate parent dir."),
+    dict(key="tongren_fundus", modality="fundus_color", center="tongren",
+         src=f"{WORK}/Dataser/shards_tongren", comp="none", extracted=True, exts=(".png",),
+         label_kind="json", label_path=None, pii="low", dedup_group="tongren_pool", role="train",
+         note="~628,392 WebDataset shards (de-id product, sex/age in per-image json). USE THIS, skip 同仁/fundus.zip. WebDataset -> needs wds reader (see build_manifest stub)."),
+    dict(key="tongren_external_fundus", modality="fundus_color", center="tongren",
+         src=f"{NFS_BACKUP}/同仁/external.zip", comp="zip", extracted=False, exts=(".png",),
+         label_kind="none", label_path=None, pii="low", dedup_group="tongren_pool", role="train",
+         note="209,091 (verified). 99.5% SAME PATIENTS as tongren_fundus but 0 same-file -> OK as extra TRAIN, NEVER as eval (leakage)."),
+    dict(key="tongren_95disease_fundus", modality="fundus_color", center="tongren",
+         src=f"{NFS_BACKUP}/tr/tr1695L2/tongren16G95DFundus", comp="none", extracted=True, exts=(".png",),
+         label_kind="folder", label_path=None, pii="low", dedup_group="tongren_pool", role="train",
+         note="264,412 (verified). 16 groups / ~95 disease subclasses (folder). GOLDMINE for downstream. dedup vs tongren_pool by 编号. SKIP the tr .7z (extracted copy already here). class=parent, group=grandparent."),
+    dict(key="eryuan_fundus", modality="fundus_color", center="eryuan",
+         src=f"{NFS_BACKUP}/data0410/eryuan.zip", comp="zip", extracted=False, exts=(".tif", ".png"),
+         label_kind="folder", label_path=None, pii="low", dedup_group="eryuan_pool", role="train",
+         note="19,599 (verified): 4 classes AMD/DR/Normal/RVO (NOT 17 as md said). SKIP eryuan_split (subset). dedup vs data0410_master."),
+    dict(key="dual_comorbidity_fundus", modality="fundus_color", center="data0410",
+         src=f"{NFS_BACKUP}/data0410/Dual_comornidity.tar.gz", comp="targz", extracted=False, exts=(".png",),
+         label_kind="folder", label_path=None, pii="low", dedup_group="data0410_pool", role="train",
+         note="~12k unique (24,120 entries = 6-class scheme + 4-class scheme of SAME pool). Keep ONE scheme in manifest. hypertension comorbidity classes."),
+    dict(key="hcw_fundus", modality="fundus_color", center="hcw",
+         src=f"{NFS_BACKUP}/data0410/fundus_hcw.zip", comp="zip", extracted=False, exts=(".tif", ".png"),
+         extract_glob="fundus/fundus_img/*", label_kind="xlsx", label_path=None, pii="low",
+         dedup_group="data0410_pool", role="train",
+         note="~15,503 imgs ONLY (extract_glob excludes 150G .pth + code!). dx-pairing xlsx keyed by image_name."),
+    dict(key="data0410_master_fundus", modality="fundus_color", center="data0410",
+         src=f"{NFS_BACKUP}/data0410/data.tar.gz", comp="targz", extracted=False, exts=(".png", ".jpg"),
+         label_kind="xlsx", label_path=None, pii="t1", dedup_group="data0410_pool", role="train",
+         note="104,505 (md-UNVERIFIED). master 二院 pool. reports_2020_2025_cleaned.xlsx has 姓名/PatientID/DOB (STRIP). ⚠ xlsx->image join key UNRESOLVED (datetime filenames vs patient key) -> label as none until join confirmed. dedup vs eryuan/hcw."),
+    dict(key="eyfrd6_fundus", modality="fundus_color", center="eryuan",
+         src=f"{DATASETS}/eyFRDCls", comp="none", extracted=True, exts=(".tif",),
+         label_kind="folder", label_path=None, pii="low", dedup_group="fundus_pool", role="train",
+         note="~645. 6 classes CSC/ERM/MH/RAO/RD/VKH (has train/val/test). tiny."),
+    dict(key="handan_fundus", modality="fundus_color", center="handan",
+         src=f"{NFS_BACKUP}/ffa/handan_ffa/only_image", comp="none", extracted=True, exts=(".png",),
+         label_kind="json", label_path=f"{NFS_BACKUP}/ffa/handan_ffa/data.json", pii="t1",
+         dedup_group="handan", role="external_test",
+         note="6,432 fundus = filenames ending _1/_2 ONLY (must filter by suffix at enumerate). HELD OUT (邯郸 external). data.json 印象 dx; strip 姓名/年龄/检查日期/ID号."),
+
+    # ===================== OCTA =====================
+    dict(key="octbuckets_octa", modality="octa", center="octbuckets",
+         src=f"{WORK}/Dataser/shards_oct", comp="none", extracted=True, exts=(".png",),
+         label_kind="json", label_path=None, pii="none", dedup_group="octa", role="train",
+         note="~34,519 WebDataset (de-id product; eye/scan_mode/frame). USE THIS, skip octBuckets.zip (raw, has name-in-filename). Is OCTA (Angio/en-face), NOT plain OCT."),
+
+    # ===================== FFA (fluorescein angiography) -- NEW modality =====================
+    dict(key="handan_ffa", modality="ffa", center="handan",
+         src=f"{NFS_BACKUP}/ffa/handan_ffa/only_image", comp="none", extracted=True, exts=(".png",),
+         label_kind="json", label_path=f"{NFS_BACKUP}/ffa/handan_ffa/data.json", pii="t1",
+         dedup_group="handan", role="external_test",
+         note="23,212 FFA = filenames _3 and higher suffix (filter by suffix). HELD OUT (邯郸 external). 3,226 study impressions; strip PII."),
+    dict(key="chengdu_ffa", modality="ffa", center="chengdu",
+         src=f"{NFS_BACKUP}/ffa/chengdu_ffa/jpg", comp="none", extracted=True, exts=(".png",),
+         label_kind="jsonl", label_path=f"{NFS_BACKUP}/ffa/chengdu_ffa/visionoph4.jsonl", pii="low",
+         dedup_group="chengdu_ffa", role="external_test",
+         note="4,938 PNG (dir misnamed 'jpg', holds .png). HELD OUT (成都 FFA external). visionoph4.jsonl is a JSON ARRAY: scan_id/structured dx codes; normalize windows backslash paths."),
+    dict(key="yinhai_ffa", modality="ffa", center="yinhai",
+         src=f"{NFS_BACKUP}/ffa/yinhai_ffa/jpg", comp="none", extracted=True, exts=(".bmp",),
+         label_kind="jsonl", label_path=f"{NFS_BACKUP}/ffa/yinhai_ffa/output2.jsonl", pii="t1",
+         dedup_group="yinhai_ffa", role="train",
+         note="1,058 BMP (dir misnamed 'jpg', holds .bmp). output2.jsonl 拟诊报告; strip 姓名+P-ID+签名."),
+    dict(key="eryuan_ffa", modality="ffa", center="eryuan",
+         src=f"{NFS_BACKUP}/ffa/Final_eryuan_FFA/FFA", comp="none", extracted=True, exts=(".tif",),
+         label_kind="none", label_path=None, pii="low", dedup_group="eryuan_ffa", role="train",
+         note="18,543 tif (verified). SKIP the redundant 72.5G Final_eryuan_FFA.zip. no labels."),
+
+    # ===================== B-scan ocular ultrasound -- NEW modality =====================
+    dict(key="yinhai_bscan", modality="bscan_us", center="yinhai",
+         src=f"{NFS_BACKUP}/pretrainNewDS/BUltrasound/YinhaiBscan", comp="none", extracted=True, exts=(".png",),
+         label_kind="json", label_path=None, pii="low", dedup_group="yinhai_bscan", role="train",
+         note="71,289 (verified). images in image/ subdir. Use RAW json (超声所见 findings); cleanedv3 nulls findings. no name/dob."),
+    dict(key="xiangya_bscan", modality="bscan_us", center="xiangya",
+         src=f"{NFS_BACKUP}/pretrainNewDS/BUltrasound/XiangyaBscan", comp="none", extracted=True, exts=(".bmp",),
+         label_kind="json", label_path=None, pii="t1", dedup_group="xiangya_bscan", role="train",
+         note="33,740 (verified) bmp in image/. cleanedv3.json 4,939 records: findings + name/dob/examdate (STRIP)."),
+    dict(key="chengdu_bscan", modality="bscan_us", center="chengdu",
+         src=f"{NFS_BACKUP}/pretrainNewDS/BUltrasound/chengdu_Bscan", comp="none", extracted=True, exts=(".jpg",),
+         label_kind="none", label_path=None, pii="none", dedup_group="chengdu_bscan", role="train",
+         note="8,726 (verified) jpg flat. no labels."),
+
+    # ===================== UBM (ultrasound biomicroscopy) -- NEW modality =====================
+    dict(key="chengdu_shiyi_ubm", modality="ubm", center="chengdu",
+         src=f"{NFS_BACKUP}/pretrainNewDS/ubm/ChengduShiyiUBM", comp="none", extracted=True, exts=(".png",),
+         label_kind="json", label_path=None, pii="low", dedup_group="chengdu_ubm", role="train",
+         note="236,028 (verified) png in image/. Use cleanedv3 json (clinical report; raw json has corrupted blobs/false-PII)."),
+    dict(key="yinhai_ubm", modality="ubm", center="yinhai",
+         src=f"{NFS_BACKUP}/pretrainNewDS/ubm/YinhaiUBM", comp="none", extracted=True, exts=(".png",),
+         label_kind="json", label_path=None, pii="low", dedup_group="yinhai_ubm", role="train",
+         note="83,750 (verified). cleanedv3 clinical text."),
+    dict(key="eryuan_ubm", modality="ubm", center="eryuan",
+         src=f"{NFS_BACKUP}/pretrainNewDS/ubm/Final_eryuan_ubm", comp="none", extracted=True, exts=(".tif",),
+         label_kind="none", label_path=None, pii="low", dedup_group="eryuan_ubm", role="train",
+         note="134,350 (verified) tif. truly no labels. SKIP the 2 redundant UBM .rar packs. ms-timestamp in filename (quasi-id)."),
+
+    # ===================== UWF (ultra-widefield) -- NEW modality, single center =====================
+    dict(key="yinhai_uwf", modality="uwf", center="yinhai",
+         src=f"{NFS_BACKUP}/pretrainNewDS/uwf/yinhai_uwf", comp="rar5", extracted=False, exts=(".jpg",),
+         label_kind="none", label_path=None, pii="low", dedup_group="yinhai_uwf", role="train",
+         note="11,113 (md-UNVERIFIED). 3 RAR5 multipart sets (Secondary_1/_2/_3). extract first volume of each set with unrar. SINGLE CENTER -> no external val possible (paper limitation)."),
+]
+
+# Archives explicitly NOT ingested (dups / products-superseded / code). Documented for transparency; never deleted.
+SKIP = {
+    "rawFundus_predicted": "dup of fq_rawfundus (quality-resorted)",
+    "testFundus_predicted": "dup of fq_testfundus",
+    "eryuan_split.tar.gz": "subset of eryuan_fundus",
+    "handan_ffa2": "strict subset of handan (0 unique files)",
+    "Final_eryuan_FFA.zip": "redundant archive of eryuan_ffa extracted dir",
+    "2-UBM-SW3200L-去噪声处理.rar / 3-UBM-SW3200L2-dataset.rar": "redundant with eryuan_ubm",
+    "同仁/fundus.zip": "superseded by tongren_fundus shards (de-id)",
+    "octBuckets.zip": "superseded by octbuckets_octa shards (de-id)",
+    "tr/*.7z": "extracted copy tr1695L2 already present",
+    "BioCliFM.tar.gz": "code, not data",
+    "fundus_hcw .pth/code": "150G checkpoints+code; only images extracted via extract_glob",
+}
+
+INCLUDE = COHORTS
+def by_role(role): return [c for c in COHORTS if c["role"] == role]
+def to_extract(): return [c for c in COHORTS if not c.get("extracted")]
+def modalities(): return sorted({c["modality"] for c in COHORTS})

tools/data_processing/report_parsing/materialize_newdata_prompts.py

@@ -0,0 +1,537 @@
+"""Materialize new-data prompt artifacts in the old OCTFlow caption format.
+
+Outputs:
+  - adapter_manifest_v1.parquet: 41-column OCTFlow-style structured manifest.
+  - captions_v2.parquet: caption_id, image_id, level, prompt_text, language, generator, grounded_in.
+  - sidecar_v1.parquet: raw non-prompt details needed to audit how fields were derived.
+  - README.md: artifact and prompt design summary.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from prompt_qc import build_prompts, clean_text, extract_finding_tags, translate_diag
+
+
+DEFAULT_MANIFEST = Path(
+    "/data/team/lisicheng/new_data_manifest/"
+    "new_data_manifest_dedup_split_labeled_with_wds_deid_leftfundus.parquet"
+)
+DEFAULT_OUT = Path("/data/team/lisicheng/new_data_manifest/prompt_adapter_v1")
+
+V2_MODALITY_OVERRIDES = {
+    "data0410_master_fundus": "oct_bscan",
+    "octbuckets_octa": "oct_bscan",
+}
+
+V2_EXCLUDE_COHORTS = {
+    "fq_validfundus",
+    "dual_comorbidity_fundus",
+}
+
+ADAPTER_COLUMNS = [
+    "cohort",
+    "study_id",
+    "patient_hash",
+    "visit_date",
+    "eye",
+    "device_vendor",
+    "device_model",
+    "device_serial_hash",
+    "device_software_version",
+    "hospital_domain",
+    "ethnicity",
+    "image_quality_score",
+    "image_quality_band",
+    "diagnosis_group",
+    "lesion_tags",
+    "lesion_location",
+    "layer_involvement",
+    "severity",
+    "diagnosis_source",
+    "label_confidence",
+    "schema_version",
+    "image_id",
+    "file_path",
+    "file_format",
+    "modality",
+    "anatomy",
+    "device_technology",
+    "scan_protocol",
+    "scan_x_mm",
+    "bscan_index",
+    "image_height_px",
+    "image_width_px",
+    "axial_resolution_um",
+    "has_segmentation",
+    "n_layers_visible",
+    "fovea_x_norm",
+    "crt_um",
+    "choroid_thickness_um",
+    "oct_footprint_bbox_fundus",
+    "oct_footprint_bbox_slo",
+    "is_valid",
+]
+
+SIDECAR_COLUMNS = [
+    "image_id",
+    "source_cohort",
+    "center",
+    "role",
+    "split",
+    "original_file_path",
+    "train_path",
+    "deid_path",
+    "pii_masked",
+    "deid_method",
+    "diagnosis_raw",
+    "group_raw",
+    "diagnosis_group_raw",
+    "caption_raw",
+    "ocr_age",
+    "ocr_sex",
+    "ocr_eye",
+    "storage",
+]
+
+ADAPTER_SCHEMA = pa.schema(
+    [
+        ("cohort", pa.string()),
+        ("study_id", pa.string()),
+        ("patient_hash", pa.string()),
+        ("visit_date", pa.string()),
+        ("eye", pa.string()),
+        ("device_vendor", pa.string()),
+        ("device_model", pa.string()),
+        ("device_serial_hash", pa.string()),
+        ("device_software_version", pa.string()),
+        ("hospital_domain", pa.string()),
+        ("ethnicity", pa.string()),
+        ("image_quality_score", pa.float64()),
+        ("image_quality_band", pa.string()),
+        ("diagnosis_group", pa.list_(pa.string())),
+        ("lesion_tags", pa.list_(pa.string())),
+        ("lesion_location", pa.list_(pa.string())),
+        ("layer_involvement", pa.list_(pa.string())),
+        ("severity", pa.string()),
+        ("diagnosis_source", pa.string()),
+        ("label_confidence", pa.float64()),
+        ("schema_version", pa.string()),
+        ("image_id", pa.string()),
+        ("file_path", pa.string()),
+        ("file_format", pa.string()),
+        ("modality", pa.string()),
+        ("anatomy", pa.string()),
+        ("device_technology", pa.string()),
+        ("scan_protocol", pa.string()),
+        ("scan_x_mm", pa.float64()),
+        ("bscan_index", pa.float64()),
+        ("image_height_px", pa.float64()),
+        ("image_width_px", pa.float64()),
+        ("axial_resolution_um", pa.float64()),
+        ("has_segmentation", pa.bool_()),
+        ("n_layers_visible", pa.int64()),
+        ("fovea_x_norm", pa.float64()),
+        ("crt_um", pa.float64()),
+        ("choroid_thickness_um", pa.float64()),
+        ("oct_footprint_bbox_fundus", pa.list_(pa.int64())),
+        ("oct_footprint_bbox_slo", pa.list_(pa.int64())),
+        ("is_valid", pa.bool_()),
+    ]
+)
+
+CAPTIONS_SCHEMA = pa.schema(
+    [
+        ("caption_id", pa.string()),
+        ("image_id", pa.string()),
+        ("level", pa.string()),
+        ("prompt_text", pa.string()),
+        ("language", pa.string()),
+        ("generator", pa.string()),
+        ("grounded_in", pa.string()),
+    ]
+)
+
+SIDECAR_SCHEMA = pa.schema(
+    [
+        ("image_id", pa.string()),
+        ("source_cohort", pa.string()),
+        ("center", pa.string()),
+        ("role", pa.string()),
+        ("split", pa.string()),
+        ("original_file_path", pa.string()),
+        ("train_path", pa.string()),
+        ("deid_path", pa.string()),
+        ("pii_masked", pa.bool_()),
+        ("deid_method", pa.string()),
+        ("diagnosis_raw", pa.string()),
+        ("group_raw", pa.string()),
+        ("diagnosis_group_raw", pa.string()),
+        ("caption_raw", pa.string()),
+        ("ocr_age", pa.float64()),
+        ("ocr_sex", pa.string()),
+        ("ocr_eye", pa.string()),
+        ("storage", pa.string()),
+    ]
+)
+
+MODALITY_META = {
+    "fundus_color": ("macula", "fundus_camera", "single_shot"),
+    "oct_bscan": ("macula", "oct", "bscan"),
+    "uwf": ("wide-field", "fundus_camera", "widefield"),
+    "ffa": ("retina", "fluorescein_angiography", "angiography"),
+    "octa": ("macula", "octa", "enface"),
+    "bscan_us": ("globe", "ultrasound", "bscan"),
+    "ubm": ("anterior_segment", "ultrasound_biomicroscopy", "bscan"),
+}
+
+
+def main() -> None:
+    args = parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+
+    df = pd.read_parquet(args.manifest)
+    if args.limit:
+        df = df.head(args.limit).copy()
+    if args.policy in {"v2", "v3"}:
+        df = apply_v2_policy(df)
+
+    adapter_path = args.out / f"adapter_manifest_{args.policy}.parquet"
+    captions_path = args.out / "captions_v2.parquet"
+    sidecar_path = args.out / f"sidecar_{args.policy}.parquet"
+
+    for path in [adapter_path, captions_path, sidecar_path]:
+        if path.exists() and not args.overwrite:
+            raise FileExistsError(f"{path} exists; pass --overwrite")
+        if path.exists():
+            path.unlink()
+
+    adapter_writer: pq.ParquetWriter | None = None
+    captions_writer: pq.ParquetWriter | None = None
+    sidecar_writer: pq.ParquetWriter | None = None
+
+    total_adapter = 0
+    total_captions = 0
+    for start in range(0, len(df), args.chunk_size):
+        chunk = df.iloc[start : start + args.chunk_size]
+        adapter_rows: list[dict[str, Any]] = []
+        caption_rows: list[dict[str, Any]] = []
+        sidecar_rows: list[dict[str, Any]] = []
+
+        for row in chunk.to_dict("records"):
+            adapter_rows.append(build_adapter_row(row))
+            sidecar_rows.append(build_sidecar_row(row))
+            prompts = build_prompts(row)
+            grounded = grounded_in(row)
+            for level in ["short", "medium", "dense"]:
+                caption_rows.append(
+                    {
+                        "caption_id": f"{row['image_id']}_{level}",
+                        "image_id": row["image_id"],
+                        "level": level,
+                        "prompt_text": prompts[level],
+                        "language": "en",
+                        "generator": f"newdata_prompt_adapter_{args.policy}",
+                        "grounded_in": grounded,
+                    }
+                )
+
+        adapter_writer = append_parquet(
+            pd.DataFrame(adapter_rows, columns=ADAPTER_COLUMNS),
+            adapter_path,
+            adapter_writer,
+            ADAPTER_SCHEMA,
+        )
+        captions_writer = append_parquet(
+            pd.DataFrame(caption_rows), captions_path, captions_writer, CAPTIONS_SCHEMA
+        )
+        sidecar_writer = append_parquet(
+            pd.DataFrame(sidecar_rows, columns=SIDECAR_COLUMNS),
+            sidecar_path,
+            sidecar_writer,
+            SIDECAR_SCHEMA,
+        )
+        total_adapter += len(adapter_rows)
+        total_captions += len(caption_rows)
+        if total_adapter % args.log_every < len(adapter_rows):
+            print(f"rows={total_adapter} captions={total_captions}", flush=True)
+
+    for writer in [adapter_writer, captions_writer, sidecar_writer]:
+        if writer is not None:
+            writer.close()
+
+    write_readme(args.out, args.manifest, len(df), total_captions, args.policy)
+    write_summary(args.out, df, total_captions, args.policy)
+    print(json.dumps({"out": str(args.out), "rows": len(df), "captions": total_captions}, ensure_ascii=False))
+
+
+def apply_v2_policy(df: pd.DataFrame) -> pd.DataFrame:
+    """Apply the first human-reviewed new-data policy before prompt materialization."""
+    out = df.copy()
+    if "split" not in out.columns:
+        raise KeyError("v2 policy requires a split column")
+    if "cohort" not in out.columns:
+        raise KeyError("v2 policy requires a cohort column")
+    if "modality" not in out.columns:
+        raise KeyError("v2 policy requires a modality column")
+
+    out = out[out["split"].eq("train")].copy()
+    out = out[~out["cohort"].isin(V2_EXCLUDE_COHORTS)].copy()
+    for cohort, modality in V2_MODALITY_OVERRIDES.items():
+        out.loc[out["cohort"].eq(cohort), "modality"] = modality
+    return out.reset_index(drop=True)
+
+
+def append_parquet(
+    frame: pd.DataFrame, path: Path, writer: pq.ParquetWriter | None, schema: pa.Schema
+) -> pq.ParquetWriter:
+    table = pa.Table.from_pandas(frame, schema=schema, preserve_index=False)
+    if writer is None:
+        writer = pq.ParquetWriter(path, table.schema, compression="zstd")
+    writer.write_table(table)
+    return writer
+
+
+def build_adapter_row(row: dict[str, Any]) -> dict[str, Any]:
+    modality = str(row.get("modality") or "unknown")
+    anatomy, technology, protocol = MODALITY_META.get(
+        modality, ("unknown", "unknown", "unknown")
+    )
+    if row.get("cohort") == "tongren_external_fundus":
+        anatomy = "anterior_segment"
+        technology = "external_photography"
+        protocol = "single_shot"
+
+    train_path = str(row.get("train_path") or row.get("file_path") or "")
+    diagnosis_group = canonical_diagnoses(row)
+    lesion_tags = canonical_lesions(row)
+    has_label = bool(diagnosis_group or lesion_tags or clean_text(row.get("caption")))
+
+    return {
+        "cohort": row.get("cohort"),
+        "study_id": row.get("image_id"),
+        "patient_hash": None,
+        "visit_date": None,
+        "eye": normalize_eye(row.get("ocr_eye")),
+        "device_vendor": "unknown",
+        "device_model": "unknown",
+        "device_serial_hash": None,
+        "device_software_version": None,
+        "hospital_domain": "new_data",
+        "ethnicity": "unknown",
+        "image_quality_score": None,
+        "image_quality_band": "unknown",
+        "diagnosis_group": diagnosis_group,
+        "lesion_tags": lesion_tags,
+        "lesion_location": [],
+        "layer_involvement": [],
+        "severity": "unknown",
+        "diagnosis_source": diagnosis_source(row),
+        "label_confidence": 1.0 if has_label else None,
+        "schema_version": "newdata_adapter_v1",
+        "image_id": row.get("image_id"),
+        "file_path": train_path,
+        "file_format": file_format(train_path),
+        "modality": modality,
+        "anatomy": anatomy,
+        "device_technology": technology,
+        "scan_protocol": protocol,
+        "scan_x_mm": None,
+        "bscan_index": None,
+        "image_height_px": None,
+        "image_width_px": None,
+        "axial_resolution_um": None,
+        "has_segmentation": False,
+        "n_layers_visible": 0,
+        "fovea_x_norm": None,
+        "crt_um": None,
+        "choroid_thickness_um": None,
+        "oct_footprint_bbox_fundus": None,
+        "oct_footprint_bbox_slo": None,
+        "is_valid": True,
+    }
+
+
+def build_sidecar_row(row: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "image_id": row.get("image_id"),
+        "source_cohort": row.get("cohort"),
+        "center": row.get("center"),
+        "role": row.get("role"),
+        "split": row.get("split"),
+        "original_file_path": row.get("file_path"),
+        "train_path": row.get("train_path"),
+        "deid_path": row.get("deid_path"),
+        "pii_masked": bool(row.get("pii_masked")),
+        "deid_method": row.get("deid_method"),
+        "diagnosis_raw": row.get("diagnosis_raw"),
+        "group_raw": row.get("group_raw"),
+        "diagnosis_group_raw": row.get("diagnosis_group"),
+        "caption_raw": row.get("caption"),
+        "ocr_age": clean_scalar(row.get("ocr_age")),
+        "ocr_sex": clean_scalar(row.get("ocr_sex")),
+        "ocr_eye": clean_scalar(row.get("ocr_eye")),
+        "storage": row.get("storage"),
+    }
+
+
+def canonical_diagnoses(row: dict[str, Any]) -> list[str]:
+    out: list[str] = []
+    for key in ["diagnosis_raw", "diagnosis_group", "group_raw"]:
+        text = clean_text(row.get(key))
+        if not text:
+            continue
+        val = translate_diag(text)
+        if is_canonical_label(val):
+            add_unique(out, val)
+    return out
+
+
+def canonical_lesions(row: dict[str, Any]) -> list[str]:
+    out: list[str] = []
+    for key in ["caption", "diagnosis_raw", "diagnosis_group", "group_raw"]:
+        for tag in extract_finding_tags(clean_text(row.get(key))):
+            add_unique(out, tag)
+    return out
+
+
+def is_canonical_label(text: str) -> bool:
+    if not text or "_" in text or len(text) > 80:
+        return False
+    return not any("\u4e00" <= ch <= "\u9fff" for ch in text)
+
+
+def add_unique(out: list[str], value: str) -> None:
+    if value and value.lower() not in {v.lower() for v in out}:
+        out.append(value)
+
+
+def diagnosis_source(row: dict[str, Any]) -> str:
+    if clean_text(row.get("caption")):
+        return "clinical_report"
+    if clean_text(row.get("diagnosis_raw")) or clean_text(row.get("diagnosis_group")):
+        return "file_label"
+    if clean_text(row.get("group_raw")):
+        return "folder_label"
+    return "none"
+
+
+def grounded_in(row: dict[str, Any]) -> str:
+    parts = ["manifest_fields"]
+    if (
+        clean_scalar(row.get("ocr_age")) is not None
+        or clean_scalar(row.get("ocr_sex")) is not None
+        or clean_scalar(row.get("ocr_eye")) is not None
+    ):
+        parts.append("nonidentifying_demographics")
+    if diagnosis_source(row) != "none":
+        parts.append("clinical_labels")
+    return "+".join(parts)
+
+
+def normalize_eye(value: Any) -> str:
+    eye = str(value or "").upper()
+    if eye in {"OD", "OS", "OU"}:
+        return eye
+    return "unknown"
+
+
+def file_format(path: str) -> str:
+    suffix = path.split("::", 1)[1] if "::" in path else path
+    ext = Path(suffix).suffix.lower().lstrip(".")
+    return ext or "unknown"
+
+
+def clean_scalar(value: Any) -> Any:
+    if value is None:
+        return None
+    if isinstance(value, float) and math.isnan(value):
+        return None
+    return value
+
+
+def write_readme(out: Path, manifest: Path, rows: int, captions: int, policy: str) -> None:
+    policy_note = ""
+    if policy in {"v2", "v3"}:
+        policy_note = f"""
+Human-reviewed {policy} data policy:
+
+- keep only `split=train`;
+- exclude cohorts: `{", ".join(sorted(V2_EXCLUDE_COHORTS))}`;
+- modality overrides: `{json.dumps(V2_MODALITY_OVERRIDES, ensure_ascii=False)}`.
+"""
+
+    text = f"""# New Data Prompt Adapter {policy}
+
+Source manifest:
+
+```text
+{manifest}
+```
+
+Artifacts:
+
+- `adapter_manifest_{policy}.parquet`: OCTFlow-style structured manifest. It follows the old
+  41-column adapter schema. `file_path` points to the actual training image path.
+- `captions_v2.parquet`: SD3 text-conditioning table with columns
+  `caption_id,image_id,level,prompt_text,language,generator,grounded_in`.
+- `sidecar_{policy}.parquet`: raw audit fields that are not copied into prompts.
+- `summary.json`: counts and coverage.
+
+Rows: {rows}
+Caption rows: {captions}
+
+{policy_note}
+
+Prompt policy:
+
+- `short`: modality phrase only.
+- `medium`: modality phrase + reliable non-identifying demographics + up to 3 English labels.
+- `dense`: modality phrase + reliable non-identifying demographics + up to 8 English labels.
+- No center, hospital, cohort, dataset name, file name, ID, exact date, DOB, raw OCR text, or
+  raw Chinese report text is copied into `prompt_text`.
+- Age enters prompts only as buckets such as `in their 60s`, never exact age.
+
+The original de-identified image routing remains controlled by the source manifest's `train_path`.
+"""
+    (out / "README.md").write_text(text, encoding="utf-8")
+
+
+def write_summary(out: Path, df: pd.DataFrame, captions: int, policy: str) -> None:
+    summary = {
+        "policy": policy,
+        "rows": int(len(df)),
+        "captions": int(captions),
+        "by_modality": df.groupby("modality").size().astype(int).to_dict(),
+        "by_cohort": df.groupby("cohort").size().astype(int).to_dict(),
+        "pii_masked": int(df["pii_masked"].fillna(False).sum()) if "pii_masked" in df else 0,
+    }
+    if policy in {"v2", "v3"}:
+        summary[f"{policy}_exclude_cohorts"] = sorted(V2_EXCLUDE_COHORTS)
+        summary[f"{policy}_modality_overrides"] = V2_MODALITY_OVERRIDES
+    (out / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    parser.add_argument("--chunk-size", type=int, default=100_000)
+    parser.add_argument("--log-every", type=int, default=500_000)
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--policy", choices=["v1", "v2", "v3"], default="v1")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/taxonomy/build_mixed_v5_taxonomy.py

@@ -0,0 +1,484 @@
+"""Build the mixed v5 prompt/taxonomy artifact from the mixed v4 artifact.
+
+v5 keeps the v4 image routing unchanged, but separates raw modality labels from
+paper-facing modality taxonomy. It also rewrites prompt prefixes so UWF, OCT
+views, and SLO variants are described as family/subtype/view/protocol rather
+than as unrelated independent modalities.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_IN = Path("/data/team/lisicheng/new_data_manifest/prompt_adapter_mixed_v4")
+DEFAULT_OUT = Path("/data/team/lisicheng/new_data_manifest/prompt_adapter_mixed_v5")
+
+NEW_COLUMNS = [
+    "taxonomy_version",
+    "modality_family",
+    "modality_subtype",
+    "view_or_projection",
+    "field_of_view",
+    "device_or_acquisition_protocol",
+    "prompt_modality_phrase",
+]
+
+OLD_PROMPT_PREFIXES = [
+    "optical coherence tomography angiography en face image",
+    "fundus fluorescein angiography image",
+    "fluorescein fundus angiography image",
+    "retinal fluorescein angiography image",
+    "ultra-widefield retinal fundus photograph",
+    "ultra-widefield color fundus photograph",
+    "ultra-widefield fundus photograph",
+    "ultra-widefield fundus image",
+    "ultra-widefield fundus",
+    "ultrasound biomicroscopy image of the anterior segment",
+    "ultrasound biomicroscopy image",
+    "B-scan ultrasonography image",
+    "ocular B-scan ultrasound image",
+    "structural OCT en face projection",
+    "structural OCT B-scan",
+    "OCTA en face image",
+    "OCT B-scan",
+    "color fundus photograph",
+    "color fundus",
+    "anterior segment photograph",
+    "slit-lamp anterior segment photograph",
+    "infrared SLO",
+    "IR-SLO",
+    "SLO",
+]
+
+
+def derive_taxonomy(row: dict[str, Any]) -> dict[str, str]:
+    modality = _clean(row.get("modality")).lower()
+    anatomy = _clean(row.get("anatomy")).lower()
+    technology = _clean(row.get("device_technology")).lower()
+    protocol = _clean(row.get("scan_protocol")).lower()
+
+    if modality == "fundus_color" and (
+        anatomy == "anterior_segment" or technology == "external_photography"
+    ):
+        return _tax(
+            "anterior_segment_photography",
+            "external_anterior_segment_photo",
+            "single_shot",
+            "anterior_segment",
+            technology,
+            protocol,
+        )
+    if modality == "fundus_color":
+        return _tax(
+            "color_fundus_photography",
+            "standard_color_fundus",
+            "single_shot",
+            _posterior_fov(anatomy, "standard"),
+            technology,
+            protocol,
+        )
+    if modality == "uwf":
+        return _tax(
+            "color_fundus_photography",
+            "uwf_color_fundus",
+            "single_shot",
+            "ultra_widefield",
+            technology or "fundus_camera",
+            protocol or "widefield",
+        )
+    if modality == "ffa":
+        return _tax(
+            "fluorescein_angiography",
+            "fundus_fluorescein_angiography",
+            "angiography",
+            _posterior_fov(anatomy, "standard"),
+            technology or "fluorescein_angiography",
+            protocol or "angiography",
+        )
+    if modality == "oct_bscan":
+        return _tax(
+            "structural_oct",
+            "oct_bscan",
+            "bscan",
+            _posterior_fov(anatomy, "macula"),
+            technology or "oct",
+            protocol or "bscan",
+        )
+    if modality == "oct_enface":
+        return _tax(
+            "structural_oct",
+            "oct_enface",
+            "en_face_projection",
+            _posterior_fov(anatomy, "macula"),
+            technology or "oct",
+            protocol or "en_face_projection",
+        )
+    if modality == "octa_enface" or modality == "octa":
+        return _tax(
+            "oct_angiography",
+            "octa_enface",
+            "en_face_projection",
+            _posterior_fov(anatomy, "macula"),
+            technology or "octa",
+            protocol or "en_face_projection",
+        )
+    if modality == "ir_slo":
+        return _tax(
+            "scanning_laser_ophthalmoscopy",
+            "infrared_slo",
+            "en_face_reflectance",
+            _posterior_fov(anatomy, "macula"),
+            technology or "slo",
+            protocol or "single_shot",
+        )
+    if modality == "slo_gray":
+        return _tax(
+            "scanning_laser_ophthalmoscopy",
+            "reflectance_slo_gray",
+            "en_face_reflectance",
+            _posterior_fov(anatomy, "macula"),
+            technology or "slo",
+            protocol or "single_shot",
+        )
+    if modality == "bscan_us":
+        return _tax(
+            "ocular_ultrasound",
+            "ocular_bscan_ultrasound",
+            "bscan",
+            "globe",
+            technology or "ultrasound",
+            protocol or "bscan",
+        )
+    if modality == "ubm":
+        return _tax(
+            "ultrasound_biomicroscopy",
+            "ubm_anterior_segment",
+            "bscan",
+            "anterior_segment",
+            technology or "ultrasound_biomicroscopy",
+            protocol or "bscan",
+        )
+    if modality == "slit_lamp":
+        return _tax(
+            "anterior_segment_photography",
+            "slit_lamp_anterior_segment",
+            "single_shot",
+            "anterior_segment",
+            technology or "slit_lamp",
+            protocol or "single_shot",
+        )
+    return _tax("unknown", modality or "unknown", protocol or "unknown", anatomy or "unknown", technology, protocol)
+
+
+def base_phrase(row: dict[str, Any], taxonomy: dict[str, str] | None = None) -> str:
+    taxonomy = taxonomy or derive_taxonomy(row)
+    subtype = taxonomy["modality_subtype"]
+    if subtype == "external_anterior_segment_photo":
+        return "anterior segment photograph"
+    if subtype == "standard_color_fundus":
+        return "color fundus photograph"
+    if subtype == "uwf_color_fundus":
+        return "ultra-widefield color fundus photograph"
+    if subtype == "fundus_fluorescein_angiography":
+        return "fundus fluorescein angiography image"
+    if subtype == "oct_bscan":
+        return "structural OCT B-scan"
+    if subtype == "oct_enface":
+        return "structural OCT en face projection"
+    if subtype == "octa_enface":
+        return "OCT angiography en face image"
+    if subtype == "infrared_slo":
+        return "infrared scanning laser ophthalmoscopy image"
+    if subtype == "reflectance_slo_gray":
+        return "scanning laser ophthalmoscopy reflectance image"
+    if subtype == "ocular_bscan_ultrasound":
+        return "ocular B-scan ultrasound image"
+    if subtype == "ubm_anterior_segment":
+        return "ultrasound biomicroscopy image"
+    if subtype == "slit_lamp_anterior_segment":
+        return "slit-lamp anterior segment photograph"
+    return f"{_clean(row.get('modality')).replace('_', ' ')} ophthalmic image".strip()
+
+
+def rewrite_prompt(old_prompt: Any, level: str, phrase: str) -> str:
+    phrase = _squash(phrase)
+    if level == "short":
+        return phrase
+    descriptor = strip_old_prefix(old_prompt)
+    if not descriptor:
+        return phrase
+    if descriptor.lower() == phrase.lower():
+        return phrase
+    if descriptor.lower().startswith(phrase.lower() + ","):
+        return _squash(descriptor)
+    return _squash(f"{phrase}, {descriptor}")
+
+
+def strip_old_prefix(text: Any) -> str:
+    text = _squash(_clean(text))
+    if not text:
+        return ""
+    for prefix in OLD_PROMPT_PREFIXES:
+        match = re.match(rf"^{re.escape(prefix)}(?:\s*[,，]\s*|\s*$)", text, flags=re.I)
+        if match:
+            return _squash(text[match.end() :])
+    return text
+
+
+def add_taxonomy_columns(frame):
+    import pandas as pd
+
+    out = frame.copy()
+    for col in NEW_COLUMNS:
+        if col in out.columns:
+            out = out.drop(columns=[col])
+
+    out["taxonomy_version"] = "mixed_v5_taxonomy_20260706"
+    out["modality_family"] = "unknown"
+    out["modality_subtype"] = out["modality"].fillna("unknown").astype(str)
+    out["view_or_projection"] = "unknown"
+    out["field_of_view"] = out.get("anatomy", pd.Series("unknown", index=out.index)).fillna("unknown").astype(str)
+    dev = out.get("device_technology", pd.Series("unknown", index=out.index)).fillna("unknown").astype(str)
+    proto = out.get("scan_protocol", pd.Series("unknown", index=out.index)).fillna("unknown").astype(str)
+    out["device_or_acquisition_protocol"] = dev + "/" + proto
+    out["prompt_modality_phrase"] = "ophthalmic image"
+
+    def set_mask(mask, family, subtype, view, fov, phrase):
+        out.loc[mask, "modality_family"] = family
+        out.loc[mask, "modality_subtype"] = subtype
+        out.loc[mask, "view_or_projection"] = view
+        out.loc[mask, "field_of_view"] = fov
+        out.loc[mask, "prompt_modality_phrase"] = phrase
+
+    mod = out["modality"].fillna("").astype(str)
+    anatomy = out.get("anatomy", pd.Series("", index=out.index)).fillna("").astype(str)
+    technology = out.get("device_technology", pd.Series("", index=out.index)).fillna("").astype(str)
+    protocol = out.get("scan_protocol", pd.Series("", index=out.index)).fillna("").astype(str)
+
+    anterior_fundus = mod.eq("fundus_color") & (
+        anatomy.eq("anterior_segment") | technology.eq("external_photography")
+    )
+    set_mask(anterior_fundus, "anterior_segment_photography", "external_anterior_segment_photo", "single_shot", "anterior_segment", "anterior segment photograph")
+    set_mask(mod.eq("fundus_color") & ~anterior_fundus, "color_fundus_photography", "standard_color_fundus", "single_shot", "standard", "color fundus photograph")
+    set_mask(mod.eq("uwf"), "color_fundus_photography", "uwf_color_fundus", "single_shot", "ultra_widefield", "ultra-widefield color fundus photograph")
+    set_mask(mod.eq("ffa"), "fluorescein_angiography", "fundus_fluorescein_angiography", "angiography", "standard", "fundus fluorescein angiography image")
+    set_mask(mod.eq("oct_bscan"), "structural_oct", "oct_bscan", "bscan", "macula", "structural OCT B-scan")
+    set_mask(mod.eq("oct_enface"), "structural_oct", "oct_enface", "en_face_projection", "macula", "structural OCT en face projection")
+    set_mask(mod.isin(["octa", "octa_enface"]), "oct_angiography", "octa_enface", "en_face_projection", "macula", "OCT angiography en face image")
+    set_mask(mod.eq("slo_gray"), "scanning_laser_ophthalmoscopy", "reflectance_slo_gray", "en_face_reflectance", "macula", "scanning laser ophthalmoscopy reflectance image")
+    set_mask(mod.eq("ir_slo"), "scanning_laser_ophthalmoscopy", "infrared_slo", "en_face_reflectance", "macula", "infrared scanning laser ophthalmoscopy image")
+    set_mask(mod.eq("bscan_us"), "ocular_ultrasound", "ocular_bscan_ultrasound", "bscan", "globe", "ocular B-scan ultrasound image")
+    set_mask(mod.eq("ubm"), "ultrasound_biomicroscopy", "ubm_anterior_segment", "bscan", "anterior_segment", "ultrasound biomicroscopy image")
+    set_mask(mod.eq("slit_lamp"), "anterior_segment_photography", "slit_lamp_anterior_segment", "single_shot", "anterior_segment", "slit-lamp anterior segment photograph")
+
+    optic = anatomy.eq("optic_disc")
+    out.loc[optic & mod.eq("oct_bscan"), "field_of_view"] = "optic_disc"
+    out.loc[optic & mod.eq("slo_gray"), "field_of_view"] = "optic_disc"
+    wide = anatomy.eq("wide-field") | protocol.str.contains("wide", case=False, na=False) | mod.eq("uwf")
+    out.loc[wide, "field_of_view"] = "ultra_widefield"
+    return out
+
+
+def build_captions(manifest, old_captions, out_path: Path, chunk_size: int) -> int:
+    import pandas as pd
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    caps = old_captions[["image_id", "level", "prompt_text"]].copy()
+    caps["image_id"] = caps["image_id"].astype(str)
+    caps = caps.drop_duplicates(["image_id", "level"], keep="first")
+    wide = caps.pivot(index="image_id", columns="level", values="prompt_text")
+
+    ids = manifest["image_id"].astype(str).reset_index(drop=True)
+    phrases = manifest["prompt_modality_phrase"].astype(str).reset_index(drop=True)
+    old_short = wide["short"].reindex(ids).reset_index(drop=True) if "short" in wide else pd.Series([None] * len(ids))
+    old_medium = wide["medium"].reindex(ids).reset_index(drop=True) if "medium" in wide else pd.Series([None] * len(ids))
+    old_dense = wide["dense"].reindex(ids).reset_index(drop=True) if "dense" in wide else pd.Series([None] * len(ids))
+    source_by_level = {
+        "short": old_short,
+        "medium": old_medium.combine_first(old_dense).combine_first(old_short),
+        "dense": old_dense.combine_first(old_medium).combine_first(old_short),
+    }
+
+    schema = pa.schema(
+        [
+            ("caption_id", pa.string()),
+            ("image_id", pa.string()),
+            ("level", pa.string()),
+            ("prompt_text", pa.string()),
+            ("language", pa.string()),
+            ("generator", pa.string()),
+            ("grounded_in", pa.string()),
+        ]
+    )
+    if out_path.exists():
+        out_path.unlink()
+    writer = pq.ParquetWriter(out_path, schema, compression="zstd")
+    total = 0
+    try:
+        for start in range(0, len(ids), chunk_size):
+            end = min(start + chunk_size, len(ids))
+            frames = []
+            phrase_chunk = phrases.iloc[start:end].tolist()
+            id_chunk = ids.iloc[start:end].tolist()
+            for level in ["short", "medium", "dense"]:
+                old_chunk = source_by_level[level].iloc[start:end].tolist()
+                prompt_text = [
+                    rewrite_prompt(old, level, phrase)
+                    for old, phrase in zip(old_chunk, phrase_chunk, strict=True)
+                ]
+                frames.append(
+                    pd.DataFrame(
+                        {
+                            "caption_id": [f"{image_id}_{level}" for image_id in id_chunk],
+                            "image_id": id_chunk,
+                            "level": level,
+                            "prompt_text": prompt_text,
+                            "language": "en",
+                            "generator": "mixed_prompt_adapter_v5_taxonomy",
+                            "grounded_in": "v5_taxonomy+v4_clean_prompt_descriptors",
+                        }
+                    )
+                )
+            table = pa.Table.from_pandas(pd.concat(frames, ignore_index=True), schema=schema, preserve_index=False)
+            writer.write_table(table)
+            total += table.num_rows
+            print(f"captions={total}", flush=True)
+    finally:
+        writer.close()
+    return total
+
+
+def write_readme(out: Path, manifest_rows: int, caption_rows: int) -> None:
+    text = f"""# Mixed Prompt Adapter v5
+
+Rows: {manifest_rows}
+Caption rows: {caption_rows}
+
+v5 keeps image paths and raw `modality` labels from v4, then adds:
+
+- `modality_family`
+- `modality_subtype`
+- `view_or_projection`
+- `field_of_view`
+- `device_or_acquisition_protocol`
+- `prompt_modality_phrase`
+
+Design:
+
+- UWF is represented as a color fundus photography variant with
+  `field_of_view=ultra_widefield`, not as an unrelated independent modality.
+- OCT B-scan and OCT en-face are structural OCT views/projections.
+- OCTA en-face is an OCT angiography en-face image.
+- SLO gray and IR-SLO are scanning-laser-ophthalmoscopy reflectance variants.
+- Ocular B-scan ultrasound and UBM remain separate ultrasound-family subtypes
+  because they image different anatomical regions at different frequencies.
+- Anterior-segment external photographs previously carried under
+  `fundus_color/anterior_segment` are prompted as anterior segment photographs.
+
+Prompt policy:
+
+- `short`: v5 modality phrase only.
+- `medium` and `dense`: v5 modality phrase plus the already-cleaned v4 prompt
+  descriptors, with only the modality prefix rewritten.
+- No raw Chinese report text or new image-derived labels are introduced here.
+"""
+    (out / "README.md").write_text(text, encoding="utf-8")
+
+
+def write_summary(out: Path, manifest, caption_rows: int) -> None:
+    summary = {
+        "rows": int(len(manifest)),
+        "captions": int(caption_rows),
+        "by_modality": manifest.groupby("modality").size().astype(int).to_dict(),
+        "by_modality_family": manifest.groupby("modality_family").size().astype(int).to_dict(),
+        "by_modality_subtype": manifest.groupby("modality_subtype").size().astype(int).to_dict(),
+        "by_family_subtype": {
+            f"{family}/{subtype}": int(n)
+            for (family, subtype), n in manifest.groupby(["modality_family", "modality_subtype"]).size().items()
+        },
+    }
+    (out / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def main() -> None:
+    import pandas as pd
+
+    args = parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+    manifest_in = args.input / "adapter_manifest_mixed_v4.parquet"
+    captions_in = args.input / "captions_v2.parquet"
+    manifest_out = args.out / "adapter_manifest_mixed_v5.parquet"
+    captions_out = args.out / "captions_v2.parquet"
+
+    if not args.overwrite:
+        for path in [manifest_out, captions_out]:
+            if path.exists():
+                raise FileExistsError(f"{path} exists; pass --overwrite")
+
+    manifest = pd.read_parquet(manifest_in)
+    if args.limit:
+        manifest = manifest.head(args.limit).copy()
+    manifest = add_taxonomy_columns(manifest)
+    manifest.to_parquet(manifest_out, index=False, compression="zstd")
+
+    captions = pd.read_parquet(captions_in, columns=["image_id", "level", "prompt_text"])
+    caption_rows = build_captions(manifest, captions, captions_out, args.chunk_size)
+    write_summary(args.out, manifest, caption_rows)
+    write_readme(args.out, len(manifest), caption_rows)
+    print(json.dumps({"out": str(args.out), "rows": len(manifest), "captions": caption_rows}, ensure_ascii=False))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input", type=Path, default=DEFAULT_IN)
+    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    parser.add_argument("--chunk-size", type=int, default=250_000)
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--overwrite", action="store_true")
+    return parser.parse_args()
+
+
+def _tax(family: str, subtype: str, view: str, fov: str, technology: str, protocol: str) -> dict[str, str]:
+    return {
+        "taxonomy_version": "mixed_v5_taxonomy_20260706",
+        "modality_family": family,
+        "modality_subtype": subtype,
+        "view_or_projection": view,
+        "field_of_view": fov,
+        "device_or_acquisition_protocol": f"{technology or 'unknown'}/{protocol or 'unknown'}",
+    }
+
+
+def _posterior_fov(anatomy: str, default: str) -> str:
+    if anatomy == "optic_disc":
+        return "optic_disc"
+    if anatomy in {"wide-field", "widefield"}:
+        return "ultra_widefield"
+    if anatomy in {"macula", "retina"}:
+        return "macula" if anatomy == "macula" else default
+    return default
+
+
+def _clean(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, float) and math.isnan(value):
+        return ""
+    return str(value).strip()
+
+
+def _squash(text: str) -> str:
+    text = re.sub(r"\s+", " ", text)
+    text = re.sub(r"\s*[,，]\s*", ", ", text)
+    return text.strip(" ,，")
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/taxonomy/build_mixed_v6_taxonomy.py

@@ -0,0 +1,470 @@
+"""Build mixed v6 prompt/taxonomy artifacts from the mixed v5 artifacts.
+
+v6 keeps image routing unchanged, but makes prompt conditioning hierarchical:
+modality family + view/projection + field of view/anatomy. It also folds the
+tiny IR-SLO split into the reflectance SLO subtype and removes dataset split
+tokens from diagnosis descriptors before they can enter prompts.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+from pathlib import Path
+from typing import Any
+
+from build_mixed_v5_taxonomy import OLD_PROMPT_PREFIXES, strip_old_prefix
+
+
+DEFAULT_IN = Path("/data/team/lisicheng/new_data_manifest/prompt_adapter_mixed_v5")
+DEFAULT_OUT = Path("/data/team/lisicheng/new_data_manifest/prompt_adapter_mixed_v6")
+VERSION = "mixed_v6_hierarchical_taxonomy_20260707"
+SPLIT_TOKENS = {"train", "test", "val", "valid", "validation", "eryuan"}
+V6_EXTRA_OLD_PROMPT_PREFIXES = [
+    "infrared scanning laser ophthalmoscopy image",
+    "scanning laser ophthalmoscopy reflectance image",
+]
+
+
+def derive_taxonomy(row: dict[str, Any]) -> dict[str, str]:
+    modality = _clean(row.get("modality")).lower()
+    anatomy = _clean(row.get("anatomy")).lower()
+    technology = _clean(row.get("device_technology")).lower()
+    protocol = _clean(row.get("scan_protocol")).lower()
+
+    if modality == "fundus_color" and (
+        anatomy == "anterior_segment" or technology == "external_photography"
+    ):
+        return _tax(
+            "anterior_segment_photography",
+            "external_anterior_segment_photo",
+            "single_shot",
+            "anterior_segment",
+            technology,
+            protocol,
+        )
+    if modality == "fundus_color":
+        return _tax(
+            "color_fundus_photography",
+            "standard_color_fundus",
+            "single_shot",
+            _posterior_fov(anatomy, "standard"),
+            technology,
+            protocol,
+        )
+    if modality == "uwf":
+        return _tax(
+            "color_fundus_photography",
+            "uwf_color_fundus",
+            "single_shot",
+            "ultra_widefield",
+            technology or "fundus_camera",
+            protocol or "widefield",
+        )
+    if modality == "ffa":
+        return _tax(
+            "fluorescein_angiography",
+            "fundus_fluorescein_angiography",
+            "angiography",
+            _posterior_fov(anatomy, "standard"),
+            technology or "fluorescein_angiography",
+            protocol or "angiography",
+        )
+    if modality == "oct_bscan":
+        return _tax("structural_oct", "oct_bscan", "bscan", _posterior_fov(anatomy, "macula"), technology or "oct", protocol or "bscan")
+    if modality == "oct_enface":
+        return _tax("structural_oct", "oct_enface", "en_face_projection", _posterior_fov(anatomy, "macula"), technology or "oct", protocol or "en_face_projection")
+    if modality in {"octa", "octa_enface"}:
+        return _tax("oct_angiography", "octa_enface", "en_face_projection", _posterior_fov(anatomy, "macula"), technology or "octa", protocol or "en_face_projection")
+    if modality in {"slo_gray", "ir_slo"}:
+        return _tax(
+            "scanning_laser_ophthalmoscopy",
+            "reflectance_slo_gray",
+            "en_face_reflectance",
+            _posterior_fov(anatomy, "macula"),
+            technology or "slo",
+            protocol or ("infrared" if modality == "ir_slo" else "single_shot"),
+        )
+    if modality == "bscan_us":
+        return _tax("ocular_ultrasound", "ocular_bscan_ultrasound", "bscan", "globe", technology or "ultrasound", protocol or "bscan")
+    if modality == "ubm":
+        return _tax("ultrasound_biomicroscopy", "ubm_anterior_segment", "bscan", "anterior_segment", technology or "ultrasound_biomicroscopy", protocol or "bscan")
+    if modality == "slit_lamp":
+        return _tax("anterior_segment_photography", "slit_lamp_anterior_segment", "single_shot", "anterior_segment", technology or "slit_lamp", protocol or "single_shot")
+    return _tax("unknown", modality or "unknown", protocol or "unknown", anatomy or "unknown", technology, protocol)
+
+
+def hierarchical_phrase(taxonomy: dict[str, str]) -> str:
+    subtype = taxonomy["modality_subtype"]
+    fov = taxonomy.get("field_of_view", "unknown")
+    if subtype == "standard_color_fundus":
+        return _join_prompt_parts("ophthalmic image", "color fundus photography", f"{_fov_text(fov)} field of view", "retina")
+    if subtype == "uwf_color_fundus":
+        return _join_prompt_parts("ophthalmic image", "color fundus photography", "ultra-widefield view", "retina")
+    if subtype == "fundus_fluorescein_angiography":
+        return _join_prompt_parts("ophthalmic image", "fundus fluorescein angiography", _fov_text(fov), "retina")
+    if subtype == "oct_bscan":
+        return _join_prompt_parts("ophthalmic image", "structural OCT", "B-scan view", _fov_text(fov))
+    if subtype == "oct_enface":
+        return _join_prompt_parts("ophthalmic image", "structural OCT", "en face projection", _fov_text(fov))
+    if subtype == "octa_enface":
+        return _join_prompt_parts("ophthalmic image", "OCT angiography", "en face projection", _fov_text(fov))
+    if subtype == "reflectance_slo_gray":
+        return _join_prompt_parts("ophthalmic image", "scanning laser ophthalmoscopy", "reflectance en face view", _fov_text(fov))
+    if subtype == "ocular_bscan_ultrasound":
+        return _join_prompt_parts("ophthalmic image", "ocular ultrasound", "B-scan view", "globe")
+    if subtype == "ubm_anterior_segment":
+        return _join_prompt_parts("ophthalmic image", "ultrasound biomicroscopy", "anterior segment", "B-scan view")
+    if subtype == "external_anterior_segment_photo":
+        return _join_prompt_parts("ophthalmic image", "anterior segment photography", "external photograph")
+    if subtype == "slit_lamp_anterior_segment":
+        return _join_prompt_parts("ophthalmic image", "slit-lamp anterior segment photography")
+    return _join_prompt_parts("ophthalmic image", taxonomy.get("modality_family", "unknown"))
+
+
+def clean_diagnosis_group(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, float) and math.isnan(value):
+        return []
+    if isinstance(value, (list, tuple)):
+        tokens = [str(v) for v in value]
+    else:
+        text = _clean(value)
+        if not text or text in {"[]", "None", "nan", "<NA>"}:
+            return []
+        tokens = re.findall(r"'([^']+)'", text)
+        if not tokens:
+            tokens = re.split(r"[;,|]", text.strip("[]"))
+    cleaned: list[str] = []
+    seen: set[str] = set()
+    for token in tokens:
+        label = _squash(str(token).strip(" \"'[]"))
+        if not label:
+            continue
+        if label.lower() in SPLIT_TOKENS:
+            continue
+        if label.lower() in seen:
+            continue
+        seen.add(label.lower())
+        cleaned.append(label)
+    return cleaned
+
+
+def rewrite_prompt(old_prompt: Any, level: str, taxonomy: dict[str, str], diagnosis: Any = None) -> str:
+    phrase = hierarchical_phrase(taxonomy)
+    if level == "short":
+        return phrase
+    descriptor = clean_prompt_descriptor(strip_old_prefix(old_prompt))
+    diagnosis_text = diagnosis_phrase(diagnosis)
+    extras = []
+    if diagnosis_text and diagnosis_text.lower() not in descriptor.lower():
+        extras.append(diagnosis_text)
+    if descriptor:
+        extras.append(descriptor)
+    return _squash(", ".join([phrase, *extras]))
+
+
+def diagnosis_phrase(value: Any) -> str:
+    labels = clean_diagnosis_group(value)
+    if not labels:
+        return ""
+    return "diagnosis: " + "; ".join(labels)
+
+
+def clean_prompt_descriptor(text: Any) -> str:
+    text = _squash(_clean(text))
+    if not text:
+        return ""
+    for prefix in [*V6_EXTRA_OLD_PROMPT_PREFIXES, *OLD_PROMPT_PREFIXES]:
+        text = re.sub(rf"^{re.escape(prefix)}(?:\s*[,，]\s*|\s*$)", "", text, flags=re.I)
+    parts = []
+    for part in re.split(r"[,，;|]+", text):
+        part = _squash(part)
+        if not part:
+            continue
+        if part.lower() in SPLIT_TOKENS:
+            continue
+        part = re.sub(r"\b(?:train|test|val|valid|validation|eryuan)\b", "", part, flags=re.I)
+        part = _squash(part.strip(" ,;"))
+        if part:
+            parts.append(part)
+    return _squash(", ".join(dict.fromkeys(parts)))
+
+
+def add_v6_columns(frame):
+    import pandas as pd
+
+    out = frame.copy()
+    for col in [
+        "taxonomy_version",
+        "modality_family",
+        "modality_subtype",
+        "view_or_projection",
+        "field_of_view",
+        "device_or_acquisition_protocol",
+        "prompt_modality_phrase",
+        "diagnosis_group_clean",
+        "subtype_sample_status",
+    ]:
+        if col in out.columns:
+            out = out.drop(columns=[col])
+
+    out["taxonomy_version"] = VERSION
+    out["modality_family"] = "unknown"
+    out["modality_subtype"] = out["modality"].fillna("unknown").astype(str)
+    out["view_or_projection"] = "unknown"
+    out["field_of_view"] = out.get("anatomy", pd.Series("unknown", index=out.index)).fillna("unknown").astype(str)
+    dev = out.get("device_technology", pd.Series("unknown", index=out.index)).fillna("unknown").astype(str)
+    proto = out.get("scan_protocol", pd.Series("unknown", index=out.index)).fillna("unknown").astype(str)
+    out["device_or_acquisition_protocol"] = dev + "/" + proto
+
+    def set_mask(mask, family, subtype, view, fov):
+        out.loc[mask, "modality_family"] = family
+        out.loc[mask, "modality_subtype"] = subtype
+        out.loc[mask, "view_or_projection"] = view
+        out.loc[mask, "field_of_view"] = fov
+
+    mod = out["modality"].fillna("").astype(str)
+    anatomy = out.get("anatomy", pd.Series("", index=out.index)).fillna("").astype(str)
+    technology = out.get("device_technology", pd.Series("", index=out.index)).fillna("").astype(str)
+    protocol = out.get("scan_protocol", pd.Series("", index=out.index)).fillna("").astype(str)
+
+    anterior_fundus = mod.eq("fundus_color") & (
+        anatomy.eq("anterior_segment") | technology.eq("external_photography")
+    )
+    set_mask(anterior_fundus, "anterior_segment_photography", "external_anterior_segment_photo", "single_shot", "anterior_segment")
+    set_mask(mod.eq("fundus_color") & ~anterior_fundus, "color_fundus_photography", "standard_color_fundus", "single_shot", "standard")
+    set_mask(mod.eq("uwf"), "color_fundus_photography", "uwf_color_fundus", "single_shot", "ultra_widefield")
+    set_mask(mod.eq("ffa"), "fluorescein_angiography", "fundus_fluorescein_angiography", "angiography", "standard")
+    set_mask(mod.eq("oct_bscan"), "structural_oct", "oct_bscan", "bscan", "macula")
+    set_mask(mod.eq("oct_enface"), "structural_oct", "oct_enface", "en_face_projection", "macula")
+    set_mask(mod.isin(["octa", "octa_enface"]), "oct_angiography", "octa_enface", "en_face_projection", "macula")
+    set_mask(mod.isin(["slo_gray", "ir_slo"]), "scanning_laser_ophthalmoscopy", "reflectance_slo_gray", "en_face_reflectance", "macula")
+    set_mask(mod.eq("bscan_us"), "ocular_ultrasound", "ocular_bscan_ultrasound", "bscan", "globe")
+    set_mask(mod.eq("ubm"), "ultrasound_biomicroscopy", "ubm_anterior_segment", "bscan", "anterior_segment")
+    set_mask(mod.eq("slit_lamp"), "anterior_segment_photography", "slit_lamp_anterior_segment", "single_shot", "anterior_segment")
+
+    optic = anatomy.eq("optic_disc")
+    out.loc[optic & mod.eq("oct_bscan"), "field_of_view"] = "optic_disc"
+    out.loc[optic & mod.isin(["slo_gray", "ir_slo"]), "field_of_view"] = "optic_disc"
+    wide = anatomy.eq("wide-field") | protocol.str.contains("wide", case=False, na=False) | mod.eq("uwf")
+    out.loc[wide, "field_of_view"] = "ultra_widefield"
+
+    tax_cols = out[["modality_family", "modality_subtype", "view_or_projection", "field_of_view"]]
+    out["prompt_modality_phrase"] = [
+        hierarchical_phrase(row)
+        for row in tax_cols.to_dict("records")
+    ]
+    diag = out.get("diagnosis_group", pd.Series([None] * len(out), index=out.index))
+    out["diagnosis_group_clean"] = ["; ".join(clean_diagnosis_group(v)) for v in diag]
+    counts = out["modality_subtype"].value_counts()
+    out["subtype_sample_status"] = out["modality_subtype"].map(
+        lambda s: "formal" if counts.get(s, 0) >= 2000 else ("supplemental" if counts.get(s, 0) >= 500 else "tiny")
+    )
+    return out
+
+
+def build_captions(manifest, old_captions, out_path: Path, chunk_size: int) -> int:
+    import pandas as pd
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    caps = old_captions[["image_id", "level", "prompt_text"]].copy()
+    caps["image_id"] = caps["image_id"].astype(str)
+    caps = caps.drop_duplicates(["image_id", "level"], keep="first")
+    wide = caps.pivot(index="image_id", columns="level", values="prompt_text")
+
+    ids = manifest["image_id"].astype(str).reset_index(drop=True)
+    tax_records = manifest[
+        ["modality_family", "modality_subtype", "view_or_projection", "field_of_view"]
+    ].to_dict("records")
+    diagnoses = manifest["diagnosis_group_clean"].astype(str).replace("nan", "").reset_index(drop=True)
+    old_short = wide["short"].reindex(ids).reset_index(drop=True) if "short" in wide else pd.Series([None] * len(ids))
+    old_medium = wide["medium"].reindex(ids).reset_index(drop=True) if "medium" in wide else pd.Series([None] * len(ids))
+    old_dense = wide["dense"].reindex(ids).reset_index(drop=True) if "dense" in wide else pd.Series([None] * len(ids))
+    source_by_level = {
+        "short": old_short,
+        "medium": old_medium.combine_first(old_dense).combine_first(old_short),
+        "dense": old_dense.combine_first(old_medium).combine_first(old_short),
+    }
+
+    schema = pa.schema(
+        [
+            ("caption_id", pa.string()),
+            ("image_id", pa.string()),
+            ("level", pa.string()),
+            ("prompt_text", pa.string()),
+            ("language", pa.string()),
+            ("generator", pa.string()),
+            ("grounded_in", pa.string()),
+        ]
+    )
+    if out_path.exists():
+        out_path.unlink()
+    writer = pq.ParquetWriter(out_path, schema, compression="zstd")
+    total = 0
+    try:
+        for start in range(0, len(ids), chunk_size):
+            end = min(start + chunk_size, len(ids))
+            frames = []
+            id_chunk = ids.iloc[start:end].tolist()
+            tax_chunk = tax_records[start:end]
+            diag_chunk = diagnoses.iloc[start:end].tolist()
+            for level in ["short", "medium", "dense"]:
+                old_chunk = source_by_level[level].iloc[start:end].tolist()
+                prompt_text = [
+                    rewrite_prompt(old, level, tax, diag)
+                    for old, tax, diag in zip(old_chunk, tax_chunk, diag_chunk, strict=True)
+                ]
+                frames.append(
+                    pd.DataFrame(
+                        {
+                            "caption_id": [f"{image_id}_{level}" for image_id in id_chunk],
+                            "image_id": id_chunk,
+                            "level": level,
+                            "prompt_text": prompt_text,
+                            "language": "en",
+                            "generator": "mixed_prompt_adapter_v6_hierarchical_taxonomy",
+                            "grounded_in": "v6_taxonomy+clean_diagnosis+v5_descriptors",
+                        }
+                    )
+                )
+            table = pa.Table.from_pandas(pd.concat(frames, ignore_index=True), schema=schema, preserve_index=False)
+            writer.write_table(table)
+            total += table.num_rows
+            print(f"captions={total}", flush=True)
+    finally:
+        writer.close()
+    return total
+
+
+def write_summary(out: Path, manifest, caption_rows: int) -> None:
+    summary = {
+        "rows": int(len(manifest)),
+        "captions": int(caption_rows),
+        "taxonomy_version": VERSION,
+        "by_modality": manifest.groupby("modality").size().astype(int).to_dict(),
+        "by_modality_family": manifest.groupby("modality_family").size().astype(int).to_dict(),
+        "by_modality_subtype": manifest.groupby("modality_subtype").size().astype(int).to_dict(),
+        "by_subtype_sample_status": manifest.groupby("subtype_sample_status").size().astype(int).to_dict(),
+    }
+    (out / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def write_readme(out: Path, manifest_rows: int, caption_rows: int) -> None:
+    text = f"""# Mixed Prompt Adapter v6
+
+Rows: {manifest_rows}
+Caption rows: {caption_rows}
+
+Changes from v5:
+
+- Prompt prefixes are hierarchical: modality family + view/projection +
+  field-of-view/anatomy.
+- `ir_slo` rows are folded into `reflectance_slo_gray`; 42 images are too few
+  for an independent subtype.
+- `diagnosis_group_clean` removes dataset split/source tokens such as
+  `train`, `test`, `val`, and `eryuan`.
+- `subtype_sample_status` marks formal/supplemental/tiny groups for reporting.
+
+Prompt policy:
+
+- `short`: imaging condition only.
+- `medium` and `dense`: imaging condition plus cleaned diagnosis and existing
+  cleaned descriptors.
+"""
+    (out / "README.md").write_text(text, encoding="utf-8")
+
+
+def main() -> None:
+    import pandas as pd
+
+    args = parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+    manifest_in = args.input / "adapter_manifest_mixed_v5.parquet"
+    captions_in = args.input / "captions_v2.parquet"
+    manifest_out = args.out / "adapter_manifest_mixed_v6.parquet"
+    captions_out = args.out / "captions_v2.parquet"
+
+    if not args.overwrite:
+        for path in [manifest_out, captions_out]:
+            if path.exists():
+                raise FileExistsError(f"{path} exists; pass --overwrite")
+
+    manifest = pd.read_parquet(manifest_in)
+    if args.limit:
+        manifest = manifest.head(args.limit).copy()
+    manifest = add_v6_columns(manifest)
+    manifest.to_parquet(manifest_out, index=False, compression="zstd")
+
+    captions = pd.read_parquet(captions_in, columns=["image_id", "level", "prompt_text"])
+    caption_rows = build_captions(manifest, captions, captions_out, args.chunk_size)
+    write_summary(args.out, manifest, caption_rows)
+    write_readme(args.out, len(manifest), caption_rows)
+    print(json.dumps({"out": str(args.out), "rows": len(manifest), "captions": caption_rows}, ensure_ascii=False))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input", type=Path, default=DEFAULT_IN)
+    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    parser.add_argument("--chunk-size", type=int, default=250_000)
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--overwrite", action="store_true")
+    return parser.parse_args()
+
+
+def _tax(family: str, subtype: str, view: str, fov: str, technology: str, protocol: str) -> dict[str, str]:
+    return {
+        "taxonomy_version": VERSION,
+        "modality_family": family,
+        "modality_subtype": subtype,
+        "view_or_projection": view,
+        "field_of_view": fov,
+        "device_or_acquisition_protocol": f"{technology or 'unknown'}/{protocol or 'unknown'}",
+        "prompt_modality_phrase": "",
+    }
+
+
+def _posterior_fov(anatomy: str, default: str) -> str:
+    if anatomy == "optic_disc":
+        return "optic_disc"
+    if anatomy in {"wide-field", "widefield", "ultra_widefield"}:
+        return "ultra_widefield"
+    if anatomy == "macula":
+        return "macula"
+    return default
+
+
+def _fov_text(value: str) -> str:
+    return {
+        "standard": "standard",
+        "macula": "macula",
+        "optic_disc": "optic disc",
+        "ultra_widefield": "ultra-widefield",
+        "anterior_segment": "anterior segment",
+        "globe": "globe",
+    }.get(str(value), str(value).replace("_", " "))
+
+
+def _join_prompt_parts(*parts: str) -> str:
+    return _squash(", ".join(part for part in parts if part and part != "unknown"))
+
+
+def _clean(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, float) and math.isnan(value):
+        return ""
+    return str(value).strip()
+
+
+def _squash(text: str) -> str:
+    return re.sub(r"\s+", " ", str(text).strip())
+
+
+if __name__ == "__main__":
+    main()

tools/data_processing/taxonomy/test_build_mixed_v6_taxonomy.py

@@ -0,0 +1,82 @@
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from build_mixed_v6_taxonomy import (
+    clean_diagnosis_group,
+    derive_taxonomy,
+    rewrite_prompt,
+)
+
+
+class BuildMixedV6TaxonomyTest(unittest.TestCase):
+    def test_ir_slo_is_folded_into_reflectance_slo_not_own_subtype(self):
+        tax = derive_taxonomy(
+            {
+                "modality": "ir_slo",
+                "anatomy": "macula",
+                "device_technology": "slo",
+                "scan_protocol": "infrared",
+            }
+        )
+
+        self.assertEqual(tax["modality_family"], "scanning_laser_ophthalmoscopy")
+        self.assertEqual(tax["modality_subtype"], "reflectance_slo_gray")
+        self.assertEqual(tax["view_or_projection"], "en_face_reflectance")
+
+    def test_hierarchical_prompt_names_family_view_and_anatomy(self):
+        tax = derive_taxonomy(
+            {
+                "modality": "oct_bscan",
+                "anatomy": "macula",
+                "device_technology": "sd_oct",
+                "scan_protocol": "volume_3d_macula",
+            }
+        )
+
+        prompt = rewrite_prompt("OCT B-scan, normal", "short", tax)
+
+        self.assertIn("ophthalmic image", prompt)
+        self.assertIn("structural OCT", prompt)
+        self.assertIn("B-scan view", prompt)
+        self.assertIn("macula", prompt)
+
+    def test_split_tokens_are_removed_from_clean_diagnosis_group(self):
+        self.assertEqual(
+            clean_diagnosis_group("['diabetic retinopathy' 'train']"),
+            ["diabetic retinopathy"],
+        )
+        self.assertEqual(clean_diagnosis_group("['normal' 'eryuan']"), ["normal"])
+        self.assertEqual(clean_diagnosis_group("[]"), [])
+
+    def test_rewrite_prompt_removes_split_tokens_from_descriptor(self):
+        tax = derive_taxonomy({"modality": "fundus_color", "anatomy": "retina"})
+
+        prompt = rewrite_prompt(
+            "color fundus photograph, diabetic retinopathy, train",
+            "medium",
+            tax,
+        )
+
+        self.assertIn("diabetic retinopathy", prompt)
+        self.assertNotIn("train", prompt.lower())
+
+    def test_rewrite_prompt_removes_folded_ir_slo_legacy_prefix(self):
+        tax = derive_taxonomy({"modality": "ir_slo", "anatomy": "macula"})
+
+        prompt = rewrite_prompt(
+            "infrared scanning laser ophthalmoscopy image",
+            "medium",
+            tax,
+        )
+
+        self.assertEqual(
+            prompt,
+            "ophthalmic image, scanning laser ophthalmoscopy, reflectance en face view, macula",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tools/data_processing/taxonomy/test_taxonomy_sampling.py

@@ -0,0 +1,54 @@
+import sys
+import types
+import unittest
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "src"))
+
+omegaconf_stub = types.ModuleType("omegaconf")
+omegaconf_stub.OmegaConf = object
+omegaconf_stub.DictConfig = object
+sys.modules.setdefault("omegaconf", omegaconf_stub)
+
+data_stub = types.ModuleType("data")
+octflow_stub = types.ModuleType("data.octflow_dataset")
+octflow_stub.OCTFlowDataset = object
+sys.modules.setdefault("data", data_stub)
+sys.modules.setdefault("data.octflow_dataset", octflow_stub)
+
+from train_sd3_t2i import build_balanced_sampling_weights
+
+
+class TaxonomySamplingTest(unittest.TestCase):
+    def test_temperature_sampling_gives_each_group_equal_total_weight_at_zero_temperature(self):
+        labels = np.array(["fundus"] * 8 + ["ubm"] * 2)
+
+        weights, counts, targets = build_balanced_sampling_weights(
+            labels,
+            temperature=0.0,
+            min_count=1,
+        )
+
+        self.assertEqual(counts, {"fundus": 8, "ubm": 2})
+        self.assertAlmostEqual(weights[:8].sum(), weights[8:].sum(), places=8)
+        self.assertEqual(set(targets), {"fundus", "ubm"})
+
+    def test_min_count_excludes_tiny_groups(self):
+        labels = np.array(["fundus"] * 8 + ["ir_slo"] * 2)
+
+        weights, counts, targets = build_balanced_sampling_weights(
+            labels,
+            temperature=0.5,
+            min_count=3,
+        )
+
+        self.assertEqual(counts, {"fundus": 8, "ir_slo": 2})
+        self.assertGreater(weights[:8].sum(), 0.0)
+        self.assertEqual(weights[8:].sum(), 0.0)
+        self.assertEqual(targets, {"fundus": 1.0})
+
+
+if __name__ == "__main__":
+    unittest.main()