Upload scripts/run_validation_pipeline.py with huggingface_hub

scripts/run_validation_pipeline.py

@@ -0,0 +1,218 @@
+"""
+run_validation_pipeline.py — ERYON validation + leakage audit pipeline.
+
+Runs inside an HF Job with eryon-datasets bucket mounted at /mnt.
+Steps:
+  1. Download manifest + splits from eryon-data-pipelines repo
+  2. Validate: required fields, sha256 checksums, split completeness
+  3. Leakage audit: patient overlap, duplicate hashes, slice leakage
+  4. Upload reports to eryon-data-pipelines repo
+
+Corruption scan (PIL open) is skipped by default — files were just written
+and never transferred across a network boundary. Set CORRUPTION_SCAN=True
+to enable it (adds ~2hr on cpu-basic).
+
+Usage:
+    python run_validation_pipeline.py
+"""
+
+import sys
+import json
+import hashlib
+from pathlib import Path
+from collections import defaultdict
+
+from huggingface_hub import HfApi, hf_hub_download
+
+# ── Config ────────────────────────────────────────────────────────────────────
+BUCKET_LIDC       = Path("/mnt/raw/lidc")
+TMP_OUT           = Path("/tmp/validation_output")
+REPO_ID           = "Chucks90/eryon-data-pipelines"
+CORRUPTION_SCAN   = False   # set True to enable PIL open on every PNG
+
+REQUIRED_FIELDS = {
+    "patient_id", "study_id", "series_id", "image_path",
+    "modality", "split", "label", "dataset_version",
+    "preprocessing_version", "sha256",
+}
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def download_inputs() -> tuple[Path, Path]:
+    print("Downloading manifest + splits from repo …")
+    manifest_path = Path(hf_hub_download(
+        REPO_ID, "manifests/lidc/manifest_v1.0.0.jsonl",
+        repo_type="dataset", local_dir="/tmp", force_download=True,
+    ))
+    splits_path = Path(hf_hub_download(
+        REPO_ID, "manifests/lidc/splits_v1.0.0.json",
+        repo_type="dataset", local_dir="/tmp", force_download=True,
+    ))
+    return manifest_path, splits_path
+
+
+def load_manifest(path: Path) -> list[dict]:
+    return [json.loads(l) for l in path.read_text().splitlines() if l.strip()]
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(65536), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+# ── Step 1: Validation ────────────────────────────────────────────────────────
+
+def run_validation(manifest_path: Path, splits_path: Path) -> dict:
+    print("Running validation …")
+    records   = load_manifest(manifest_path)
+    split_map = json.loads(splits_path.read_text()).get("splits", {})
+    errors, warnings = [], []
+    total = len(records)
+
+    for i, rec in enumerate(records):
+        if i % 20000 == 0:
+            print(f"  validating {i}/{total} …")
+
+        missing = REQUIRED_FIELDS - rec.keys()
+        if missing:
+            errors.append(f"record {i}: missing fields {missing}")
+            continue
+
+        img_path = BUCKET_LIDC / rec["image_path"]
+        if not img_path.exists():
+            errors.append(f"record {i}: file not found {rec['image_path']}")
+            continue
+
+        # sha256 verification
+        actual = sha256_file(img_path)
+        if actual != rec["sha256"]:
+            errors.append(f"record {i}: sha256 mismatch {rec['image_path']}")
+
+        # corruption scan (optional)
+        if CORRUPTION_SCAN:
+            try:
+                from PIL import Image
+                with Image.open(img_path) as img:
+                    img.verify()
+            except Exception as exc:
+                errors.append(f"record {i}: corrupt image {rec['image_path']}: {exc}")
+
+        # split assignment
+        if rec["series_id"] not in split_map:
+            warnings.append(f"record {i}: series {rec['series_id']} has no split")
+
+    result = {
+        "total_records": total,
+        "errors": errors[:500],   # cap at 500 to keep report readable
+        "error_count": len(errors),
+        "warnings": warnings[:200],
+        "warning_count": len(warnings),
+        "passed": len(errors) == 0,
+    }
+    print(f"  Validation {'PASSED' if result['passed'] else 'FAILED'}: "
+          f"{result['error_count']} errors, {result['warning_count']} warnings")
+    return result
+
+
+# ── Step 2: Leakage audit ─────────────────────────────────────────────────────
+
+def run_leakage_audit(manifest_path: Path, splits_path: Path) -> dict:
+    print("Running leakage audit …")
+    records   = load_manifest(manifest_path)
+    split_map = json.loads(splits_path.read_text()).get("splits", {})
+    critical, warnings = [], []
+
+    # patient overlap across splits
+    patient_splits: dict[str, set] = defaultdict(set)
+    for r in records:
+        sid   = r["series_id"]
+        split = split_map.get(sid, "unassigned")
+        patient_splits[r["patient_id"]].add(split)
+    for pid, splits in patient_splits.items():
+        real = splits - {"unassigned"}
+        if len(real) > 1:
+            critical.append(f"Patient {pid} spans splits: {sorted(real)}")
+
+    # exact hash duplicates across splits
+    hash_records: dict[str, list] = defaultdict(list)
+    for r in records:
+        hash_records[r["sha256"]].append(r)
+    for h, recs in hash_records.items():
+        split_set = {split_map.get(r["series_id"], "unassigned") for r in recs} - {"unassigned"}
+        if len(split_set) > 1:
+            critical.append(f"Exact duplicate sha256 {h[:12]}… spans splits {sorted(split_set)}")
+        elif len(recs) > 1:
+            warnings.append(f"Duplicate sha256 {h[:12]}… within same split ({len(recs)} copies)")
+
+    # slice leakage — series_id in multiple splits
+    series_splits: dict[str, set] = defaultdict(set)
+    for r in records:
+        series_splits[r["series_id"]].add(split_map.get(r["series_id"], "unassigned"))
+    for sid, splits in series_splits.items():
+        real = splits - {"unassigned"}
+        if len(real) > 1:
+            critical.append(f"series_id {sid} spans splits: {sorted(real)}")
+
+    result = {
+        "total_records": len(records),
+        "critical": critical[:200],
+        "critical_count": len(critical),
+        "warnings": warnings[:200],
+        "warning_count": len(warnings),
+        "passed": len(critical) == 0,
+    }
+    print(f"  Leakage audit {'PASSED' if result['passed'] else 'FAILED'}: "
+          f"{result['critical_count']} critical, {result['warning_count']} warnings")
+    return result
+
+
+# ── Step 3: Upload reports ────────────────────────────────────────────────────
+
+def upload_reports(val_result: dict, leakage_result: dict) -> None:
+    print("Uploading reports …")
+    TMP_OUT.mkdir(parents=True, exist_ok=True)
+    api = HfApi()
+
+    val_path = TMP_OUT / "validation_lidc_v1.0.0.json"
+    val_path.write_text(json.dumps(val_result, indent=2))
+    api.upload_file(
+        path_or_fileobj=str(val_path),
+        path_in_repo="reports/validation/lidc_v1.0.0.json",
+        repo_id=REPO_ID, repo_type="dataset",
+    )
+    print("  validation report uploaded")
+
+    leakage_path = TMP_OUT / "leakage_lidc_v1.0.0.json"
+    leakage_path.write_text(json.dumps(leakage_result, indent=2))
+    api.upload_file(
+        path_or_fileobj=str(leakage_path),
+        path_in_repo="reports/leakage/lidc_v1.0.0.json",
+        repo_id=REPO_ID, repo_type="dataset",
+    )
+    print("  leakage report uploaded")
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    if not BUCKET_LIDC.exists():
+        print(f"ERROR: bucket not mounted at {BUCKET_LIDC}", file=sys.stderr)
+        sys.exit(1)
+
+    manifest_path, splits_path = download_inputs()
+    val_result     = run_validation(manifest_path, splits_path)
+    leakage_result = run_leakage_audit(manifest_path, splits_path)
+    upload_reports(val_result, leakage_result)
+
+    if not val_result["passed"] or not leakage_result["passed"]:
+        print("\nPIPELINE FAILED — check reports before training", file=sys.stderr)
+        sys.exit(1)
+
+    print("\nAll checks passed. Dataset is trainable.")
+
+
+if __name__ == "__main__":
+    main()