Add files using upload-large-folder tool

LICENSE

@@ -0,0 +1,12 @@
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+
+You are free to:
+  - Share — copy and redistribute the material in any medium or format
+  - Adapt — remix, transform, and build upon the material for any purpose,
+    even commercially.
+
+Under the following terms:
+  - Attribution — You must give appropriate credit, provide a link to the
+    license, and indicate if changes were made.
+
+Full text: https://creativecommons.org/licenses/by/4.0/legalcode

README.md

@@ -0,0 +1,138 @@
+---
+license: cc-by-4.0
+task_categories:
+- image-segmentation
+language:
+- en
+size_categories:
+- n<1K
+tags:
+- medical-imaging
+- spine
+- ct
+- segmentation
+- vertebra
+- lstv
+- tltv
+- verse
+pretty_name: "VerSeFusion: Re-fused VerSe 2019+2020 with VERIDAH corrections"
+---
+
+# VerSeFusion-Sample
+
+A re-fused, PIR-canonical version of the VerSe 2019 and VerSe 2020 vertebra
+segmentation challenges, with VERIDAH (Möller 2026) label corrections applied
+for thoracolumbar transitional vertebrae.
+
+## Dataset stats
+
+- **Total scans:** 10
+- **Total patients:** 10
+- **Splits:** training=1, validation=4, test=5
+- **Source:** VerSe 2019 + VerSe 2020 (combined) with VERIDAH corrections
+- **Canonical orientation:** PIR (axis 0 = P, axis 1 = I, axis 2 = R)
+- **VERIDAH-corrected subjects:** 0
+
+## Orientation
+
+Every scan in this dataset has been reoriented to a single canonical frame:
+
+- **axis 0** increases toward **P** (posterior — i.e., anterior → posterior)
+- **axis 1** increases toward **I** (inferior — i.e., superior → inferior; this is the spine axis)
+- **axis 2** increases toward **R** (right — i.e., left → right)
+
+This is verified end-to-end: see `orientation_audit.json` for the
+per-subject report.  Rendering conventions in `previews/`:
+
+- **Coronal:** head at top, patient's right at viewer's right
+- **Axial:** anterior at top, patient's right at viewer's right
+- **Sagittal:** head at top, anterior at left
+
+## Structure
+
+```
+gregoryschwingmdphd/VerseFusion-Sample/
+├── README.md
+├── LICENSE
+├── splits.csv                  # series_id → split (training/validation/test)
+├── orientation_audit.json      # per-subject orientation verification
+├── scans/
+│   └── <series_id>/
+│       ├── ct.nii.gz           # CT volume, HU values, PIR-oriented
+│       ├── mask.nii.gz         # vertebra labels (uint8), PIR-oriented
+│       └── meta.json           # per-scan provenance
+├── corrections/
+│   └── veridah_manifest.json   # which subjects had labels corrected
+└── previews/                   # optional QC renders
+    └── <series_id>.png
+```
+
+## Label schema
+
+| Label | Anatomy | | Label | Anatomy |
+|-------|---------|-|-------|---------|
+| 1–7   | C1–C7   | | 20    | L1 |
+| 8     | T1      | | 21    | L2 |
+| 9     | T2      | | 22    | L3 |
+| 10    | T3      | | 23    | L4 |
+| 11    | T4      | | 24    | L5 |
+| 12    | T5      | | 25    | L6 (supernumerary lumbar) |
+| 13    | T6      | | 26    | sacrum (variably annotated) |
+| 14    | T7      | | 27    | coccyx |
+| 15    | T8      | | 28    | T13 (supernumerary thoracic) |
+| 16    | T9      | | | |
+| 17    | T10     | | | |
+| 18    | T11     | | | |
+| 19    | T12     | | | |
+
+## Loading example
+
+```python
+import nibabel as nib
+
+ct  = nib.load("scans/verse001/ct.nii.gz")
+msk = nib.load("scans/verse001/mask.nii.gz")
+
+# Both are guaranteed to be PIR-oriented:
+assert nib.aff2axcodes(ct.affine)  == ('P', 'I', 'R')
+assert nib.aff2axcodes(msk.affine) == ('P', 'I', 'R')
+```
+
+## Citation
+
+If you use this dataset, please cite the original VerSe challenges and the
+VERIDAH corrections paper:
+
+```bibtex
+@article{sekuboyina2021verse,
+  title={VerSe: A vertebrae labelling and segmentation benchmark for multi-detector CT images},
+  author={Sekuboyina, A. and others},
+  journal={Medical Image Analysis},
+  year={2021}
+}
+
+@article{loffler2020verse2020,
+  title={A vertebral segmentation dataset with fracture grading},
+  author={Löffler, M.T. and others},
+  journal={Radiology: Artificial Intelligence},
+  year={2020}
+}
+
+@article{moller2026veridah,
+  title={VERIDAH: Vertebral identification and transitional anomaly detection},
+  author={Möller, H. and others},
+  year={2026}
+}
+```
+
+## Acknowledgments
+
+VerSe challenge data: Technical University Munich.  VERIDAH corrections:
+H. Möller et al. (2026).
+
+
+## Note: this is a sample
+
+This is a 10-scan sample from the full dataset, chosen as the most-completely-labeled scans (highest unique-vertebra-label count, with VERIDAH-corrected subjects prioritized to showcase the thoracolumbar transitional-vertebra corrections).
+
+For the full VerSeFusion dataset, see: https://huggingface.co/datasets/gregoryschwingmdphd/VerseFusion

corrections/veridah_manifest.json

@@ -0,0 +1,13 @@
+{
+  "version": "0.6.0",
+  "csv_source": "/wsu/home/go/go24/go2432/VerSeFusion/configs/veridah_corrections.csv",
+  "n_scans": 374,
+  "n_corrected": 0,
+  "n_passthrough": 360,
+  "by_correction_type": {
+    "t13_shift": 12,
+    "label_override": 2
+  },
+  "corrections": [],
+  "subset_filtered": true
+}

dataset_interface.py

@@ -0,0 +1,757 @@
+"""
+dataset_interface.py — Runtime interface for the VerSeFusion HF dataset.
+
+Two classes:
+  VerSeFusion           dict-style dataset wrapping an HF export directory.
+                        No torch dependency.  Use this for
+                        benchmarking / visualization / cohort analysis.
+  VerSeFusionDataset    PyTorch Dataset adapter on top of VerSeFusion.
+
+Expected layout (produced by stages 10a+10b+11 of the pipeline):
+  <root>/
+    scans/<series_id>/ct.nii.gz
+    scans/<series_id>/mask.nii.gz
+    manifest.json                 schema_version: 1
+    manifest.csv                  same data, flat tabular form
+    manifest_summary.json         cross-tabs by split × lstv_class
+    splits_5fold.json             schema_version: 1, patient-level
+                                  CV folds with test held out
+    corrections/veridah_manifest.json
+    orientation_audit.json
+    LICENSE
+    README.md
+
+Quickstart (analysis / viz — no torch needed):
+  >>> from dataset_interface import VerSeFusion
+  >>> ds = VerSeFusion("data/hf_staging")
+  >>> print(ds.stats())
+  >>> t13_cases = ds.filter(lstv_class="t13_supernumerary")
+
+Quickstart (HF Hub — lazy NIfTI fetch on first access):
+  >>> ds = VerSeFusion.from_hub("gregoryschwingmdphd/VerseFusion")
+  >>> ct_arr, affine = ds.cases[0].load_ct()   # downloads on first call
+
+Quickstart (training):
+  >>> from dataset_interface import VerSeFusionDataset
+  >>> ds_tr = VerSeFusionDataset("data/hf_staging", split=("fold", 0, "train"))
+  >>> ds_va = VerSeFusionDataset("data/hf_staging", split=("fold", 0, "val"))
+  >>> ds_te = VerSeFusionDataset("data/hf_staging", split="test")
+
+PATIENT-LEVEL SPLITS
+====================
+Both the test holdout and the 5-fold CV are stratified at the patient
+level.  Paired patients (where a single patient has multiple scans) keep
+all their scans in the same fold to prevent leakage.
+
+LSTV CLASSES
+============
+The dataset is stratified on a 4-way `lstv_class` derived from the LSTV
+audit flags during manifest construction:
+    t13_supernumerary   has_T13 = True  (~18 cases)
+    lumbarization       has_L6  = True  (~44 cases)
+    truncated           lacks_T12_TLJ_in_FOV  (~6 cases)
+    normal              otherwise  (~290 cases)
+
+The per-patient class is the WORST-CASE across that patient's scans
+(t13 > lumb > trunc > normal).  See verse_pipeline/splits_builder.py.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+
+# VerSeFusion mask label scheme (28-class):
+#   0       background
+#   1-7     C1-C7
+#   8-19    T1-T12
+#   20-25   L1-L6
+#   26      sacrum
+#   27      coccyx
+#   28      T13 (supernumerary, after VERIDAH t13_shift)
+LABEL_NAMES = (
+    "background",
+    "C1", "C2", "C3", "C4", "C5", "C6", "C7",
+    "T1", "T2", "T3", "T4", "T5", "T6", "T7", "T8", "T9", "T10", "T11", "T12",
+    "L1", "L2", "L3", "L4", "L5", "L6",
+    "sacrum", "coccyx",
+    "T13",
+)
+NUM_CLASSES = len(LABEL_NAMES)
+
+
+# ============================================================================
+# Case record
+# ============================================================================
+
+@dataclass
+class Case:
+    """One scan (CT + mask) with metadata.
+
+    For HF-backed datasets, ct_path / mask_path may not exist on disk yet —
+    files are fetched lazily on first call to load_ct() / load_mask() via
+    the back-reference to the parent dataset.  For local roots the
+    back-reference is None and load_* just opens the file directly.
+    """
+    series_id:          str
+    patient_id:         Optional[str]
+    ct_path:            Path
+    mask_path:          Path
+    split:              str = "unknown"     # training/validation/test
+    source_dataset:     Optional[str] = None
+    source_format:      Optional[str] = None
+
+    # geometry
+    shape:              Optional[Tuple[int, int, int]] = None
+    spacing_mm:         Optional[Tuple[float, float, float]] = None
+
+    # demographics (often missing)
+    age:                Optional[float] = None
+    sex:                Optional[str] = None
+    patient_pos:        Optional[str] = None
+
+    # corrections
+    veridah_applied:    bool = False
+    veridah_action:     Optional[str] = None
+    veridah_kind:       Optional[str] = None
+
+    # LSTV
+    n_labels:           int = 0
+    labels_present:     List[int] = field(default_factory=list)
+    has_T13:            bool = False
+    has_L6:             bool = False
+    lacks_T12_TLJ_in_FOV: bool = False
+    lstv_class:         str = "normal"
+
+    # Manifest-relative paths (used by lazy fetch)
+    ct_file_rel:        str = ""
+    mask_file_rel:      str = ""
+
+    # Back-ref to parent VerSeFusion instance for HF lazy fetch.
+    # Marked compare=False so equality / repr stay sane.
+    _parent: object = field(default=None, repr=False, compare=False)
+
+    def exists(self) -> bool:
+        """True iff both files are present on disk RIGHT NOW.  Returns
+        False for HF-backed cases that haven't been fetched yet."""
+        return self.ct_path.exists() and self.mask_path.exists()
+
+    def has_label(self, label: int) -> bool:
+        return int(label) in self.labels_present
+
+    def _ensure_local(self) -> None:
+        """Download from HF if needed.  No-op for local datasets."""
+        if self._parent is None:
+            return
+        fetcher = getattr(self._parent, "_hf_fetch", None)
+        if fetcher is None:
+            return
+        if not self.ct_path.exists():
+            new_ct = fetcher(self.ct_file_rel)
+            if new_ct is not None:
+                self.ct_path = Path(new_ct)
+        if not self.mask_path.exists():
+            new_msk = fetcher(self.mask_file_rel)
+            if new_msk is not None:
+                self.mask_path = Path(new_msk)
+
+    def load_ct(self):
+        """Returns (ct_array float32 in PIR, affine 4x4)."""
+        import nibabel as nib
+        import numpy as np
+        self._ensure_local()
+        img = nib.load(str(self.ct_path))
+        return np.asarray(img.dataobj, dtype=np.float32), img.affine
+
+    def load_mask(self):
+        """Returns (mask_array int16 in PIR, affine 4x4)."""
+        import nibabel as nib
+        import numpy as np
+        self._ensure_local()
+        img = nib.load(str(self.mask_path))
+        return np.asarray(img.dataobj, dtype=np.int16), img.affine
+
+    # Backwards-compat alias for code expecting CTSpinoPelvic1K's load_label
+    def load_label(self):
+        return self.load_mask()
+
+
+# ============================================================================
+# coercion / path resolution helpers (mirror CTSpinoPelvic1K conventions)
+# ============================================================================
+
+def _coerce_optional_str(v) -> Optional[str]:
+    if v is None:
+        return None
+    try:
+        import pandas as _pd
+        if _pd.isna(v):
+            return None
+    except Exception:
+        pass
+    s = str(v)
+    return s if s and s.lower() != "nan" else None
+
+
+def _coerce_optional_float(v) -> Optional[float]:
+    if v is None or v == "":
+        return None
+    try:
+        import pandas as _pd
+        if _pd.isna(v):
+            return None
+    except Exception:
+        pass
+    try:
+        f = float(v)
+    except (TypeError, ValueError):
+        return None
+    return None if f != f else f
+
+
+def _coerce_optional_int(v) -> Optional[int]:
+    f = _coerce_optional_float(v)
+    return int(f) if f is not None else None
+
+
+def _coerce_bool(v) -> bool:
+    if isinstance(v, bool):
+        return v
+    if v is None:
+        return False
+    if isinstance(v, str):
+        return v.strip().lower() in ("true", "1", "yes")
+    try:
+        return bool(int(v))
+    except (TypeError, ValueError):
+        return bool(v)
+
+
+def _coerce_labels_list(v) -> List[int]:
+    """labels_present may be a JSON string (from CSV) or already a list."""
+    if v is None or v == "":
+        return []
+    if isinstance(v, list):
+        return [int(x) for x in v]
+    if isinstance(v, str):
+        try:
+            parsed = json.loads(v)
+            if isinstance(parsed, list):
+                return [int(x) for x in parsed]
+        except (TypeError, ValueError, json.JSONDecodeError):
+            pass
+    return []
+
+
+def _resolve_file(root: Path, rel: str) -> Path:
+    """Resolve a manifest-declared relative path against the root.
+
+    Always tries `root/rel` first.  For HF-backed datasets where the file
+    hasn't been fetched yet, the result won't exist — that's fine, the
+    lazy-fetch path in Case._ensure_local() handles it.
+    """
+    if not rel:
+        return root
+    return root / rel
+
+
+# ============================================================================
+# main dataset class (no torch dep)
+# ============================================================================
+
+class VerSeFusion:
+    """Directory-backed dataset with rich per-scan metadata.
+
+    For HF-backed instances (via from_hub), only metadata files are
+    downloaded eagerly (manifest, splits, README — kilobytes).  CT and
+    mask NIfTIs are fetched lazily on first call to Case.load_ct() /
+    load_mask() via _hf_fetch(), and cached for future calls under the
+    huggingface_hub cache.
+    """
+
+    # Splits schema recorded after _resolve_splits so callers can introspect
+    splits_schema_version: Optional[int] = None
+    splits_scheme:         Optional[str] = None
+
+    # HF lazy-fetch state.  None for purely local datasets.
+    _hf_repo_id:    Optional[str] = None
+    _hf_token:      Optional[str] = None
+    _hf_cache_dir:  Optional[str] = None
+
+    def __init__(self, root):
+        self.root = Path(os.path.expanduser(str(root)))
+        if not self.root.exists():
+            raise FileNotFoundError(f"Dataset root not found: {self.root}")
+        self._load()
+
+    # ── HF lazy-fetch ────────────────────────────────────────────────────
+    def _hf_fetch(self, rel_path: str) -> Optional[str]:
+        """Ensure the file at rel_path exists locally.  Returns local path
+        as a string, or None if this dataset isn't HF-backed.
+
+        Race-safe across processes (huggingface_hub uses file locks).
+        Network errors propagate.
+        """
+        if not self._hf_repo_id or not rel_path:
+            return None
+        try:
+            from huggingface_hub import hf_hub_download
+        except ImportError as e:
+            raise RuntimeError(
+                "huggingface_hub not installed.  pip install huggingface_hub"
+            ) from e
+        return hf_hub_download(
+            repo_id   = self._hf_repo_id,
+            repo_type = "dataset",
+            filename  = rel_path,
+            token     = self._hf_token,
+            cache_dir = self._hf_cache_dir,
+        )
+
+    # ── splits resolution ────────────────────────────────────────────────
+    def _resolve_splits(self) -> Tuple[Dict[str, str], Optional[Dict]]:
+        """Read splits_5fold.json.  Returns (series_id_to_split, cv_doc).
+
+        series_id_to_split maps to "test" or "trainval".  cv_doc is the
+        full splits document for fold() lookups, or None if missing.
+
+        Falls back to the manifest's native `split` column for the
+        "split" attribute when splits_5fold.json is absent — but in
+        that case fold() will raise.
+        """
+        series_to_split: Dict[str, str] = {}
+        cv_doc: Optional[Dict] = None
+
+        splits_path = self.root / "splits_5fold.json"
+        if splits_path.exists():
+            try:
+                doc = json.loads(splits_path.read_text())
+                self.splits_schema_version = int(doc.get("schema_version", 0) or 0)
+                self.splits_scheme = doc.get("strata_scheme")
+                for sid in doc.get("test_series_ids", []) or []:
+                    series_to_split[str(sid)] = "test"
+                if "folds" in doc:
+                    cv_doc = doc
+                return series_to_split, cv_doc
+            except (OSError, ValueError, TypeError) as e:
+                import warnings as _w
+                _w.warn(
+                    f"Could not read {splits_path}: {e}.  fold() will fail.",
+                    stacklevel=3,
+                )
+        return series_to_split, cv_doc
+
+    def _load_manifest_records(self) -> List[Dict[str, Any]]:
+        """Read manifest.json (preferred) or manifest.csv as records."""
+        json_path = self.root / "manifest.json"
+        if json_path.exists():
+            doc = json.loads(json_path.read_text())
+            if isinstance(doc, dict):
+                return list(doc.get("subjects", []))
+            if isinstance(doc, list):
+                return list(doc)
+        csv_path = self.root / "manifest.csv"
+        if csv_path.exists():
+            import pandas as pd
+            return pd.read_csv(csv_path).to_dict(orient="records")
+        raise FileNotFoundError(
+            f"No manifest found under {self.root}.  Looked for "
+            f"manifest.json and manifest.csv.  Did you run "
+            f"`make manifest-slurm`?"
+        )
+
+    def _load(self) -> None:
+        records = self._load_manifest_records()
+        series_to_split, self.cv = self._resolve_splits()
+
+        self.cases: List[Case] = []
+        for r in records:
+            sid = str(r.get("series_id", ""))
+            if not sid:
+                continue
+
+            ct_rel  = r.get("ct_relative_path")   or f"scans/{sid}/ct.nii.gz"
+            msk_rel = r.get("mask_relative_path") or f"scans/{sid}/mask.nii.gz"
+
+            # Determine split: splits_5fold.json wins; else manifest's native
+            # split column.  Native splits are training/validation/test
+            # (per VerSe).  splits_5fold.json collapses non-test to
+            # "trainval" so fold() can do the rest.
+            split = series_to_split.get(sid) or _coerce_optional_str(r.get("split")) or "unknown"
+
+            shape = (
+                _coerce_optional_int(r.get("shape_p")),
+                _coerce_optional_int(r.get("shape_i")),
+                _coerce_optional_int(r.get("shape_r")),
+            )
+            spacing = (
+                _coerce_optional_float(r.get("spacing_p_mm")),
+                _coerce_optional_float(r.get("spacing_i_mm")),
+                _coerce_optional_float(r.get("spacing_r_mm")),
+            )
+
+            self.cases.append(Case(
+                series_id            = sid,
+                patient_id           = _coerce_optional_str(r.get("patient_id")),
+                ct_path              = _resolve_file(self.root, ct_rel),
+                mask_path            = _resolve_file(self.root, msk_rel),
+                split                = split,
+                source_dataset       = _coerce_optional_str(r.get("source_dataset")),
+                source_format        = _coerce_optional_str(r.get("source_format")),
+                shape                = shape if all(v is not None for v in shape) else None,
+                spacing_mm           = spacing if all(v is not None for v in spacing) else None,
+                age                  = _coerce_optional_float(r.get("age")),
+                sex                  = _coerce_optional_str(r.get("sex")),
+                patient_pos          = _coerce_optional_str(r.get("patient_pos")),
+                veridah_applied      = _coerce_bool(r.get("veridah_applied", False)),
+                veridah_action       = _coerce_optional_str(r.get("veridah_action")),
+                veridah_kind         = _coerce_optional_str(r.get("veridah_kind")),
+                n_labels             = _coerce_optional_int(r.get("n_labels")) or 0,
+                labels_present       = _coerce_labels_list(r.get("labels_present")),
+                has_T13              = _coerce_bool(r.get("has_T13", False)),
+                has_L6               = _coerce_bool(r.get("has_L6", False)),
+                lacks_T12_TLJ_in_FOV = _coerce_bool(r.get("lacks_T12_TLJ_in_FOV", False)),
+                lstv_class           = _coerce_optional_str(r.get("lstv_class")) or "normal",
+                ct_file_rel          = ct_rel,
+                mask_file_rel        = msk_rel,
+                _parent              = self,
+            ))
+
+        self._by_series: Dict[str, Case] = {c.series_id: c for c in self.cases}
+
+    # ── construction from the Hub ────────────────────────────────────────
+    @classmethod
+    def from_hub(cls,
+                  repo_id:   str,
+                  token:     Optional[str] = None,
+                  cache_dir: Optional[str] = None) -> "VerSeFusion":
+        """Construct a dataset backed by a HuggingFace dataset repo.
+
+        Eagerly downloads only metadata files (manifest, splits, README,
+        small auxiliary JSONs).  NIfTIs are fetched lazily on first
+        Case.load_ct() / load_mask() call.
+        """
+        try:
+            from huggingface_hub import snapshot_download
+        except ImportError as e:
+            raise RuntimeError(
+                "huggingface_hub not installed.  pip install huggingface_hub"
+            ) from e
+        local_dir = snapshot_download(
+            repo_id   = repo_id,
+            repo_type = "dataset",
+            token     = token,
+            cache_dir = str(Path(os.path.expanduser(cache_dir))) if cache_dir else None,
+            allow_patterns = [
+                "manifest.json",
+                "manifest.csv",
+                "manifest_summary.json",
+                "splits_5fold.json",
+                "splits.csv",
+                "corrections/**",
+                "orientation_audit.json",
+                "sample_selection.json",
+                "README.md",
+                "LICENSE",
+                "LICENSE.txt",
+                "dataset_interface.py",
+            ],
+        )
+        inst = cls(local_dir)
+        inst._hf_repo_id   = repo_id
+        inst._hf_token     = token
+        inst._hf_cache_dir = (
+            str(Path(os.path.expanduser(cache_dir))) if cache_dir else None
+        )
+        return inst
+
+    # ── filtering ────────────────────────────────────────────────────────
+    def filter(self,
+                split:           Optional[str | Sequence[str]] = None,
+                lstv_class:      Optional[str | Sequence[str]] = None,
+                source_dataset:  Optional[str | Sequence[str]] = None,
+                veridah_applied: Optional[bool] = None,
+                has_label:       Optional[int] = None,
+                present_only:    bool = False) -> List[Case]:
+        """Filter cases by metadata attributes.
+
+        Each filter accepts a single value or a list of values to match
+        against.  `present_only=True` means present-on-disk RIGHT NOW —
+        for HF-backed datasets that haven't fetched the data yet this
+        will return an empty list.
+        """
+        def _as_list(x):
+            if x is None: return None
+            return [x] if isinstance(x, str) else list(x)
+
+        sp  = _as_list(split)
+        lc  = _as_list(lstv_class)
+        sd  = _as_list(source_dataset)
+
+        out = list(self.cases)
+        if sp:  out = [c for c in out if c.split in sp]
+        if lc:  out = [c for c in out if c.lstv_class in lc]
+        if sd:  out = [c for c in out if c.source_dataset in sd]
+        if veridah_applied is not None:
+            out = [c for c in out if bool(c.veridah_applied) == bool(veridah_applied)]
+        if has_label is not None:
+            out = [c for c in out if c.has_label(int(has_label))]
+        if present_only:
+            out = [c for c in out if c.exists()]
+        return out
+
+    # ── split accessors ──────────────────────────────────────────────────
+    def test_set(self) -> List[Case]:
+        """Fixed test holdout (patient-level), per splits_5fold.json or
+        the manifest's native `split` column."""
+        return [c for c in self.cases if c.split == "test"]
+
+    def trainval(self) -> List[Case]:
+        """Train+val pool — everything not in the test holdout.
+
+        Native VerSe splits are training/validation; the splits_5fold.json
+        path collapses both into "trainval".  We accept all three labels
+        here so the same code works whichever splits source is in play.
+        """
+        keep = {"training", "validation", "trainval"}
+        return [c for c in self.cases if c.split in keep]
+
+    def fold(self, i: int) -> Tuple[List[Case], List[Case]]:
+        """Return (train_cases, val_cases) for fold i.
+
+        Lookup is by series_id against splits_5fold.json fold[i].
+        Raises RuntimeError if no CV folds are available.
+        """
+        if self.cv is None:
+            raise RuntimeError(
+                f"No 5-fold CV found at {self.root}/splits_5fold.json.  "
+                f"Run `python -m verse_pipeline.splits_builder` "
+                f"or `make splits-slurm` to produce one."
+            )
+        folds = self.cv.get("folds", [])
+        if not 0 <= i < len(folds):
+            raise IndexError(f"fold {i} out of range [0, {len(folds)})")
+        train_set = set(folds[i].get("train_series_ids", []))
+        val_set   = set(folds[i].get("val_series_ids",   []))
+        train = [c for c in self.cases if c.series_id in train_set]
+        val   = [c for c in self.cases if c.series_id in val_set]
+        return train, val
+
+    @property
+    def n_folds(self) -> int:
+        if not self.cv:
+            return 0
+        return len(self.cv.get("folds", []))
+
+    def splits(self) -> Tuple[List[Case], List[Case], List[Case]]:
+        """Backward-compatible 3-tuple (train, val, test) — train is the
+        full train+val pool, val is empty.  Use fold(i) for real splits."""
+        return self.trainval(), [], self.test_set()
+
+    # ── lookup ───────────────────────────────────────────────────────────
+    def get(self, series_id: str) -> Optional[Case]:
+        return self._by_series.get(str(series_id))
+
+    def __len__(self) -> int:
+        return len(self.cases)
+
+    def __iter__(self):
+        return iter(self.cases)
+
+    # ── stats ────────────────────────────────────────────────────────────
+    def stats(self) -> str:
+        from collections import Counter
+        sp   = Counter(c.split for c in self.cases)
+        lst  = Counter(c.lstv_class for c in self.cases)
+        sd   = Counter(c.source_dataset or "?" for c in self.cases)
+        fmt  = Counter(c.source_format or "?"  for c in self.cases)
+        n_present = sum(1 for c in self.cases if c.exists())
+        n_t13     = sum(1 for c in self.cases if c.has_T13)
+        n_l6      = sum(1 for c in self.cases if c.has_L6)
+        n_trunc   = sum(1 for c in self.cases if c.lacks_T12_TLJ_in_FOV)
+        n_ver     = sum(1 for c in self.cases if c.veridah_applied)
+        n_pats    = len({c.patient_id for c in self.cases if c.patient_id})
+
+        lines = [
+            "VerSeFusion",
+            f"  root:            {self.root}",
+            f"  scans:           {len(self.cases)}  (present on disk: {n_present})",
+            f"  unique patients: {n_pats}",
+            f"  splits:          {dict(sp)}",
+            f"  lstv_class:      {dict(lst)}",
+            f"  source_dataset:  {dict(sd)}",
+            f"  source_format:   {dict(fmt)}",
+            f"  flags:           has_T13={n_t13}  has_L6={n_l6}  truncated={n_trunc}",
+            f"  veridah_applied: {n_ver}",
+            f"  cv folds:        {self.n_folds}",
+        ]
+        if self.splits_schema_version:
+            lines.append(f"  splits source:   schema_v{self.splits_schema_version}  "
+                         f"scheme={self.splits_scheme or '-'}")
+        else:
+            lines.append("  splits source:   (manifest native splits; no CV)")
+        if self._hf_repo_id:
+            lines.append(
+                f"  hf-backed:       {self._hf_repo_id}  "
+                f"(NIfTIs fetched lazily; cache_dir={self._hf_cache_dir or 'default'})"
+            )
+        return "\n".join(lines)
+
+    def __repr__(self) -> str:
+        return f"VerSeFusion(root={self.root!s}, n_scans={len(self)}, n_folds={self.n_folds})"
+
+
+# ============================================================================
+# PyTorch Dataset adapter
+# ============================================================================
+
+try:
+    import torch
+    from torch.utils.data import Dataset
+    _HAS_TORCH = True
+except ImportError:
+    _HAS_TORCH = False
+    Dataset = object  # type: ignore
+
+
+class VerSeFusionDataset(Dataset):
+    """PyTorch Dataset yielding per-case tensors from NIfTI files.
+
+    Split selection:
+        split="trainval"           — whole train+val pool
+        split="test"               — fixed test holdout
+        split=("fold", 0, "train") — fold 0 train side of 5-fold CV
+        split=("fold", 0, "val")   — fold 0 val side
+        split="all"                — every scan
+
+    HF-backed roots fetch NIfTIs lazily on first __getitem__.  With
+    num_workers>0, multiple workers may race to fetch the same case —
+    huggingface_hub uses file locks to make this safe.
+    """
+
+    def __init__(self,
+                 root,
+                 split=("fold", 0, "train"),
+                 lstv_class: Optional[str | Sequence[str]] = None,
+                 transform=None,
+                 cache_dir: Optional[str] = None):
+        if not _HAS_TORCH:
+            raise RuntimeError("torch is required for VerSeFusionDataset")
+
+        # Auto-detect HF vs local
+        root_path = Path(os.path.expanduser(str(root)))
+        if root_path.exists() and (root_path / "manifest.json").exists():
+            self._ds = VerSeFusion(root_path)
+        else:
+            self._ds = VerSeFusion.from_hub(repo_id=str(root), cache_dir=cache_dir)
+
+        self.split     = split
+        self.transform = transform
+
+        if isinstance(split, tuple) and len(split) == 3 and split[0] == "fold":
+            _, fold_i, side = split
+            tr, va = self._ds.fold(int(fold_i))
+            cases = tr if side == "train" else va
+        elif split == "test":
+            cases = self._ds.test_set()
+        elif split == "trainval":
+            cases = self._ds.trainval()
+        elif split == "all":
+            cases = list(self._ds.cases)
+        else:
+            raise ValueError(f"Unknown split spec: {split!r}")
+
+        # Optional further filter
+        if lstv_class is not None:
+            lc = [lstv_class] if isinstance(lstv_class, str) else list(lstv_class)
+            cases = [c for c in cases if c.lstv_class in lc]
+
+        # For HF-backed: don't filter on present_only (files arrive lazily)
+        if self._ds._hf_repo_id:
+            self.cases: List[Case] = list(cases)
+        else:
+            self.cases = [c for c in cases if c.exists()]
+
+    def __len__(self) -> int:
+        return len(self.cases)
+
+    def __getitem__(self, idx: int) -> dict:
+        c = self.cases[idx]
+        ct_np,  affine = c.load_ct()
+        msk_np, _      = c.load_mask()
+        return self._collate(c, ct_np, msk_np, affine)
+
+    def _collate(self, c: Case, ct_np, msk_np, affine) -> dict:
+        ct   = torch.from_numpy(ct_np.astype("float32")).unsqueeze(0)   # (1, P, I, R)
+        mask = torch.from_numpy(msk_np.astype("int64"))                  # (P, I, R)
+        item = {
+            "ct":         ct,
+            "mask":       mask,
+            "affine":     torch.from_numpy(affine.astype("float32")),
+            "series_id":  c.series_id,
+            "patient_id": c.patient_id or "",
+            "split":      c.split,
+            "meta": {
+                "source_dataset":       c.source_dataset,
+                "source_format":        c.source_format,
+                "spacing_mm":           c.spacing_mm,
+                "shape":                c.shape,
+                "age":                  c.age,
+                "sex":                  c.sex,
+                "veridah_applied":      c.veridah_applied,
+                "veridah_action":       c.veridah_action,
+                "lstv_class":           c.lstv_class,
+                "has_T13":              c.has_T13,
+                "has_L6":               c.has_L6,
+                "lacks_T12_TLJ_in_FOV": c.lacks_T12_TLJ_in_FOV,
+                "n_labels":             c.n_labels,
+                "labels_present":       list(c.labels_present),
+            },
+        }
+        if self.transform is not None:
+            item = self.transform(item)
+        return item
+
+
+# ============================================================================
+# CLI smoke test
+# ============================================================================
+
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser(description="Smoke test: load + print stats.")
+    ap.add_argument("--root", required=True,
+                    help="Local dataset dir OR HF repo_id (e.g. user/repo)")
+    ap.add_argument("--cache_dir", default=None)
+    args = ap.parse_args()
+
+    root_path = Path(os.path.expanduser(args.root))
+    if root_path.exists():
+        ds = VerSeFusion(root_path)
+    else:
+        ds = VerSeFusion.from_hub(args.root, cache_dir=args.cache_dir)
+    print(ds.stats())
+
+    print(f"\ntest / trainval: {len(ds.test_set())} / {len(ds.trainval())}")
+    if ds.n_folds > 0:
+        tr, va = ds.fold(0)
+        print(f"fold 0 train/val: {len(tr)} / {len(va)}")
+
+    sample = ds.trainval() or list(ds.cases)
+    if sample:
+        c = sample[0]
+        print(f"\nfirst case:")
+        print(f"  series_id:   {c.series_id}")
+        print(f"  patient_id:  {c.patient_id}")
+        print(f"  split:       {c.split}")
+        print(f"  lstv_class:  {c.lstv_class}")
+        print(f"  ct_path:     {c.ct_path}  (exists={c.ct_path.exists()})")
+        print(f"  mask_path:   {c.mask_path}  (exists={c.mask_path.exists()})")
+        print(f"  spacing_mm:  {c.spacing_mm}")
+        print(f"  shape:       {c.shape}")
+        print(f"  veridah:     applied={c.veridah_applied}  action={c.veridah_action}")
+        print(f"  n_labels:    {c.n_labels}")

manifest.csv

@@ -0,0 +1,11 @@
+series_id,patient_id,split,source_dataset,source_format,shape_p,shape_i,shape_r,spacing_p_mm,spacing_i_mm,spacing_r_mm,age,sex,patient_pos,veridah_applied,veridah_action,veridah_kind,n_labels,labels_present,has_T13,has_L6,lacks_T12_TLJ_in_FOV,lstv_class,lstv_class_audit,tltv_class_audit,ct_relative_path,mask_relative_path
+verse108,verse108,test,verse20,miccai,459,733,494,1.0,1.0,1.0,52.0,F,1 of 1,False,,,24,"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]",False,False,False,normal,lsj_fov_truncated,normal_thoracolumbar,scans/verse108/ct.nii.gz,scans/verse108/mask.nii.gz
+verse236,verse236,test,verse20,miccai,369,787,369,1.0,1.0,1.0,88.0,M,1 of 1,False,,,24,"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]",False,False,False,normal,lsj_fov_truncated,normal_thoracolumbar,scans/verse236/ct.nii.gz,scans/verse236/mask.nii.gz
+verse547,verse547,validation,verse20,miccai,512,900,512,0.923828125,0.899993896484375,0.923828125,24.0,F,1 of 1,False,,,25,"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 28]",True,False,False,t13_supernumerary,lsj_fov_truncated,t13_supernumerary,scans/verse547/ct.nii.gz,scans/verse547/mask.nii.gz
+verse585,verse585,validation,verse20,miccai,512,1258,164,0.68359375,0.683624804019928,2.0,35.0,M,1 of 1,False,,,25,"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]",False,True,False,lumbarization,lumbarization,normal_thoracolumbar,scans/verse585/ct.nii.gz,scans/verse585/mask.nii.gz
+verse602,verse602,test,verse20,miccai,512,2023,512,0.9765625,0.9000005722045898,0.9765625,65.0,M,1 of 1,False,,,25,"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 28]",True,False,False,t13_supernumerary,lsj_fov_truncated,t13_supernumerary,scans/verse602/ct.nii.gz,scans/verse602/mask.nii.gz
+verse631,verse631,training,verse20,miccai,512,1190,158,0.685546875,0.6857143044471741,2.0,64.0,M,1 of 1,False,,,25,"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 28]",True,False,False,t13_supernumerary,lsj_fov_truncated,t13_supernumerary,scans/verse631/ct.nii.gz,scans/verse631/mask.nii.gz
+verse644,verse644,validation,verse20,miccai,512,2048,76,0.4023437370719854,0.4023437385580621,2.9997239631125714,29.0,F,1 of 1,False,,,24,"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]",False,False,False,normal,lsj_fov_truncated,normal_thoracolumbar,scans/verse644/ct.nii.gz,scans/verse644/mask.nii.gz
+verse649,verse649,test,verse20,miccai,512,1346,162,0.55859375,0.5586923956871033,2.0,48.0,M,1 of 1,False,,,24,"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]",False,False,False,normal,lsj_fov_truncated,normal_thoracolumbar,scans/verse649/ct.nii.gz,scans/verse649/mask.nii.gz
+verse758,verse758,test,verse20,miccai,512,780,512,1.3671879768371582,1.25,1.3671879768371582,37.0,F,1 of 1,False,,,24,"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]",False,False,False,normal,lsj_fov_truncated,normal_thoracolumbar,scans/verse758/ct.nii.gz,scans/verse758/mask.nii.gz
+verse759,verse759,validation,verse20,miccai,512,512,168,1.6748050451278689,1.6748050451278689,2.5,83.0,M,1 of 1,False,,,24,"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]",False,False,False,normal,lsj_fov_truncated,normal_thoracolumbar,scans/verse759/ct.nii.gz,scans/verse759/mask.nii.gz

manifest.json

@@ -0,0 +1,552 @@
+{
+  "schema_version": 1,
+  "dataset_name": "VerSeFusion",
+  "n_subjects": 10,
+  "subjects": [
+    {
+      "series_id": "verse108",
+      "patient_id": "verse108",
+      "split": "test",
+      "source_dataset": "verse20",
+      "source_format": "miccai",
+      "shape_p": 459,
+      "shape_i": 733,
+      "shape_r": 494,
+      "spacing_p_mm": 1.0,
+      "spacing_i_mm": 1.0,
+      "spacing_r_mm": 1.0,
+      "age": 52.0,
+      "sex": "F",
+      "patient_pos": "1 of 1",
+      "veridah_applied": false,
+      "veridah_action": null,
+      "veridah_kind": null,
+      "n_labels": 24,
+      "labels_present": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24
+      ],
+      "has_T13": false,
+      "has_L6": false,
+      "lacks_T12_TLJ_in_FOV": false,
+      "lstv_class": "normal",
+      "lstv_class_audit": "lsj_fov_truncated",
+      "tltv_class_audit": "normal_thoracolumbar",
+      "ct_relative_path": "scans/verse108/ct.nii.gz",
+      "mask_relative_path": "scans/verse108/mask.nii.gz"
+    },
+    {
+      "series_id": "verse236",
+      "patient_id": "verse236",
+      "split": "test",
+      "source_dataset": "verse20",
+      "source_format": "miccai",
+      "shape_p": 369,
+      "shape_i": 787,
+      "shape_r": 369,
+      "spacing_p_mm": 1.0,
+      "spacing_i_mm": 1.0,
+      "spacing_r_mm": 1.0,
+      "age": 88.0,
+      "sex": "M",
+      "patient_pos": "1 of 1",
+      "veridah_applied": false,
+      "veridah_action": null,
+      "veridah_kind": null,
+      "n_labels": 24,
+      "labels_present": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24
+      ],
+      "has_T13": false,
+      "has_L6": false,
+      "lacks_T12_TLJ_in_FOV": false,
+      "lstv_class": "normal",
+      "lstv_class_audit": "lsj_fov_truncated",
+      "tltv_class_audit": "normal_thoracolumbar",
+      "ct_relative_path": "scans/verse236/ct.nii.gz",
+      "mask_relative_path": "scans/verse236/mask.nii.gz"
+    },
+    {
+      "series_id": "verse547",
+      "patient_id": "verse547",
+      "split": "validation",
+      "source_dataset": "verse20",
+      "source_format": "miccai",
+      "shape_p": 512,
+      "shape_i": 900,
+      "shape_r": 512,
+      "spacing_p_mm": 0.923828125,
+      "spacing_i_mm": 0.899993896484375,
+      "spacing_r_mm": 0.923828125,
+      "age": 24.0,
+      "sex": "F",
+      "patient_pos": "1 of 1",
+      "veridah_applied": false,
+      "veridah_action": null,
+      "veridah_kind": null,
+      "n_labels": 25,
+      "labels_present": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24,
+        28
+      ],
+      "has_T13": true,
+      "has_L6": false,
+      "lacks_T12_TLJ_in_FOV": false,
+      "lstv_class": "t13_supernumerary",
+      "lstv_class_audit": "lsj_fov_truncated",
+      "tltv_class_audit": "t13_supernumerary",
+      "ct_relative_path": "scans/verse547/ct.nii.gz",
+      "mask_relative_path": "scans/verse547/mask.nii.gz"
+    },
+    {
+      "series_id": "verse585",
+      "patient_id": "verse585",
+      "split": "validation",
+      "source_dataset": "verse20",
+      "source_format": "miccai",
+      "shape_p": 512,
+      "shape_i": 1258,
+      "shape_r": 164,
+      "spacing_p_mm": 0.68359375,
+      "spacing_i_mm": 0.683624804019928,
+      "spacing_r_mm": 2.0,
+      "age": 35.0,
+      "sex": "M",
+      "patient_pos": "1 of 1",
+      "veridah_applied": false,
+      "veridah_action": null,
+      "veridah_kind": null,
+      "n_labels": 25,
+      "labels_present": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24,
+        25
+      ],
+      "has_T13": false,
+      "has_L6": true,
+      "lacks_T12_TLJ_in_FOV": false,
+      "lstv_class": "lumbarization",
+      "lstv_class_audit": "lumbarization",
+      "tltv_class_audit": "normal_thoracolumbar",
+      "ct_relative_path": "scans/verse585/ct.nii.gz",
+      "mask_relative_path": "scans/verse585/mask.nii.gz"
+    },
+    {
+      "series_id": "verse602",
+      "patient_id": "verse602",
+      "split": "test",
+      "source_dataset": "verse20",
+      "source_format": "miccai",
+      "shape_p": 512,
+      "shape_i": 2023,
+      "shape_r": 512,
+      "spacing_p_mm": 0.9765625,
+      "spacing_i_mm": 0.9000005722045898,
+      "spacing_r_mm": 0.9765625,
+      "age": 65.0,
+      "sex": "M",
+      "patient_pos": "1 of 1",
+      "veridah_applied": false,
+      "veridah_action": null,
+      "veridah_kind": null,
+      "n_labels": 25,
+      "labels_present": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24,
+        28
+      ],
+      "has_T13": true,
+      "has_L6": false,
+      "lacks_T12_TLJ_in_FOV": false,
+      "lstv_class": "t13_supernumerary",
+      "lstv_class_audit": "lsj_fov_truncated",
+      "tltv_class_audit": "t13_supernumerary",
+      "ct_relative_path": "scans/verse602/ct.nii.gz",
+      "mask_relative_path": "scans/verse602/mask.nii.gz"
+    },
+    {
+      "series_id": "verse631",
+      "patient_id": "verse631",
+      "split": "training",
+      "source_dataset": "verse20",
+      "source_format": "miccai",
+      "shape_p": 512,
+      "shape_i": 1190,
+      "shape_r": 158,
+      "spacing_p_mm": 0.685546875,
+      "spacing_i_mm": 0.6857143044471741,
+      "spacing_r_mm": 2.0,
+      "age": 64.0,
+      "sex": "M",
+      "patient_pos": "1 of 1",
+      "veridah_applied": false,
+      "veridah_action": null,
+      "veridah_kind": null,
+      "n_labels": 25,
+      "labels_present": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24,
+        28
+      ],
+      "has_T13": true,
+      "has_L6": false,
+      "lacks_T12_TLJ_in_FOV": false,
+      "lstv_class": "t13_supernumerary",
+      "lstv_class_audit": "lsj_fov_truncated",
+      "tltv_class_audit": "t13_supernumerary",
+      "ct_relative_path": "scans/verse631/ct.nii.gz",
+      "mask_relative_path": "scans/verse631/mask.nii.gz"
+    },
+    {
+      "series_id": "verse644",
+      "patient_id": "verse644",
+      "split": "validation",
+      "source_dataset": "verse20",
+      "source_format": "miccai",
+      "shape_p": 512,
+      "shape_i": 2048,
+      "shape_r": 76,
+      "spacing_p_mm": 0.4023437370719854,
+      "spacing_i_mm": 0.40234373855806216,
+      "spacing_r_mm": 2.9997239631125714,
+      "age": 29.0,
+      "sex": "F",
+      "patient_pos": "1 of 1",
+      "veridah_applied": false,
+      "veridah_action": null,
+      "veridah_kind": null,
+      "n_labels": 24,
+      "labels_present": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24
+      ],
+      "has_T13": false,
+      "has_L6": false,
+      "lacks_T12_TLJ_in_FOV": false,
+      "lstv_class": "normal",
+      "lstv_class_audit": "lsj_fov_truncated",
+      "tltv_class_audit": "normal_thoracolumbar",
+      "ct_relative_path": "scans/verse644/ct.nii.gz",
+      "mask_relative_path": "scans/verse644/mask.nii.gz"
+    },
+    {
+      "series_id": "verse649",
+      "patient_id": "verse649",
+      "split": "test",
+      "source_dataset": "verse20",
+      "source_format": "miccai",
+      "shape_p": 512,
+      "shape_i": 1346,
+      "shape_r": 162,
+      "spacing_p_mm": 0.55859375,
+      "spacing_i_mm": 0.5586923956871033,
+      "spacing_r_mm": 2.0,
+      "age": 48.0,
+      "sex": "M",
+      "patient_pos": "1 of 1",
+      "veridah_applied": false,
+      "veridah_action": null,
+      "veridah_kind": null,
+      "n_labels": 24,
+      "labels_present": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24
+      ],
+      "has_T13": false,
+      "has_L6": false,
+      "lacks_T12_TLJ_in_FOV": false,
+      "lstv_class": "normal",
+      "lstv_class_audit": "lsj_fov_truncated",
+      "tltv_class_audit": "normal_thoracolumbar",
+      "ct_relative_path": "scans/verse649/ct.nii.gz",
+      "mask_relative_path": "scans/verse649/mask.nii.gz"
+    },
+    {
+      "series_id": "verse758",
+      "patient_id": "verse758",
+      "split": "test",
+      "source_dataset": "verse20",
+      "source_format": "miccai",
+      "shape_p": 512,
+      "shape_i": 780,
+      "shape_r": 512,
+      "spacing_p_mm": 1.3671879768371582,
+      "spacing_i_mm": 1.25,
+      "spacing_r_mm": 1.3671879768371582,
+      "age": 37.0,
+      "sex": "F",
+      "patient_pos": "1 of 1",
+      "veridah_applied": false,
+      "veridah_action": null,
+      "veridah_kind": null,
+      "n_labels": 24,
+      "labels_present": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24
+      ],
+      "has_T13": false,
+      "has_L6": false,
+      "lacks_T12_TLJ_in_FOV": false,
+      "lstv_class": "normal",
+      "lstv_class_audit": "lsj_fov_truncated",
+      "tltv_class_audit": "normal_thoracolumbar",
+      "ct_relative_path": "scans/verse758/ct.nii.gz",
+      "mask_relative_path": "scans/verse758/mask.nii.gz"
+    },
+    {
+      "series_id": "verse759",
+      "patient_id": "verse759",
+      "split": "validation",
+      "source_dataset": "verse20",
+      "source_format": "miccai",
+      "shape_p": 512,
+      "shape_i": 512,
+      "shape_r": 168,
+      "spacing_p_mm": 1.6748050451278687,
+      "spacing_i_mm": 1.6748050451278687,
+      "spacing_r_mm": 2.5,
+      "age": 83.0,
+      "sex": "M",
+      "patient_pos": "1 of 1",
+      "veridah_applied": false,
+      "veridah_action": null,
+      "veridah_kind": null,
+      "n_labels": 24,
+      "labels_present": [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24
+      ],
+      "has_T13": false,
+      "has_L6": false,
+      "lacks_T12_TLJ_in_FOV": false,
+      "lstv_class": "normal",
+      "lstv_class_audit": "lsj_fov_truncated",
+      "tltv_class_audit": "normal_thoracolumbar",
+      "ct_relative_path": "scans/verse759/ct.nii.gz",
+      "mask_relative_path": "scans/verse759/mask.nii.gz"
+    }
+  ],
+  "subset_filtered": true
+}

sample_selection.json

@@ -0,0 +1,90 @@
+{
+  "criteria": "top-N by unique vertebra-label count, veridah-corrected tiebreak",
+  "source": "manifest.csv",
+  "n_requested": 10,
+  "n_selected": 10,
+  "selected_ids": [
+    "verse547",
+    "verse585",
+    "verse602",
+    "verse631",
+    "verse108",
+    "verse236",
+    "verse644",
+    "verse649",
+    "verse758",
+    "verse759"
+  ],
+  "all_scores": [
+    {
+      "series_id": "verse547",
+      "n_labels": 25,
+      "veridah_applied": false,
+      "lstv_class": "t13_supernumerary",
+      "source_tag": "manifest"
+    },
+    {
+      "series_id": "verse585",
+      "n_labels": 25,
+      "veridah_applied": false,
+      "lstv_class": "lumbarization",
+      "source_tag": "manifest"
+    },
+    {
+      "series_id": "verse602",
+      "n_labels": 25,
+      "veridah_applied": false,
+      "lstv_class": "t13_supernumerary",
+      "source_tag": "manifest"
+    },
+    {
+      "series_id": "verse631",
+      "n_labels": 25,
+      "veridah_applied": false,
+      "lstv_class": "t13_supernumerary",
+      "source_tag": "manifest"
+    },
+    {
+      "series_id": "verse108",
+      "n_labels": 24,
+      "veridah_applied": false,
+      "lstv_class": "normal",
+      "source_tag": "manifest"
+    },
+    {
+      "series_id": "verse236",
+      "n_labels": 24,
+      "veridah_applied": false,
+      "lstv_class": "normal",
+      "source_tag": "manifest"
+    },
+    {
+      "series_id": "verse644",
+      "n_labels": 24,
+      "veridah_applied": false,
+      "lstv_class": "normal",
+      "source_tag": "manifest"
+    },
+    {
+      "series_id": "verse649",
+      "n_labels": 24,
+      "veridah_applied": false,
+      "lstv_class": "normal",
+      "source_tag": "manifest"
+    },
+    {
+      "series_id": "verse758",
+      "n_labels": 24,
+      "veridah_applied": false,
+      "lstv_class": "normal",
+      "source_tag": "manifest"
+    },
+    {
+      "series_id": "verse759",
+      "n_labels": 24,
+      "veridah_applied": false,
+      "lstv_class": "normal",
+      "source_tag": "manifest"
+    }
+  ]
+}

scans/verse108/ct.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8882c99993d224198c1ff6e12619bde1f1246e44e24b79b0c32f27585bbdebf
+size 482821100

scans/verse108/mask.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:050d698d69f8726ddf14e581a7aa37b48fc29d3037447ad867b0c0cd4d751a27
+size 6149902

scans/verse108/meta.json

@@ -0,0 +1,26 @@
+{
+  "series_id": "verse108",
+  "source_tag": "canonical",
+  "files": {
+    "ct": "ct.nii.gz",
+    "mask": "mask.nii.gz"
+  },
+  "orientation_axcodes": [
+    "P",
+    "I",
+    "R"
+  ],
+  "spacing_mm": [
+    1.0,
+    1.0,
+    1.0
+  ],
+  "shape": [
+    459,
+    733,
+    494
+  ],
+  "split": "test",
+  "patient_id": "verse108",
+  "source_format": "miccai"
+}

scans/verse236/ct.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6d58b4428bd2d0fb9477b946b4b1e9de4c2afa10dd8772882626e0139eb8122
+size 383094427

scans/verse236/mask.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd580799ca908a04f566b894e8e8d326eac44a502a00a9bf0b996e21dd0ecf5f
+size 4175482

scans/verse236/meta.json

@@ -0,0 +1,26 @@
+{
+  "series_id": "verse236",
+  "source_tag": "canonical",
+  "files": {
+    "ct": "ct.nii.gz",
+    "mask": "mask.nii.gz"
+  },
+  "orientation_axcodes": [
+    "P",
+    "I",
+    "R"
+  ],
+  "spacing_mm": [
+    1.0,
+    1.0,
+    1.0
+  ],
+  "shape": [
+    369,
+    787,
+    369
+  ],
+  "split": "test",
+  "patient_id": "verse236",
+  "source_format": "miccai"
+}

scans/verse547/ct.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21e09470e29e01d05aeb200102d2657a0babca14a0ab0cf44b461d0a0b4ec833
+size 394188825

scans/verse547/mask.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd4d8718a4683e91fa74504dbb7284a169752decf21afb6adf0141224bd59a6d
+size 8630196

scans/verse547/meta.json

@@ -0,0 +1,26 @@
+{
+  "series_id": "verse547",
+  "source_tag": "canonical",
+  "files": {
+    "ct": "ct.nii.gz",
+    "mask": "mask.nii.gz"
+  },
+  "orientation_axcodes": [
+    "P",
+    "I",
+    "R"
+  ],
+  "spacing_mm": [
+    0.923828125,
+    0.899993896484375,
+    0.923828125
+  ],
+  "shape": [
+    512,
+    900,
+    512
+  ],
+  "split": "validation",
+  "patient_id": "verse547",
+  "source_format": "miccai"
+}

scans/verse585/ct.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68e08707453cada93e0b9a95e0cae8a3373e01db9ca93cda0577252df5c4ae80
+size 210544816

scans/verse585/mask.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2374502ccf154ef540e40f75f3e1bce69062c5c570c788c2d5d0685b18cfa118
+size 4003475

scans/verse585/meta.json

@@ -0,0 +1,26 @@
+{
+  "series_id": "verse585",
+  "source_tag": "canonical",
+  "files": {
+    "ct": "ct.nii.gz",
+    "mask": "mask.nii.gz"
+  },
+  "orientation_axcodes": [
+    "P",
+    "I",
+    "R"
+  ],
+  "spacing_mm": [
+    0.68359375,
+    0.683624804019928,
+    2.0
+  ],
+  "shape": [
+    512,
+    1258,
+    164
+  ],
+  "split": "validation",
+  "patient_id": "verse585",
+  "source_format": "miccai"
+}

scans/verse602/ct.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4cd20975f4074298b67c4ded90823206064785f4aaada444433d09419b391c2
+size 759015608

scans/verse602/mask.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf85a200f8eb5eceeaf5f52c1431e1655e1797547ed5fcc6b7b9c73f65c38e62
+size 19040194

scans/verse602/meta.json

@@ -0,0 +1,26 @@
+{
+  "series_id": "verse602",
+  "source_tag": "canonical",
+  "files": {
+    "ct": "ct.nii.gz",
+    "mask": "mask.nii.gz"
+  },
+  "orientation_axcodes": [
+    "P",
+    "I",
+    "R"
+  ],
+  "spacing_mm": [
+    0.9765625,
+    0.9000005722045898,
+    0.9765625
+  ],
+  "shape": [
+    512,
+    2023,
+    512
+  ],
+  "split": "test",
+  "patient_id": "verse602",
+  "source_format": "miccai"
+}

scans/verse631/ct.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a69b7bf1c1c0f4ba91cf7e9d6601ab0f68b8de207e8d678941b7a9aff5ba92be
+size 203189638

scans/verse631/mask.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:367229270c4794bf789b0f2d9cf64484dec157916b8f08e92f11fa4b1e53da15
+size 3731529

scans/verse631/meta.json

@@ -0,0 +1,26 @@
+{
+  "series_id": "verse631",
+  "source_tag": "canonical",
+  "files": {
+    "ct": "ct.nii.gz",
+    "mask": "mask.nii.gz"
+  },
+  "orientation_axcodes": [
+    "P",
+    "I",
+    "R"
+  ],
+  "spacing_mm": [
+    0.685546875,
+    0.6857143044471741,
+    2.0
+  ],
+  "shape": [
+    512,
+    1190,
+    158
+  ],
+  "split": "training",
+  "patient_id": "verse631",
+  "source_format": "miccai"
+}

scans/verse644/ct.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71a70a2ffb460af65a54a2beb533f7bd358f0623a516557f4c29bfec68ab003a
+size 176860007

scans/verse644/mask.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1f0490f8bacf1454fe2cb343cc420215ffaf6fc7b632be92cc81925e98b0494
+size 3040579

scans/verse644/meta.json

@@ -0,0 +1,26 @@
+{
+  "series_id": "verse644",
+  "source_tag": "canonical",
+  "files": {
+    "ct": "ct.nii.gz",
+    "mask": "mask.nii.gz"
+  },
+  "orientation_axcodes": [
+    "P",
+    "I",
+    "R"
+  ],
+  "spacing_mm": [
+    0.4023437370719854,
+    0.40234373855806216,
+    2.9997239631125714
+  ],
+  "shape": [
+    512,
+    2048,
+    76
+  ],
+  "split": "validation",
+  "patient_id": "verse644",
+  "source_format": "miccai"
+}

scans/verse649/ct.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8c3667eef7e890c4f456a2ccfb6a35811702d69599f734a60787d18e0417151
+size 226060173

scans/verse649/mask.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bf78336e68d82bfc26d2cbeb219fda74f71525e4c0fd9ae388018a207164d4d
+size 4298197

scans/verse649/meta.json

@@ -0,0 +1,26 @@
+{
+  "series_id": "verse649",
+  "source_tag": "canonical",
+  "files": {
+    "ct": "ct.nii.gz",
+    "mask": "mask.nii.gz"
+  },
+  "orientation_axcodes": [
+    "P",
+    "I",
+    "R"
+  ],
+  "spacing_mm": [
+    0.55859375,
+    0.5586923956871033,
+    2.0
+  ],
+  "shape": [
+    512,
+    1346,
+    162
+  ],
+  "split": "test",
+  "patient_id": "verse649",
+  "source_format": "miccai"
+}

scans/verse758/ct.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03db55533e07164c68b20f6147100946480205f34529587ac006a3371f0f50a9
+size 267847263

scans/verse758/mask.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ba93eca4870d516f83ac5aa7a39ba8c95b97fa8f71ddd85c4b001181271f94c
+size 7313194

scans/verse758/meta.json

@@ -0,0 +1,26 @@
+{
+  "series_id": "verse758",
+  "source_tag": "canonical",
+  "files": {
+    "ct": "ct.nii.gz",
+    "mask": "mask.nii.gz"
+  },
+  "orientation_axcodes": [
+    "P",
+    "I",
+    "R"
+  ],
+  "spacing_mm": [
+    1.3671879768371582,
+    1.25,
+    1.3671879768371582
+  ],
+  "shape": [
+    512,
+    780,
+    512
+  ],
+  "split": "test",
+  "patient_id": "verse758",
+  "source_format": "miccai"
+}

scans/verse759/ct.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c3672b0113370e785817a6a2dd07cf31361b5aded516a2a54b36a02747f47a7
+size 44808136

scans/verse759/mask.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a58fbe75a1746315a8f582e5cc9547695e33408f8228ab72a98d40e6c6a81d7
+size 1626719

scans/verse759/meta.json

@@ -0,0 +1,26 @@
+{
+  "series_id": "verse759",
+  "source_tag": "canonical",
+  "files": {
+    "ct": "ct.nii.gz",
+    "mask": "mask.nii.gz"
+  },
+  "orientation_axcodes": [
+    "P",
+    "I",
+    "R"
+  ],
+  "spacing_mm": [
+    1.6748050451278687,
+    1.6748050451278687,
+    2.5
+  ],
+  "shape": [
+    512,
+    512,
+    168
+  ],
+  "split": "validation",
+  "patient_id": "verse759",
+  "source_format": "miccai"
+}

splits.csv

@@ -0,0 +1,11 @@
+series_id,split
+verse108,test
+verse236,test
+verse547,validation
+verse585,validation
+verse602,test
+verse631,training
+verse644,validation
+verse649,test
+verse758,test
+verse759,validation