| |
| """Read-only validation of a downloaded M4Raw Brain v1.6 release.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| import os |
| import re |
| import xml.etree.ElementTree as etree |
| from collections import Counter |
| from concurrent.futures import ProcessPoolExecutor |
| from pathlib import Path |
| from typing import Any |
|
|
| import h5py |
| import numpy as np |
| EXPECTED = { |
| "h5": 2230, |
| "train": 1024, |
| "validation": 240, |
| "test": 400, |
| "motion_inter_scan": 64, |
| "motion_intra_scan": 136, |
| "gre": 366, |
| "T1": 699, |
| "T2": 699, |
| "FLAIR": 466, |
| "GRE": 366, |
| "subjects": 208, |
| } |
| REQUIRED_H5_DATASETS = {"ismrmrd_header", "kspace", "reconstruction_rss"} |
| H5_RE = re.compile( |
| r"^(?P<scan>\d+)_(?P<sequence>T1|T2|FLAIR|GRE)(?P<rep>\d{2})\.h5$" |
| ) |
| CHECKSUM_EXCLUSIONS = { |
| "SHA256SUMS", |
| "metadata/hf_upload_audit.json", |
| } |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--release-root", type=Path, default=Path(".")) |
| parser.add_argument("--mode", choices=("quick", "full"), default="quick") |
| parser.add_argument("--workers", type=int, default=min(8, os.cpu_count() or 1)) |
| parser.add_argument("--skip-checksums", action="store_true") |
| return parser.parse_args() |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for block in iter(lambda: handle.read(8 * 1024 * 1024), b""): |
| digest.update(block) |
| return digest.hexdigest() |
|
|
|
|
| def relative_l2(reference: np.ndarray, observed: np.ndarray) -> float: |
| difference = np.asarray(reference) - np.asarray(observed) |
| numerator = np.sqrt(np.sum(np.abs(difference) ** 2, dtype=np.float64)) |
| denominator = np.sqrt(np.sum(np.abs(reference) ** 2, dtype=np.float64)) |
| return float(numerator / max(float(denominator), 1e-12)) |
|
|
|
|
| def centered_ifft_rss(kspace: np.ndarray) -> np.ndarray: |
| coil_images = np.fft.fftshift( |
| np.fft.ifft2( |
| np.fft.ifftshift(kspace, axes=(-2, -1)), |
| axes=(-2, -1), |
| norm="ortho", |
| ), |
| axes=(-2, -1), |
| ) |
| return np.sqrt(np.sum(np.abs(coil_images) ** 2, axis=1)).astype(np.float32) |
|
|
|
|
| def classify_h5(path: Path) -> tuple[str, str, int]: |
| match = H5_RE.fullmatch(path.name) |
| if match is None: |
| raise ValueError(f"Invalid H5 filename: {path.name}") |
| return match.group("scan"), match.group("sequence"), int(match.group("rep")) |
|
|
|
|
| def validate_h5_task(task: tuple[str, bool]) -> dict[str, Any]: |
| path_text, full = task |
| path = Path(path_text) |
| errors: list[str] = [] |
| rss_relative_l2 = None |
| try: |
| scan_id, sequence, repetition = classify_h5(path) |
| with h5py.File(path, "r") as handle: |
| missing = REQUIRED_H5_DATASETS - set(handle.keys()) |
| if missing: |
| errors.append(f"missing datasets {sorted(missing)}") |
| kspace_dataset = handle["kspace"] |
| target_dataset = handle["reconstruction_rss"] |
| if kspace_dataset.ndim != 4: |
| errors.append(f"kspace rank/shape {kspace_dataset.shape}") |
| if target_dataset.ndim != 3: |
| errors.append(f"target rank/shape {target_dataset.shape}") |
| if kspace_dataset.ndim == 4 and target_dataset.ndim == 3: |
| if kspace_dataset.shape[0] != target_dataset.shape[0]: |
| errors.append("slice count mismatch") |
| if kspace_dataset.shape[1] != 4: |
| errors.append(f"receiver coils {kspace_dataset.shape[1]}") |
| if kspace_dataset.shape[-2:] != target_dataset.shape[-2:]: |
| errors.append("spatial matrix mismatch") |
| if kspace_dataset.shape[-2:] != (256, 256): |
| errors.append(f"spatial matrix {kspace_dataset.shape[-2:]}") |
| if kspace_dataset.dtype != np.dtype(np.complex64): |
| errors.append(f"kspace dtype {kspace_dataset.dtype}") |
| if target_dataset.dtype != np.dtype(np.float32): |
| errors.append(f"target dtype {target_dataset.dtype}") |
|
|
| header = handle["ismrmrd_header"][()] |
| payload = header if isinstance(header, bytes) else str(header).encode() |
| root = etree.fromstring(payload) |
| if root.tag.rsplit("}", 1)[-1] != "ismrmrdHeader": |
| errors.append("unexpected XML root") |
|
|
| attrs = handle.attrs |
| for field in ("acquisition", "max", "patient_id"): |
| if field not in attrs: |
| errors.append(f"missing root attribute {field}") |
|
|
| kspace = np.asarray(kspace_dataset) |
| target = np.asarray(target_dataset) |
| stored_mask = ( |
| np.asarray(handle["acquired_pe_mask"], dtype=np.uint8) |
| if "acquired_pe_mask" in handle |
| else None |
| ) |
| if not np.all(np.isfinite(kspace.real)) or not np.all(np.isfinite(kspace.imag)): |
| errors.append("nonfinite kspace") |
| if not np.all(np.isfinite(target)): |
| errors.append("nonfinite target") |
| pe_mask = np.any(kspace != 0, axis=(0, 1, 2)).astype(np.uint8) |
| orthogonal_mask = np.any(kspace != 0, axis=(0, 1, 3)).astype(np.uint8) |
| if stored_mask is not None and not np.array_equal(stored_mask, pe_mask): |
| errors.append("stored acquired PE mask mismatch") |
| if np.count_nonzero(pe_mask) == 0: |
| errors.append("empty PE support") |
| if ( |
| sequence != "GRE" |
| and np.count_nonzero(pe_mask) == 256 |
| and np.count_nonzero(orthogonal_mask) < 256 |
| ): |
| errors.append("partial support is not on documented final PE axis") |
| if full: |
| rss_relative_l2 = relative_l2(centered_ifft_rss(kspace), target) |
| if rss_relative_l2 > 2e-6: |
| errors.append(f"RSS relative L2 {rss_relative_l2:.3g}") |
| return { |
| "path": path_text, |
| "scan_id": scan_id, |
| "sequence": sequence, |
| "repetition": repetition, |
| "shape": list(kspace.shape), |
| "pe_lines": int(np.count_nonzero(pe_mask)), |
| "rss_relative_l2": rss_relative_l2, |
| "errors": errors, |
| "pass": not errors, |
| } |
| except Exception as error: |
| return { |
| "path": path_text, |
| "errors": [f"{type(error).__name__}: {error}"], |
| "pass": False, |
| } |
|
|
|
|
| def read_tsv(path: Path) -> list[dict[str, str]]: |
| with path.open(newline="", encoding="utf-8") as handle: |
| return list(csv.DictReader(handle, delimiter="\t")) |
|
|
|
|
| def validate_manifests(root: Path) -> dict[str, Any]: |
| errors: list[str] = [] |
| acquisitions = read_tsv(root / "metadata" / "acquisitions.tsv") |
| subjects = read_tsv(root / "metadata" / "subjects.tsv") |
| manifest_paths: set[str] = set() |
| sequence_manifests: dict[str, list[dict[str, str]]] = {} |
| for sequence in ("T1", "T2", "FLAIR", "GRE"): |
| rows = read_tsv(root / "metadata" / f"{sequence}_manifest.tsv") |
| sequence_manifests[sequence] = rows |
| expected_rows = 183 if sequence == "GRE" else 208 |
| if len(rows) != expected_rows: |
| errors.append(f"{sequence} manifest rows {len(rows)}") |
| if len({row["scan_id"] for row in rows}) != len(rows): |
| errors.append(f"{sequence} duplicate scan IDs") |
| for row in rows: |
| present_repetitions = sum( |
| bool(row.get(f"h5_rep{index:02d}")) for index in range(1, 7) |
| ) |
| expected_repetitions = ( |
| 2 |
| if sequence == "GRE" |
| else 6 |
| if sequence in {"T1", "T2"} and row["participant_split"] == "test" |
| else 4 |
| if sequence == "FLAIR" and row["participant_split"] == "test" |
| else 3 |
| if sequence in {"T1", "T2"} |
| else 2 |
| ) |
| if present_repetitions != expected_repetitions: |
| errors.append( |
| f"{sequence} repetitions {row['scan_id']}={present_repetitions}" |
| ) |
| for index in range(1, 7): |
| value = row.get(f"h5_rep{index:02d}", "") |
| if value: |
| manifest_paths.add(value) |
| actual_paths = { |
| str(path.relative_to(root)) |
| for directory in ( |
| "multicoil_train", |
| "multicoil_val", |
| "multicoil_test", |
| "multicoil_motion", |
| "multicoil_gre", |
| ) |
| for path in (root / directory).rglob("*.h5") |
| } |
| acquisition_paths = {row["relative_path"] for row in acquisitions} |
| if manifest_paths != actual_paths: |
| errors.append("sequence manifest path set mismatch") |
| if acquisition_paths != actual_paths: |
| errors.append("acquisition table path set mismatch") |
| if len(subjects) != EXPECTED["subjects"]: |
| errors.append(f"subject rows {len(subjects)}") |
| if len({row["scan_id"] for row in subjects}) != len(subjects): |
| errors.append("duplicate subject IDs") |
| expected_subject_splits = { |
| "train": 128, |
| "validation": 30, |
| "test": 25, |
| "motion_inter_scan": 8, |
| "motion_intra_scan": 17, |
| } |
| subject_splits = dict(Counter(row["participant_split"] for row in subjects)) |
| if subject_splits != expected_subject_splits: |
| errors.append(f"subject split counts {subject_splits}") |
| if any( |
| row["participant_split"] == "test" and row["GRE_available"] != "false" |
| for row in subjects |
| ): |
| errors.append("GRE unexpectedly available in expanded test cohort") |
| if len(acquisitions) != EXPECTED["h5"]: |
| errors.append(f"acquisition rows {len(acquisitions)}") |
| if len({row["relative_path"] for row in acquisitions}) != len(acquisitions): |
| errors.append("duplicate acquisition paths") |
| if any(row["native_axis_order"] != "slice,coil,FE,PE" for row in acquisitions): |
| errors.append("acquisition axis contract") |
| if any( |
| row["kspace_dtype"] != "complex64" or row["target_dtype"] != "float32" |
| for row in acquisitions |
| ): |
| errors.append("acquisition dtype contract") |
| missing = [relative for relative in actual_paths if not (root / relative).is_file()] |
| if missing: |
| errors.append(f"missing H5 files {len(missing)}") |
| return { |
| "pass": not errors, |
| "acquisition_rows": len(acquisitions), |
| "subject_rows": len(subjects), |
| "errors": errors, |
| } |
|
|
|
|
| def validate_checksums(root: Path) -> dict[str, Any]: |
| expected: dict[str, str] = {} |
| for line in (root / "SHA256SUMS").read_text(encoding="ascii").splitlines(): |
| digest, relative = line.split(" ", 1) |
| expected[relative] = digest |
| failures: list[str] = [] |
| for relative, digest in expected.items(): |
| path = root / relative |
| if not path.is_file() or sha256(path) != digest: |
| failures.append(relative) |
| actual = { |
| str(path.relative_to(root)) |
| for path in root.rglob("*") |
| if path.is_file() |
| and str(path.relative_to(root)) not in CHECKSUM_EXCLUSIONS |
| } |
| if actual != set(expected): |
| failures.append("checksum path set mismatch") |
| return {"pass": not failures, "checked": len(expected), "failures": failures} |
|
|
|
|
| def observed_counts(root: Path, results: list[dict[str, Any]]) -> dict[str, int]: |
| paths = [Path(result["path"]) for result in results] |
| sequences = Counter(result.get("sequence") for result in results) |
| return { |
| "h5": len(paths), |
| "train": sum("multicoil_train" in path.parts for path in paths), |
| "validation": sum("multicoil_val" in path.parts for path in paths), |
| "test": sum("multicoil_test" in path.parts for path in paths), |
| "motion_inter_scan": sum( |
| "multicoil_motion" in path.parts and "inter_scan" in path.parts |
| for path in paths |
| ), |
| "motion_intra_scan": sum( |
| "multicoil_motion" in path.parts and "intra_scan" in path.parts |
| for path in paths |
| ), |
| "gre": sum("multicoil_gre" in path.parts for path in paths), |
| "T1": sequences["T1"], |
| "T2": sequences["T2"], |
| "FLAIR": sequences["FLAIR"], |
| "GRE": sequences["GRE"], |
| "subjects": len({result.get("scan_id") for result in results}), |
| } |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| root = args.release_root.resolve() |
| h5_paths = sorted( |
| path |
| for directory in ( |
| "multicoil_train", |
| "multicoil_val", |
| "multicoil_test", |
| "multicoil_motion", |
| "multicoil_gre", |
| ) |
| for path in (root / directory).rglob("*.h5") |
| ) |
| tasks = [(str(path), args.mode == "full") for path in h5_paths] |
| with ProcessPoolExecutor(max_workers=args.workers) as executor: |
| results = list(executor.map(validate_h5_task, tasks, chunksize=4)) |
| counts = observed_counts(root, results) |
| structure = { |
| "pass": counts == EXPECTED and all(result["pass"] for result in results), |
| "counts": counts, |
| "expected": EXPECTED, |
| "failed_h5": [result for result in results if not result["pass"]], |
| "maximum_rss_relative_l2": max( |
| (result["rss_relative_l2"] or 0.0 for result in results), default=0.0 |
| ), |
| } |
| manifests = validate_manifests(root) |
| checksums = ( |
| {"pass": True, "skipped": True} |
| if args.skip_checksums |
| else validate_checksums(root) |
| ) |
| forbidden = [ |
| str(path.relative_to(root)) |
| for path in root.rglob("*") |
| if path.is_file() |
| and (path.suffix in {".zip", ".pyc"} or "__pycache__" in path.parts) |
| ] |
| report = { |
| "release_root": str(root), |
| "mode": args.mode, |
| "structure_and_h5": structure, |
| "manifests": manifests, |
| "checksums": checksums, |
| "forbidden_files": forbidden, |
| } |
| report["pass"] = ( |
| structure["pass"] and manifests["pass"] and checksums["pass"] and not forbidden |
| ) |
| print(json.dumps(report, indent=2, sort_keys=True)) |
| if not report["pass"]: |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
