Datasets:

UCSC-VLAA
/

ClinSeek-Bench

@@ -1,157 +0,0 @@
-# Rebuilding ClinSeek-MM-Bench
-This directory contains the reconstruction scripts for the multimodal part of
-ClinSeek-Bench. The released file `inputs/mm_bench.jsonl` is the source of
-truth for the evaluated `qid`s, questions, labels, and image/report pointers.
-Protected MIMIC-derived patient databases, CXR JPG files, and report text are
-not redistributed. The scripts below use the manifest plus locally downloaded
-PhysioNet/source datasets to rebuild the `data/mm_bench` tree on an authorized
-machine.
-The scripts build two artifacts:
-1. Source-aligned subsets that preserve each upstream benchmark's own format
-   and pairing metadata for audit.
-2. The ClinSeek-MM-Bench runtime package used by the evaluation code.
-The source-aligned subsets are provenance artifacts only. They may include
-upstream labels and listfile metadata, so do not use them as model input.
-Use the final `ClinSeek-MM-Bench` package for evaluation.
-## Required source data
-Download the following datasets under your own PhysioNet credentials and data
-use agreements:
-- MIMIC-IV, latest available local release.
-- MIMIC-CXR, with the `files/` and `mimic-cxr-reports/` folders.
-- MIMIC-CXR-JPG, either v2.0.0 or v2.1.0 layout is acceptable if the JPG files
-  resolve by subject/study/DICOM path.
-- EHRXQA release from PhysioNet, used for the EHRXQA-derived rows.
-- MIMIC-IV-Note is optional for this build; the released EHRXQA rows use CXR
-  report text from MIMIC-CXR.
-For MedMod-derived rows, clone the official MedMod repository because the
-scripts verify the released rows against its task listfiles:
-```bash
-git clone https://github.com/nyuad-cai/MedMod.git /path/to/MedMod
-```
-## Configure paths
-Use paths on your machine. The examples below intentionally use placeholders.
-```bash
-export CLINSEEK_BENCH=/path/to/ClinSeek-Bench
-export BUILD_ROOT=/path/to/clinseek-mm-rebuild
-export EHRXQA_ROOT=/path/to/ehrxqa/1.0.0
-export MIMIC_CXR_ROOT=/path/to/mimic-cxr/2.0.0
-export MIMIC_CXR_JPG_ROOT=/path/to/mimic-cxr-jpg
-export MIMICIV_ROOT=/path/to/mimiciv
-export MIMIC_IV_NOTE_ROOT=/path/to/mimic-iv-note
-export MEDMOD_REPO_ROOT=/path/to/MedMod
-```
-## Build source-aligned subsets
-```bash
-python "$CLINSEEK_BENCH/rebuild/mm_bench/build_ehrxqa_release_original_subset.py" \
-  --input "$CLINSEEK_BENCH/inputs/mm_bench.jsonl" \
-  --output-root "$BUILD_ROOT/source/EHRXQA" \
-  --ehrxqa-root "$EHRXQA_ROOT" \
-  --cxr-root "$MIMIC_CXR_ROOT" \
-  --cxr-jpg-root "$MIMIC_CXR_JPG_ROOT" \
-  --mimiciv-root "$MIMICIV_ROOT" \
-  --mimic-iv-note-root "$MIMIC_IV_NOTE_ROOT" \
-  --overwrite
-python "$CLINSEEK_BENCH/rebuild/mm_bench/build_medmod_release_original_subset.py" \
-  --input "$CLINSEEK_BENCH/inputs/mm_bench.jsonl" \
-  --output-root "$BUILD_ROOT/source/MedMod" \
-  --medmod-repo-root "$MEDMOD_REPO_ROOT" \
-  --cxr-jpg-root "$MIMIC_CXR_JPG_ROOT" \
-  --cxr-meta-root "$MIMIC_CXR_ROOT" \
-  --mimiciv-root "$MIMICIV_ROOT" \
-  --overwrite
-```
-The MedMod script intentionally rebuilds only the rows present in
-`inputs/mm_bench.jsonl`; it does not rebuild the full MedMod benchmark.
-It also writes audit warnings when a frozen released row differs from the
-script's latest-AP CXR pairing check. These warnings are preserved in metadata;
-use `--strict-official-match` if you want such rows to fail reconstruction.
-## Convert to ClinSeek-MM-Bench format
-```bash
-python "$CLINSEEK_BENCH/rebuild/mm_bench/build_ehrxqa_clinseek_mm_subset.py" \
-  --original-root "$BUILD_ROOT/source/EHRXQA" \
-  --output-root "$BUILD_ROOT/runtime/EHRXQA" \
-  --overwrite
-python "$CLINSEEK_BENCH/rebuild/mm_bench/build_medmod_clinseek_mm_subset.py" \
-  --original-root "$BUILD_ROOT/source/MedMod" \
-  --output-root "$BUILD_ROOT/runtime/MedMod" \
-  --overwrite
-python "$CLINSEEK_BENCH/rebuild/mm_bench/combine_clinseek_mm_bench.py" \
-  --reference-input "$CLINSEEK_BENCH/inputs/mm_bench.jsonl" \
-  --ehrxqa-root "$BUILD_ROOT/runtime/EHRXQA" \
-  --medmod-root "$BUILD_ROOT/runtime/MedMod" \
-  --output-root "$BUILD_ROOT/final/ClinSeek-MM-Bench" \
-  --overwrite
-```
-The final package will be:
-```text
-$BUILD_ROOT/final/ClinSeek-MM-Bench/
-├── inputs/mm_bench.jsonl
-└── data/mm_bench/
-    ├── ehrxqa/
-    └── medmod/
-```
-The source-only `inputs/mm_bench.jsonl` does not store pre-rendered
-`input_text`, because that field contains MIMIC-derived EHR table rows. During
-conversion, the scripts render `input_text` locally from the rebuilt patient
-databases and CXR asset pointers.
-## Validate
-Validate either a local rebuilt package:
-```bash
-python "$CLINSEEK_BENCH/rebuild/mm_bench/validate_multimodal_release.py" \
-  --bench-root "$BUILD_ROOT/final/ClinSeek-MM-Bench"
-```
-Validate this source-only Hugging Face checkout without requiring protected
-assets:
-```bash
-python "$CLINSEEK_BENCH/rebuild/mm_bench/validate_multimodal_release.py" \
-  --bench-root "$CLINSEEK_BENCH" \
-  --manifest-only
-```
-If you have a local checkout that also materializes rebuilt assets, you can
-validate by file names in the git tree:
-```bash
-python "$CLINSEEK_BENCH/rebuild/mm_bench/validate_multimodal_release.py" \
-  --bench-root "$CLINSEEK_BENCH" \
-  --use-git-tree
-```
-Expected release counts:
-- 989 total rows.
-- 497 EHRXQA-derived rows and 492 MedMod-derived rows.
-- 165 EHRXQA patient DBs and 395 MedMod patient DBs.
-- 350 EHRXQA JPG files and 477 MedMod JPG files.
-- 356 EHRXQA CXR report text files.
-- 0 missing DB/image/report references.

rebuild/mm_bench/build_ehrxqa_clinseek_mm_subset.py DELETED Viewed

@@ -1,744 +0,0 @@
-#!/usr/bin/env python3
-"""Convert a source-aligned EHRXQA subset into ClinSeek-MM-Bench format."""
-from __future__ import annotations
-import argparse
-import csv
-import json
-import os
-import shutil
-import sqlite3
-import sys
-from collections import Counter
-from pathlib import Path
-from typing import Any
-import pandas as pd
-REPO_ROOT = Path(__file__).resolve().parents[2]
-SRC_ROOT = REPO_ROOT / "src"
-if str(SRC_ROOT) not in sys.path:
-    sys.path.insert(0, str(SRC_ROOT))
-DEFAULT_ORIGINAL_ROOT = Path(
-    os.environ.get(
-        "EHRXQA_ORIGINAL_SUBSET_ROOT",
-        "data/build/ClinSeek-MM-Bench-EHRXQA-source",
-    )
-)
-DEFAULT_OUTPUT_ROOT = Path(
-    os.environ.get(
-        "CLINSEEK_EHRXQA_MM_ROOT",
-        "data/build/ClinSeek-MM-Bench-EHRXQA",
-    )
-)
-TIME_COLUMNS = {
-    "admissions": "admittime",
-    "chartevents": "charttime",
-    "cost": "chargetime",
-    "diagnoses_icd": "charttime",
-    "icustays": "intime",
-    "inputevents": "starttime",
-    "labevents": "charttime",
-    "microbiologyevents": "charttime",
-    "outputevents": "charttime",
-    "prescriptions": "starttime",
-    "procedures_icd": "charttime",
-    "tb_cxr": "studydatetime",
-    "transfers": "intime",
-}
-LEAKAGE_POLICY = {
-    "sanitize_datetime_columns": True,
-    "mask_future_datetime_columns": True,
-    "row_timestamp_columns": TIME_COLUMNS,
-    "datetime_columns": {
-        "admissions": ["admittime", "dischtime"],
-        "chartevents": ["charttime"],
-        "cost": ["chargetime"],
-        "diagnoses_icd": ["charttime"],
-        "icustays": ["intime", "outtime"],
-        "inputevents": ["starttime"],
-        "labevents": ["charttime"],
-        "microbiologyevents": ["charttime"],
-        "outputevents": ["charttime"],
-        "patients": ["dod"],
-        "prescriptions": ["starttime", "stoptime"],
-        "procedures_icd": ["charttime"],
-        "tb_cxr": ["studydatetime"],
-        "transfers": ["intime", "outtime"],
-    },
-}
-REFERENCE_TABLES = {"d_icd_diagnoses", "d_icd_procedures", "d_items", "d_labitems"}
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--original-root", type=Path, default=DEFAULT_ORIGINAL_ROOT)
-    parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
-    parser.add_argument("--asset-prefix", default="EHRXQAOriginalLinked_v1")
-    parser.add_argument("--max-table-rows", type=int, default=80)
-    parser.add_argument(
-        "--render-input-text",
-        action="store_true",
-        help="Render input_text from the rebuilt patient DB instead of preserving the released HF JSONL field.",
-    )
-    parser.add_argument(
-        "--copy-cxr-context",
-        choices=("linked", "all"),
-        default="linked",
-        help="Copy only JSONL-linked assets or all CXR assets packaged by the source-aligned subset.",
-    )
-    parser.add_argument("--overwrite", action="store_true")
-    return parser.parse_args()
-def ensure_dir(path: Path) -> None:
-    path.mkdir(parents=True, exist_ok=True)
-def reset_dir(path: Path, overwrite: bool) -> None:
-    if path.exists():
-        if not overwrite:
-            raise FileExistsError(f"Output root already exists: {path}")
-        shutil.rmtree(path)
-    path.mkdir(parents=True, exist_ok=True)
-def link_or_copy(src: Path, dst: Path) -> None:
-    src = src.resolve()
-    ensure_dir(dst.parent)
-    if dst.exists():
-        return
-    try:
-        os.link(src, dst)
-    except OSError:
-        shutil.copy2(src, dst)
-def copytree_links(src: Path, dst: Path) -> None:
-    if not src.exists():
-        return
-    if dst.exists():
-        return
-    shutil.copytree(src, dst, copy_function=lambda s, d: (link_or_copy(Path(s), Path(d)) or str(d)))
-def write_json(path: Path, payload: Any) -> None:
-    ensure_dir(path.parent)
-    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-def read_jsonl(path: Path) -> list[dict[str, Any]]:
-    rows: list[dict[str, Any]] = []
-    with path.open("r", encoding="utf-8") as handle:
-        for line in handle:
-            if line.strip():
-                rows.append(json.loads(line))
-    return rows
-def safe_int(value: Any) -> int | None:
-    if value is None or value == "":
-        return None
-    try:
-        if pd.isna(value):
-            return None
-    except TypeError:
-        pass
-    try:
-        return int(float(str(value).strip()))
-    except ValueError:
-        return None
-def compact_value(value: Any) -> Any:
-    try:
-        if pd.isna(value):
-            return ""
-    except TypeError:
-        pass
-    if hasattr(value, "isoformat"):
-        return value.isoformat(sep=" ")
-    return value
-def table_to_text(table_name: str, frame: pd.DataFrame, max_rows: int) -> str:
-    total = len(frame)
-    if total == 0:
-        return f"### {table_name}\nRows visible before cutoff: 0\n"
-    display = frame
-    sort_col = TIME_COLUMNS.get(table_name)
-    if sort_col and sort_col in display.columns:
-        display = display.sort_values(sort_col, kind="stable")
-    if max_rows and len(display) > max_rows:
-        display = display.tail(max_rows)
-        shown = f"latest {len(display)} of {total}"
-    else:
-        shown = f"{total} of {total}"
-    clean = display.copy()
-    for column in clean.columns:
-        clean[column] = clean[column].map(compact_value)
-    return (
-        f"### {table_name}\n"
-        f"Rows visible before cutoff: {total}; rows included below: {shown}\n"
-        f"{clean.to_csv(index=False)}"
-    )
-def render_ehr_context_from_manager(manager: Any, sample: dict[str, Any], max_table_rows: int) -> str:
-    manager.load_ehr_for_sample(str(sample["subject_id"]), sample["prediction_time"])
-    blocks = []
-    for table_name in sorted(manager.ehr_data):
-        blocks.append(table_to_text(table_name, manager.ehr_data[table_name], max_table_rows))
-    return "\n".join(blocks).strip()
-def parse_datetime(value: Any) -> pd.Timestamp | None:
-    if value in (None, ""):
-        return None
-    try:
-        parsed = pd.Timestamp(value)
-    except (TypeError, ValueError):
-        return None
-    if pd.isna(parsed):
-        return None
-    return parsed
-def filter_by_cutoff(table_name: str, frame: pd.DataFrame, cutoff: pd.Timestamp | None) -> pd.DataFrame:
-    if cutoff is None:
-        return frame
-    time_column = TIME_COLUMNS.get(table_name)
-    if not time_column or time_column not in frame.columns:
-        return frame
-    parsed = pd.to_datetime(frame[time_column], errors="coerce")
-    return frame.loc[parsed.notna() & (parsed <= cutoff)].copy()
-def render_ehr_context(db_path: Path, prediction_time: str, max_table_rows: int) -> str:
-    cutoff = parse_datetime(prediction_time)
-    blocks: list[str] = []
-    with sqlite3.connect(db_path) as conn:
-        table_names = [
-            row[0]
-            for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
-        ]
-        for table_name in table_names:
-            frame = pd.read_sql_query(f'SELECT * FROM "{table_name}"', conn)
-            visible = filter_by_cutoff(table_name, frame, cutoff)
-            blocks.append(table_to_text(table_name, visible, max_table_rows))
-    return "\n".join(blocks).strip()
-def build_input_text(sample: dict[str, Any], image_paths: list[str], ehr_text: str) -> str:
-    return "\n\n".join(
-        [
-            str(sample.get("question") or "").strip(),
-            "<ehr_context>",
-            ehr_text,
-            "</ehr_context>",
-            "<image_inputs>",
-            "\n".join(f"- {path}" for path in image_paths) if image_paths else "NONE",
-            "</image_inputs>",
-        ]
-    )
-def strip_asset_prefix(path: str) -> str:
-    text = str(path).replace("\\", "/")
-    if "/" in text and text.split("/", 1)[0].endswith("OriginalLinked_v1"):
-        return text.split("/", 1)[1]
-    return text
-def load_manifest(original_root: Path) -> list[dict[str, Any]]:
-    manifest = original_root / "linked_manifests" / "test.jsonl"
-    if not manifest.exists():
-        raise FileNotFoundError(f"Missing source manifest: {manifest}")
-    return read_jsonl(manifest)
-def source_tables_dir(original_root: Path) -> Path:
-    path = original_root / "source_release" / "1.0.0" / "ehrxqa" / "database" / "gold"
-    if not path.is_dir():
-        raise FileNotFoundError(f"Missing EHRXQA gold table root: {path}")
-    return path
-def table_is_reference(table_name: str) -> bool:
-    return table_name in REFERENCE_TABLES or table_name.startswith("d_")
-def write_frame(conn: sqlite3.Connection, table_name: str, frame: pd.DataFrame, *, append: bool = False) -> None:
-    clean = frame.where(pd.notna(frame), None)
-    clean.to_sql(table_name, conn, if_exists="append" if append else "replace", index=False)
-def quote_identifier(name: str) -> str:
-    return '"' + name.replace('"', '""') + '"'
-def list_sqlite_tables(conn: sqlite3.Connection) -> list[str]:
-    return [
-        row[0]
-        for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
-    ]
-def list_attached_sqlite_tables(conn: sqlite3.Connection, schema: str) -> list[str]:
-    q_schema = quote_identifier(schema)
-    return [
-        row[0]
-        for row in conn.execute(f"SELECT name FROM {q_schema}.sqlite_master WHERE type='table' ORDER BY name")
-    ]
-def sqlite_table_columns(conn: sqlite3.Connection, table_name: str) -> list[str]:
-    return [row[1] for row in conn.execute(f"PRAGMA table_info({quote_identifier(table_name)})")]
-def source_sqlite_path(original_root: Path) -> Path:
-    return source_tables_dir(original_root) / "mimic_iv_cxr.sqlite"
-def build_reference_database(tables_dir: Path, output_db: Path) -> list[str]:
-    written: list[str] = []
-    if output_db.exists():
-        output_db.unlink()
-    with sqlite3.connect(output_db) as conn:
-        for csv_path in sorted(tables_dir.glob("*.csv")):
-            table_name = csv_path.stem
-            if not table_is_reference(table_name):
-                continue
-            write_frame(conn, table_name, pd.read_csv(csv_path, low_memory=False))
-            written.append(table_name)
-    return written
-def create_text_table(
-    conn: sqlite3.Connection,
-    table_name: str,
-    columns: list[str],
-    rows: list[list[Any]],
-) -> None:
-    q_table = quote_identifier(table_name)
-    column_sql = ", ".join(f"{quote_identifier(column)} TEXT" for column in columns)
-    conn.execute(f"CREATE TABLE {q_table} ({column_sql})")
-    if not rows:
-        return
-    placeholders = ", ".join(["?"] * len(columns))
-    conn.executemany(f"INSERT INTO {q_table} VALUES ({placeholders})", rows)
-def csv_value(value: Any) -> Any:
-    if value is None or value == "":
-        return None
-    return value
-def build_reference_database_from_csvs(tables_dir: Path, output_db: Path) -> list[str]:
-    written: list[str] = []
-    if output_db.exists():
-        output_db.unlink()
-    with sqlite3.connect(output_db) as conn:
-        for csv_path in sorted(tables_dir.glob("*.csv")):
-            table_name = csv_path.stem
-            if not table_is_reference(table_name):
-                continue
-            with csv_path.open("r", encoding="utf-8", newline="") as handle:
-                reader = csv.reader(handle)
-                columns = next(reader)
-                rows = [[csv_value(value) for value in row] for row in reader]
-            create_text_table(conn, table_name, columns, rows)
-            written.append(table_name)
-        conn.commit()
-    return written
-def build_patient_databases_from_source_csvs(
-    *,
-    original_root: Path,
-    database_root: Path,
-    subject_ids: set[int],
-) -> dict[str, Any]:
-    tables_dir = source_tables_dir(original_root)
-    subject_lookup = {str(subject_id): subject_id for subject_id in subject_ids}
-    subject_tables: dict[int, list[tuple[str, list[str], list[list[Any]]]]] = {
-        subject_id: [] for subject_id in subject_ids
-    }
-    built_tables: list[str] = []
-    for csv_path in sorted(tables_dir.glob("*.csv")):
-        table_name = csv_path.stem
-        if table_is_reference(table_name):
-            continue
-        with csv_path.open("r", encoding="utf-8", newline="") as handle:
-            reader = csv.DictReader(handle)
-            if not reader.fieldnames or "subject_id" not in reader.fieldnames:
-                continue
-            columns = list(reader.fieldnames)
-            if table_name == "patients":
-                columns = [column for column in columns if column != "dod"]
-            grouped: dict[int, list[list[Any]]] = {}
-            for row in reader:
-                subject_id = subject_lookup.get(str(row.get("subject_id") or ""))
-                if subject_id is None:
-                    continue
-                grouped.setdefault(subject_id, []).append([csv_value(row.get(column)) for column in columns])
-        if not grouped:
-            continue
-        built_tables.append(table_name)
-        for subject_id, rows in grouped.items():
-            subject_tables[subject_id].append((table_name, columns, rows))
-    built_subjects = {subject_id for subject_id, tables in subject_tables.items() if tables}
-    missing = sorted(subject_ids - built_subjects)
-    if missing:
-        raise FileNotFoundError(f"Missing built patient DBs for subjects: {missing[:20]}")
-    ensure_dir(database_root)
-    for subject_id, tables in sorted(subject_tables.items()):
-        db_path = database_root / f"patient_{subject_id}.db"
-        if db_path.exists():
-            db_path.unlink()
-        with sqlite3.connect(db_path) as conn:
-            conn.execute("PRAGMA journal_mode=OFF")
-            conn.execute("PRAGMA synchronous=OFF")
-            for table_name, columns, rows in tables:
-                create_text_table(conn, table_name, columns, rows)
-            conn.commit()
-    reference_tables = build_reference_database_from_csvs(tables_dir, database_root / "reference_table.db")
-    return {
-        "patient_db_source": "source_aligned_subset_csv",
-        "source_table_root": "source_release/1.0.0/ehrxqa/database/gold",
-        "built_subjects": len(built_subjects),
-        "built_tables": built_tables,
-        "reference_tables": reference_tables,
-    }
-def build_reference_database_from_sqlite(source_db: Path, output_db: Path) -> list[str]:
-    written: list[str] = []
-    if output_db.exists():
-        output_db.unlink()
-    with sqlite3.connect(output_db) as conn:
-        conn.execute("ATTACH DATABASE ? AS src", (str(source_db),))
-        for table_name in list_attached_sqlite_tables(conn, "src"):
-            if not table_is_reference(table_name):
-                continue
-            q_table = quote_identifier(table_name)
-            conn.execute(f"CREATE TABLE {q_table} AS SELECT * FROM src.{q_table}")
-            written.append(table_name)
-        conn.commit()
-    return written
-def build_patient_databases_from_source_sqlite(
-    *,
-    original_root: Path,
-    database_root: Path,
-    subject_ids: set[int],
-) -> dict[str, Any]:
-    source_db = source_sqlite_path(original_root)
-    if not source_db.exists():
-        raise FileNotFoundError(f"Missing EHRXQA source SQLite: {source_db}")
-    ensure_dir(database_root)
-    with sqlite3.connect(source_db) as src_conn:
-        table_names = list_sqlite_tables(src_conn)
-        patient_tables = [
-            table_name
-            for table_name in table_names
-            if not table_is_reference(table_name)
-            and "subject_id" in sqlite_table_columns(src_conn, table_name)
-        ]
-    built_subjects = set()
-    for subject_id in sorted(subject_ids):
-        db_path = database_root / f"patient_{subject_id}.db"
-        if db_path.exists():
-            db_path.unlink()
-        with sqlite3.connect(db_path) as dst_conn:
-            dst_conn.execute("PRAGMA journal_mode=OFF")
-            dst_conn.execute("PRAGMA synchronous=OFF")
-            dst_conn.execute("ATTACH DATABASE ? AS src", (str(source_db),))
-            rows_written = 0
-            for table_name in patient_tables:
-                q_table = quote_identifier(table_name)
-                row_count = dst_conn.execute(
-                    f"SELECT COUNT(*) FROM src.{q_table} WHERE subject_id = ?",
-                    (subject_id,),
-                ).fetchone()[0]
-                if row_count == 0:
-                    continue
-                columns = [
-                    row[1]
-                    for row in dst_conn.execute(f"PRAGMA src.table_info({quote_identifier(table_name)})")
-                ]
-                if table_name == "patients":
-                    columns = [column for column in columns if column != "dod"]
-                select_columns = ", ".join(quote_identifier(column) for column in columns)
-                dst_conn.execute(
-                    f"CREATE TABLE {q_table} AS SELECT {select_columns} FROM src.{q_table} WHERE subject_id = ?",
-                    (subject_id,),
-                )
-                rows_written += row_count
-            dst_conn.commit()
-        if rows_written:
-            built_subjects.add(subject_id)
-    missing = sorted(subject_ids - built_subjects)
-    if missing:
-        raise FileNotFoundError(f"Missing built patient DBs for subjects: {missing[:20]}")
-    reference_tables = build_reference_database_from_sqlite(source_db, database_root / "reference_table.db")
-    return {
-        "patient_db_source": "source_aligned_subset_sqlite",
-        "source_sqlite": "source_release/1.0.0/ehrxqa/database/gold/mimic_iv_cxr.sqlite",
-        "built_subjects": len(built_subjects),
-        "built_tables": patient_tables,
-        "reference_tables": reference_tables,
-    }
-def build_patient_databases_from_source(
-    *,
-    original_root: Path,
-    database_root: Path,
-    subject_ids: set[int],
-) -> dict[str, Any]:
-    tables_dir = source_tables_dir(original_root)
-    if any(tables_dir.glob("*.csv")):
-        return build_patient_databases_from_source_csvs(
-            original_root=original_root,
-            database_root=database_root,
-            subject_ids=subject_ids,
-        )
-    sqlite_path = source_sqlite_path(original_root)
-    if sqlite_path.exists():
-        return build_patient_databases_from_source_sqlite(
-            original_root=original_root,
-            database_root=database_root,
-            subject_ids=subject_ids,
-        )
-    built_tables: list[str] = []
-    subject_frames: dict[int, list[tuple[str, pd.DataFrame]]] = {subject_id: [] for subject_id in subject_ids}
-    for csv_path in sorted(tables_dir.glob("*.csv")):
-        table_name = csv_path.stem
-        if table_is_reference(table_name):
-            continue
-        header = pd.read_csv(csv_path, nrows=0)
-        if "subject_id" not in header.columns:
-            continue
-        built_tables.append(table_name)
-        frame = pd.read_csv(csv_path, low_memory=False)
-        subset = frame[frame["subject_id"].isin(subject_ids)]
-        if subset.empty:
-            continue
-        for subject_id, group in subset.groupby("subject_id", sort=True):
-            subject_frames[int(subject_id)].append((table_name, group.copy()))
-    built_subjects = {subject_id for subject_id, frames in subject_frames.items() if frames}
-    missing = sorted(subject_ids - built_subjects)
-    if missing:
-        raise FileNotFoundError(f"Missing built patient DBs for subjects: {missing[:20]}")
-    ensure_dir(database_root)
-    for subject_id, frames in sorted(subject_frames.items()):
-        db_path = database_root / f"patient_{subject_id}.db"
-        if db_path.exists():
-            db_path.unlink()
-        with sqlite3.connect(db_path) as conn:
-            for table_name, frame in frames:
-                write_frame(conn, table_name, frame)
-    reference_tables = build_reference_database(tables_dir, database_root / "reference_table.db")
-    return {
-        "patient_db_source": "source_aligned_subset",
-        "built_subjects": len(built_subjects),
-        "built_tables": built_tables,
-        "reference_tables": reference_tables,
-    }
-def write_runtime_metadata(bench_root: Path) -> None:
-    write_json(
-        bench_root / "metadata.json",
-        {
-            "package_name": "ClinSeek-MM-Bench-EHRXQA-runtime",
-            "leakage_policy": LEAKAGE_POLICY,
-            "path_contract": {
-                "db_path_hint": "relative_to_benchmark_root",
-                "image_paths": "relative_to_benchmark_root",
-                "report_paths": "relative_to_benchmark_root",
-                "tb_cxr.image_path": "relative_to_benchmark_root",
-                "tb_cxr.report_path": "relative_to_benchmark_root",
-            },
-        },
-    )
-def copy_linked_assets(original_root: Path, bench_root: Path, row: dict[str, Any]) -> tuple[list[str], list[str]]:
-    rel_images = [strip_asset_prefix(path) for path in row.get("packaged_image_relpaths") or []]
-    rel_reports = [strip_asset_prefix(path) for path in row.get("packaged_report_relpaths") or []]
-    for relpath in rel_images + rel_reports:
-        link_or_copy(original_root / relpath, bench_root / relpath)
-    return rel_images, rel_reports
-def copy_all_cxr_context(original_root: Path, bench_root: Path) -> None:
-    copytree_links(original_root / "mimic-cxr", bench_root / "mimic-cxr")
-def write_table_descriptions(bench_root: Path) -> None:
-    dst = bench_root / "table_description"
-    ensure_dir(dst)
-    (dst / "link_information.json").write_text("", encoding="utf-8")
-    (dst / "shorten_description.json").write_text("", encoding="utf-8")
-def main() -> None:
-    args = parse_args()
-    reset_dir(args.output_root, args.overwrite)
-    manifest_rows = load_manifest(args.original_root)
-    bench_root = args.output_root / "data" / "mm_bench" / "ehrxqa"
-    database_root = bench_root / "database"
-    inputs_root = args.output_root / "inputs"
-    ensure_dir(database_root)
-    ensure_dir(inputs_root)
-    by_subject: dict[int, dict[str, Any]] = {}
-    for row in manifest_rows:
-        subject_id = safe_int(row.get("subject_id"))
-        if subject_id is None:
-            raise ValueError(f"Missing subject_id: {row.get('qid')}")
-        by_subject.setdefault(subject_id, row)
-    db_build_summary = build_patient_databases_from_source(
-        original_root=args.original_root,
-        database_root=database_root,
-        subject_ids=set(by_subject),
-    )
-    write_table_descriptions(bench_root)
-    ehr_manager_root = bench_root
-    write_runtime_metadata(bench_root)
-    if args.copy_cxr_context == "all":
-        copy_all_cxr_context(args.original_root, bench_root)
-    ehr_manager = None
-    need_rendered_input_text = args.render_input_text or any(
-        not row.get("released_input_text") for row in manifest_rows
-    )
-    if need_rendered_input_text:
-        try:
-            from agentlite.commons.EHRManager import EHRManager  # type: ignore
-            ehr_manager = EHRManager(str(ehr_manager_root))
-        except Exception as exc:  # pragma: no cover - fallback for portable envs
-            print({"ehr_manager_unavailable": repr(exc)}, flush=True)
-    output_rows: list[dict[str, Any]] = []
-    stats = Counter()
-    linked_image_count = 0
-    linked_report_count = 0
-    for index, row in enumerate(manifest_rows):
-        rel_images, rel_reports = copy_linked_assets(args.original_root, bench_root, row)
-        linked_image_count += len(rel_images)
-        linked_report_count += len(rel_reports)
-        prefixed_images = [f"{args.asset_prefix}/{relpath}" for relpath in rel_images]
-        prefixed_reports = [f"{args.asset_prefix}/{relpath}" for relpath in rel_reports]
-        if args.render_input_text or not row.get("released_input_text"):
-            if ehr_manager is not None:
-                ehr_text = render_ehr_context_from_manager(ehr_manager, row, args.max_table_rows)
-            else:
-                subject_id = safe_int(row.get("subject_id"))
-                if subject_id is None:
-                    raise ValueError(f"Missing subject_id: {row.get('qid')}")
-                ehr_text = render_ehr_context(
-                    database_root / f"patient_{subject_id}.db",
-                    str(row.get("prediction_time")),
-                    args.max_table_rows,
-                )
-            input_text = build_input_text(row, prefixed_images, ehr_text)
-        else:
-            input_text = row.get("released_input_text")
-        output_rows.append(
-            {
-                "qid": row.get("qid"),
-                "source_index": row.get("source_index"),
-                "source_benchmark": "ehrxqa",
-                "task": row.get("task"),
-                "source_split": row.get("source_split"),
-                "subject_id": row.get("subject_id"),
-                "hadm_id": row.get("hadm_id"),
-                "stay_id": row.get("stay_id"),
-                "prediction_time": row.get("prediction_time"),
-                "question": row.get("question"),
-                "input_text": input_text,
-                "image_paths": prefixed_images,
-                "report_paths": prefixed_reports,
-                "ground_truth": row.get("ground_truth"),
-                "answer_type": row.get("answer_type"),
-                "modalities": row.get("modalities") or ["cxr_table", "cxr_image"],
-            }
-        )
-        stats[f"task:{row.get('task')}"] += 1
-        if (index + 1) % 100 == 0:
-            print({"rendered_rows": index + 1, "total": len(manifest_rows)}, flush=True)
-    output_path = inputs_root / "mm_bench_ehrxqa.jsonl"
-    with output_path.open("w", encoding="utf-8") as handle:
-        for row in output_rows:
-            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
-    metadata = {
-        "package_name": "ClinSeek-MM-Bench-EHRXQA",
-        "original_root": "EHRXQA_ORIGINAL_SUBSET_ROOT",
-        "records": len(output_rows),
-        "subjects": len(by_subject),
-        "patient_dbs": len(list(database_root.glob("patient_*.db"))),
-        "db_build_summary": db_build_summary,
-        "unique_linked_images": len({p for row in output_rows for p in row["image_paths"]}),
-        "unique_linked_reports": len({p for row in output_rows for p in row["report_paths"]}),
-        "linked_image_refs": linked_image_count,
-        "linked_report_refs": linked_report_count,
-        "copy_cxr_context": args.copy_cxr_context,
-        "input_text_source": "rendered_from_db" if need_rendered_input_text else "released_hf_jsonl",
-        "input_file": "inputs/mm_bench_ehrxqa.jsonl",
-        "bench_root": "data/mm_bench/ehrxqa",
-        "asset_prefix": args.asset_prefix,
-        "stats": dict(sorted(stats.items())),
-        "path_contract": {
-            "image_paths": "strip asset_prefix, then resolve relative to bench_root",
-            "report_paths": "strip asset_prefix, then resolve relative to bench_root",
-            "patient_db": "data/mm_bench/ehrxqa/database/patient_<subject_id>.db",
-        },
-        "leakage_policy": {
-            "ground_truth": "kept only in output JSONL field, never in input_text",
-            "patient_db_source": db_build_summary.get("patient_db_source"),
-            "runtime_policy": "EHRManager uses benchmark metadata leakage_policy at load time",
-        },
-    }
-    write_json(args.output_root / "metadata.json", metadata)
-    readme = """# ClinSeek-MM-Bench-EHRXQA
-This directory contains the EHRXQA-derived portion of ClinSeek-MM-Bench.
-Use:
-- `inputs/mm_bench_ehrxqa.jsonl`
-- `data/mm_bench/ehrxqa`
-The JSONL contains both agentic fields (`question`, `image_paths`, `subject_id`)
-and curated-input fields (`input_text`, `image_paths`).  Patient SQLite DBs are
-under `data/mm_bench/ehrxqa/database`.
-"""
-    (args.output_root / "README.md").write_text(readme, encoding="utf-8")
-    print(json.dumps(metadata, ensure_ascii=False, indent=2))
-if __name__ == "__main__":
-    main()

rebuild/mm_bench/build_ehrxqa_release_original_subset.py DELETED Viewed

@@ -1,570 +0,0 @@
-#!/usr/bin/env python3
-"""Build the source-aligned EHRXQA subset used by ClinSeek MM-Bench.
-This script rebuilds only the EHRXQA rows present in the released
-inputs/mm_bench.jsonl.  It keeps the official EHRXQA schema, writes subset
-CSV/SQLite tables, and packages the CXR files needed by the selected patients
-using relative paths.
-"""
-from __future__ import annotations
-import argparse
-import json
-import os
-import re
-import shutil
-import sqlite3
-from collections import Counter
-from pathlib import Path
-from typing import Any
-import pandas as pd
-DEFAULT_INPUT = Path(
-    os.environ.get(
-        "CLINSEEK_MM_BENCH_JSONL",
-        "data/ClinSeek-Bench/inputs/mm_bench.jsonl",
-    )
-)
-DEFAULT_OUTPUT_ROOT = Path(
-    os.environ.get(
-        "EHRXQA_ORIGINAL_SUBSET_ROOT",
-        "data/build/ClinSeek-MM-Bench-EHRXQA-source",
-    )
-)
-DEFAULT_EHRXQA_ROOT = Path(
-    os.environ.get("EHRXQA_ROOT", "external/ehrxqa/1.0.0")
-)
-DEFAULT_CXR_ROOT = Path(
-    os.environ.get("MIMIC_CXR_ROOT", "external/mimic-cxr/2.0.0")
-)
-DEFAULT_CXR_JPG_ROOT = Path(
-    os.environ.get("MIMIC_CXR_JPG_ROOT", "external/mimic-cxr-jpg")
-)
-DEFAULT_MIMICIV_ROOT = Path(os.environ.get("MIMICIV_ROOT", "external/mimiciv/3.1"))
-DEFAULT_MIMIC_IV_NOTE_ROOT = Path(
-    os.environ.get("MIMIC_IV_NOTE_ROOT", "external/mimic-iv-note/2.2")
-)
-QID_RE = re.compile(r"^ehrxqa_(?P<split>[a-zA-Z0-9-]+)_(?P<source_id>\d+)$")
-IMAGE_RE = re.compile(
-    r"(?:^|/)files/p\d+/p(?P<subject_id>\d+)/s(?P<study_id>\d+)/(?P<dicom_id>[^/]+)\.jpg$"
-)
-REFERENCE_TABLE_PREFIXES = ("d_",)
-REFERENCE_TABLES = {"d_icd_diagnoses", "d_icd_procedures", "d_items", "d_labitems"}
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--input", type=Path, default=DEFAULT_INPUT)
-    parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
-    parser.add_argument("--ehrxqa-root", type=Path, default=DEFAULT_EHRXQA_ROOT)
-    parser.add_argument(
-        "--cxr-root",
-        type=Path,
-        default=DEFAULT_CXR_ROOT,
-        help="MIMIC-CXR root containing files/ and mimic-cxr-reports/.",
-    )
-    parser.add_argument(
-        "--cxr-jpg-root",
-        type=Path,
-        default=DEFAULT_CXR_JPG_ROOT,
-        help="Optional MIMIC-CXR-JPG root or flat mimic-cxr2 export used as an image fallback.",
-    )
-    parser.add_argument("--mimiciv-root", type=Path, default=DEFAULT_MIMICIV_ROOT)
-    parser.add_argument(
-        "--mimic-iv-note-root",
-        type=Path,
-        default=DEFAULT_MIMIC_IV_NOTE_ROOT,
-        help="Optional MIMIC-IV-Note root kept for provenance; this EHRXQA build uses CXR report TXT files.",
-    )
-    parser.add_argument("--overwrite", action="store_true")
-    parser.add_argument(
-        "--allow-missing-nonlinked-assets",
-        action="store_true",
-        help=(
-            "Deprecated compatibility flag. Non-linked patient-context CXR assets "
-            "are optional; linked benchmark assets are still required."
-        ),
-    )
-    return parser.parse_args()
-def ensure_dir(path: Path) -> None:
-    path.mkdir(parents=True, exist_ok=True)
-def reset_dir(path: Path, overwrite: bool) -> None:
-    if path.exists():
-        if not overwrite:
-            raise FileExistsError(f"Output root already exists: {path}")
-        shutil.rmtree(path)
-    path.mkdir(parents=True, exist_ok=True)
-def link_or_copy(src: Path, dst: Path) -> None:
-    src = src.resolve()
-    ensure_dir(dst.parent)
-    if dst.exists():
-        return
-    try:
-        os.link(src, dst)
-    except OSError:
-        shutil.copy2(src, dst)
-def write_json(path: Path, payload: Any, *, compact: bool = False) -> None:
-    ensure_dir(path.parent)
-    kwargs = {"ensure_ascii": False}
-    if not compact:
-        kwargs["indent"] = 2
-    path.write_text(json.dumps(payload, **kwargs) + "\n", encoding="utf-8")
-def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
-    ensure_dir(path.parent)
-    with path.open("w", encoding="utf-8") as handle:
-        for row in rows:
-            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
-def safe_int(value: Any) -> int | None:
-    if value is None or value == "":
-        return None
-    try:
-        if pd.isna(value):
-            return None
-    except TypeError:
-        pass
-    try:
-        return int(float(str(value).strip()))
-    except ValueError:
-        return None
-def normalize_ehrxqa_root(path: Path) -> tuple[Path, Path]:
-    """Return (release_root, ehrxqa_dir)."""
-    if (path / "ehrxqa" / "dataset").is_dir():
-        return path, path / "ehrxqa"
-    if (path / "dataset").is_dir() and (path / "database").is_dir():
-        return path.parent, path
-    raise FileNotFoundError(
-        f"Could not find EHRXQA dataset/database under {path}. "
-        "Pass either the 1.0.0 root or the 1.0.0/ehrxqa directory."
-    )
-def load_release_rows(input_path: Path) -> list[dict[str, Any]]:
-    rows: list[dict[str, Any]] = []
-    with input_path.open("r", encoding="utf-8") as handle:
-        for line_index, line in enumerate(handle):
-            if not line.strip():
-                continue
-            row = json.loads(line)
-            if row.get("source_benchmark") != "ehrxqa":
-                continue
-            match = QID_RE.match(str(row.get("qid") or ""))
-            if not match:
-                raise ValueError(f"Cannot parse EHRXQA qid: {row.get('qid')}")
-            row["_source_line_index"] = line_index
-            row["_source_split_from_qid"] = match.group("split")
-            row["_source_id_from_qid"] = int(match.group("source_id"))
-            rows.append(row)
-    return rows
-def strip_asset_prefix(path: str) -> str:
-    text = path.replace("\\", "/")
-    if "/" in text and text.split("/", 1)[0].endswith("OriginalLinked_v1"):
-        return text.split("/", 1)[1]
-    return text
-def parse_image_ref(path: str) -> dict[str, Any]:
-    stripped = strip_asset_prefix(path)
-    match = IMAGE_RE.search(stripped)
-    if not match:
-        raise ValueError(f"Cannot parse EHRXQA image path: {path}")
-    subject_id = int(match.group("subject_id"))
-    study_id = int(match.group("study_id"))
-    dicom_id = match.group("dicom_id")
-    nested_relpath = (
-        f"mimic-cxr/2.0.0/files/p{str(subject_id)[:2]}/p{subject_id}/"
-        f"s{study_id}/{dicom_id}.jpg"
-    )
-    report_relpath = (
-        f"mimic-cxr/2.0.0/mimic-cxr-reports/files/p{str(subject_id)[:2]}/"
-        f"p{subject_id}/s{study_id}.txt"
-    )
-    return {
-        "subject_id": subject_id,
-        "study_id": study_id,
-        "dicom_id": dicom_id,
-        "image_relpath": nested_relpath,
-        "report_relpath": report_relpath,
-    }
-def nested_file_relpath(subject_id: int, study_id: int, dicom_id: str) -> str:
-    return (
-        f"mimic-cxr/2.0.0/files/p{str(subject_id)[:2]}/p{subject_id}/"
-        f"s{study_id}/{dicom_id}.jpg"
-    )
-def nested_report_relpath(subject_id: int, study_id: int) -> str:
-    return (
-        f"mimic-cxr/2.0.0/mimic-cxr-reports/files/p{str(subject_id)[:2]}/"
-        f"p{subject_id}/s{study_id}.txt"
-    )
-def find_cxr_image(
-    cxr_root: Path,
-    cxr_jpg_root: Path,
-    subject_id: int,
-    study_id: int,
-    dicom_id: str,
-) -> Path | None:
-    nested = Path(nested_file_relpath(subject_id, study_id, dicom_id)).relative_to("mimic-cxr/2.0.0")
-    flat_name = f"p{str(subject_id)[:2]}_p{subject_id}_s{study_id}_{dicom_id}.jpg"
-    candidates = [
-        cxr_root / nested,
-        cxr_root / "files" / nested.relative_to("files"),
-        cxr_root / "mimic-cxr" / "2.0.0" / nested,
-        cxr_root / "2.0.0" / nested,
-        cxr_root / "2.1.0" / nested,
-        cxr_root / "2.1.0-lite" / nested,
-        cxr_root / "2.1.0-working-subset" / nested,
-        cxr_root / "mimic-cxr2" / flat_name,
-        cxr_root / flat_name,
-        cxr_jpg_root / nested,
-        cxr_jpg_root / "files" / nested.relative_to("files"),
-        cxr_jpg_root / "2.0.0" / nested,
-        cxr_jpg_root / "2.1.0" / nested,
-        cxr_jpg_root / "2.1.0-lite" / nested,
-        cxr_jpg_root / "2.1.0-working-subset" / nested,
-        cxr_jpg_root / "mimic-cxr2" / flat_name,
-        cxr_jpg_root / flat_name,
-    ]
-    for candidate in candidates:
-        if candidate.exists():
-            return candidate
-    return None
-def find_cxr_report(cxr_root: Path, subject_id: int, study_id: int) -> Path | None:
-    nested = Path(nested_report_relpath(subject_id, study_id)).relative_to("mimic-cxr/2.0.0")
-    candidates = [
-        cxr_root / nested,
-        cxr_root / "mimic-cxr-reports" / nested.relative_to("mimic-cxr-reports"),
-        cxr_root / "mimic-cxr" / "2.0.0" / nested,
-        cxr_root / "2.0.0" / nested,
-    ]
-    for candidate in candidates:
-        if candidate.exists():
-            return candidate
-    return None
-def table_is_reference(table_name: str) -> bool:
-    return table_name in REFERENCE_TABLES or table_name.startswith(REFERENCE_TABLE_PREFIXES)
-def load_source_records(ehrxqa_dir: Path, split: str, source_ids: set[int]) -> dict[int, dict[str, Any]]:
-    path = ehrxqa_dir / "dataset" / f"{split}.json"
-    rows = json.loads(path.read_text(encoding="utf-8"))
-    by_id = {int(row["id"]): row for row in rows if int(row["id"]) in source_ids}
-    missing = sorted(source_ids - set(by_id))
-    if missing:
-        raise ValueError(f"Missing EHRXQA source ids in {path}: {missing[:20]}")
-    return by_id
-def load_tb_cxr(
-    table_path: Path,
-    selected_subjects: set[int],
-    cxr_root: Path,
-    cxr_jpg_root: Path,
-) -> pd.DataFrame:
-    frame = pd.read_csv(table_path)
-    frame = frame[frame["subject_id"].isin(selected_subjects)].copy()
-    frame = frame.where(pd.notna(frame), None)
-    image_paths: list[str | None] = []
-    report_paths: list[str | None] = []
-    for row in frame.to_dict(orient="records"):
-        subject_id = safe_int(row.get("subject_id"))
-        study_id = safe_int(row.get("study_id"))
-        dicom_id = str(row.get("image_id") or "").strip()
-        if subject_id is None or study_id is None or not dicom_id:
-            image_paths.append(None)
-            report_paths.append(None)
-            continue
-        image_paths.append(
-            nested_file_relpath(subject_id, study_id, dicom_id)
-            if find_cxr_image(cxr_root, cxr_jpg_root, subject_id, study_id, dicom_id) is not None
-            else None
-        )
-        report_paths.append(nested_report_relpath(subject_id, study_id))
-    frame["image_path"] = image_paths
-    frame["report_path"] = report_paths
-    return frame
-def write_subset_tables(
-    *,
-    source_tables_dir: Path,
-    output_tables_dir: Path,
-    selected_subjects: set[int],
-    selected_tb_cxr: pd.DataFrame,
-) -> list[str]:
-    ensure_dir(output_tables_dir)
-    written: list[str] = []
-    for csv_path in sorted(source_tables_dir.glob("*.csv")):
-        table_name = csv_path.stem
-        if table_name == "tb_cxr":
-            frame = selected_tb_cxr
-        else:
-            header = pd.read_csv(csv_path, nrows=0)
-            if table_is_reference(table_name) or "subject_id" not in header.columns:
-                frame = pd.read_csv(csv_path)
-            else:
-                chunks = []
-                for chunk in pd.read_csv(csv_path, chunksize=200_000):
-                    chunks.append(chunk[chunk["subject_id"].isin(selected_subjects)])
-                frame = pd.concat(chunks, ignore_index=True) if chunks else header
-        frame = frame.where(pd.notna(frame), None)
-        out_path = output_tables_dir / csv_path.name
-        frame.to_csv(out_path, index=False)
-        written.append(table_name)
-    for extra_name in ("mimic_iv_cxr.sql", "index.html"):
-        src = source_tables_dir / extra_name
-        if src.exists():
-            link_or_copy(src, output_tables_dir / extra_name)
-    return written
-def write_sqlite_from_csvs(tables_dir: Path, sqlite_path: Path) -> None:
-    if sqlite_path.exists():
-        sqlite_path.unlink()
-    with sqlite3.connect(sqlite_path) as conn:
-        for csv_path in sorted(tables_dir.glob("*.csv")):
-            frame = pd.read_csv(csv_path)
-            frame = frame.where(pd.notna(frame), None)
-            frame.to_sql(csv_path.stem, conn, if_exists="replace", index=False)
-def copy_asset(src: Path | None, dst: Path, *, required: bool, label: str) -> bool:
-    if src is None:
-        if required:
-            raise FileNotFoundError(f"Missing required {label}: {dst}")
-        return False
-    link_or_copy(src, dst)
-    return True
-def main() -> None:
-    args = parse_args()
-    reset_dir(args.output_root, args.overwrite)
-    release_root, ehrxqa_dir = normalize_ehrxqa_root(args.ehrxqa_root)
-    rows = load_release_rows(args.input)
-    if not rows:
-        raise ValueError(f"No EHRXQA rows found in {args.input}")
-    split_ids: dict[str, set[int]] = {}
-    for row in rows:
-        split_ids.setdefault(row["_source_split_from_qid"], set()).add(row["_source_id_from_qid"])
-    if set(split_ids) != {"test"}:
-        raise ValueError(f"This release subset expects only EHRXQA test rows, got {sorted(split_ids)}")
-    source_by_id = load_source_records(ehrxqa_dir, "test", split_ids["test"])
-    linked_study_ids: set[int] = set()
-    linked_image_refs: dict[tuple[int, int, str], dict[str, Any]] = {}
-    for row in rows:
-        for image_path in row.get("image_paths") or []:
-            ref = parse_image_ref(image_path)
-            linked_study_ids.add(ref["study_id"])
-            linked_image_refs[(ref["subject_id"], ref["study_id"], ref["dicom_id"])] = ref
-    selected_subjects = {int(row["subject_id"]) for row in rows}
-    source_tables_dir = ehrxqa_dir / "database" / "gold"
-    selected_tb_cxr = load_tb_cxr(
-        source_tables_dir / "tb_cxr.csv",
-        selected_subjects,
-        args.cxr_root,
-        args.cxr_jpg_root,
-    )
-    tb_cxr_by_study = {
-        int(record["study_id"]): record
-        for record in selected_tb_cxr.to_dict(orient="records")
-        if safe_int(record.get("study_id")) is not None
-    }
-    output_ehrxqa_dir = args.output_root / "source_release" / "1.0.0" / "ehrxqa"
-    output_dataset_dir = output_ehrxqa_dir / "dataset"
-    output_tables_dir = output_ehrxqa_dir / "database" / "gold"
-    subset_source_rows = [source_by_id[row["_source_id_from_qid"]] for row in rows]
-    write_json(output_dataset_dir / "test.json", subset_source_rows)
-    written_tables = write_subset_tables(
-        source_tables_dir=source_tables_dir,
-        output_tables_dir=output_tables_dir,
-        selected_subjects=selected_subjects,
-        selected_tb_cxr=selected_tb_cxr,
-    )
-    sqlite_relpath = "source_release/1.0.0/ehrxqa/database/gold/mimic_iv_cxr.sqlite"
-    write_sqlite_from_csvs(output_tables_dir, args.output_root / sqlite_relpath)
-    for rel in ("index.html", "LICENSE.txt", "SHA256SUMS.txt"):
-        src = release_root / rel
-        if src.exists():
-            link_or_copy(src, args.output_root / "source_release" / "1.0.0" / rel)
-    copied_images = 0
-    copied_reports = 0
-    missing_nonlinked_assets = 0
-    asset_rows = selected_tb_cxr.to_dict(orient="records")
-    for asset_row in asset_rows:
-        subject_id = safe_int(asset_row.get("subject_id"))
-        study_id = safe_int(asset_row.get("study_id"))
-        dicom_id = str(asset_row.get("image_id") or "").strip()
-        if subject_id is None or study_id is None or not dicom_id:
-            continue
-        linked = (subject_id, study_id, dicom_id) in linked_image_refs
-        image_rel = nested_file_relpath(subject_id, study_id, dicom_id)
-        report_rel = nested_report_relpath(subject_id, study_id)
-        image_src = find_cxr_image(args.cxr_root, args.cxr_jpg_root, subject_id, study_id, dicom_id)
-        report_src = find_cxr_report(args.cxr_root, subject_id, study_id)
-        if copy_asset(image_src, args.output_root / image_rel, required=linked, label="CXR image"):
-            copied_images += 1
-        else:
-            missing_nonlinked_assets += 1
-        if copy_asset(report_src, args.output_root / report_rel, required=linked, label="CXR report"):
-            copied_reports += 1
-        else:
-            missing_nonlinked_assets += 1
-    manifest_rows: list[dict[str, Any]] = []
-    for row in rows:
-        source_id = row["_source_id_from_qid"]
-        source_row = source_by_id[source_id]
-        packaged_images = [strip_asset_prefix(path) for path in row.get("image_paths") or []]
-        packaged_reports = [strip_asset_prefix(path) for path in row.get("report_paths") or []]
-        study_ids = []
-        dicom_ids = []
-        raw_images = []
-        raw_reports = []
-        for image_path in packaged_images:
-            ref = parse_image_ref(image_path)
-            study_ids.append(ref["study_id"])
-            dicom_ids.append(ref["dicom_id"])
-            raw_images.append(str(Path("files") / Path(ref["image_relpath"]).relative_to("mimic-cxr/2.0.0/files")))
-        for report_path in packaged_reports:
-            raw_reports.append(
-                str(Path("mimic-cxr-reports") / Path(report_path).relative_to("mimic-cxr/2.0.0/mimic-cxr-reports"))
-            )
-        manifest_rows.append(
-            {
-                "qid": row.get("qid"),
-                "source_line_index": row.get("_source_line_index"),
-                "source_index": row.get("source_index"),
-                "source_benchmark": "ehrxqa",
-                "task": row.get("task"),
-                "source_split": row.get("source_split"),
-                "source_id": source_id,
-                "variant": "gold",
-                "subject_id": row.get("subject_id"),
-                "hadm_id": row.get("hadm_id"),
-                "stay_id": row.get("stay_id"),
-                "prediction_time": row.get("prediction_time"),
-                "question": row.get("question"),
-                "released_input_text": row.get("input_text"),
-                "source_question": source_row.get("question"),
-                "source_sql": source_row.get("query"),
-                "source_template": source_row.get("template"),
-                "source_value": source_row.get("value"),
-                "source_answer": source_row.get("answer"),
-                "ground_truth": row.get("ground_truth"),
-                "answer_type": row.get("answer_type"),
-                "modalities": row.get("modalities") or ["cxr_table", "cxr_image"],
-                "study_ids": study_ids,
-                "dicom_ids": dicom_ids,
-                "packaged_db_relpath": sqlite_relpath,
-                "packaged_table_root_relpath": "source_release/1.0.0/ehrxqa/database/gold",
-                "packaged_image_relpaths": packaged_images,
-                "packaged_report_relpaths": packaged_reports,
-                "raw_image_source_relpaths": raw_images,
-                "raw_report_source_relpaths": raw_reports,
-                "source_dataset_relpath": "source_release/1.0.0/ehrxqa/dataset/test.json",
-                "tb_cxr_context_rows": len(
-                    [record for record in asset_rows if safe_int(record.get("subject_id")) == row.get("subject_id")]
-                ),
-            }
-        )
-    write_jsonl(args.output_root / "linked_manifests" / "test.jsonl", manifest_rows)
-    readme = """# ClinSeek-MM-Bench-EHRXQA-source
-This package is the source-aligned EHRXQA subset used by ClinSeek MM-Bench.
-It contains only the EHRXQA rows present in `inputs/mm_bench.jsonl`.
-Required source downloads:
-- EHRXQA 1.0.0 answered release: `$EHRXQA_ROOT`
-- MIMIC-CXR / MIMIC-CXR-JPG files and reports: `$MIMIC_CXR_ROOT`
-- MIMIC-CXR-JPG fallback root: `$MIMIC_CXR_JPG_ROOT`
-- MIMIC-IV latest local release kept for provenance: `$MIMICIV_ROOT`
-- MIMIC-IV-Note kept for provenance when local notes are inspected: `$MIMIC_IV_NOTE_ROOT`
-Contents:
-- `source_release/1.0.0/ehrxqa/dataset/test.json`: official EHRXQA rows selected by ClinSeek.
-- `source_release/1.0.0/ehrxqa/database/gold/`: official-schema subset tables.
-- `source_release/1.0.0/ehrxqa/database/gold/mimic_iv_cxr.sqlite`: SQLite materialization of the subset tables.
-	- `linked_manifests/test.jsonl`: row-level provenance and package-relative asset paths.
-	- `mimic-cxr/2.0.0/...`: packaged CXR JPG and report TXT assets for selected patient context.
-The linked manifest is a provenance artifact. It contains gold answers and the
-original EHRXQA SQL fields, so it must not be used as the runtime model input.
-	"""
-    (args.output_root / "README.md").write_text(readme, encoding="utf-8")
-    metadata = {
-        "package_name": "ClinSeek-MM-Bench-EHRXQA-source",
-        "input": "CLINSEEK_MM_BENCH_JSONL",
-        "records": len(manifest_rows),
-        "subjects": len(selected_subjects),
-        "variant": "gold",
-        "source_splits": dict(Counter(row["source_split"] for row in manifest_rows)),
-        "written_tables": written_tables,
-        "tb_cxr_context_rows": len(asset_rows),
-        "unique_linked_images": len({p for row in manifest_rows for p in row["packaged_image_relpaths"]}),
-        "unique_linked_reports": len({p for row in manifest_rows for p in row["packaged_report_relpaths"]}),
-        "copied_images": copied_images,
-        "copied_reports": copied_reports,
-        "missing_nonlinked_context_assets": missing_nonlinked_assets,
-        "source_path_env_vars": {
-            "ehrxqa_root": "EHRXQA_ROOT",
-            "cxr_root": "MIMIC_CXR_ROOT",
-            "cxr_jpg_root": "MIMIC_CXR_JPG_ROOT",
-            "mimiciv_root": "MIMICIV_ROOT",
-            "mimic_iv_note_root": "MIMIC_IV_NOTE_ROOT",
-        },
-        "path_contract": {
-            "manifest_paths": "relative_to_package_root",
-            "packaged_image_relpaths": "relative_to_package_root",
-            "packaged_report_relpaths": "relative_to_package_root",
-            "raw_image_source_relpaths": "relative_to_MIMIC_CXR_ROOT_or_MIMIC_CXR_JPG_ROOT",
-            "raw_report_source_relpaths": "relative_to_MIMIC_CXR_ROOT",
-        },
-    }
-    write_json(args.output_root / "metadata.json", metadata)
-    print(json.dumps(metadata, ensure_ascii=False, indent=2))
-if __name__ == "__main__":
-    main()

rebuild/mm_bench/build_medmod_clinseek_mm_subset.py DELETED Viewed

@@ -1,679 +0,0 @@
-#!/usr/bin/env python3
-"""Convert a source-aligned MedMod subset into ClinSeek-MM-Bench format.
-Input is the package produced by build_medmod_release_original_subset.py.
-Output is a compact release tree with:
-- inputs/mm_bench_medmod.jsonl
-- data/mm_bench/medmod/database/patient_<subject_id>.db
-- data/mm_bench/medmod/mimic-cxr/2.0.0/files/...
-- data/mm_bench/medmod/table_description/*
-"""
-from __future__ import annotations
-import argparse
-import csv
-import json
-import os
-import shutil
-import sqlite3
-import sys
-from collections import Counter, defaultdict
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-import pandas as pd
-REPO_ROOT = Path(__file__).resolve().parents[2]
-SRC_ROOT = REPO_ROOT / "src"
-if str(SRC_ROOT) not in sys.path:
-    sys.path.insert(0, str(SRC_ROOT))
-DEFAULT_ORIGINAL_ROOT = Path(
-    os.environ.get(
-        "MEDMOD_ORIGINAL_SUBSET_ROOT",
-        "data/build/ClinSeek-MM-Bench-MedMod-source",
-    )
-)
-DEFAULT_OUTPUT_ROOT = Path(
-    os.environ.get(
-        "CLINSEEK_MEDMOD_MM_ROOT",
-        "data/build/ClinSeek-MM-Bench-MedMod",
-    )
-)
-LEAKY_STAY_COLUMNS = {
-    "outtime",
-    "los",
-    "dischtime",
-    "deathtime",
-    "dod",
-    "mortality_inunit",
-    "mortality",
-    "mortality_inhospital",
-}
-TIME_COLUMNS = {
-    "events": "charttime",
-    "stays": "intime",
-    "tb_cxr": "studydatetime",
-}
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--original-root", type=Path, default=DEFAULT_ORIGINAL_ROOT)
-    parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
-    parser.add_argument("--asset-prefix", default="MedModOriginalLinked_v1")
-    parser.add_argument("--max-table-rows", type=int, default=80)
-    parser.add_argument(
-        "--patient-db-scope",
-        choices=("selected_stays", "full_subject"),
-        default="selected_stays",
-        help=(
-            "Build patient DBs from only the official stays selected by the release manifest, or from the "
-            "whole extracted subject folder."
-        ),
-    )
-    parser.add_argument("--overwrite", action="store_true")
-    parser.add_argument(
-        "--render-input-text",
-        action="store_true",
-        help="Render input_text from the rebuilt patient DB instead of preserving the released HF JSONL field.",
-    )
-    return parser.parse_args()
-def ensure_dir(path: Path) -> None:
-    path.mkdir(parents=True, exist_ok=True)
-def reset_dir(path: Path, overwrite: bool) -> None:
-    if path.exists():
-        if not overwrite:
-            raise FileExistsError(f"Output root already exists: {path}")
-        shutil.rmtree(path)
-    path.mkdir(parents=True, exist_ok=True)
-def link_or_copy(src: Path, dst: Path) -> None:
-    src = src.resolve()
-    ensure_dir(dst.parent)
-    if dst.exists():
-        return
-    try:
-        os.link(src, dst)
-    except OSError:
-        shutil.copy2(src, dst)
-def write_json(path: Path, payload: Any) -> None:
-    ensure_dir(path.parent)
-    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-def read_jsonl(path: Path) -> list[dict[str, Any]]:
-    rows = []
-    with path.open("r", encoding="utf-8") as handle:
-        for line in handle:
-            rows.append(json.loads(line))
-    return rows
-def safe_int(value: Any) -> int | None:
-    if value is None or value == "":
-        return None
-    try:
-        if pd.isna(value):
-            return None
-    except TypeError:
-        pass
-    try:
-        return int(float(str(value).strip()))
-    except ValueError:
-        return None
-def compact_value(value: Any) -> Any:
-    try:
-        if pd.isna(value):
-            return ""
-    except TypeError:
-        pass
-    if hasattr(value, "isoformat"):
-        return value.isoformat(sep=" ")
-    return value
-def parse_datetime(value: Any) -> datetime | None:
-    if not value:
-        return None
-    if isinstance(value, datetime):
-        return value
-    text = str(value)
-    for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M:%S.%f"):
-        try:
-            return datetime.strptime(text, fmt)
-        except ValueError:
-            pass
-    return None
-def study_datetime_from_metadata(record: dict[str, Any]) -> str | None:
-    date = record.get("StudyDate")
-    time = record.get("StudyTime")
-    if date in (None, "") or time in (None, ""):
-        return None
-    try:
-        time_text = f"{int(float(time)):06d}"
-        dt = datetime.strptime(f"{int(float(date))} {time_text}", "%Y%m%d %H%M%S")
-        return dt.strftime("%Y-%m-%d %H:%M:%S")
-    except (TypeError, ValueError):
-        return None
-def load_manifest(original_root: Path) -> list[dict[str, Any]]:
-    manifest = original_root / "linked_manifests" / "all.jsonl"
-    if not manifest.exists():
-        raise FileNotFoundError(f"Missing source manifest: {manifest}")
-    return read_jsonl(manifest)
-def load_cxr_metadata(original_root: Path) -> tuple[dict[str, dict[str, Any]], dict[str, str]]:
-    meta_root = original_root / "source_release" / "cxr_metadata"
-    metadata_path = meta_root / "mimic-cxr-2.0.0-metadata.csv"
-    if not metadata_path.exists():
-        raise FileNotFoundError(f"Missing packaged CXR metadata: {metadata_path}")
-    metadata_df = pd.read_csv(metadata_path)
-    metadata_by_dicom = {
-        str(record["dicom_id"]): record for record in metadata_df.to_dict(orient="records")
-    }
-    split_by_dicom: dict[str, str] = {}
-    split_path = meta_root / "mimic-cxr-2.0.0-split.csv"
-    if split_path.exists():
-        split_df = pd.read_csv(split_path)
-        if {"dicom_id", "split"}.issubset(split_df.columns):
-            split_by_dicom = {
-                str(record["dicom_id"]): str(record["split"])
-                for record in split_df.to_dict(orient="records")
-            }
-    return metadata_by_dicom, split_by_dicom
-def build_tb_cxr_rows(
-    manifest_rows: list[dict[str, Any]],
-    metadata_by_dicom: dict[str, dict[str, Any]],
-    split_by_dicom: dict[str, str],
-) -> dict[int, pd.DataFrame]:
-    rows_by_subject: dict[int, list[dict[str, Any]]] = defaultdict(list)
-    seen: set[tuple[int, int, str, int | None]] = set()
-    for sample in manifest_rows:
-        subject_id = safe_int(sample.get("subject_id"))
-        hadm_id = safe_int(sample.get("hadm_id"))
-        stay_id = safe_int(sample.get("stay_id"))
-        if subject_id is None:
-            continue
-        for study_id, dicom_id, image_relpath in zip(
-            sample.get("study_ids") or [],
-            sample.get("dicom_ids") or [],
-            sample.get("packaged_image_relpaths") or [],
-        ):
-            study_id_int = safe_int(study_id)
-            if study_id_int is None:
-                continue
-            key = (subject_id, study_id_int, str(dicom_id), stay_id)
-            if key in seen:
-                continue
-            seen.add(key)
-            metadata = metadata_by_dicom.get(str(dicom_id), {})
-            rows_by_subject[subject_id].append(
-                {
-                    "subject_id": subject_id,
-                    "study_id": study_id_int,
-                    "studydatetime": study_datetime_from_metadata(metadata)
-                    or sample.get("prediction_time"),
-                    "split": split_by_dicom.get(str(dicom_id), sample.get("source_split") or "test"),
-                    "image_id": str(dicom_id),
-                    "image_path": image_relpath,
-                    "viewposition": str(metadata.get("ViewPosition") or "AP"),
-                    "hadm_id": hadm_id,
-                    "stay_id": stay_id,
-                }
-            )
-    return {
-        subject_id: pd.DataFrame(rows).sort_values(["studydatetime", "study_id", "image_id"])
-        for subject_id, rows in rows_by_subject.items()
-    }
-def sanitize_stays(frame: pd.DataFrame) -> pd.DataFrame:
-    drop_cols = [col for col in frame.columns if col.lower() in LEAKY_STAY_COLUMNS]
-    return frame.drop(columns=drop_cols) if drop_cols else frame
-def write_frame(conn: sqlite3.Connection, table_name: str, frame: pd.DataFrame) -> None:
-    clean = frame.where(pd.notna(frame), None)
-    clean.to_sql(table_name, conn, if_exists="replace", index=False)
-def quote_identifier(name: str) -> str:
-    return '"' + name.replace('"', '""') + '"'
-def csv_value(value: Any) -> Any:
-    if value is None or value == "":
-        return None
-    return value
-def create_text_table(
-    conn: sqlite3.Connection,
-    table_name: str,
-    columns: list[str],
-    rows: list[list[Any]],
-) -> None:
-    q_table = quote_identifier(table_name)
-    column_sql = ", ".join(f"{quote_identifier(column)} TEXT" for column in columns)
-    conn.execute(f"CREATE TABLE {q_table} ({column_sql})")
-    if not rows:
-        return
-    placeholders = ", ".join(["?"] * len(columns))
-    conn.executemany(f"INSERT INTO {q_table} VALUES ({placeholders})", rows)
-def sample_stay_ids(samples: list[dict[str, Any]]) -> set[int]:
-    stay_ids: set[int] = set()
-    for sample in samples:
-        for candidate in (
-            sample.get("stay_id"),
-            (sample.get("official_data_full_row") or {}).get("stay_id")
-            if isinstance(sample.get("official_data_full_row"), dict)
-            else None,
-            (sample.get("official_listfile_row") or {}).get("stay_id")
-            if isinstance(sample.get("official_listfile_row"), dict)
-            else None,
-        ):
-            stay_id = safe_int(candidate)
-            if stay_id is not None:
-                stay_ids.add(stay_id)
-    return stay_ids
-def filter_frame_to_stays(frame: pd.DataFrame, stay_ids: set[int]) -> pd.DataFrame:
-    if not stay_ids or "stay_id" not in frame.columns:
-        return frame
-    numeric_stay_ids = pd.to_numeric(frame["stay_id"], errors="coerce").astype("Int64")
-    return frame[numeric_stay_ids.isin(stay_ids)].copy()
-def write_csv_table(
-    conn: sqlite3.Connection,
-    table_name: str,
-    csv_path: Path,
-    *,
-    stay_ids: set[int],
-    drop_lower_columns: set[str] | None = None,
-) -> None:
-    drop_lower_columns = drop_lower_columns or set()
-    with csv_path.open("r", encoding="utf-8", newline="") as handle:
-        reader = csv.reader(handle)
-        source_columns = next(reader)
-        keep_indexes = [
-            index
-            for index, column in enumerate(source_columns)
-            if column.lower() not in drop_lower_columns
-        ]
-        columns = [source_columns[index] for index in keep_indexes]
-        stay_index = source_columns.index("stay_id") if "stay_id" in source_columns else None
-        rows: list[list[Any]] = []
-        for row in reader:
-            if stay_ids and stay_index is not None:
-                stay_id = safe_int(row[stay_index] if stay_index < len(row) else None)
-                if stay_id not in stay_ids:
-                    continue
-            rows.append([csv_value(row[index]) if index < len(row) else None for index in keep_indexes])
-    create_text_table(conn, table_name, columns, rows)
-def build_patient_db(
-    *,
-    original_root: Path,
-    samples: list[dict[str, Any]],
-    output_db: Path,
-    tb_cxr: pd.DataFrame | None,
-    patient_db_scope: str,
-) -> None:
-    ensure_dir(output_db.parent)
-    if not samples:
-        raise ValueError("Cannot build MedMod patient DB from an empty sample list")
-    sample = samples[0]
-    subject_dirs = sample.get("ehr_subject_relpaths") or []
-    if not subject_dirs:
-        raise FileNotFoundError(f"Sample has no EHR subject path: {sample.get('qid')}")
-    subject_dir = original_root / subject_dirs[0]
-    if not subject_dir.is_dir():
-        raise FileNotFoundError(f"Missing EHR subject dir: {subject_dir}")
-    stay_ids = sample_stay_ids(samples) if patient_db_scope == "selected_stays" else set()
-    with sqlite3.connect(output_db) as conn:
-        conn.execute("PRAGMA journal_mode=OFF")
-        conn.execute("PRAGMA synchronous=OFF")
-        events_path = subject_dir / "events.csv"
-        stays_path = subject_dir / "stays.csv"
-        if events_path.exists():
-            write_csv_table(conn, "events", events_path, stay_ids=stay_ids)
-        if stays_path.exists():
-            write_csv_table(
-                conn,
-                "stays",
-                stays_path,
-                stay_ids=stay_ids,
-                drop_lower_columns=LEAKY_STAY_COLUMNS,
-            )
-        if tb_cxr is not None and not tb_cxr.empty:
-            write_frame(conn, "tb_cxr", filter_frame_to_stays(tb_cxr, stay_ids))
-        conn.commit()
-def materialize_patient_db(
-    *,
-    original_root: Path,
-    samples: list[dict[str, Any]],
-    output_db: Path,
-    tb_cxr: pd.DataFrame | None,
-    patient_db_scope: str,
-) -> str:
-    if not samples:
-        raise ValueError("Cannot materialize MedMod patient DB from an empty sample list")
-    sample = samples[0]
-    subject_id = safe_int(sample.get("subject_id"))
-    if subject_id is None:
-        raise ValueError(f"Missing subject_id for {sample.get('qid')}")
-    build_patient_db(
-        original_root=original_root,
-        samples=samples,
-        output_db=output_db,
-        tb_cxr=tb_cxr,
-        patient_db_scope=patient_db_scope,
-    )
-    return f"source_aligned_{patient_db_scope}"
-def filter_by_cutoff(table_name: str, frame: pd.DataFrame, cutoff: datetime | None) -> pd.DataFrame:
-    if cutoff is None:
-        return frame.copy()
-    column = TIME_COLUMNS.get(table_name)
-    if not column or column not in frame.columns:
-        return frame.copy()
-    parsed = pd.to_datetime(frame[column], errors="coerce")
-    return frame[parsed.isna() | (parsed <= pd.Timestamp(cutoff))].copy()
-def table_to_text(table_name: str, frame: pd.DataFrame, max_rows: int) -> str:
-    total = len(frame)
-    if total == 0:
-        return f"### {table_name}\nRows visible before cutoff: 0\n"
-    sort_col = TIME_COLUMNS.get(table_name)
-    display = frame
-    if sort_col and sort_col in display.columns:
-        display = display.sort_values(sort_col, kind="stable")
-    if max_rows and len(display) > max_rows:
-        display = display.tail(max_rows)
-        shown = f"latest {len(display)} of {total}"
-    else:
-        shown = f"{total} of {total}"
-    clean = display.copy()
-    for column in clean.columns:
-        clean[column] = clean[column].map(compact_value)
-    return (
-        f"### {table_name}\n"
-        f"Rows visible before cutoff: {total}; rows included below: {shown}\n"
-        f"{clean.to_csv(index=False)}"
-    )
-def render_ehr_context_from_manager(manager: Any, sample: dict[str, Any], max_table_rows: int) -> str:
-    manager.load_ehr_for_sample(str(sample["subject_id"]), sample["prediction_time"])
-    blocks = []
-    for table_name in sorted(manager.ehr_data):
-        blocks.append(table_to_text(table_name, manager.ehr_data[table_name], max_table_rows))
-    return "\n".join(blocks).strip()
-def render_ehr_context(db_path: Path, prediction_time: str, max_table_rows: int) -> str:
-    cutoff = parse_datetime(prediction_time)
-    blocks: list[str] = []
-    with sqlite3.connect(db_path) as conn:
-        table_names = [
-            row[0]
-            for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
-        ]
-        for table_name in table_names:
-            frame = pd.read_sql_query(f'SELECT * FROM "{table_name}"', conn)
-            visible = filter_by_cutoff(table_name, frame, cutoff)
-            blocks.append(table_to_text(table_name, visible, max_table_rows))
-    return "\n".join(blocks).strip()
-def build_input_text(sample: dict[str, Any], image_paths: list[str], ehr_text: str) -> str:
-    return "\n\n".join(
-        [
-            str(sample.get("question") or "").strip(),
-            "<ehr_context>",
-            ehr_text,
-            "</ehr_context>",
-            "<image_inputs>",
-            "\n".join(f"- {path}" for path in image_paths) if image_paths else "NONE",
-            "</image_inputs>",
-        ]
-    )
-def write_table_descriptions(benchmark_root: Path) -> None:
-    database_root = benchmark_root / "database"
-    table_desc_root = benchmark_root / "table_description"
-    ensure_dir(table_desc_root)
-    schemas: dict[str, list[str]] = {}
-    for db_path in sorted(database_root.glob("patient_*.db"))[:50]:
-        with sqlite3.connect(db_path) as conn:
-            for (table_name,) in conn.execute("SELECT name FROM sqlite_master WHERE type='table'"):
-                columns = [row[1] for row in conn.execute(f'PRAGMA table_info("{table_name}")')]
-                known = schemas.setdefault(table_name, [])
-                for column in columns:
-                    if column not in known:
-                        known.append(column)
-    desc_records = [
-        {
-            "file_name": table_name,
-            "class": "ehr",
-            "description": f"Schema extracted from MedMod subset table '{table_name}'.",
-            "columns": [
-                {
-                    "column_name": column,
-                    "description": f"Column '{column}' in table '{table_name}'.",
-                }
-                for column in columns
-            ],
-        }
-        for table_name, columns in sorted(schemas.items())
-    ]
-    with (table_desc_root / "shorten_description.json").open("w", encoding="utf-8") as handle:
-        for record in desc_records:
-            handle.write(json.dumps(record, ensure_ascii=False) + "\n")
-    (table_desc_root / "link_information.json").write_text("", encoding="utf-8")
-def write_runtime_metadata(benchmark_root: Path) -> None:
-    write_json(
-        benchmark_root / "metadata.json",
-        {
-            "package_name": "ClinSeek-MM-Bench-MedMod-runtime",
-            "leakage_policy": {
-                "sanitize_datetime_columns": True,
-                "mask_future_datetime_columns": True,
-                "row_timestamp_columns": TIME_COLUMNS,
-                "datetime_columns": {
-                    "events": ["charttime"],
-                    "stays": ["intime", "admittime"],
-                    "tb_cxr": ["studydatetime"],
-                },
-                "drop_columns": {
-                    "stays": sorted(LEAKY_STAY_COLUMNS),
-                },
-            },
-            "path_contract": {
-                "db_path_hint": "relative_to_benchmark_root",
-                "image_paths": "relative_to_benchmark_root",
-                "report_paths": "relative_to_benchmark_root",
-                "tb_cxr.image_path": "relative_to_benchmark_root",
-            },
-        },
-    )
-def main() -> None:
-    args = parse_args()
-    reset_dir(args.output_root, args.overwrite)
-    manifest_rows = load_manifest(args.original_root)
-    metadata_by_dicom, split_by_dicom = load_cxr_metadata(args.original_root)
-    tb_cxr_by_subject = build_tb_cxr_rows(manifest_rows, metadata_by_dicom, split_by_dicom)
-    bench_root = args.output_root / "data" / "mm_bench" / "medmod"
-    database_root = bench_root / "database"
-    inputs_root = args.output_root / "inputs"
-    ensure_dir(database_root)
-    ensure_dir(inputs_root)
-    by_subject: dict[int, list[dict[str, Any]]] = defaultdict(list)
-    for sample in manifest_rows:
-        subject_id = safe_int(sample.get("subject_id"))
-        if subject_id is not None:
-            by_subject[subject_id].append(sample)
-    db_source_counts = Counter()
-    for subject_id, samples in sorted(by_subject.items()):
-        source = materialize_patient_db(
-            original_root=args.original_root,
-            samples=samples,
-            output_db=database_root / f"patient_{subject_id}.db",
-            tb_cxr=tb_cxr_by_subject.get(subject_id),
-            patient_db_scope=args.patient_db_scope,
-        )
-        db_source_counts[source] += 1
-    write_table_descriptions(bench_root)
-    write_runtime_metadata(bench_root)
-    ehr_manager = None
-    need_rendered_input_text = args.render_input_text or any(
-        not sample.get("released_input_text") for sample in manifest_rows
-    )
-    if need_rendered_input_text:
-        try:
-            from agentlite.commons.EHRManager import EHRManager  # type: ignore
-            ehr_manager = EHRManager(str(bench_root))
-        except Exception as exc:  # pragma: no cover - fallback for portable envs
-            print({"ehr_manager_unavailable": repr(exc)}, flush=True)
-    output_rows: list[dict[str, Any]] = []
-    stats = Counter()
-    for index, sample in enumerate(manifest_rows):
-        subject_id = safe_int(sample.get("subject_id"))
-        if subject_id is None:
-            raise ValueError(f"Missing subject_id: {sample.get('qid')}")
-        rel_images = list(sample.get("packaged_image_relpaths") or [])
-        rel_reports = list(sample.get("packaged_report_relpaths") or [])
-        for relpath in rel_images + rel_reports:
-            link_or_copy(args.original_root / relpath, bench_root / relpath)
-        prefixed_images = [f"{args.asset_prefix}/{relpath}" for relpath in rel_images]
-        prefixed_reports = [f"{args.asset_prefix}/{relpath}" for relpath in rel_reports]
-        db_path = database_root / f"patient_{subject_id}.db"
-        if args.render_input_text or not sample.get("released_input_text"):
-            if ehr_manager is not None:
-                ehr_text = render_ehr_context_from_manager(ehr_manager, sample, args.max_table_rows)
-            else:
-                ehr_text = render_ehr_context(db_path, str(sample.get("prediction_time")), args.max_table_rows)
-            input_text = build_input_text(sample, prefixed_images, ehr_text)
-        else:
-            input_text = sample.get("released_input_text")
-        output_rows.append(
-            {
-                "qid": sample.get("qid"),
-                "source_index": sample.get("source_index"),
-                "source_benchmark": "medmod",
-                "task": sample.get("source_task"),
-                "source_split": sample.get("source_split"),
-                "subject_id": sample.get("subject_id"),
-                "hadm_id": sample.get("hadm_id"),
-                "stay_id": sample.get("stay_id"),
-                "prediction_time": sample.get("prediction_time"),
-                "question": sample.get("question"),
-                "input_text": input_text,
-                "image_paths": prefixed_images,
-                "report_paths": prefixed_reports,
-                "ground_truth": sample.get("ground_truth"),
-                "answer_type": sample.get("answer_type"),
-                "modalities": sample.get("modalities") or ["ehr", "cxr"],
-            }
-        )
-        stats[f"task:{sample.get('source_task')}"] += 1
-        if (index + 1) % 100 == 0:
-            print({"rendered_rows": index + 1, "total": len(manifest_rows)}, flush=True)
-    output_path = inputs_root / "mm_bench_medmod.jsonl"
-    with output_path.open("w", encoding="utf-8") as handle:
-        for row in output_rows:
-            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
-    metadata = {
-        "package_name": "ClinSeek-MM-Bench-MedMod",
-        "original_root": "MEDMOD_ORIGINAL_SUBSET_ROOT",
-        "records": len(output_rows),
-        "subjects": len(by_subject),
-        "patient_dbs": len(list(database_root.glob("patient_*.db"))),
-        "patient_db_sources": dict(sorted(db_source_counts.items())),
-        "patient_db_scope": args.patient_db_scope,
-        "unique_images": len({p for row in output_rows for p in row["image_paths"]}),
-        "unique_reports": len({p for row in output_rows for p in row["report_paths"]}),
-        "input_file": "inputs/mm_bench_medmod.jsonl",
-        "bench_root": "data/mm_bench/medmod",
-        "asset_prefix": args.asset_prefix,
-        "input_text_source": "rendered_from_db" if need_rendered_input_text else "released_hf_jsonl",
-        "stats": dict(sorted(stats.items())),
-        "path_contract": {
-            "image_paths": "strip asset_prefix, then resolve relative to bench_root",
-            "report_paths": "strip asset_prefix, then resolve relative to bench_root",
-            "patient_db": "data/mm_bench/medmod/database/patient_<subject_id>.db",
-        },
-        "leakage_policy": {
-            "ground_truth": "kept only in output JSONL field, never in input_text",
-            "stays_dropped_columns": sorted(LEAKY_STAY_COLUMNS),
-            "diagnoses_table": "not materialized in patient DB",
-            "runtime_cutoff_columns": TIME_COLUMNS,
-        },
-    }
-    write_json(args.output_root / "metadata.json", metadata)
-    readme = f"""# ClinSeek-MM-Bench-MedMod
-This directory contains the MedMod-derived portion of ClinSeek-MM-Bench.
-Use:
-- `inputs/mm_bench_medmod.jsonl`
-- `data/mm_bench/medmod`
-The JSONL contains both agentic fields (`question`, `image_paths`, `subject_id`)
-and one-shot fields (`input_text`, `image_paths`).  Patient SQLite DBs are under
-`data/mm_bench/medmod/database`.
-"""
-    (args.output_root / "README.md").write_text(readme, encoding="utf-8")
-    print(json.dumps(metadata, ensure_ascii=False, indent=2))
-if __name__ == "__main__":
-    main()

rebuild/mm_bench/build_medmod_release_original_subset.py DELETED Viewed

@@ -1,929 +0,0 @@
-#!/usr/bin/env python3
-"""Build the source-aligned MedMod subset used by ClinSeek MM-Bench.
-This script intentionally does not rebuild the full MedMod benchmark.  It reads
-the released ClinSeek multimodal input file, keeps only the MedMod rows that are
-actually evaluated, verifies them against the official MedMod listfiles and
-MIMIC-CXR labels/metadata, and packages the required source-format EHR folders
-and CXR files with relative paths.
-"""
-from __future__ import annotations
-import argparse
-import json
-import os
-import re
-import shutil
-import sqlite3
-from collections import Counter, defaultdict
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-import pandas as pd
-DEFAULT_INPUT = Path(
-    os.environ.get(
-        "CLINSEEK_MM_BENCH_JSONL",
-        "data/ClinSeek-Bench/inputs/mm_bench.jsonl",
-    )
-)
-DEFAULT_OUTPUT_ROOT = Path(
-    os.environ.get(
-        "MEDMOD_ORIGINAL_SUBSET_ROOT",
-        "data/build/ClinSeek-MM-Bench-MedMod-source",
-    )
-)
-DEFAULT_MEDMOD_REPO = Path(os.environ.get("MEDMOD_REPO_ROOT", "external/MedMod"))
-DEFAULT_CXR_JPG_ROOT = Path(
-    os.environ.get("MIMIC_CXR_JPG_ROOT", "external/mimic-cxr-jpg")
-)
-DEFAULT_CXR_META_ROOT = Path(
-    os.environ.get("MIMIC_CXR_META_ROOT", "external/mimic-cxr/2.0.0")
-)
-DEFAULT_MIMICIV_ROOT = Path(os.environ.get("MIMICIV_ROOT", "external/mimiciv/3.1"))
-IMAGE_RE = re.compile(
-    r"(?:^|/)files/p\d+/p(?P<subject_id>\d+)/s(?P<study_id>\d+)/(?P<dicom_id>[^/]+)\.jpg$"
-)
-TASK_MAP = {
-    "medmod_decompensation": "decompensation",
-    "medmod_in_hospital_mortality": "in-hospital-mortality",
-    "medmod_length_of_stay": "length-of-stay",
-    "medmod_phenotyping": "phenotyping",
-    "medmod_radiology": "radiology",
-    "decompensation": "decompensation",
-    "in-hospital-mortality": "in-hospital-mortality",
-    "length-of-stay": "length-of-stay",
-    "phenotyping": "phenotyping",
-    "radiology": "radiology",
-}
-PHENOTYPE_CLASSES = [
-    "Acute and unspecified renal failure",
-    "Acute cerebrovascular disease",
-    "Acute myocardial infarction",
-    "Cardiac dysrhythmias",
-    "Chronic kidney disease",
-    "Chronic obstructive pulmonary disease and bronchiectasis",
-    "Complications of surgical procedures or medical care",
-    "Conduction disorders",
-    "Congestive heart failure; nonhypertensive",
-    "Coronary atherosclerosis and other heart disease",
-    "Diabetes mellitus with complications",
-    "Diabetes mellitus without complication",
-    "Disorders of lipid metabolism",
-    "Essential hypertension",
-    "Fluid and electrolyte disorders",
-    "Gastrointestinal hemorrhage",
-    "Hypertension with complications and secondary hypertension",
-    "Other liver diseases",
-    "Other lower respiratory disease",
-    "Other upper respiratory disease",
-    "Pleurisy; pneumothorax; pulmonary collapse",
-    "Pneumonia (except that caused by tuberculosis or sexually transmitted disease)",
-    "Respiratory failure; insufficiency; arrest (adult)",
-    "Septicemia (except in labor)",
-    "Shock",
-]
-RADIOLOGY_CLASSES = [
-    "Atelectasis",
-    "Cardiomegaly",
-    "Consolidation",
-    "Edema",
-    "Enlarged Cardiomediastinum",
-    "Fracture",
-    "Lung Lesion",
-    "Lung Opacity",
-    "No Finding",
-    "Pleural Effusion",
-    "Pleural Other",
-    "Pneumonia",
-    "Pneumothorax",
-    "Support Devices",
-]
-LEAKY_STAY_COLUMNS = {
-    "outtime",
-    "los",
-    "dischtime",
-    "deathtime",
-    "dod",
-    "mortality_inunit",
-    "mortality",
-    "mortality_inhospital",
-}
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--input", type=Path, default=DEFAULT_INPUT)
-    parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
-    parser.add_argument("--medmod-repo-root", type=Path, default=DEFAULT_MEDMOD_REPO)
-    parser.add_argument("--cxr-jpg-root", type=Path, default=DEFAULT_CXR_JPG_ROOT)
-    parser.add_argument("--cxr-meta-root", type=Path, default=DEFAULT_CXR_META_ROOT)
-    parser.add_argument("--mimiciv-root", type=Path, default=DEFAULT_MIMICIV_ROOT)
-    parser.add_argument("--overwrite", action="store_true")
-    parser.add_argument(
-        "--include-reports",
-        action="store_true",
-        help="Also package CXR report TXT files. Keep disabled for the ClinSeek MedMod release.",
-    )
-    parser.add_argument(
-        "--allow-warnings",
-        action="store_true",
-        help="Deprecated compatibility flag; warnings are non-fatal unless --strict-official-match is set.",
-    )
-    parser.add_argument(
-        "--strict-official-match",
-        action="store_true",
-        help="Exit non-zero if official pairing/label validation warnings are found.",
-    )
-    return parser.parse_args()
-def ensure_dir(path: Path) -> None:
-    path.mkdir(parents=True, exist_ok=True)
-def reset_dir(path: Path, overwrite: bool) -> None:
-    if path.exists():
-        if not overwrite:
-            raise FileExistsError(f"Output root already exists: {path}")
-        shutil.rmtree(path)
-    path.mkdir(parents=True, exist_ok=True)
-def link_or_copy(src: Path, dst: Path) -> None:
-    src = src.resolve()
-    ensure_dir(dst.parent)
-    if dst.exists():
-        return
-    try:
-        os.link(src, dst)
-    except OSError:
-        shutil.copy2(src, dst)
-def copytree_links(src: Path, dst: Path) -> None:
-    if dst.exists():
-        return
-    shutil.copytree(src, dst, copy_function=lambda s, d: (link_or_copy(Path(s), Path(d)) or str(d)))
-def relpath_or_name(path: Path, root: Path) -> str:
-    try:
-        return str(path.resolve().relative_to(root.resolve()))
-    except ValueError:
-        return path.name
-def write_json(path: Path, payload: Any) -> None:
-    ensure_dir(path.parent)
-    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
-    ensure_dir(path.parent)
-    with path.open("w", encoding="utf-8") as handle:
-        for row in rows:
-            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
-def safe_int(value: Any) -> int | None:
-    if value is None or value == "":
-        return None
-    try:
-        if pd.isna(value):
-            return None
-    except TypeError:
-        pass
-    try:
-        return int(float(str(value).strip()))
-    except ValueError:
-        return None
-def safe_float(value: Any) -> float | None:
-    if value is None or value == "":
-        return None
-    try:
-        if pd.isna(value):
-            return None
-    except TypeError:
-        pass
-    try:
-        return float(str(value).strip())
-    except ValueError:
-        return None
-def normalize_split(split: str) -> str:
-    return "valid" if split in {"val", "validate", "validation"} else split
-def medmod_listfile_name(split: str, *, mml_ssl: bool) -> str:
-    split = normalize_split(split)
-    if split == "valid":
-        return "validate_listfile.csv" if mml_ssl else "val_listfile.csv"
-    return f"{split}_listfile.csv"
-def canonical_task(task: str) -> str:
-    if task not in TASK_MAP:
-        raise ValueError(f"Unsupported MedMod task: {task}")
-    return TASK_MAP[task]
-def ground_truth_names(row: dict[str, Any]) -> list[str]:
-    values = row.get("ground_truth")
-    if values is None:
-        values = row.get("label")
-    if isinstance(values, list):
-        names = []
-        for item in values:
-            if isinstance(item, dict) and item.get("name") is not None:
-                names.append(str(item["name"]))
-            elif item is not None:
-                names.append(str(item))
-        return names
-    if values is None:
-        return []
-    return [str(values)]
-def parse_image_ref(path: str) -> dict[str, Any]:
-    stripped = path
-    if "/" in stripped and stripped.split("/", 1)[0].endswith("OriginalLinked_v1"):
-        stripped = stripped.split("/", 1)[1]
-    match = IMAGE_RE.search(stripped)
-    if not match:
-        raise ValueError(f"Cannot parse CXR image path: {path}")
-    subject_id = int(match.group("subject_id"))
-    study_id = int(match.group("study_id"))
-    dicom_id = match.group("dicom_id")
-    nested_relpath = (
-        f"mimic-cxr/2.0.0/files/p{str(subject_id)[:2]}/p{subject_id}/"
-        f"s{study_id}/{dicom_id}.jpg"
-    )
-    return {
-        "subject_id": subject_id,
-        "study_id": study_id,
-        "dicom_id": dicom_id,
-        "nested_relpath": nested_relpath,
-    }
-def parse_stay_period_from_qid(qid: str, task: str) -> tuple[int | None, float | None]:
-    if task == "radiology":
-        return None, None
-    try:
-        _, stay_text, period_text = qid.rsplit("_", 2)
-    except ValueError:
-        return None, None
-    return safe_int(stay_text), safe_float(period_text)
-def load_medmod_rows(input_path: Path) -> list[dict[str, Any]]:
-    rows: list[dict[str, Any]] = []
-    with input_path.open("r", encoding="utf-8") as handle:
-        for line_index, line in enumerate(handle):
-            row = json.loads(line)
-            if row.get("source_benchmark") != "medmod":
-                continue
-            task = canonical_task(str(row.get("task")))
-            stay_from_qid, period_from_qid = parse_stay_period_from_qid(str(row.get("qid")), task)
-            image_refs = [parse_image_ref(path) for path in row.get("image_paths") or []]
-            row["_source_line_index"] = line_index
-            row["_canonical_task"] = task
-            row["_stay_id_from_qid"] = stay_from_qid
-            row["_period_length_from_qid"] = period_from_qid
-            row["_image_refs"] = image_refs
-            rows.append(row)
-    return rows
-def row_key(row: dict[str, Any], task: str) -> tuple[int, float | None]:
-    stay_id = safe_int(row.get("stay_id"))
-    if stay_id is None:
-        raise ValueError(f"Listfile row missing stay_id: {row}")
-    if task in {"decompensation", "length-of-stay", "phenotyping"}:
-        period = safe_float(row.get("period_length"))
-        return stay_id, period
-    return stay_id, None
-def sample_key(sample: dict[str, Any]) -> tuple[int, float | None]:
-    task = sample["_canonical_task"]
-    stay_id = safe_int(sample.get("stay_id")) or sample.get("_stay_id_from_qid")
-    if stay_id is None:
-        raise ValueError(f"Sample missing stay_id: {sample.get('qid')}")
-    if task in {"decompensation", "length-of-stay", "phenotyping"}:
-        return int(stay_id), safe_float(sample.get("_period_length_from_qid"))
-    return int(stay_id), None
-def load_filtered_csv_index(
-    path: Path,
-    *,
-    task: str,
-    needed_keys: set[tuple[int, float | None]],
-) -> tuple[dict[tuple[int, float | None], dict[str, Any]], list[str]]:
-    if not path.exists():
-        return {}, []
-    rows: dict[tuple[int, float | None], dict[str, Any]] = {}
-    columns: list[str] = []
-    for chunk in pd.read_csv(path, chunksize=200_000):
-        if not columns:
-            columns = list(chunk.columns)
-        for record in chunk.to_dict(orient="records"):
-            key = row_key(record, task)
-            if key in needed_keys and key not in rows:
-                rows[key] = record
-        if len(rows) == len(needed_keys):
-            break
-    return rows, columns
-def load_listfile_index(
-    repo_root: Path,
-    task: str,
-    split: str,
-    needed_keys: set[tuple[int, float | None]],
-) -> dict[str, Any]:
-    split_name = normalize_split(split)
-    mml_path = repo_root / "mml-ssl-full" / task / medmod_listfile_name(split_name, mml_ssl=True)
-    data_path = repo_root / "data_full" / task / medmod_listfile_name(split_name, mml_ssl=False)
-    if not mml_path.exists():
-        raise FileNotFoundError(f"Missing official MedMod mml-ssl listfile: {mml_path}")
-    mml_by_key, mml_columns = load_filtered_csv_index(
-        mml_path,
-        task=task,
-        needed_keys=needed_keys,
-    )
-    data_by_key, data_columns = load_filtered_csv_index(
-        data_path,
-        task=task,
-        needed_keys=needed_keys,
-    )
-    return {
-        "mml_path": mml_path,
-        "data_path": data_path if data_path.exists() else None,
-        "mml_by_key": mml_by_key,
-        "data_by_key": data_by_key,
-        "mml_columns": mml_columns,
-        "data_columns": data_columns,
-    }
-def expected_label_from_listfile(task: str, record: dict[str, Any]) -> list[str]:
-    if task in {"decompensation", "in-hospital-mortality"}:
-        return ["yes" if safe_int(record.get("y_true")) == 1 else "no"]
-    if task == "phenotyping":
-        return [label for label in PHENOTYPE_CLASSES if safe_int(record.get(label)) == 1]
-    if task == "length-of-stay":
-        value = safe_float(record.get("y_true"))
-        return [] if value is None else [str(value)]
-    raise ValueError(f"No listfile label parser for task: {task}")
-def find_subject_dir(repo_root: Path, subject_id: int) -> tuple[Path, str]:
-    for split in ("test", "train"):
-        path = repo_root / "data_full" / "root" / split / str(subject_id)
-        if path.is_dir():
-            return path, split
-    raise FileNotFoundError(f"Missing MedMod subject directory for subject_id={subject_id}")
-def local_episode_filename(subject_id: int, official_stay: str | None) -> str | None:
-    if not official_stay:
-        return None
-    prefix = f"{subject_id}_"
-    if official_stay.startswith(prefix):
-        return official_stay[len(prefix) :]
-    return official_stay
-def task_data_split_dir(split: str) -> str:
-    split = normalize_split(split)
-    if split == "valid":
-        return "train"
-    return split
-def find_cxr_file(cxr_jpg_root: Path, image_ref: dict[str, Any], suffix: str) -> Path | None:
-    subject_id = image_ref["subject_id"]
-    study_id = image_ref["study_id"]
-    dicom_id = image_ref["dicom_id"]
-    flat_name = f"p{str(subject_id)[:2]}_p{subject_id}_s{study_id}_{dicom_id}.{suffix}"
-    nested = Path(image_ref["nested_relpath"]).with_suffix(f".{suffix}")
-    candidates = [
-        cxr_jpg_root / "mimic-cxr2" / flat_name,
-        cxr_jpg_root / nested.relative_to("mimic-cxr/2.0.0"),
-        cxr_jpg_root / "2.1.0-lite" / nested.relative_to("mimic-cxr/2.0.0"),
-        cxr_jpg_root / "2.1.0-working-subset" / nested.relative_to("mimic-cxr/2.0.0"),
-        cxr_jpg_root / nested,
-    ]
-    for candidate in candidates:
-        if candidate.exists():
-            return candidate
-    return None
-def read_csv_subset(path: Path, column: str, values: set[Any]) -> pd.DataFrame:
-    if not path.exists():
-        return pd.DataFrame()
-    df = pd.read_csv(path)
-    if column not in df.columns:
-        return df.iloc[0:0].copy()
-    return df[df[column].isin(values)].copy()
-def build_metadata_indexes(cxr_meta_root: Path) -> dict[str, Any]:
-    metadata_path = cxr_meta_root / "mimic-cxr-2.0.0-metadata.csv"
-    chexpert_path = cxr_meta_root / "mimic-cxr-2.0.0-chexpert.csv"
-    if not metadata_path.exists():
-        raise FileNotFoundError(f"Missing MIMIC-CXR metadata: {metadata_path}")
-    if not chexpert_path.exists():
-        raise FileNotFoundError(f"Missing MIMIC-CXR CheXpert labels: {chexpert_path}")
-    metadata_df = pd.read_csv(metadata_path)
-    chexpert_df = pd.read_csv(chexpert_path)
-    chexpert_df[RADIOLOGY_CLASSES] = chexpert_df[RADIOLOGY_CLASSES].fillna(0)
-    chexpert_df = chexpert_df.replace(-1.0, 0.0)
-    metadata_by_dicom = {
-        str(record["dicom_id"]): record for record in metadata_df.to_dict(orient="records")
-    }
-    ap_rows_by_subject: dict[int, list[dict[str, Any]]] = defaultdict(list)
-    for record in metadata_df.to_dict(orient="records"):
-        if str(record.get("ViewPosition") or "").upper() != "AP":
-            continue
-        subject_id = safe_int(record.get("subject_id"))
-        study_id = safe_int(record.get("study_id"))
-        if subject_id is None or study_id is None:
-            continue
-        study_datetime = parse_cxr_datetime(record)
-        if study_datetime is None:
-            continue
-        ap_rows_by_subject[subject_id].append(
-            {
-                "subject_id": subject_id,
-                "study_id": study_id,
-                "dicom_id": str(record.get("dicom_id") or ""),
-                "study_datetime": study_datetime,
-                "view_position": "AP",
-            }
-        )
-    for rows in ap_rows_by_subject.values():
-        rows.sort(key=lambda item: item["study_datetime"])
-    chexpert_by_study: dict[int, list[str]] = {}
-    for record in chexpert_df.to_dict(orient="records"):
-        study_id = safe_int(record.get("study_id"))
-        if study_id is None:
-            continue
-        chexpert_by_study[study_id] = [
-            label for label in RADIOLOGY_CLASSES if safe_float(record.get(label)) == 1.0
-        ]
-    return {
-        "metadata_path": metadata_path,
-        "chexpert_path": chexpert_path,
-        "metadata_df": metadata_df,
-        "chexpert_df": chexpert_df,
-        "metadata_by_dicom": metadata_by_dicom,
-        "ap_rows_by_subject": ap_rows_by_subject,
-        "chexpert_by_study": chexpert_by_study,
-    }
-def parse_cxr_datetime(record: dict[str, Any]) -> pd.Timestamp | None:
-    date = record.get("StudyDate")
-    time = record.get("StudyTime")
-    if date in (None, "") or time in (None, ""):
-        return None
-    try:
-        time_text = f"{int(float(time)):06d}"
-        return pd.Timestamp(datetime.strptime(f"{int(float(date))} {time_text}", "%Y%m%d %H%M%S"))
-    except (TypeError, ValueError):
-        return None
-def parse_timestamp(value: Any) -> pd.Timestamp | None:
-    if value in (None, ""):
-        return None
-    try:
-        parsed = pd.Timestamp(value)
-    except (TypeError, ValueError):
-        return None
-    if pd.isna(parsed):
-        return None
-    return parsed
-def validate_latest_ap_pairing(
-    sample: dict[str, Any],
-    official_row: dict[str, Any] | None,
-    cxr_indexes: dict[str, Any],
-) -> list[str]:
-    if official_row is None:
-        return []
-    task = sample["_canonical_task"]
-    if task == "radiology":
-        return []
-    subject_id = safe_int(sample.get("subject_id"))
-    selected_study_ids = {ref["study_id"] for ref in sample["_image_refs"]}
-    intime = parse_timestamp(official_row.get("intime"))
-    prediction_time = parse_timestamp(sample.get("prediction_time") or official_row.get("prediction_time"))
-    if subject_id is None or intime is None or prediction_time is None or not selected_study_ids:
-        return ["pairing_window_unverifiable"]
-    in_window = [
-        row
-        for row in cxr_indexes["ap_rows_by_subject"].get(subject_id, [])
-        if row["study_datetime"] >= intime and row["study_datetime"] <= prediction_time
-    ]
-    if not in_window:
-        return ["official_pairing_no_ap_in_window"]
-    latest_time = max(row["study_datetime"] for row in in_window)
-    latest_studies = {row["study_id"] for row in in_window if row["study_datetime"] == latest_time}
-    if selected_study_ids.isdisjoint(latest_studies):
-        return [
-            "official_pairing_latest_ap_mismatch "
-            f"expected_study_ids={sorted(latest_studies)} got={sorted(selected_study_ids)}"
-        ]
-    return []
-def same_label_set(left: list[str], right: list[str]) -> bool:
-    return set(left) == set(right)
-def validate_sample(
-    sample: dict[str, Any],
-    *,
-    list_indexes: dict[tuple[str, str], dict[str, Any]],
-    cxr_indexes: dict[str, Any],
-) -> tuple[dict[str, Any], list[str], dict[str, Any] | None, dict[str, Any] | None]:
-    task = sample["_canonical_task"]
-    split = normalize_split(str(sample.get("source_split") or "test"))
-    gt = ground_truth_names(sample)
-    warnings: list[str] = []
-    official_row = None
-    official_source_row = None
-    if task == "radiology":
-        study_ids = [ref["study_id"] for ref in sample["_image_refs"]]
-        expected = sorted({label for study_id in study_ids for label in cxr_indexes["chexpert_by_study"].get(study_id, [])})
-        if not same_label_set(gt, expected):
-            warnings.append(f"radiology_label_mismatch expected={expected} got={gt}")
-    else:
-        index = list_indexes[(task, split)]
-        key = sample_key(sample)
-        official_row = index["mml_by_key"].get(key)
-        official_source_row = index["data_by_key"].get(key)
-        if official_row is None:
-            warnings.append(f"missing_official_listfile_row key={key}")
-        else:
-            expected = expected_label_from_listfile(task, official_row)
-            if not same_label_set(gt, expected):
-                warnings.append(f"listfile_label_mismatch expected={expected} got={gt}")
-            for field in ("subject_id", "hadm_id", "prediction_time"):
-                if field in official_row and sample.get(field) is not None:
-                    if str(official_row.get(field)) != str(sample.get(field)):
-                        warnings.append(
-                            f"{field}_mismatch official={official_row.get(field)} got={sample.get(field)}"
-                        )
-            warnings.extend(validate_latest_ap_pairing(sample, official_row, cxr_indexes))
-    for image_ref in sample["_image_refs"]:
-        metadata = cxr_indexes["metadata_by_dicom"].get(image_ref["dicom_id"])
-        if metadata is None:
-            warnings.append(f"missing_cxr_metadata dicom_id={image_ref['dicom_id']}")
-            continue
-        if safe_int(metadata.get("study_id")) != image_ref["study_id"]:
-            warnings.append(f"cxr_metadata_study_mismatch dicom_id={image_ref['dicom_id']}")
-        if str(metadata.get("ViewPosition") or "").upper() != "AP":
-            warnings.append(f"cxr_not_ap dicom_id={image_ref['dicom_id']}")
-    validation = {
-        "official_match_ok": not warnings,
-        "warnings": warnings,
-    }
-    return validation, warnings, official_row, official_source_row
-def write_subset_csvs(
-    *,
-    output_root: Path,
-    medmod_repo_root: Path,
-    rows_by_task_split: dict[tuple[str, str], list[dict[str, Any]]],
-    list_indexes: dict[tuple[str, str], dict[str, Any]],
-) -> None:
-    for (task, split), rows in sorted(rows_by_task_split.items()):
-        if task == "radiology":
-            continue
-        index = list_indexes[(task, split)]
-        mml_rows = [row["official_listfile_row"] for row in rows if row.get("official_listfile_row")]
-        data_rows = [row["official_data_full_row"] for row in rows if row.get("official_data_full_row")]
-        mml_out = (
-            output_root
-            / "source_release"
-            / "mml-ssl-full"
-            / task
-            / medmod_listfile_name(split, mml_ssl=True)
-        )
-        ensure_dir(mml_out.parent)
-        pd.DataFrame(mml_rows, columns=index["mml_columns"]).to_csv(mml_out, index=False)
-        if data_rows:
-            data_out = (
-                output_root
-                / "source_release"
-                / "data_full"
-                / task
-                / medmod_listfile_name(split, mml_ssl=False)
-            )
-            ensure_dir(data_out.parent)
-            pd.DataFrame(data_rows, columns=index["data_columns"]).to_csv(data_out, index=False)
-    for name in ("README.md", "LICENSE"):
-        src = medmod_repo_root / name
-        if src.exists():
-            link_or_copy(src, output_root / "source_release" / "repo_docs" / name)
-def write_root_table_subsets(output_root: Path, repo_root: Path, subject_ids: set[int], stay_ids: set[int]) -> None:
-    root_out = output_root / "source_release" / "root_tables"
-    ensure_dir(root_out)
-    for table_name in ("all_stays.csv", "all_diagnoses.csv", "diagnosis_counts.csv", "phenotype_labels.csv"):
-        src = repo_root / "data_full" / "root" / table_name
-        if not src.exists():
-            continue
-        df = pd.read_csv(src)
-        if "subject_id" in df.columns:
-            df = df[df["subject_id"].isin(subject_ids)].copy()
-        if "stay_id" in df.columns and stay_ids:
-            stay_filtered = df[df["stay_id"].isin(stay_ids)].copy()
-            if not stay_filtered.empty:
-                df = stay_filtered
-        df.to_csv(root_out / table_name, index=False)
-def write_cxr_metadata_subsets(output_root: Path, cxr_meta_root: Path, cxr_indexes: dict[str, Any], image_refs: list[dict[str, Any]]) -> None:
-    meta_out = output_root / "source_release" / "cxr_metadata"
-    ensure_dir(meta_out)
-    dicom_ids = {ref["dicom_id"] for ref in image_refs}
-    study_ids = {ref["study_id"] for ref in image_refs}
-    cxr_indexes["metadata_df"][cxr_indexes["metadata_df"]["dicom_id"].isin(dicom_ids)].to_csv(
-        meta_out / "mimic-cxr-2.0.0-metadata.csv", index=False
-    )
-    cxr_indexes["chexpert_df"][cxr_indexes["chexpert_df"]["study_id"].isin(study_ids)].to_csv(
-        meta_out / "mimic-cxr-2.0.0-chexpert.csv", index=False
-    )
-    optional_specs = [
-        ("mimic-cxr-2.0.0-split.csv", "dicom_id", dicom_ids),
-        ("mimic-cxr-ehr-split.csv", "dicom_id", dicom_ids),
-    ]
-    for filename, column, values in optional_specs:
-        subset = read_csv_subset(cxr_meta_root / filename, column, values)
-        if not subset.empty:
-            subset.to_csv(meta_out / filename, index=False)
-def main() -> None:
-    args = parse_args()
-    reset_dir(args.output_root, args.overwrite)
-    rows = load_medmod_rows(args.input)
-    if not rows:
-        raise ValueError(f"No MedMod rows found in {args.input}")
-    needed_keys_by_index: dict[tuple[str, str], set[tuple[int, float | None]]] = defaultdict(set)
-    for row in rows:
-        task = row["_canonical_task"]
-        if task == "radiology":
-            continue
-        split = normalize_split(str(row.get("source_split") or "test"))
-        needed_keys_by_index[(task, split)].add(sample_key(row))
-    list_indexes = {
-        key: load_listfile_index(
-            args.medmod_repo_root,
-            key[0],
-            key[1],
-            needed_keys=needed_keys,
-        )
-        for key, needed_keys in sorted(needed_keys_by_index.items())
-    }
-    cxr_indexes = build_metadata_indexes(args.cxr_meta_root)
-    manifest_rows: list[dict[str, Any]] = []
-    rows_by_task_split: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list)
-    subject_ids: set[int] = set()
-    stay_ids: set[int] = set()
-    all_image_refs: list[dict[str, Any]] = []
-    stats = Counter()
-    warning_rows: list[dict[str, Any]] = []
-    for row in rows:
-        task = row["_canonical_task"]
-        split = normalize_split(str(row.get("source_split") or "test"))
-        validation, warnings, official_row, official_source_row = validate_sample(
-            row,
-            list_indexes=list_indexes,
-            cxr_indexes=cxr_indexes,
-        )
-        if warnings:
-            stats["rows_with_warnings"] += 1
-            warning_rows.append({"qid": row.get("qid"), "warnings": warnings})
-        subject_id = safe_int(row.get("subject_id"))
-        stay_id = safe_int(row.get("stay_id"))
-        if subject_id is None:
-            raise ValueError(f"Sample missing subject_id: {row.get('qid')}")
-        subject_ids.add(subject_id)
-        if stay_id is not None:
-            stay_ids.add(stay_id)
-        subject_dir, subject_partition = find_subject_dir(args.medmod_repo_root, subject_id)
-        subject_rel = f"source_release/data_full/root/{subject_partition}/{subject_id}"
-        copytree_links(subject_dir, args.output_root / subject_rel)
-        official_stay = None
-        if official_row is not None:
-            official_stay = official_row.get("stay")
-        if official_stay is None and official_source_row is not None:
-            official_stay = official_source_row.get("stay")
-        official_stay = str(official_stay) if official_stay not in (None, "") else None
-        official_period = None
-        if official_row is not None:
-            official_period = official_row.get("period_length")
-        if official_period is None and official_source_row is not None:
-            official_period = official_source_row.get("period_length")
-        local_stay = local_episode_filename(subject_id, official_stay)
-        ehr_timeseries_relpath = f"{subject_rel}/{local_stay}" if local_stay else None
-        ehr_episode_relpath = None
-        if local_stay and local_stay.endswith("_timeseries.csv"):
-            candidate_episode = f"{subject_rel}/{local_stay.replace('_timeseries.csv', '.csv')}"
-            if (args.output_root / candidate_episode).exists():
-                ehr_episode_relpath = candidate_episode
-        ehr_task_timeseries_relpath = None
-        if official_stay and task != "radiology":
-            split_dir = task_data_split_dir(split)
-            task_src = args.medmod_repo_root / "data_full" / task / split_dir / official_stay
-            if task_src.exists():
-                ehr_task_timeseries_relpath = (
-                    f"source_release/data_full/{task}/{split_dir}/{official_stay}"
-                )
-                link_or_copy(task_src, args.output_root / ehr_task_timeseries_relpath)
-        packaged_images: list[str] = []
-        packaged_reports: list[str] = []
-        raw_images: list[str] = []
-        raw_reports: list[str] = []
-        for image_ref in row["_image_refs"]:
-            all_image_refs.append(image_ref)
-            jpg_src = find_cxr_file(args.cxr_jpg_root, image_ref, "jpg")
-            if jpg_src is None:
-                raise FileNotFoundError(f"Missing CXR JPG for {row.get('qid')}: {image_ref}")
-            jpg_rel = image_ref["nested_relpath"]
-            link_or_copy(jpg_src, args.output_root / jpg_rel)
-            packaged_images.append(jpg_rel)
-            raw_images.append(relpath_or_name(jpg_src, args.cxr_jpg_root))
-            txt_src = find_cxr_file(args.cxr_jpg_root, image_ref, "txt") if args.include_reports else None
-            if txt_src is not None:
-                txt_rel = str(Path(jpg_rel).with_suffix(".txt"))
-                link_or_copy(txt_src, args.output_root / txt_rel)
-                packaged_reports.append(txt_rel)
-                raw_reports.append(relpath_or_name(txt_src, args.cxr_jpg_root))
-        sidecar = {
-            "qid": row.get("qid"),
-            "source_line_index": row.get("_source_line_index"),
-            "source_index": row.get("source_index"),
-            "task": task,
-            "source_task": row.get("task"),
-            "source_split": split,
-            "subject_id": row.get("subject_id"),
-            "hadm_id": row.get("hadm_id"),
-            "stay_id": row.get("stay_id"),
-            "prediction_time": row.get("prediction_time"),
-            "question": row.get("question"),
-            "released_input_text": row.get("input_text"),
-            "ground_truth": row.get("ground_truth"),
-            "answer_type": row.get("answer_type"),
-            "modalities": row.get("modalities") or ["ehr", "cxr"],
-            "study_ids": [ref["study_id"] for ref in row["_image_refs"]],
-            "dicom_ids": [ref["dicom_id"] for ref in row["_image_refs"]],
-            "packaged_image_relpaths": packaged_images,
-            "packaged_report_relpaths": packaged_reports,
-            "raw_image_source_relpaths": raw_images,
-            "raw_report_source_relpaths": raw_reports,
-            "ehr_subject_relpaths": [subject_rel],
-            "official_stay": official_stay,
-            "official_period_length": official_period,
-            "ehr_timeseries_relpath": ehr_timeseries_relpath,
-            "ehr_episode_relpath": ehr_episode_relpath,
-            "ehr_task_timeseries_relpath": ehr_task_timeseries_relpath,
-            "official_listfile_row": official_row,
-            "official_data_full_row": official_source_row,
-            "official_validation": validation,
-            "raw_join_key": {
-                "stay_id": row.get("stay_id"),
-                "period_length_hours": row.get("_period_length_from_qid"),
-            },
-        }
-        manifest_rows.append(sidecar)
-        rows_by_task_split[(task, split)].append(sidecar)
-        stats[f"task:{task}"] += 1
-        stats[f"split:{split}"] += 1
-    write_subset_csvs(
-        output_root=args.output_root,
-        medmod_repo_root=args.medmod_repo_root,
-        rows_by_task_split=rows_by_task_split,
-        list_indexes=list_indexes,
-    )
-    write_root_table_subsets(args.output_root, args.medmod_repo_root, subject_ids, stay_ids)
-    write_cxr_metadata_subsets(args.output_root, args.cxr_meta_root, cxr_indexes, all_image_refs)
-    write_jsonl(args.output_root / "linked_manifests" / "all.jsonl", manifest_rows)
-    for (task, split), task_rows in sorted(rows_by_task_split.items()):
-        write_jsonl(args.output_root / "linked_manifests" / task / f"{split}.jsonl", task_rows)
-    readme = f"""# ClinSeek-MM-Bench-MedMod-source
-This package is the source-aligned MedMod subset used by ClinSeek MM-Bench.
-It contains only the MedMod rows present in `$CLINSEEK_MM_BENCH_JSONL`.
-The layout preserves the official MedMod task/listfile style where possible:
-- `source_release/mml-ssl-full/<task>/*_listfile.csv`: subset of official MedMod rows.
-- `source_release/data_full/<task>/*_listfile.csv`: subset of original task listfiles when available.
-- `source_release/data_full/root/<split>/<subject_id>/`: official extracted MedMod EHR folders.
-- `source_release/root_tables/`: filtered MedMod root tables kept only for provenance.
-  Some files in this directory contain labels and must not be mounted as runtime
-  EHR tables for agent inference.
-- `source_release/cxr_metadata/`: subset MIMIC-CXR metadata and CheXpert labels.
-- `mimic-cxr/2.0.0/files/...`: packaged JPG files. TXT reports are only included
-  when `--include-reports` is explicitly set.
-- `linked_manifests/`: row-level sidecar manifests with questions, gold labels, and relative paths.
-Important: each manifest row records `official_stay`, `ehr_timeseries_relpath`,
-and `ehr_episode_relpath` so downstream rendering can use the exact MedMod
-episode from the official listfile instead of all episodes for the same subject.
-Input root contract:
-- ClinSeek multimodal input: `$CLINSEEK_MM_BENCH_JSONL`
-- MedMod repository: `$MEDMOD_REPO_ROOT`
-- Raw MIMIC-CXR JPG root: `$MIMIC_CXR_JPG_ROOT`
-- Raw MIMIC-CXR metadata root: `$MIMIC_CXR_META_ROOT`
-- Raw MIMIC-IV latest local release kept for provenance: `$MIMICIV_ROOT`
-"""
-    (args.output_root / "README.md").write_text(readme, encoding="utf-8")
-    metadata = {
-        "package_name": "ClinSeek-MM-Bench-MedMod-source",
-        "input": "CLINSEEK_MM_BENCH_JSONL",
-        "records": len(manifest_rows),
-        "subjects": len(subject_ids),
-        "unique_images": len({p for row in manifest_rows for p in row["packaged_image_relpaths"]}),
-        "unique_reports": len({p for row in manifest_rows for p in row["packaged_report_relpaths"]}),
-        "reports_included": bool(args.include_reports),
-        "stats": dict(sorted(stats.items())),
-        "warning_rows": warning_rows,
-        "source_path_env_vars": {
-            "medmod_repo_root": "MEDMOD_REPO_ROOT",
-            "cxr_jpg_root": "MIMIC_CXR_JPG_ROOT",
-            "cxr_meta_root": "MIMIC_CXR_META_ROOT",
-            "mimiciv_root": "MIMICIV_ROOT",
-        },
-        "path_contract": {
-            "manifest_paths": "relative_to_package_root",
-            "packaged_image_relpaths": "relative_to_package_root",
-            "packaged_report_relpaths": "relative_to_package_root",
-            "ehr_subject_relpaths": "relative_to_package_root",
-            "raw_image_source_relpaths": "relative_to_MIMIC_CXR_JPG_ROOT",
-            "raw_report_source_relpaths": "relative_to_MIMIC_CXR_JPG_ROOT",
-        },
-    }
-    write_json(args.output_root / "metadata.json", metadata)
-    if warning_rows and args.strict_official_match and not args.allow_warnings:
-        raise SystemExit(
-            f"Built package but found {len(warning_rows)} validation warning rows. "
-            "Inspect metadata.json or rerun without --strict-official-match."
-        )
-    print(json.dumps(metadata, ensure_ascii=False, indent=2))
-if __name__ == "__main__":
-    main()

rebuild/mm_bench/combine_clinseek_mm_bench.py DELETED Viewed

@@ -1,169 +0,0 @@
-#!/usr/bin/env python3
-"""Combine EHRXQA and MedMod subsets into the ClinSeek-MM-Bench package."""
-from __future__ import annotations
-import argparse
-import json
-import os
-import shutil
-from pathlib import Path
-from typing import Any
-REPO_ROOT = Path(__file__).resolve().parents[2]
-DEFAULT_REFERENCE_INPUT = Path(
-    os.environ.get(
-        "CLINSEEK_MM_BENCH_JSONL",
-        str(REPO_ROOT / "inputs" / "mm_bench.jsonl"),
-    )
-)
-DEFAULT_EHRXQA_SUBSET_ROOT = Path(
-    os.environ.get("CLINSEEK_EHRXQA_MM_ROOT", "data/build/ClinSeek-MM-Bench-EHRXQA")
-)
-DEFAULT_MEDMOD_SUBSET_ROOT = Path(
-    os.environ.get("CLINSEEK_MEDMOD_MM_ROOT", "data/build/ClinSeek-MM-Bench-MedMod")
-)
-DEFAULT_OUTPUT_ROOT = Path(
-    os.environ.get("CLINSEEK_MM_RELEASE_ROOT", "data/build/ClinSeek-MM-Bench")
-)
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--reference-input", type=Path, default=DEFAULT_REFERENCE_INPUT)
-    parser.add_argument("--ehrxqa-root", type=Path, default=DEFAULT_EHRXQA_SUBSET_ROOT)
-    parser.add_argument("--medmod-root", type=Path, default=DEFAULT_MEDMOD_SUBSET_ROOT)
-    parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
-    parser.add_argument("--overwrite", action="store_true")
-    return parser.parse_args()
-def ensure_dir(path: Path) -> None:
-    path.mkdir(parents=True, exist_ok=True)
-def reset_dir(path: Path, overwrite: bool) -> None:
-    if path.exists():
-        if not overwrite:
-            raise FileExistsError(f"Output root already exists: {path}")
-        shutil.rmtree(path)
-    path.mkdir(parents=True, exist_ok=True)
-def link_or_copy(src: Path, dst: Path) -> None:
-    src = src.resolve()
-    ensure_dir(dst.parent)
-    if dst.exists():
-        return
-    try:
-        os.link(src, dst)
-    except OSError:
-        shutil.copy2(src, dst)
-def copytree_links(src: Path, dst: Path) -> None:
-    if not src.exists():
-        raise FileNotFoundError(f"Missing source directory: {src}")
-    if dst.exists():
-        return
-    shutil.copytree(src, dst, copy_function=lambda s, d: (link_or_copy(Path(s), Path(d)) or str(d)))
-def drop_runtime_sidecars(output_root: Path) -> None:
-    """Keep final data/mm_bench file layout aligned with the HF release tree."""
-    for relpath in (
-        "data/mm_bench/ehrxqa/database/reference_table.db",
-        "data/mm_bench/ehrxqa/metadata.json",
-        "data/mm_bench/medmod/metadata.json",
-    ):
-        path = output_root / relpath
-        if path.exists():
-            path.unlink()
-def read_jsonl(path: Path) -> list[dict[str, Any]]:
-    rows: list[dict[str, Any]] = []
-    with path.open("r", encoding="utf-8") as handle:
-        for line in handle:
-            if line.strip():
-                rows.append(json.loads(line))
-    return rows
-def write_json(path: Path, payload: Any) -> None:
-    ensure_dir(path.parent)
-    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
-    ensure_dir(path.parent)
-    with path.open("w", encoding="utf-8") as handle:
-        for row in rows:
-            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
-def load_subset_rows(root: Path, filename: str) -> dict[str, dict[str, Any]]:
-    path = root / "inputs" / filename
-    rows = read_jsonl(path)
-    return {str(row["qid"]): row for row in rows}
-def main() -> None:
-    args = parse_args()
-    reset_dir(args.output_root, args.overwrite)
-    reference_rows = read_jsonl(args.reference_input)
-    ehrxqa_by_qid = load_subset_rows(args.ehrxqa_root, "mm_bench_ehrxqa.jsonl")
-    medmod_by_qid = load_subset_rows(args.medmod_root, "mm_bench_medmod.jsonl")
-    by_qid = {**ehrxqa_by_qid, **medmod_by_qid}
-    missing = [row["qid"] for row in reference_rows if row.get("qid") not in by_qid]
-    extra = sorted(set(by_qid) - {row.get("qid") for row in reference_rows})
-    if missing or extra:
-        raise ValueError({"missing": missing[:20], "extra": extra[:20]})
-    output_rows = [by_qid[str(row["qid"])] for row in reference_rows]
-    write_jsonl(args.output_root / "inputs" / "mm_bench.jsonl", output_rows)
-    copytree_links(
-        args.ehrxqa_root / "data" / "mm_bench" / "ehrxqa",
-        args.output_root / "data" / "mm_bench" / "ehrxqa",
-    )
-    copytree_links(
-        args.medmod_root / "data" / "mm_bench" / "medmod",
-        args.output_root / "data" / "mm_bench" / "medmod",
-    )
-    drop_runtime_sidecars(args.output_root)
-    metadata = {
-        "package_name": "ClinSeek-MM-Bench",
-        "reference_input": "CLINSEEK_MM_BENCH_JSONL",
-        "ehrxqa_root": "CLINSEEK_EHRXQA_MM_ROOT",
-        "medmod_root": "CLINSEEK_MEDMOD_MM_ROOT",
-        "records": len(output_rows),
-        "source_counts": {
-            "ehrxqa": len(ehrxqa_by_qid),
-            "medmod": len(medmod_by_qid),
-        },
-        "input_file": "inputs/mm_bench.jsonl",
-        "bench_root": "data/mm_bench",
-    }
-    write_json(args.output_root / "metadata.json", metadata)
-    readme = """# ClinSeek-MM-Bench
-This package combines the EHRXQA-derived and MedMod-derived subsets into the
-final ClinSeek multimodal benchmark layout.
-Use:
-- `inputs/mm_bench.jsonl`
-- `data/mm_bench`
-"""
-    (args.output_root / "README.md").write_text(readme, encoding="utf-8")
-    print(json.dumps(metadata, ensure_ascii=False, indent=2))
-if __name__ == "__main__":
-    main()

rebuild/mm_bench/validate_multimodal_release.py DELETED Viewed

@@ -1,207 +0,0 @@
-#!/usr/bin/env python3
-"""Validate the released ClinSeek multimodal benchmark manifest or package.
-The validator checks the ClinSeek-MM-Bench release tree:
-- every row in inputs/mm_bench.jsonl has an expected source/task distribution;
-- in package mode, every referenced patient database exists;
-- in package mode, every referenced image/report path resolves under data/mm_bench/<source>/;
-- in manifest-only mode, protected MIMIC-derived assets are not required;
-- optional git-tree mode can validate a Hugging Face repository checkout without
-  downloading all LFS file contents.
-"""
-from __future__ import annotations
-import argparse
-import json
-import subprocess
-import sys
-from collections import Counter, defaultdict
-from pathlib import Path
-from typing import Any
-EXPECTED_SOURCE_COUNTS = {"ehrxqa": 497, "medmod": 492}
-EXPECTED_TASK_COUNTS = {
-    "ehrxqa_image": 497,
-    "medmod_decompensation": 125,
-    "medmod_in_hospital_mortality": 125,
-    "medmod_phenotyping": 120,
-    "medmod_radiology": 122,
-}
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        "--bench-root",
-        type=Path,
-        default=Path("data/ClinSeek-Bench"),
-        help="Root of the ClinSeek-Bench repository or downloaded package.",
-    )
-    parser.add_argument(
-        "--input",
-        type=Path,
-        default=None,
-        help="Optional explicit mm_bench.jsonl path. Defaults to <bench-root>/inputs/mm_bench.jsonl.",
-    )
-    parser.add_argument(
-        "--use-git-tree",
-        action="store_true",
-        help="Validate file presence against git ls-tree instead of local filesystem contents.",
-    )
-    parser.add_argument(
-        "--manifest-only",
-        action="store_true",
-        help="Validate only inputs/mm_bench.jsonl counts/schema and referenced path strings. Do not require DB/JPG/report files.",
-    )
-    parser.add_argument(
-        "--allow-unexpected-counts",
-        action="store_true",
-        help="Do not fail if source/task counts differ from the frozen release counts.",
-    )
-    return parser.parse_args()
-def read_jsonl(path: Path) -> list[dict[str, Any]]:
-    rows: list[dict[str, Any]] = []
-    with path.open("r", encoding="utf-8") as handle:
-        for line in handle:
-            if line.strip():
-                rows.append(json.loads(line))
-    return rows
-def safe_int(value: Any) -> int | None:
-    if value is None or value == "":
-        return None
-    try:
-        return int(float(str(value)))
-    except ValueError:
-        return None
-def git_tree_paths(root: Path) -> set[str]:
-    output = subprocess.check_output(
-        ["git", "-C", str(root), "ls-tree", "-r", "--name-only", "HEAD"],
-        text=True,
-    )
-    return {line.strip() for line in output.splitlines() if line.strip()}
-def release_asset_relpath(source: str, raw_path: str) -> str:
-    """Map JSONL asset paths to their release-relative locations.
-    The JSONL preserves original package prefixes such as
-    EHRXQAOriginalLinked_v1/ or MedModOriginalLinked_v1/.  The released HF tree
-    stores the actual assets under data/mm_bench/<source>/.
-    """
-    parts = Path(raw_path).parts
-    if parts and parts[0].endswith("OriginalLinked_v1"):
-        parts = parts[1:]
-    return str(Path("data") / "mm_bench" / source / Path(*parts))
-def exists(path: str, *, root: Path, tree: set[str] | None) -> bool:
-    if tree is not None:
-        return path in tree
-    return (root / path).exists()
-def validate(args: argparse.Namespace) -> tuple[dict[str, Any], list[dict[str, Any]]]:
-    bench_root = args.bench_root
-    input_path = args.input or bench_root / "inputs" / "mm_bench.jsonl"
-    rows = read_jsonl(input_path)
-    tree = git_tree_paths(bench_root) if args.use_git_tree and not args.manifest_only else None
-    source_counts = Counter(row.get("source_benchmark") for row in rows)
-    task_counts = Counter(row.get("task") for row in rows)
-    subjects_by_source: dict[str, set[int]] = defaultdict(set)
-    images_by_source: dict[str, set[str]] = defaultdict(set)
-    reports_by_source: dict[str, set[str]] = defaultdict(set)
-    errors: list[dict[str, Any]] = []
-    missing_by_kind = Counter()
-    for row in rows:
-        qid = row.get("qid")
-        source = str(row.get("source_benchmark") or "")
-        subject_id = safe_int(row.get("subject_id"))
-        if source not in {"ehrxqa", "medmod"}:
-            errors.append({"qid": qid, "kind": "bad_source", "value": source})
-            continue
-        if subject_id is None:
-            errors.append({"qid": qid, "kind": "missing_subject_id"})
-            continue
-        subjects_by_source[source].add(subject_id)
-        db_rel = str(Path("data") / "mm_bench" / source / "database" / f"patient_{subject_id}.db")
-        if not args.manifest_only and not exists(db_rel, root=bench_root, tree=tree):
-            missing_by_kind["database"] += 1
-            errors.append({"qid": qid, "kind": "missing_database", "path": db_rel})
-        for raw_path in row.get("image_paths") or []:
-            rel = release_asset_relpath(source, str(raw_path))
-            images_by_source[source].add(rel)
-            if not args.manifest_only and not exists(rel, root=bench_root, tree=tree):
-                missing_by_kind["image"] += 1
-                errors.append({"qid": qid, "kind": "missing_image", "path": rel})
-        for raw_path in row.get("report_paths") or []:
-            rel = release_asset_relpath(source, str(raw_path))
-            reports_by_source[source].add(rel)
-            if not args.manifest_only and not exists(rel, root=bench_root, tree=tree):
-                missing_by_kind["report"] += 1
-                errors.append({"qid": qid, "kind": "missing_report", "path": rel})
-    if not args.allow_unexpected_counts:
-        if dict(source_counts) != EXPECTED_SOURCE_COUNTS:
-            errors.append(
-                {
-                    "kind": "unexpected_source_counts",
-                    "actual": dict(source_counts),
-                    "expected": EXPECTED_SOURCE_COUNTS,
-                }
-            )
-        if dict(task_counts) != EXPECTED_TASK_COUNTS:
-            errors.append(
-                {
-                    "kind": "unexpected_task_counts",
-                    "actual": dict(task_counts),
-                    "expected": EXPECTED_TASK_COUNTS,
-                }
-            )
-    summary = {
-        "rows": len(rows),
-        "source_counts": dict(source_counts),
-        "task_counts": dict(task_counts),
-        "subjects": {key: len(value) for key, value in subjects_by_source.items()},
-        "unique_images": {key: len(value) for key, value in images_by_source.items()},
-        "unique_reports": {key: len(value) for key, value in reports_by_source.items()},
-        "missing_by_kind": dict(missing_by_kind),
-        "error_count": len(errors),
-        "validated_against": "manifest_only"
-        if args.manifest_only
-        else ("git_tree" if args.use_git_tree else "filesystem"),
-        "bench_root": str(bench_root),
-        "input": str(input_path),
-    }
-    return summary, errors
-def main() -> int:
-    args = parse_args()
-    summary, errors = validate(args)
-    print(json.dumps(summary, ensure_ascii=False, indent=2))
-    if errors:
-        print("First errors:", file=sys.stderr)
-        for error in errors[:20]:
-            print(json.dumps(error, ensure_ascii=False), file=sys.stderr)
-        return 1
-    return 0
-if __name__ == "__main__":
-    raise SystemExit(main())