Initial release: 12 checkpoints, inference and transfer code

.gitattributes

@@ -1,35 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,7 @@
+# Your filled-in metadata describes real patients -- keep it out of the repo.
+meta_files/
+predictions/
+
+__pycache__/
+*.py[cod]
+.DS_Store

LICENSE

@@ -0,0 +1,51 @@
+Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
+
+Copyright (c) 2026 Lu Jiang, Emily Hirata, Evan Porter, Di Xu, Jiayi Du,
+                Wensha Yang, Qihui Lyu, Minsong Cao, Ke Sheng
+                Department of Radiation Oncology,
+                University of California, San Francisco
+
+The model weights, source code and documentation in this repository are licensed
+under the Creative Commons Attribution-NonCommercial 4.0 International License.
+
+You are free to:
+
+  Share  — copy and redistribute the material in any medium or format
+  Adapt  — remix, transform, and build upon the material
+
+Under the following terms:
+
+  Attribution   — You must give appropriate credit, provide a link to the
+                  license, and indicate if changes were made. You may do so in
+                  any reasonable manner, but not in any way that suggests the
+                  licensor endorses you or your use.
+
+  NonCommercial — You may not use the material for commercial purposes.
+
+  No additional restrictions — You may not apply legal terms or technological
+                  measures that legally restrict others from doing anything the
+                  license permits.
+
+Full license text: https://creativecommons.org/licenses/by-nc/4.0/legalcode
+Human-readable summary: https://creativecommons.org/licenses/by-nc/4.0/
+
+--------------------------------------------------------------------------------
+NO CLINICAL USE
+
+These models are research artefacts. They are NOT a medical device, have not
+been reviewed or cleared by any regulatory body, and must not be used to plan,
+guide, verify or inform the treatment of any patient. Predicted dose
+distributions carry no guarantee of accuracy or deliverability.
+
+THE MATERIAL IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+--------------------------------------------------------------------------------
+THIRD-PARTY COMPONENTS
+
+Portions of the data pipeline are derived from the GDP-HMM / Flexible-CM GAN
+codebase (Gao et al., CVPR 2023). The C3D architecture follows Liu et al.,
+Medical Physics 2021. SwinUNETR is provided by MONAI (Apache 2.0) and MedNeXt by
+MIC-DKFZ (Apache 2.0); neither is redistributed here. Their respective licenses
+apply to those components.

README.md

@@ -0,0 +1,383 @@
+---
+license: cc-by-nc-4.0
+tags:
+  - radiotherapy
+  - dose-prediction
+  - medical-imaging
+  - transfer-learning
+  - 3d-segmentation
+  - pytorch
+library_name: pytorch
+pipeline_tag: image-to-image
+---
+
+# Transfer Learning for 3D Radiotherapy Dose Prediction
+
+Model weights and inference code for **"End-to-end Automated Radiotherapy Planning
+Using Transfer Learning to Overcome Data Scarcity"** (Jiang et al., Department of
+Radiation Oncology, UCSF).
+
+Pretrained and transfer-learned 3D dose-prediction models for head-and-neck and
+pancreas radiotherapy, across three architectures (**C3D**, **MedNeXt-B**,
+**SwinUNETR-L**).
+
+Each architecture ships three checkpoints so the effect of transfer learning is
+directly measurable:
+
+| checkpoint | what it is |
+|---|---|
+| `*_pretrained` | trained on a large public dose dataset (the **source domain**) |
+| `*_finetuned` | that model fine-tuned on the private target cohort |
+| `*_fromscratch` | same architecture and schedule, random init — the **no-transfer baseline** |
+
+> **Research use only.** Not a medical device, not cleared by any regulatory
+> body, and not to be used for treating patients. See [LICENSE](LICENSE).
+
+---
+
+## ⚠️ Read this first: the models do not all take the same input
+
+There are **three different input encodings** in this release. All of them are
+5-channel or 8-channel volumes of shape `(Z, Y, X) = (128, 192, 192)`, so
+feeding a model the wrong one **runs without error and silently produces wrong
+dose**. Every checkpoint records which encoding it expects in
+`ckpt["channel_spec"]`, and `src/inference.py` picks the matching data loader
+automatically.
+
+| encoding | channels | used by |
+|---|---|---|
+| `source_8ch` | 8 | all three `*_pretrained` checkpoints |
+| `han_5ch` | 5 | `c3d/mednext/swinunetr_finetuned` and `_fromscratch` |
+| `pancreas_5ch` | 5 | `pancreas_c3d_finetuned` and `_fromscratch` |
+
+`src/channels.py` is the authoritative spec. Print any of them with:
+
+```bash
+python src/channels.py
+```
+
+### The 8 source-domain channels (`*_pretrained`)
+
+The pretrained models come from a public challenge dataset that carried beam
+geometry and plan metadata:
+
+| ch | name | content |
+|---|---|---|
+| 0 | `comb_optptv` | optimisation PTVs (`OPTName` structures) × prescription/10, merged by voxel-wise max |
+| 1 | `comb_ptv` | planning PTVs (`StructName` structures) × prescription/10, merged by max |
+| 2 | `comb_oar` | all OARs in one label-encoded channel, each mask scaled by `1 + 4·i/30` |
+| 3 | `body` | binary external / BODY mask |
+| 4 | `img` | CT clipped to `[-1000, 1000]` HU, divided by 500 → `[-2, 2]` |
+| 5 | `beam_plate` | ray-traced beam paths from source through the PTV surface, inverse-square weighted, summed over gantry angles |
+| 6 | `angle_plate` | 2D gantry-angle map replicated over the ±5 slices around the isocentre in Z, zero elsewhere |
+| 7 | `prompt_extend` | `[isVMAT, n_PTVs, site, cohort]` broadcast into four equal blocks along Z |
+
+### **Which channels are unused, and why they were removed rather than zeroed**
+
+**The paper's models use 5 input channels.** The private target cohorts have no
+beam-geometry or plan-prompt information, so **channels 5, 6 and 7 carry no
+signal at all** for this data.
+
+They were **dropped, not zero-filled**. The released `*_finetuned` and
+`*_fromscratch` checkpoints physically have a 5-channel input stem — you cannot
+feed them 8 channels, and you should not pad your 5 channels to 8 for them.
+Channels 0–4 keep the same positions and meanings, which is what makes transfer
+possible; only the input stem changed shape. See
+[Transfer mechanics](#transfer-mechanics) below.
+
+The consequence for the `*_pretrained` checkpoints: they still expect 8
+channels, and they were trained with *real* beam and prompt channels, so they
+are published as a **fine-tuning starting point, not as a runnable predictor**
+on data that lacks those channels. `src/inference.py` refuses to run them by
+default. `channels.pad_to_source_8ch` exists for shape debugging only.
+
+### How the two 5-channel encodings differ
+
+Channels 3 (`body`) and 4 (`img`) are identical between HaN and pancreas.
+**Channels 0, 1 and 2 are not** — this is the trap:
+
+| ch | `han_5ch` | `pancreas_5ch` |
+|---|---|---|
+| 0 `comb_optptv` | PTV × Rx/10 | **PTV with every overlapping OAR subtracted** (`ptv · (1 − any_oar)`), × Rx/10 |
+| 1 `comb_ptv` | PTV × Rx/10 | PTV × **`min(Rx/10, 3.0)`** — the value is **capped at 30 Gy** |
+| 2 `comb_oar` | 23 HaN OARs, each scaled `1 + 4·i/30` → `[1.13, 4.07]` | 14 PancVMAT OARs in **two tiers**: dose-limiting OARs (Stomach, Bowel_Small, Bowel_Large + PRVs) → `[2.0, 2.5]`; all others → `[0.5, 0.8]` |
+
+Two consequences worth knowing:
+
+* **In `han_5ch`, channel 0 and channel 1 are byte-identical.** The HaN loader
+  builds the optimisation and planning PTV sets from the same `StructName`
+  masks, so the channel is duplicated. It is kept as a separate channel only to
+  preserve the pretrained model's layout. (Verified on real cases, not inferred
+  from the code.)
+* **In `pancreas_5ch`, channel 1 is capped at 3.0.** A 40 Gy PTV appears as
+  `3.0`, not `4.0`, while channel 0 for the same PTV is uncapped at `4.0`. If
+  you reimplement the pipeline and skip the cap, the model sees inputs it was
+  never trained on.
+
+The dose *target* differs too: HaN normalises the planned dose to the PTV_High
+D97 before dividing by `dose_div_factor`; pancreas does not renormalise
+(`norm_scale = 1.0`).
+
+---
+
+## Available weights
+
+All files are plain `state_dict` + metadata, safe under
+`torch.load(..., weights_only=True)`. SHA-256 sums are in
+[`weights/MANIFEST.json`](weights/MANIFEST.json).
+
+| file | arch | input encoding | params | size |
+|---|---|---|---|---|
+| `c3d_pretrained.pt` | C3D | `source_8ch` | 32.4 M | 129 MB |
+| `c3d_finetuned.pt` | C3D | `han_5ch` | 32.3 M | 129 MB |
+| `c3d_fromscratch.pt` | C3D | `han_5ch` | 32.3 M | 129 MB |
+| `mednext_pretrained.pt` | MedNeXt-B | `source_8ch` | 10.5 M | 42 MB |
+| `mednext_finetuned.pt` | MedNeXt-B | `han_5ch` | 10.5 M | 42 MB |
+| `mednext_fromscratch.pt` | MedNeXt-B | `han_5ch` | 10.5 M | 42 MB |
+| `swinunetr_pretrained.pt` | SwinUNETR-L | `source_8ch` | 291.4 M | 1169 MB |
+| `swinunetr_finetuned.pt` | SwinUNETR-L | `han_5ch` | 291.3 M | 1169 MB |
+| `swinunetr_fromscratch.pt` | SwinUNETR-L | `han_5ch` | 291.3 M | 1169 MB |
+| `pancreas_c3d_pretrained.pt` | C3D | `source_8ch` | 32.4 M | 129 MB |
+| `pancreas_c3d_finetuned.pt` | C3D | `pancreas_5ch` | 32.3 M | 129 MB |
+| `pancreas_c3d_fromscratch.pt` | C3D | `pancreas_5ch` | 32.3 M | 129 MB |
+
+Notes:
+
+* `pancreas_c3d_pretrained.pt` has **byte-identical weights** to
+  `c3d_pretrained.pt` — the pancreas model was fine-tuned **directly from the
+  source-domain model, not from the head-and-neck model**. It is duplicated so
+  the pancreas set stands alone; only its `scale_out` metadata differs.
+* The `*_pretrained` files have marginally more parameters than their 5-channel
+  descendants — that difference is entirely the 8- vs 5-channel input stem.
+
+## Output convention
+
+Every model emits a raw tensor that must be rescaled to physical dose:
+
+```
+dose_Gy = sigmoid(output) × scale_out × dose_div_factor
+```
+
+with `scale_out = 7.5` for head-and-neck, `5.5` for pancreas, and
+`dose_div_factor = 10` everywhere. `checkpoint.to_dose()` does this for you
+using each checkpoint's own constants.
+
+**C3D returns a list `[output_A, output_B]`** — `output_A` is the coarse first
+U-Net, **`output_B` is the refined prediction you want**. MedNeXt and SwinUNETR
+return a single tensor.
+
+---
+
+## Quick start
+
+```bash
+pip install -r requirements.txt
+# MedNeXt checkpoints only:
+pip install git+https://github.com/MIC-DKFZ/MedNeXt.git
+```
+
+Minimal load-and-predict:
+
+```python
+import sys, torch
+sys.path.insert(0, "src")
+from checkpoint import load_model, to_dose
+
+model, ckpt = load_model("weights/c3d_finetuned.pt", device="cuda")
+print(ckpt["channel_spec"], ckpt["channel_names"])
+# han_5ch ['comb_optptv', 'comb_ptv', 'comb_oar', 'body', 'img']
+
+x = torch.randn(1, 5, 128, 192, 192, device="cuda")   # your prepared input
+with torch.no_grad():
+    dose_gy = to_dose(model(x), ckpt)                 # [1, 1, 128, 192, 192] in Gy
+```
+
+Full inference over a dataset, writing NIfTI volumes:
+
+```bash
+cp -r meta_files_template/han meta_files      # then fill in your own cases
+# edit configs/c3d_han.yaml -> loader_params.data_root
+
+python src/inference.py \
+    --ckpt   weights/c3d_finetuned.pt \
+    --config configs/c3d_han.yaml \
+    --out    predictions/c3d_finetuned
+```
+
+The script derives the architecture, channel encoding, data loader and dose
+rescaling from the checkpoint, then per case: converts to Gy, clips to
+`clip_factor × PTV_High prescription`, zeroes everything outside the BODY mask,
+copies the CT's spacing/origin/direction, and writes `<case_id>_pred.nii.gz`.
+
+Inspect a checkpoint's expected channels without running anything:
+
+```bash
+python src/inference.py --ckpt weights/pancreas_c3d_finetuned.pt \
+    --config configs/c3d_pancreas.yaml --out /tmp/x --describe
+```
+
+---
+
+## Transfer mechanics
+
+How the `*_finetuned` checkpoints were actually produced, so you can reproduce
+it on your own data.
+
+Every tensor whose shape matched was copied from the pretrained model; the rest
+kept their fresh initialisation. Because only the input channel count changed,
+that means **only the input stem was re-initialised**:
+
+| architecture | transferred | re-initialised |
+|---|---|---|
+| C3D | 170 / 172 | `net_A.encoder.encoder_1.0.single_conv.0.weight` (16,8,3,3,3 → 16,5,3,3,3), `net_B...` (32,24 → 32,21) |
+| MedNeXt-B | 228 / 229 | `stem.weight` (32,8,1,1,1 → 32,5,1,1,1) |
+| SwinUNETR-L | 164 / 167 | `swinViT.patch_embed.proj.weight`, `encoder1.layer.conv1.conv.weight`, `encoder1.layer.conv3.conv.weight` |
+
+**No channel slicing, averaging or repetition was applied to the input stem** —
+it was simply retrained from scratch alongside the rest of the network.
+
+`src/transfer.py` reproduces this exactly:
+
+```python
+import sys; sys.path.insert(0, "src")
+from build_model import build_model
+from transfer import load_pretrained_into
+
+model  = build_model("c3d", in_channels=5)      # your own channel count
+report = load_pretrained_into(model, "weights/c3d_pretrained.pt")
+print(report)      # names every tensor that was NOT transferred -- read it
+```
+
+Training hyperparameters used for the released head-and-neck C3D run: Adam,
+`lr = 3e-5`, `weight_decay = 1e-4`, cosine schedule to `eta_min = 1e-7`,
+275 epochs. The `_fromscratch` baseline used the same schedule at `lr = 1e-4`.
+
+---
+
+## Repository layout
+
+```
+├── README.md
+├── LICENSE                       CC BY-NC 4.0 + no-clinical-use notice
+├── requirements.txt
+├── configs/                      one YAML per model/anatomy
+│   ├── c3d_han.yaml
+│   ├── mednext_han.yaml
+│   ├── swinunetr_han.yaml
+│   └── c3d_pancreas.yaml
+├── src/
+│   ├── channels.py               THE channel spec -- read this first
+│   ├── model_c3d.py              C3D architecture
+│   ├── build_model.py            arch name + channel count -> model
+│   ├── checkpoint.py             loading weights, rescaling output to Gy
+│   ├── transfer.py               warm-starting your own model
+│   ├── inference.py              dataset -> NIfTI dose volumes
+│   ├── data_loader_han.py        produces han_5ch
+│   ├── toolkit_han.py
+│   ├── data_loader_pancreas.py   produces pancreas_5ch
+│   └── toolkit_pancreas.py
+├── meta_files_template/          de-identified metadata schema + data layout
+│   ├── han/  pancreas/  README.md
+├── weights/                      12 checkpoints + MANIFEST.json
+└── tools/
+    └── convert_checkpoints.py    provenance: raw training ckpts -> weights/*.pt
+```
+
+Training code (loss functions, trainer loop, W&B logging, evaluation) is **not**
+included — this release is scoped to using the weights. Everything needed for
+that is here: architectures, both data loaders, inference, and transfer.
+
+### What is not published
+
+* **The training data.** Both target cohorts are private patient data.
+* **The real metadata files.** `meta_files_template/` gives the schema instead.
+* **Few-shot and low-LR checkpoints.** The study also produced 5/10/20/50 %
+  few-shot runs (two seeds each) and a low-learning-rate variant. They are not
+  in this release; open an issue if you need them.
+
+---
+
+## Citation
+
+If you use these weights or code, please cite:
+
+```bibtex
+@article{jiang_endtoend_rtplanning,
+  title   = {End-to-end Automated Radiotherapy Planning Using Transfer Learning
+             to Overcome Data Scarcity},
+  author  = {Jiang, Lu and Hirata, Emily and Porter, Evan and Xu, Di and Du, Jiayi
+             and Yang, Wensha and Lyu, Qihui and Cao, Minsong and Sheng, Ke},
+  journal = {Medical Physics},
+  year    = {2026},
+  note    = {In press; DOI to be assigned}
+}
+```
+
+> This paper has been provisionally accepted at *Medical Physics*. The BibTeX
+> entry above will be updated with the final volume, pages and DOI once they are
+> assigned.
+
+**Authors:** Lu Jiang, Emily Hirata, Evan Porter, Di Xu, Jiayi Du, Wensha Yang,
+Qihui Lyu, Minsong Cao, Ke Sheng — Department of Radiation Oncology, University
+of California, San Francisco.
+
+**Corresponding author:** Ke Sheng, PhD — Professor and Vice Chair of Medical
+Physics, Department of Radiation Oncology, UCSF —
+[ke.sheng@ucsf.edu](mailto:ke.sheng@ucsf.edu)
+
+**Paper:** *Medical Physics* (in press) &nbsp;·&nbsp; **Model repository:**
+`https://huggingface.co/<your-username>/radiotherapy-dose-prediction-transfer-learning`
+
+## Please also cite the work this builds on
+
+```bibtex
+@inproceedings{gao2023flexible,
+  title     = {Flexible-CM GAN: Towards Precise 3D Dose Prediction in Radiotherapy},
+  author    = {Gao, Riqiang and Lou, Bin and Xu, Zhoubing and Comaniciu, Dorin and Kamen, Ali},
+  booktitle = {CVPR},
+  year      = {2023}
+}
+
+@article{liu2021cascade,
+  title   = {A cascade 3D U-Net for dose prediction in radiotherapy},
+  author  = {Liu, Shuolin and Zhang, Jingjing and Li, Teng and Yan, Hui and Liu, Jianfei},
+  journal = {Medical Physics},
+  year    = {2021}
+}
+
+@inproceedings{roy2023mednext,
+  title     = {MedNeXt: Transformer-driven Scaling of ConvNets for Medical Image Segmentation},
+  author    = {Roy, Saikat and Koehler, Gregor and Ulrich, Constantin and Baumgartner, Michael
+               and Petersen, Jens and Isensee, Fabian and Jaeger, Paul F and Maier-Hein, Klaus},
+  booktitle = {MICCAI},
+  year      = {2023}
+}
+
+@inproceedings{hatamizadeh2022swinunetr,
+  title     = {Swin UNETR: Swin Transformers for Semantic Segmentation of Brain Tumors in MRI Images},
+  author    = {Hatamizadeh, Ali and Nath, Vishwesh and Tang, Yucheng and Yang, Dong
+               and Roth, Holger R and Xu, Daguang},
+  booktitle = {MICCAI Brainlesion Workshop},
+  year      = {2022}
+}
+```
+
+## Ethics and funding
+
+This retrospective study was approved by the Institutional Review Board of the
+University of California, San Francisco (**IRB #24-42071**); the requirement for
+informed consent was waived. The private UCSF head-and-neck and pancreas
+cohorts used for fine-tuning and evaluation are not redistributed here; only
+model weights and code are.
+
+Supported by **NIH R01CA255432**, **NIH R44CA183390**, and **NIH R01CA259008**.
+
+**Disclosures.** Dr. Ke Sheng reports grant funding from the National Institutes
+of Health (NIH). Dr. Minsong Cao reports consulting fees and honoraria from
+Varian Medical Systems, Siemens Healthineers, and the Medical Dosimetrist
+Certification Board. The other authors declare no conflicts of interest.
+
+## License
+
+[CC BY-NC 4.0](LICENSE) — attribution required, non-commercial use only.
+**Research use only; not for clinical use.**

configs/c3d_han.yaml

@@ -0,0 +1,35 @@
+# C3D (cascade 3D U-Net) on head-and-neck data
+#
+# Paths are resolved relative to the repository root -- run inference from there.
+# Copy meta_files_template/ to meta_files/ and fill it with your own cases first.
+
+loader_params:
+
+    train_bs: 4
+    val_bs: 4
+    test_bs: 4
+    num_workers: 8
+
+    csv_root:        'meta_files/meta_data.csv'
+    scale_dose_dict: 'meta_files/ptv_dict.json'
+    pat_obj_dict:    'meta_files/oar_dict.json'
+    data_root:       '/path/to/DATA/HaN'      # <-- point this at your data
+
+    # CT intensity normalisation: clip to [down_HU, up_HU], then divide by denom_norm_HU
+    down_HU: -1000
+    up_HU: 1000
+    denom_norm_HU: 500
+
+    in_size:  [128, 192, 192]    # Z, Y, X -- crop/pad size around the isocentre
+    out_size: [128, 192, 192]    # Z, Y, X -- resampled network input size
+
+    norm_oar: True               # scale each OAR label rather than using raw indices
+    CatStructures: False         # False -> merge OARs into 1 channel and PTVs into 1 channel
+                                 # (must stay False: the released weights take 5 channels)
+
+    dose_div_factor: 10          # dose targets are divided by this
+    with_aug: True               # only affects the 'train' split; inference always uses tt_augmentation
+
+# Output rescaling. dose_Gy = sigmoid(out) * scale_out * dose_div_factor
+act_sig: True
+scale_out: 7.5

configs/c3d_pancreas.yaml

@@ -0,0 +1,35 @@
+# C3D (cascade 3D U-Net) on pancreas VMAT data
+#
+# Paths are resolved relative to the repository root -- run inference from there.
+# Copy meta_files_template/ to meta_files/ and fill it with your own cases first.
+
+loader_params:
+
+    train_bs: 4
+    val_bs: 4
+    test_bs: 4
+    num_workers: 8
+
+    csv_root:        'meta_files/meta_data.csv'
+    scale_dose_dict: 'meta_files/ptv_dict.json'
+    pat_obj_dict:    'meta_files/oar_dict.json'
+    data_root:       '/path/to/DATA/PancVMAT'      # <-- point this at your data
+
+    # CT intensity normalisation: clip to [down_HU, up_HU], then divide by denom_norm_HU
+    down_HU: -1000
+    up_HU: 1000
+    denom_norm_HU: 500
+
+    in_size:  [128, 192, 192]    # Z, Y, X -- crop/pad size around the isocentre
+    out_size: [128, 192, 192]    # Z, Y, X -- resampled network input size
+
+    norm_oar: True               # scale each OAR label rather than using raw indices
+    CatStructures: False         # False -> merge OARs into 1 channel and PTVs into 1 channel
+                                 # (must stay False: the released weights take 5 channels)
+
+    dose_div_factor: 10          # dose targets are divided by this
+    with_aug: True               # only affects the 'train' split; inference always uses tt_augmentation
+
+# Output rescaling. dose_Gy = sigmoid(out) * scale_out * dose_div_factor
+act_sig: True
+scale_out: 5.5

configs/mednext_han.yaml

@@ -0,0 +1,35 @@
+# MedNeXt-B (kernel 3) on head-and-neck data
+#
+# Paths are resolved relative to the repository root -- run inference from there.
+# Copy meta_files_template/ to meta_files/ and fill it with your own cases first.
+
+loader_params:
+
+    train_bs: 2
+    val_bs: 2
+    test_bs: 2
+    num_workers: 8
+
+    csv_root:        'meta_files/meta_data.csv'
+    scale_dose_dict: 'meta_files/ptv_dict.json'
+    pat_obj_dict:    'meta_files/oar_dict.json'
+    data_root:       '/path/to/DATA/HaN'      # <-- point this at your data
+
+    # CT intensity normalisation: clip to [down_HU, up_HU], then divide by denom_norm_HU
+    down_HU: -1000
+    up_HU: 1000
+    denom_norm_HU: 500
+
+    in_size:  [128, 192, 192]    # Z, Y, X -- crop/pad size around the isocentre
+    out_size: [128, 192, 192]    # Z, Y, X -- resampled network input size
+
+    norm_oar: True               # scale each OAR label rather than using raw indices
+    CatStructures: False         # False -> merge OARs into 1 channel and PTVs into 1 channel
+                                 # (must stay False: the released weights take 5 channels)
+
+    dose_div_factor: 10          # dose targets are divided by this
+    with_aug: True               # only affects the 'train' split; inference always uses tt_augmentation
+
+# Output rescaling. dose_Gy = sigmoid(out) * scale_out * dose_div_factor
+act_sig: True
+scale_out: 7.5

configs/swinunetr_han.yaml

@@ -0,0 +1,35 @@
+# SwinUNETR-L (feature_size 96, v2) on head-and-neck data
+#
+# Paths are resolved relative to the repository root -- run inference from there.
+# Copy meta_files_template/ to meta_files/ and fill it with your own cases first.
+
+loader_params:
+
+    train_bs: 2
+    val_bs: 2
+    test_bs: 2
+    num_workers: 8
+
+    csv_root:        'meta_files/meta_data.csv'
+    scale_dose_dict: 'meta_files/ptv_dict.json'
+    pat_obj_dict:    'meta_files/oar_dict.json'
+    data_root:       '/path/to/DATA/HaN'      # <-- point this at your data
+
+    # CT intensity normalisation: clip to [down_HU, up_HU], then divide by denom_norm_HU
+    down_HU: -1000
+    up_HU: 1000
+    denom_norm_HU: 500
+
+    in_size:  [128, 192, 192]    # Z, Y, X -- crop/pad size around the isocentre
+    out_size: [128, 192, 192]    # Z, Y, X -- resampled network input size
+
+    norm_oar: True               # scale each OAR label rather than using raw indices
+    CatStructures: False         # False -> merge OARs into 1 channel and PTVs into 1 channel
+                                 # (must stay False: the released weights take 5 channels)
+
+    dose_div_factor: 10          # dose targets are divided by this
+    with_aug: True               # only affects the 'train' split; inference always uses tt_augmentation
+
+# Output rescaling. dose_Gy = sigmoid(out) * scale_out * dose_div_factor
+act_sig: True
+scale_out: 7.5

meta_files_template/README.md

@@ -0,0 +1,68 @@
+# Metadata templates
+
+The released data loaders read three metadata files. The real ones describe a
+private patient cohort and are not published, so these are **de-identified
+templates showing the exact schema** — copy the folder for your anatomy to
+`meta_files/` at the repository root and fill it in with your own cases.
+
+```bash
+cp -r meta_files_template/han meta_files          # head and neck
+# or
+cp -r meta_files_template/pancreas meta_files     # pancreas
+```
+
+The `PatientID` values here (`case_0001`, …) are placeholders. Whatever you use
+must match the case directory names under `data_root`.
+
+## `meta_data.csv`
+
+One row per case. Read by `pandas.read_csv`.
+
+| column | meaning |
+|---|---|
+| `PatientID` | case id; must equal the directory name under `data_root/<split>/` |
+| `dev_split` | `train`, `valid` or `test` — this is what selects the split |
+| `phase` | free-text bookkeeping column; not used by the loader |
+| `site` | anatomical site code. **Must be `< 1.5` (use `1`) for the HaN loader**, which raises `NotImplementedError` otherwise. Any value works for the pancreas loader. |
+| `cohort` | cohort code; forwarded into `data_dict['prompt']` only |
+| `num_OAR`, `num_PTV` | bookkeeping columns; not used by the loader |
+
+## `ptv_dict.json`
+
+`PatientID -> {PTV_High|PTV_Mid|PTV_Low: {PDose, StructName}}`.
+
+`PDose` is the prescription in Gy. `StructName` is the filename stem under
+`Masks/PTV/`, so `"StructName": "PTV_70"` means `Masks/PTV/PTV_70.nii.gz`.
+
+`PTV_High` is required — inference clips predictions at a multiple of its
+`PDose`, and the HaN loader normalises the dose target to its D97.
+
+## `oar_dict.json`
+
+`PatientID -> [OAR names]`, listing which OARs to load for that case. Names are
+filename stems under `Masks/OAR/`. Names not in the loader's site OAR list
+(`HaN_OAR_LIST` / `Panc_OAR_LIST`) are ignored; listed-but-missing files are
+silently treated as empty masks.
+
+Order does not matter — the channel encoding uses each OAR's index in the
+loader's own list, not its position here. See `src/channels.py`.
+
+## Expected data layout
+
+```
+data_root/
+├── train_valid/          <- cases with dev_split = train or valid
+│   └── <PatientID>/
+│       ├── CT.nii.gz
+│       ├── dose.nii.gz            (not needed for inference)
+│       └── Masks/
+│           ├── BODY.nii.gz
+│           ├── PTV/<StructName>.nii.gz
+│           └── OAR/<OARName>.nii.gz
+└── test/                 <- cases with dev_split = test
+    └── <PatientID>/ ...
+```
+
+All volumes for a case must share a grid; they are read with `nibabel` and
+transposed to `(Z, Y, X)`, then cropped/padded to `in_size` around the volume
+centre and resampled to `out_size`.

meta_files_template/han/meta_data.csv

@@ -0,0 +1,4 @@
+PatientID,dev_split,phase,site,cohort,num_OAR,num_PTV
+case_0001,train,train,1,2,21,3
+case_0002,valid,train,1,2,19,2
+case_0003,test,test,1,2,22,3

meta_files_template/han/oar_dict.json

@@ -0,0 +1,14 @@
+{
+  "case_0001": ["Bone_Mandible", "Brainstem", "Cavity_Oral", "Esophagus", "Glnd_Thyroid",
+                "Larynx", "Parotid_L", "Parotid_R", "SpinalCord", "Submandibular_L",
+                "Submandibular_R", "Brain", "Eye_L", "Eye_R", "OpticNrv_L", "OpticNrv_R",
+                "OpticChiasm", "Lens_L", "Lens_R", "Lips", "Trachea"],
+  "case_0002": ["Bone_Mandible", "Brainstem", "Cavity_Oral", "Esophagus", "Glnd_Thyroid",
+                "Larynx", "Parotid_L", "Parotid_R", "SpinalCord", "Submandibular_L",
+                "Submandibular_R", "Brain", "Eye_L", "Eye_R", "OpticNrv_L", "OpticNrv_R",
+                "OpticChiasm", "Lips", "Trachea"],
+  "case_0003": ["Bone_Mandible", "Brainstem", "Cavity_Oral", "Esophagus", "Glnd_Thyroid",
+                "Larynx", "Parotid_L", "Parotid_R", "SpinalCord", "Submandibular_L",
+                "Submandibular_R", "Brain", "Eye_L", "Eye_R", "OpticNrv_L", "OpticNrv_R",
+                "OpticChiasm", "Lens_L", "Lens_R", "Lips", "Trachea", "Lung_L"]
+}

meta_files_template/han/ptv_dict.json

@@ -0,0 +1,16 @@
+{
+  "case_0001": {
+    "PTV_High": {"PDose": 70, "StructName": "PTV_70"},
+    "PTV_Mid":  {"PDose": 59, "StructName": "PTV_59"},
+    "PTV_Low":  {"PDose": 54, "StructName": "PTV_54"}
+  },
+  "case_0002": {
+    "PTV_High": {"PDose": 66, "StructName": "PTV_66"},
+    "PTV_Low":  {"PDose": 54, "StructName": "PTV_54"}
+  },
+  "case_0003": {
+    "PTV_High": {"PDose": 70, "StructName": "PTV_70"},
+    "PTV_Mid":  {"PDose": 63, "StructName": "PTV_63"},
+    "PTV_Low":  {"PDose": 56, "StructName": "PTV_56"}
+  }
+}

meta_files_template/pancreas/meta_data.csv

@@ -0,0 +1,4 @@
+PatientID,dev_split,phase,site,cohort,num_OAR,num_PTV
+case_0001,train,train,2,1,7,2
+case_0002,valid,train,2,1,10,1
+case_0003,test,test,2,1,13,1

meta_files_template/pancreas/oar_dict.json

@@ -0,0 +1,9 @@
+{
+  "case_0001": ["Kidney_L", "Kidney_R", "Liver", "SpinalCord", "Stomach",
+                "Bowel_Small", "Bowel_Large"],
+  "case_0002": ["Kidney_L", "Kidney_R", "Kidneys", "Liver", "SpinalCord", "SpinalCanal",
+                "Esophagus", "Stomach", "Bowel_Small", "Bowel_Large"],
+  "case_0003": ["Kidney_L", "Kidney_R", "Kidneys", "Liver", "SpinalCord", "SpinalCanal",
+                "Esophagus", "Heart", "Stomach", "Stomach_PRV", "Bowel_Small",
+                "Bowel_Small_PRV", "Bowel_Large"]
+}

meta_files_template/pancreas/ptv_dict.json

@@ -0,0 +1,8 @@
+{
+  "case_0001": {
+    "PTV_High": {"PDose": 55, "StructName": "PTV_55"},
+    "PTV_Mid":  {"PDose": 50, "StructName": "PTV_50"}
+  },
+  "case_0002": {"PTV_High": {"PDose": 40, "StructName": "PTV_40"}},
+  "case_0003": {"PTV_High": {"PDose": 45, "StructName": "PTV_45"}}
+}

requirements.txt

@@ -0,0 +1,22 @@
+# Core (needed for every model)
+torch>=2.0
+numpy>=1.24
+nibabel>=5.0
+SimpleITK>=2.2
+pandas>=2.0
+PyYAML>=6.0
+scipy>=1.10
+tqdm>=4.65
+
+# MONAI provides the data-augmentation transforms used by both data loaders,
+# and the SwinUNETR architecture.
+#
+# These models were trained with MONAI < 1.3, whose SwinUNETR took an `img_size`
+# argument that was removed in 1.5. src/build_model.py passes it only when the
+# installed version accepts it, so 1.2 through 1.5+ all work and load the same
+# weights -- the argument never affected the parameters.
+monai>=1.2
+
+# MedNeXt checkpoints only. Not on PyPI; install from source:
+#   pip install git+https://github.com/MIC-DKFZ/MedNeXt.git
+# nnunet_mednext

src/build_model.py

@@ -0,0 +1,84 @@
+"""
+One place that turns an architecture name + input-channel count into a model.
+
+The three architectures are built exactly as they were during training, so the
+released state_dicts load with `strict=True`. If you change any argument here
+(feature_size, model_id, list_ch_*, ...) the checkpoints will no longer fit.
+
+MedNeXt and SwinUNETR are imported lazily so that, e.g., running the C3D model
+does not require the MedNeXt package to be installed.
+"""
+
+import torch.nn as nn
+
+# --- architecture arguments, frozen to match the released checkpoints -------
+C3D_KWARGS = dict(
+    list_ch_A=[-1, 16, 32, 64, 128, 256],
+    list_ch_B=[-1, 32, 64, 128, 256, 512],
+)
+
+MEDNEXT_KWARGS = dict(
+    model_id="B",
+    kernel_size=3,
+    deep_supervision=False,
+)
+
+SWINUNETR_KWARGS = dict(
+    spatial_dims=3,
+    feature_size=96,            # "L" size
+    dropout_path_rate=0.1,
+    use_v2=True,
+    use_checkpoint=True,
+)
+
+# These models were trained with MONAI < 1.3, whose SwinUNETR took an `img_size`
+# argument. It was only used to sanity-check the window size and never affected
+# the parameters, and MONAI removed it in 1.5. We pass it only if the installed
+# version still accepts it, so one checkpoint works across MONAI versions.
+SWINUNETR_IMG_SIZE = (128, 192, 192)   # Z, Y, X
+
+ARCHITECTURES = ("c3d", "mednext", "swinunetr")
+
+
+def build_model(arch: str, in_channels: int = 5, out_channels: int = 1) -> nn.Module:
+    """
+    Build an untrained model.
+
+    arch         : one of ARCHITECTURES
+    in_channels  : 5 for every fine-tuned / from-scratch checkpoint,
+                   8 for the source-domain *pretrained* checkpoints
+    out_channels : 1 (dose)
+
+    Note the C3D forward returns a list ``[output_A, output_B]``; ``output_B``
+    is the refined prediction and the one you want. MedNeXt and SwinUNETR
+    return a single tensor.
+    """
+    arch = arch.lower()
+
+    if arch == "c3d":
+        from model_c3d import Model
+        return Model(in_ch=in_channels, out_ch=out_channels, **C3D_KWARGS)
+
+    if arch == "mednext":
+        # pip install git+https://github.com/MIC-DKFZ/MedNeXt.git
+        from nnunet_mednext import create_mednext_v1
+        return create_mednext_v1(
+            num_input_channels=in_channels,
+            num_classes=out_channels,
+            **MEDNEXT_KWARGS,
+        )
+
+    if arch == "swinunetr":
+        import inspect
+        from monai.networks.nets import SwinUNETR
+
+        kwargs = dict(SWINUNETR_KWARGS)
+        if "img_size" in inspect.signature(SwinUNETR.__init__).parameters:
+            kwargs["img_size"] = SWINUNETR_IMG_SIZE
+        return SwinUNETR(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            **kwargs,
+        )
+
+    raise ValueError(f"unknown arch {arch!r}; expected one of {ARCHITECTURES}")

src/channels.py

@@ -0,0 +1,129 @@
+"""
+The single source of truth for what every input channel means.
+
+There are three different input encodings in this release. Getting them mixed up
+is the easiest way to get silently wrong dose predictions, so they are all
+spelled out here and every checkpoint records which one it expects
+(``ckpt["channel_spec"]``).
+
+    SOURCE_8CH    the 8-channel encoding the *pretrained* checkpoints expect
+    HAN_5CH       the 5-channel encoding the head-and-neck models expect
+    PANCREAS_5CH  the 5-channel encoding the pancreas model expects
+
+The first five channels line up positionally across all three, which is why
+transfer learning works at all. They are NOT numerically interchangeable --
+see the per-spec notes below.
+
+Dose-valued channels are always divided by ``dose_div_factor`` (10), so a 70 Gy
+prescription appears as 7.0.
+"""
+
+# --------------------------------------------------------------------------
+# 8-channel source-domain encoding (the *_pretrained.pt checkpoints)
+# --------------------------------------------------------------------------
+# Reproduced from the pretraining data loader (GDP-HMM / RT dose challenge
+# codebase), whose pipeline follows Gao et al., "Flexible-CM GAN", CVPR 2023.
+SOURCE_8CH = [
+    ("comb_optptv",   "Optimisation PTVs (the plan's OPTName structures), each "
+                      "multiplied by its prescription/10, merged by voxel-wise max."),
+    ("comb_ptv",      "Planning PTVs (the StructName structures), each multiplied "
+                      "by its prescription/10, merged by voxel-wise max."),
+    ("comb_oar",      "All OARs merged into one label-encoded channel: each mask "
+                      "scaled by 1 + 4*i/30 (i = index in the site's OAR list), "
+                      "merged by max."),
+    ("body",          "Binary external / BODY mask."),
+    ("img",           "CT, clipped to [-1000, 1000] HU and divided by 500 -> [-2, 2]."),
+    ("beam_plate",    "Beam geometry map: for each gantry angle, rays are traced "
+                      "from the source through the PTV surface, dilated/eroded and "
+                      "weighted by inverse-square distance; summed over all angles."),
+    ("angle_plate",   "2D gantry-angle map replicated over the +/-5 slices around "
+                      "the isocentre in Z; zero on every other slice."),
+    ("prompt_extend", "Plan metadata [isVMAT, n_PTVs, site, cohort] broadcast to a "
+                      "full volume as four equal blocks stacked along Z."),
+]
+
+# --------------------------------------------------------------------------
+# 5-channel head-and-neck encoding (c3d/mednext/swinunetr _finetuned/_fromscratch)
+# --------------------------------------------------------------------------
+# Channels 5-7 of the source encoding are DROPPED, not zero-filled: the released
+# HaN models physically have a 5-channel input stem. The private HaN dataset has
+# no beam geometry or plan-prompt metadata, so those three channels carried no
+# signal and were removed rather than fed as zeros.
+HAN_5CH = [
+    ("comb_optptv",   "PTVs multiplied by prescription/10, merged by max. "
+                      "NOTE: byte-identical to channel 1 -- the HaN loader builds "
+                      "the optimisation and planning PTV sets from the same "
+                      "StructName masks. Kept as a separate channel only to match "
+                      "the pretrained model's layout."),
+    ("comb_ptv",      "Same as channel 0. See the note above."),
+    ("comb_oar",      "23 HaN OARs merged into one channel, each mask scaled by "
+                      "1 + 4*i/30 for i = 1..23, merged by max -> values in "
+                      "[1.13, 4.07]."),
+    ("body",          "Binary external / BODY mask."),
+    ("img",           "CT, clipped to [-1000, 1000] HU and divided by 500 -> [-2, 2]."),
+]
+
+# --------------------------------------------------------------------------
+# 5-channel pancreas encoding (pancreas_c3d_finetuned / _fromscratch)
+# --------------------------------------------------------------------------
+# Same five slots as HAN_5CH, but channels 0, 1 and 2 are computed differently.
+# A HaN-encoded volume fed to the pancreas model (or vice versa) will run
+# without error and give wrong answers.
+PANCREAS_5CH = [
+    ("comb_optptv",   "PTVs with every overlapping OAR subtracted "
+                      "(ptv * (1 - any_oar)), then multiplied by prescription/10. "
+                      "Models the sub-volume that can realistically reach the "
+                      "prescription. NOT equal to channel 1."),
+    ("comb_ptv",      "PTVs multiplied by min(prescription/10, 3.0) -- the value is "
+                      "CAPPED at 30 Gy. A 40 Gy PTV appears as 3.0, not 4.0."),
+    ("comb_oar",      "14 PancVMAT OARs merged into one channel with two tiers: "
+                      "dose-limiting OARs (Stomach, Bowel_Small, Bowel_Large and "
+                      "their PRVs) scale to 2.0 + 0.5*i/14 -> [2.0, 2.5]; all other "
+                      "OARs scale to 0.5 + 0.3*i/14 -> [0.5, 0.8]."),
+    ("body",          "Binary external / BODY mask."),
+    ("img",           "CT, clipped to [-1000, 1000] HU and divided by 500 -> [-2, 2]."),
+]
+
+CHANNEL_SPECS = {
+    "source_8ch": SOURCE_8CH,
+    "han_5ch": HAN_5CH,
+    "pancreas_5ch": PANCREAS_5CH,
+}
+
+
+def names(spec):
+    """Channel names for a spec key, in order."""
+    return [n for n, _ in CHANNEL_SPECS[spec]]
+
+
+def describe(spec):
+    """Human-readable description of a channel spec."""
+    lines = [f"{spec} ({len(CHANNEL_SPECS[spec])} channels)"]
+    for i, (name, doc) in enumerate(CHANNEL_SPECS[spec]):
+        lines.append(f"  ch{i}  {name}")
+        lines.append(f"        {doc}")
+    return "\n".join(lines)
+
+
+def pad_to_source_8ch(x):
+    """
+    Zero-pad a 5-channel batch [B, 5, Z, Y, X] to the 8-channel source layout.
+
+    This lets a *_pretrained.pt checkpoint run on data prepared by the released
+    5-channel loaders, but the result is not a meaningful dose prediction: the
+    pretrained model was trained with real beam_plate / angle_plate / prompt
+    channels and relies on them. Use it for shape debugging and for warm-starting
+    your own fine-tuning, not for evaluation.
+    """
+    import torch
+
+    if x.shape[1] != 5:
+        raise ValueError(f"expected 5 input channels, got {x.shape[1]}")
+    pad = torch.zeros(x.shape[0], 3, *x.shape[2:], dtype=x.dtype, device=x.device)
+    return torch.cat((x, pad), dim=1)
+
+
+if __name__ == "__main__":
+    for key in CHANNEL_SPECS:
+        print(describe(key))
+        print()

src/checkpoint.py

@@ -0,0 +1,71 @@
+"""
+Loading the released weights.
+
+Every file under weights/ is a plain dict of tensors + primitives, so it loads
+under `torch.load(..., weights_only=True)` -- no custom classes, no pickled
+training objects, no need to have this repo importable to read it.
+
+Layout of a checkpoint file::
+
+    {
+      "state_dict":   OrderedDict[str, Tensor],   # no "module." prefix
+      "arch":         "c3d" | "mednext" | "swinunetr",
+      "in_channels":  8 (pretrained) or 5 (finetuned / fromscratch),
+      "out_channels": 1,
+      "anatomy":      "han" | "pancreas" | "source-domain",
+      "regime":       "pretrained" | "finetuned" | "fromscratch",
+      "act_sig":      True,        # apply sigmoid to the raw output
+      "scale_out":    7.5 | 5.5,   # then multiply by this
+      "dose_div_factor": 10,       # then multiply by this -> dose in Gy
+      "source": "...", "note": "...",
+    }
+
+So the raw network output becomes physical dose as::
+
+    dose_Gy = sigmoid(out) * scale_out * dose_div_factor
+"""
+
+import torch
+
+from build_model import build_model
+
+
+def load_checkpoint(path, map_location="cpu"):
+    """Read a released checkpoint file. Returns the full dict."""
+    return torch.load(path, map_location=map_location, weights_only=True)
+
+
+def load_model(path, device="cpu", strict=True):
+    """
+    Build the right architecture for a checkpoint and load its weights.
+
+    Returns ``(model_in_eval_mode, checkpoint_dict)``. The checkpoint dict
+    carries the post-processing constants (``act_sig``, ``scale_out``,
+    ``dose_div_factor``) you need to turn the output into Gy.
+    """
+    ckpt = load_checkpoint(path, map_location="cpu")
+
+    model = build_model(
+        ckpt["arch"],
+        in_channels=ckpt["in_channels"],
+        out_channels=ckpt.get("out_channels", 1),
+    )
+    model.load_state_dict(ckpt["state_dict"], strict=strict)
+    model.to(device).eval()
+    return model, ckpt
+
+
+def to_dose(output, ckpt):
+    """
+    Convert a raw network output to dose in Gy using the checkpoint's own
+    constants. Handles C3D's ``[output_A, output_B]`` and MedNeXt's optional
+    deep-supervision list by taking the refined / main head.
+    """
+    if isinstance(output, (list, tuple)):
+        # C3D: [coarse A, refined B] -> take B. MedNeXt DS: [main, aux...] -> take main.
+        output = output[-1] if ckpt["arch"] == "c3d" else output[0]
+
+    if ckpt.get("act_sig", True):
+        output = torch.sigmoid(output)
+
+    return output * ckpt["scale_out"] * ckpt["dose_div_factor"]

src/data_loader_han.py

@@ -0,0 +1,259 @@
+"""
+Data loader for the head-and-neck (HaN) dose-prediction models.
+
+Produces the 5-channel input the released HaN checkpoints expect:
+
+    data_dict['data']  : [B, 5, 128, 192, 192]  (Z, Y, X)
+        ch0 comb_optptv - PTVs weighted by prescription dose (optimisation set)
+        ch1 comb_ptv    - PTVs weighted by prescription dose
+        ch2 comb_oar    - all OARs merged into one label-encoded channel
+        ch3 body        - external/BODY mask
+        ch4 img         - CT, clipped to [down_HU, up_HU] and divided by denom_norm_HU
+    data_dict['label'] : [B, 1, 128, 192, 192]  dose, D97-normalised and
+                         divided by `dose_div_factor`, masked by BODY
+
+The *pretrained* (source-domain) checkpoints instead take 8 channels: the five
+above plus beam_plate, angle_plate and prompt_extend. Those three are all-zero
+for this dataset, which is why the released transfer-learned models drop them.
+See README.md for how the input stem was re-initialised.
+
+Data pipeline derived from:
+    Riqiang Gao, Bin Lou, Zhoubing Xu, Dorin Comaniciu, and Ali Kamen.
+    "Flexible-CM GAN: Towards Precise 3D Dose Prediction in Radiotherapy."
+    CVPR 2023.
+"""
+
+
+
+from torch.utils.data import Dataset, DataLoader
+import pandas as pd
+import torch
+import numpy as np
+import json
+import yaml
+
+from scipy import ndimage 
+from toolkit_han import *
+
+HaN_OAR_LIST = ["Bone_Mandible",
+                "Brainstem",
+                "Cavity_Oral",
+                "Esophagus",
+                "Glnd_Thyroid",
+                "Larynx",
+                "Parotid_L",
+                "Parotid_R",
+                "SpinalCord",
+                "Submandibular_L",
+                "Submandibular_R",
+                
+                "Brain",
+                "Eye_L",
+                "Eye_R",
+                "OpticNrv_L",
+                "OpticNrv_R",
+                "OpticChiasm",
+                "Lens_L",
+                "Lens_R",
+                "Lips",
+                "Trachea",
+                "Lung_L",
+                "SpinalCord_PRV05",
+                ]  # 23 OARs in HaN
+
+HaN_OAR_DICT = {HaN_OAR_LIST[i]: (i+1) for i in range(len(HaN_OAR_LIST))}
+
+
+class MyDataset(Dataset):
+    
+    def __init__(self, cfig, phase):
+        '''
+        phase: train, validation, or testing 
+        
+        cfig: the configuration dictionary
+        
+            train_bs: training batch size
+            val_bs: validation batch size
+            num_workers: the number of workers when call the DataLoader of PyTorch
+            
+            csv_root: the meta data file, include patient id and some conditions of the plan. 
+            scale_dose_dict: path of a dictionary. The dictionary includes the prescribed doses of the PTVs. 
+            pat_obj_dict: path of a dictionary. The dictionary includes the OARs names used in optimization. 
+            
+            down_HU: bottom clip of the CT HU value. 
+            up_HU: upper clip of the CT HU value. 
+            denom_norm_HU: the denominator when normalizing the CT. 
+            
+            in_size & out_size: the size parameters used in data transformation. 
+
+            norm_oar: True or False. Normalize the OAR channel or not. 
+            CatStructures: True or False. Concat the PTVs and OARs in multiple channels, or merge them in one channel, respectively. 
+
+            dose_div_factor: the value used to normalize dose. 
+            
+        '''
+        
+        self.cfig = cfig
+        
+        df = pd.read_csv(cfig['csv_root'])
+        df = df.loc[df['dev_split'] == phase] # !!! Actual train + valid + test split.
+
+        self.phase = phase
+        self.data_list = df['PatientID'].tolist()
+        self.site_list = df['site'].tolist()
+        self.cohort_list = df['cohort'].tolist()
+
+        self.scale_dose_Dict = json.load(open(cfig['scale_dose_dict'], 'r'))
+        self.pat_obj_dict = json.load(open(cfig['pat_obj_dict'], 'r'))
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, index):
+        ID = self.data_list[index]
+        PatientID = ID
+        if self.phase == 'test':
+            root_dir = os.path.join(self.cfig['data_root'], 'test')
+        else:
+            root_dir = os.path.join(self.cfig['data_root'], 'train_valid')
+
+        patient_dir = os.path.join(root_dir, ID)
+
+        ct = load_nifti(os.path.join(patient_dir, 'CT.nii.gz'))
+        dose = load_nifti(os.path.join(patient_dir, 'dose.nii.gz'))
+        body = load_nifti(os.path.join(patient_dir, 'Masks', 'BODY.nii.gz'))
+        # print(f"Loading patient {ID} with CT shape {ct.shape} and dose shape {dose.shape}")
+
+        # Normalize CT img.
+        ct = np.clip(ct, self.cfig['down_HU'], self.cfig['up_HU']) / self.cfig['denom_norm_HU']
+        ori_img_size = ct.shape
+        
+        # Normalize dose by D97
+        if 'PTV_High' in self.scale_dose_Dict[PatientID]:
+            ptv_high = self.scale_dose_Dict[PatientID]['PTV_High']
+            pdose = ptv_high['PDose']
+            struct_name = ptv_high['StructName']
+            ptv_mask = load_nifti(os.path.join(patient_dir, 'Masks', 'PTV', f"{struct_name}.nii.gz"))
+
+            d97 = np.percentile(dose[ptv_mask > 0], 3)
+            norm_scale = pdose / (d97 + 1e-5)
+            dose = dose * norm_scale / self.cfig['dose_div_factor']
+            dose = np.clip(dose, 0, pdose * 1.2)
+            
+        isocenter = np.array(ct.shape) // 2
+
+        # Load masks
+        if self.site_list[index] < 1.5:
+            OAR_LIST = HaN_OAR_LIST
+            OAR_DICT = HaN_OAR_DICT
+        else:
+            raise NotImplementedError("Only HaN site supported in this loader.")
+        
+        try:
+            need_list = self.pat_obj_dict[ID.split('+')[0]]
+        except:
+            need_list = OAR_LIST
+        
+        In_dict = {
+            'img': ct,
+            'body': body,
+            'dose': dose,
+            'isocenter': isocenter,
+        }
+
+
+        for name in need_list:
+            path = os.path.join(patient_dir, 'Masks', 'OAR', f"{name}.nii.gz")
+            if os.path.exists(path):
+                In_dict[name] = load_nifti(path)
+
+        ptv_dict = self.scale_dose_Dict[PatientID]
+        opt_dose_dict = {}
+        dose_dict = {}
+
+        for k in ['PTV_High', 'PTV_Mid', 'PTV_Low']:
+            if k in ptv_dict:
+                pdose = ptv_dict[k]['PDose'] / self.cfig['dose_div_factor']
+                struct = ptv_dict[k]['StructName']
+                path = os.path.join(patient_dir, 'Masks', 'PTV', f"{struct}.nii.gz")
+                if os.path.exists(path):
+                    In_dict[struct] = load_nifti(path)
+                    opt_dose_dict[struct] = pdose
+                    dose_dict[struct] = pdose
+
+        # Convert to torch tensor
+        KEYS = list(In_dict.keys())
+        for key in list(KEYS):
+            if isinstance(In_dict[key], np.ndarray) and len(In_dict[key].shape) == 3:
+                In_dict[key] = torch.from_numpy(In_dict[key].astype('float'))[None]
+            else:
+                KEYS.remove(key)
+
+        use_aug = self.cfig.get('with_aug', True)
+        if self.phase == 'train':
+            if use_aug:
+                self.aug = tr_augmentation(KEYS, self.cfig['in_size'], self.cfig['out_size'], isocenter)
+            else:
+                self.aug = tt_augmentation(KEYS, self.cfig['in_size'], self.cfig['out_size'], isocenter)
+        else:
+            self.aug = tt_augmentation(KEYS, self.cfig['in_size'], self.cfig['out_size'], isocenter)
+
+        In_dict = self.aug(In_dict)
+
+        comb_oar, cat_oar = combine_oar(In_dict, need_list, self.cfig['norm_oar'], OAR_DICT)
+        comb_optptv, prs_opt, cat_optptv = combine_ptv(In_dict, opt_dose_dict)
+        comb_ptv, _, cat_ptv = combine_ptv(In_dict, dose_dict)
+
+        # Plan-level metadata. The source-domain (8-channel) models consumed this
+        # broadcast into a `prompt_extend` channel; the released 5-channel models
+        # do not. It is still returned in data_dict for reference. See channels.py.
+        prompt = torch.tensor([1.0, len(prs_opt), self.site_list[index], self.cohort_list[index]]).float()
+
+        # 5-channel input: comb_optptv, comb_ptv, comb_oar, body, img.
+        # The source-domain models additionally took beam_plate, angle_plate and
+        # prompt_extend; this dataset has no beam geometry, so those three
+        # channels were dropped rather than fed as zeros, and the input stem was
+        # re-initialised. See README.md and channels.py.
+        if self.cfig['CatStructures']:
+            input_data = torch.cat((cat_optptv, cat_ptv, cat_oar, In_dict['body'], In_dict['img']), dim=0)
+        else:
+            input_data = torch.cat((comb_optptv, comb_ptv, comb_oar, In_dict['body'], In_dict['img']), dim=0)
+
+
+        data_dict = {
+            'data': input_data,
+            'label': In_dict['dose'] * In_dict['body'],
+            'oar': cat_oar,
+            'ptv': cat_ptv,
+            'optptv': cat_optptv,
+            'id': ID,
+            'ori_img_size': torch.tensor(ori_img_size),
+            'ori_isocenter': torch.tensor(isocenter),
+            'prompt': prompt
+        }
+
+        prescribed_dose = [ptv_dict['PTV_High']['PDose'] if 'PTV_High' in ptv_dict else 0]
+        prescribed_dose.append(ptv_dict['PTV_Mid']['PDose'] if 'PTV_Mid' in ptv_dict else 0)
+        prescribed_dose.append(ptv_dict['PTV_Low']['PDose'] if 'PTV_Low' in ptv_dict else 0)
+        data_dict['prescrbed_dose'] = torch.tensor(prescribed_dose).float()
+
+        return data_dict
+
+    
+
+class GetLoader(object):
+    def __init__(self, cfig):
+        super().__init__()
+        self.cfig = cfig
+        
+    def train_dataloader(self):
+        dataset = MyDataset(self.cfig,  phase='train') 
+        return DataLoader(dataset, batch_size=self.cfig['train_bs'],  shuffle=True, num_workers=self.cfig['num_workers'])
+    
+    def val_dataloader(self):
+        dataset = MyDataset(self.cfig, phase='valid') 
+        return DataLoader(dataset, batch_size=self.cfig['val_bs'], shuffle=False, num_workers=self.cfig['num_workers'])
+    
+    def test_dataloader(self):
+        dataset = MyDataset(self.cfig, phase='test') 
+        return DataLoader(dataset, batch_size=self.cfig['val_bs'], shuffle=False, num_workers=self.cfig['num_workers'])

src/data_loader_pancreas.py

@@ -0,0 +1,243 @@
+"""
+Data loader for the pancreas (PancVMAT) dose-prediction model.
+
+Same 5-channel layout as data_loader_han.py, with two deliberate differences:
+
+  * `combine_optptv` (see toolkit_pancreas.py) subtracts every overlapping OAR
+    from the PTV before building channel 0.
+  * The dose target is NOT D97-renormalised (`norm_scale = 1.0`); the planned
+    dose is used as-is, only divided by `dose_div_factor`.
+
+The OAR list is the 14 PancVMAT structures below, not the 23 HaN ones.
+
+Data pipeline derived from:
+    Riqiang Gao, Bin Lou, Zhoubing Xu, Dorin Comaniciu, and Ali Kamen.
+    "Flexible-CM GAN: Towards Precise 3D Dose Prediction in Radiotherapy."
+    CVPR 2023.
+"""
+
+
+
+from torch.utils.data import Dataset, DataLoader
+import pandas as pd
+import torch
+import numpy as np
+import json
+import yaml
+
+from scipy import ndimage 
+from toolkit_pancreas import *
+
+Panc_OAR_LIST = ["Kidney_L.nii.gz",
+                "Kidney_R.nii.gz",
+                "Kidneys.nii.gz",
+                "Liver.nii.gz",
+                "SpinalCord",
+                "SpinalCanal.nii.gz",
+                "Esophagus.nii.gz",
+                "Heart.nii.gz",
+
+                "Stomach.nii.gz",
+                "Stomach_PRV.nii.gz",
+                "Bowel_Small.nii.gz",
+                "Bowel_Small_PRV.nii.gz",
+                "Bowel_Large.nii.gz",
+                "Bowel_Large_PRV.nii.gz",
+                ]  # 14 OARs in PancVMAT
+
+Panc_OAR_DICT = {Panc_OAR_LIST[i]: (i+1) for i in range(len(Panc_OAR_LIST))}
+
+
+class MyDataset(Dataset):
+    
+    def __init__(self, cfig, phase):
+        '''
+        phase: train, validation, or testing 
+        
+        cfig: the configuration dictionary
+        
+            train_bs: training batch size
+            val_bs: validation batch size
+            num_workers: the number of workers when call the DataLoader of PyTorch
+            
+            csv_root: the meta data file, include patient id and some conditions of the plan. 
+            scale_dose_dict: path of a dictionary. The dictionary includes the prescribed doses of the PTVs. 
+            pat_obj_dict: path of a dictionary. The dictionary includes the OARs names used in optimization. 
+            
+            down_HU: bottom clip of the CT HU value. 
+            up_HU: upper clip of the CT HU value. 
+            denom_norm_HU: the denominator when normalizing the CT. 
+            
+            in_size & out_size: the size parameters used in data transformation. 
+
+            norm_oar: True or False. Normalize the OAR channel or not. 
+            CatStructures: True or False. Concat the PTVs and OARs in multiple channels, or merge them in one channel, respectively. 
+
+            dose_div_factor: the value used to normalize dose. 
+            
+        '''
+        
+        self.cfig = cfig
+        
+        df = pd.read_csv(cfig['csv_root'])
+        df = df.loc[df['dev_split'] == phase] # !!! Actual train + valid + test split.
+
+        self.phase = phase
+        self.data_list = df['PatientID'].tolist()
+        self.site_list = df['site'].tolist()
+        self.cohort_list = df['cohort'].tolist()
+
+        self.scale_dose_Dict = json.load(open(cfig['scale_dose_dict'], 'r'))
+        self.pat_obj_dict = json.load(open(cfig['pat_obj_dict'], 'r'))
+        self.pat_obj_dict = json.load(open(cfig['pat_obj_dict'], 'r'))
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, index):
+        ID = self.data_list[index]
+        PatientID = ID
+        if self.phase == 'test':
+            root_dir = os.path.join(self.cfig['data_root'], 'test')
+        else:
+            root_dir = os.path.join(self.cfig['data_root'], 'train_valid')
+
+        patient_dir = os.path.join(root_dir, ID)
+
+        ct = load_nifti(os.path.join(patient_dir, 'CT.nii.gz'))
+        dose = load_nifti(os.path.join(patient_dir, 'dose.nii.gz'))
+        body = load_nifti(os.path.join(patient_dir, 'Masks', 'BODY.nii.gz'))
+        # print(f"Loading patient {ID} with CT shape {ct.shape} and dose shape {dose.shape}")
+
+        # Normalize CT img.
+        ct = np.clip(ct, self.cfig['down_HU'], self.cfig['up_HU']) / self.cfig['denom_norm_HU']
+        ori_img_size = ct.shape
+        
+        # NO Normalize dose by D95!!!
+        if 'PTV_High' in self.scale_dose_Dict[PatientID]:
+            ptv_high = self.scale_dose_Dict[PatientID]['PTV_High']
+            pdose = ptv_high['PDose']
+            struct_name = ptv_high['StructName']
+            ptv_mask = load_nifti(os.path.join(patient_dir, 'Masks', 'PTV', f"{struct_name}.nii.gz"))
+
+            # d95 = np.percentile(dose[ptv_mask > 0], 5)
+            # norm_scale = pdose / (d95 + 1e-5)
+            norm_scale = 1.0
+            dose = dose * norm_scale / self.cfig['dose_div_factor']
+            dose = np.clip(dose, 0, pdose * 1.2)
+            
+        isocenter = np.array(ct.shape) // 2
+
+        # Load masks
+        if self.site_list[index] == 2:
+            OAR_LIST = Panc_OAR_LIST
+            OAR_DICT = Panc_OAR_DICT
+        else:
+            raise NotImplementedError("Only PancVMAT site supported in this loader.")
+        
+        try:
+            need_list = self.pat_obj_dict[ID.split('+')[0]]
+        except:
+            need_list = OAR_LIST
+        
+        In_dict = {
+            'img': ct,
+            'body': body,
+            'dose': dose,
+            'isocenter': isocenter,
+        }
+
+
+        for name in need_list:
+            path = os.path.join(patient_dir, 'Masks', 'OAR', f"{name}.nii.gz")
+            if os.path.exists(path):
+                In_dict[name] = load_nifti(path)
+
+        ptv_dict = self.scale_dose_Dict[PatientID]
+        opt_dose_dict = {}
+        dose_dict = {}
+
+        for k in ['PTV_High', 'PTV_Mid', 'PTV_Low']:
+            if k in ptv_dict:
+                pdose = ptv_dict[k]['PDose'] / self.cfig['dose_div_factor']
+                struct = ptv_dict[k]['StructName']
+                path = os.path.join(patient_dir, 'Masks', 'PTV', f"{struct}.nii.gz")
+                if os.path.exists(path):
+                    In_dict[struct] = load_nifti(path)
+                    opt_dose_dict[struct] = pdose
+                    dose_dict[struct] = pdose
+
+        # Convert to torch tensor
+        KEYS = list(In_dict.keys())
+        for key in list(KEYS):
+            if isinstance(In_dict[key], np.ndarray) and len(In_dict[key].shape) == 3:
+                In_dict[key] = torch.from_numpy(In_dict[key].astype('float'))[None]
+            else:
+                KEYS.remove(key)
+
+        use_aug = self.cfig.get('with_aug', True)
+        if self.phase == 'train':
+            if use_aug:
+                self.aug = tr_augmentation(KEYS, self.cfig['in_size'], self.cfig['out_size'], isocenter)
+            else:
+                self.aug = tt_augmentation(KEYS, self.cfig['in_size'], self.cfig['out_size'], isocenter)
+        else:
+            self.aug = tt_augmentation(KEYS, self.cfig['in_size'], self.cfig['out_size'], isocenter)
+
+        In_dict = self.aug(In_dict)
+
+        comb_oar, cat_oar = combine_oar(In_dict, need_list, self.cfig['norm_oar'], OAR_DICT)
+        comb_optptv, prs_opt, cat_optptv = combine_optptv(In_dict, opt_dose_dict, OAR_DICT)
+        comb_ptv, _, cat_ptv = combine_ptv(In_dict, dose_dict)
+
+        # Plan-level metadata. The source-domain (8-channel) models consumed this
+        # broadcast into a `prompt_extend` channel; the released 5-channel models
+        # do not. It is still returned in data_dict for reference. See channels.py.
+        prompt = torch.tensor([1.0, len(prs_opt), self.site_list[index], self.cohort_list[index]]).float()
+
+        # 5-channel input: comb_optptv, comb_ptv, comb_oar, body, img.
+        # Channels 0-2 are computed differently from the HaN loader -- see
+        # channels.py (PANCREAS_5CH). Do not mix the two encodings.
+        if self.cfig['CatStructures']:
+            input_data = torch.cat((cat_optptv, cat_ptv, cat_oar, In_dict['body'], In_dict['img']), dim=0)
+        else:
+            input_data = torch.cat((comb_optptv, comb_ptv, comb_oar, In_dict['body'], In_dict['img']), dim=0)
+
+
+        data_dict = {
+            'data': input_data,
+            'label': In_dict['dose'] * In_dict['body'],
+            'oar': cat_oar,
+            'ptv': cat_ptv,
+            'optptv': cat_optptv,
+            'id': ID,
+            'ori_img_size': torch.tensor(ori_img_size),
+            'ori_isocenter': torch.tensor(isocenter),
+            'prompt': prompt
+        }
+
+        prescribed_dose = [ptv_dict['PTV_High']['PDose'] if 'PTV_High' in ptv_dict else 0]
+        prescribed_dose.append(ptv_dict['PTV_Mid']['PDose'] if 'PTV_Mid' in ptv_dict else 0)
+        prescribed_dose.append(ptv_dict['PTV_Low']['PDose'] if 'PTV_Low' in ptv_dict else 0)
+        data_dict['prescrbed_dose'] = torch.tensor(prescribed_dose).float()
+
+        return data_dict
+
+    
+
+class GetLoader(object):
+    def __init__(self, cfig):
+        super().__init__()
+        self.cfig = cfig
+        
+    def train_dataloader(self):
+        dataset = MyDataset(self.cfig,  phase='train') 
+        return DataLoader(dataset, batch_size=self.cfig['train_bs'],  shuffle=True, num_workers=self.cfig['num_workers'])
+    
+    def val_dataloader(self):
+        dataset = MyDataset(self.cfig, phase='valid') 
+        return DataLoader(dataset, batch_size=self.cfig['val_bs'], shuffle=False, num_workers=self.cfig['num_workers'])
+    
+    def test_dataloader(self):
+        dataset = MyDataset(self.cfig, phase='test') 
+        return DataLoader(dataset, batch_size=self.cfig['val_bs'], shuffle=False, num_workers=self.cfig['num_workers'])

src/inference.py

@@ -0,0 +1,162 @@
+"""
+Run a released checkpoint over a test set and write predicted dose as NIfTI.
+
+    python src/inference.py \
+        --ckpt   weights/c3d_finetuned.pt \
+        --config configs/c3d_han.yaml \
+        --out    predictions/c3d_finetuned
+
+The architecture, input-channel count and dose rescaling all come from the
+checkpoint itself, so the same command works for any file under weights/.
+
+Post-processing applied to every case (same as during evaluation):
+  1. raw output -> Gy   (sigmoid * scale_out * dose_div_factor)
+  2. clip to [0, 1.2 x prescription of PTV_High]  (1.1x for C3D-HaN, see --clip_factor)
+  3. zero everything outside the BODY mask
+  4. copy spacing/origin/direction from the case's CT and write <case_id>_pred.nii.gz
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+
+import numpy as np
+import SimpleITK as sitk
+import torch
+import yaml
+from tqdm.auto import tqdm
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from channels import describe, pad_to_source_8ch  # noqa: E402
+from checkpoint import load_model, to_dose  # noqa: E402
+
+
+def copy_sitk_imageinfo(reference, image):
+    image.SetSpacing(reference.GetSpacing())
+    image.SetDirection(reference.GetDirection())
+    image.SetOrigin(reference.GetOrigin())
+    return image
+
+
+def get_loader(channel_spec, loader_cfig):
+    """
+    Pick the data loader that produces the channel encoding this checkpoint wants.
+
+    The two 5-channel encodings are NOT interchangeable -- channels 0, 1 and 2
+    are computed differently. Feeding one model the other's inputs runs cleanly
+    and silently produces wrong dose. See channels.py.
+    """
+    if channel_spec == "pancreas_5ch":
+        import data_loader_pancreas as dl
+    else:
+        import data_loader_han as dl
+    return dl.GetLoader(cfig=loader_cfig)
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--ckpt", required=True, help="a file under weights/")
+    p.add_argument("--config", required=True, help="a file under configs/")
+    p.add_argument("--out", required=True, help="directory for the predicted NIfTIs")
+    p.add_argument("--phase", default="test", choices=["train", "valid", "test"],
+                   help="which dev_split of meta_data.csv to run on")
+    p.add_argument("--data_root", default=None,
+                   help="overrides loader_params.data_root in the config")
+    p.add_argument("--clip_factor", type=float, default=None,
+                   help="clip dose at this multiple of the PTV_High prescription; "
+                        "defaults to the value the checkpoint was evaluated with")
+    p.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    p.add_argument("--pad_to_8ch", action="store_true",
+                   help="zero-pad 5-channel inputs to the 8-channel source layout so a "
+                        "*_pretrained checkpoint will run. Shape-debugging only -- the "
+                        "padded channels carry real signal during pretraining, so the "
+                        "output is not a valid dose prediction.")
+    p.add_argument("--describe", action="store_true",
+                   help="print the checkpoint's channel spec and exit")
+    args = p.parse_args()
+
+    cfig = yaml.safe_load(open(args.config))
+    loader_cfig = cfig["loader_params"]
+    if args.data_root:
+        loader_cfig["data_root"] = args.data_root
+
+    device = torch.device(args.device)
+    model, ckpt = load_model(args.ckpt, device=device)
+    print(f"Loaded {ckpt['arch']} / {ckpt['regime']} / {ckpt['anatomy']} "
+          f"({ckpt['in_channels']}-channel input) from {args.ckpt}")
+
+    print(describe(ckpt["channel_spec"]))
+    if args.describe:
+        return
+
+    if ckpt["in_channels"] == 8 and not args.pad_to_8ch:
+        p.error(
+            "This is a source-domain *pretrained* checkpoint: it takes 8 input channels, "
+            "but the released data loaders emit 5 (no beam_plate / angle_plate / "
+            "prompt_extend for this data). It is published as a fine-tuning starting "
+            "point, not as a runnable predictor. Use a *_finetuned or *_fromscratch "
+            "checkpoint, or pass --pad_to_8ch if you really want a zero-padded forward "
+            "pass. See README.md.")
+
+    clip_factor = args.clip_factor
+    if clip_factor is None:
+        clip_factor = ckpt.get("eval_clip_factor", 1.2)
+
+    loaders = get_loader(ckpt["channel_spec"], loader_cfig)
+    test_loader = {"train": loaders.train_dataloader,
+                   "valid": loaders.val_dataloader,
+                   "test": loaders.test_dataloader}[args.phase]()
+
+    ptv_dict = json.load(open(loader_cfig["scale_dose_dict"]))
+    os.makedirs(args.out, exist_ok=True)
+    split_dir = "test" if args.phase == "test" else "train_valid"
+
+    t0 = time.time()
+    n_written = 0
+    with torch.no_grad():
+        for data_dict in tqdm(test_loader, desc="Running inference"):
+            inputs = data_dict["data"].to(device)
+            if args.pad_to_8ch:
+                inputs = pad_to_source_8ch(inputs)
+            dose = to_dose(model(inputs), ckpt)
+
+            for i in range(len(dose)):
+                pred = dose[i, 0].cpu().numpy()
+                case_id = data_dict["id"][i]
+                key = case_id.split("+")[0]
+
+                entry = ptv_dict.get(key) or ptv_dict.get(key.zfill(3))
+                if entry and "PTV_High" in entry:
+                    pred = np.clip(pred, 0, entry["PTV_High"]["PDose"] * clip_factor)
+                else:
+                    print(f"[Warning] no PTV_High prescription for {case_id}; clipping at 80 Gy")
+                    pred = np.clip(pred, 0, 80.0)
+
+                case_dir = os.path.join(loader_cfig["data_root"], split_dir, case_id)
+                ct_path = os.path.join(case_dir, "CT.nii.gz")
+                body_path = os.path.join(case_dir, "Masks", "BODY.nii.gz")
+                if not (os.path.exists(ct_path) and os.path.exists(body_path)):
+                    print(f"[Skip] missing CT or BODY for {case_id}")
+                    continue
+
+                pred = pred * (sitk.GetArrayFromImage(sitk.ReadImage(body_path)) > 0)
+
+                pred_img = sitk.GetImageFromArray(pred.astype(np.float32))
+                pred_img = copy_sitk_imageinfo(sitk.ReadImage(ct_path), pred_img)
+                sitk.WriteImage(pred_img, os.path.join(args.out, f"{case_id}_pred.nii.gz"))
+                n_written += 1
+
+    elapsed = time.time() - t0
+    print(f"Wrote {n_written} predictions to {args.out}")
+    if n_written:
+        print(f"Avg time/scan: {elapsed / n_written:.2f} s")
+    if device.type == "cuda":
+        print(f"Peak GPU memory: {torch.cuda.max_memory_allocated(device) / 1024 ** 3:.2f} GB")
+
+
+if __name__ == "__main__":
+    main()

src/model_c3d.py

@@ -0,0 +1,176 @@
+"""
+C3D -- the cascade 3D U-Net used for the C3D and pancreas checkpoints.
+
+Two U-Nets in series: net_A makes a coarse prediction, net_B refines it from
+the concatenation of net_A's features and the original input. `forward` returns
+``[output_A, output_B]``; **output_B is the prediction you want**.
+
+Architecture as published in:
+    Shuolin Liu, Jingjing Zhang, Teng Li, Hui Yan, Jianfei Liu.
+    "A Cascade 3D U-Net for Dose Prediction in Radiotherapy." Med. Phys. 2021.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class SingleConv(nn.Module):
+    def __init__(self, in_ch, out_ch, kernel_size, stride, padding):
+        super(SingleConv, self).__init__()
+
+        self.single_conv = nn.Sequential(
+            nn.Conv3d(in_ch, out_ch, kernel_size=kernel_size, padding=padding, stride=stride, bias=True),
+            nn.InstanceNorm3d(out_ch, affine=True),
+            nn.ReLU(inplace=True)
+        )
+
+    def forward(self, x):
+        return self.single_conv(x)
+
+
+class UpConv(nn.Module):
+    def __init__(self, in_ch, out_ch):
+        super(UpConv, self).__init__()
+
+        self.conv = nn.Sequential(
+            nn.Conv3d(in_ch, out_ch, kernel_size=3, padding=1, stride=1, bias=True),
+            nn.InstanceNorm3d(out_ch, affine=True),
+            nn.ReLU(inplace=True)
+        )
+
+    def forward(self, x):
+        x = F.interpolate(x, scale_factor=2, mode='trilinear', align_corners=True)
+        x = self.conv(x)
+        return x
+
+
+class Encoder(nn.Module):
+    def __init__(self, in_ch, list_ch):
+        super(Encoder, self).__init__()
+        self.encoder_1 = nn.Sequential(
+            SingleConv(in_ch, list_ch[1], kernel_size=3, stride=1, padding=1),
+            SingleConv(list_ch[1], list_ch[1], kernel_size=3, stride=1, padding=1)
+        )
+        self.encoder_2 = nn.Sequential(
+            SingleConv(list_ch[1], list_ch[2], kernel_size=3, stride=2, padding=1),
+            SingleConv(list_ch[2], list_ch[2], kernel_size=3, stride=1, padding=1)
+        )
+        self.encoder_3 = nn.Sequential(
+            SingleConv(list_ch[2], list_ch[3], kernel_size=3, stride=2, padding=1),
+            SingleConv(list_ch[3], list_ch[3], kernel_size=3, stride=1, padding=1)
+        )
+        self.encoder_4 = nn.Sequential(
+            SingleConv(list_ch[3], list_ch[4], kernel_size=3, stride=2, padding=1),
+            SingleConv(list_ch[4], list_ch[4], kernel_size=3, stride=1, padding=1)
+        )
+        self.encoder_5 = nn.Sequential(
+            SingleConv(list_ch[4], list_ch[5], kernel_size=3, stride=2, padding=1),
+            SingleConv(list_ch[5], list_ch[5], kernel_size=3, stride=1, padding=1)
+        )
+
+    def forward(self, x):
+        out_encoder_1 = self.encoder_1(x)
+        out_encoder_2 = self.encoder_2(out_encoder_1)
+        out_encoder_3 = self.encoder_3(out_encoder_2)
+        out_encoder_4 = self.encoder_4(out_encoder_3)
+        out_encoder_5 = self.encoder_5(out_encoder_4)
+
+        return [out_encoder_1, out_encoder_2, out_encoder_3, out_encoder_4, out_encoder_5]
+
+
+class Decoder(nn.Module):
+    def __init__(self, list_ch):
+        super(Decoder, self).__init__()
+
+        self.upconv_4 = UpConv(list_ch[5], list_ch[4])
+        self.decoder_conv_4 = nn.Sequential(
+            SingleConv(2 * list_ch[4], list_ch[4], kernel_size=3, stride=1, padding=1),
+            SingleConv(list_ch[4], list_ch[4], kernel_size=3, stride=1, padding=1)
+        )
+        self.upconv_3 = UpConv(list_ch[4], list_ch[3])
+        self.decoder_conv_3 = nn.Sequential(
+            SingleConv(2 * list_ch[3], list_ch[3], kernel_size=3, stride=1, padding=1),
+            SingleConv(list_ch[3], list_ch[3], kernel_size=3, stride=1, padding=1)
+        )
+        self.upconv_2 = UpConv(list_ch[3], list_ch[2])
+        self.decoder_conv_2 = nn.Sequential(
+            SingleConv(2 * list_ch[2], list_ch[2], kernel_size=3, stride=1, padding=1),
+            SingleConv(list_ch[2], list_ch[2], kernel_size=3, stride=1, padding=1)
+        )
+        self.upconv_1 = UpConv(list_ch[2], list_ch[1])
+        self.decoder_conv_1 = nn.Sequential(
+            SingleConv(2 * list_ch[1], list_ch[1], kernel_size=3, stride=1, padding=1)
+        )
+
+    def forward(self, out_encoder):
+        out_encoder_1, out_encoder_2, out_encoder_3, out_encoder_4, out_encoder_5 = out_encoder
+
+        out_decoder_4 = self.decoder_conv_4(
+            torch.cat((self.upconv_4(out_encoder_5), out_encoder_4), dim=1)
+        )
+        out_decoder_3 = self.decoder_conv_3(
+            torch.cat((self.upconv_3(out_decoder_4), out_encoder_3), dim=1)
+        )
+        out_decoder_2 = self.decoder_conv_2(
+            torch.cat((self.upconv_2(out_decoder_3), out_encoder_2), dim=1)
+        )
+        out_decoder_1 = self.decoder_conv_1(
+            torch.cat((self.upconv_1(out_decoder_2), out_encoder_1), dim=1)
+        )
+
+        return out_decoder_1
+
+
+class BaseUNet(nn.Module):
+    def __init__(self, in_ch, list_ch):
+        super(BaseUNet, self).__init__()
+        self.encoder = Encoder(in_ch, list_ch)
+        self.decoder = Decoder(list_ch)
+
+        # init
+        self.initialize()
+
+    @staticmethod
+    def init_conv_IN(modules):
+        for m in modules():
+            if isinstance(m, nn.Conv3d):
+                nn.init.kaiming_uniform_(m.weight, mode='fan_in', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0.)
+            elif isinstance(m, nn.InstanceNorm3d):
+                nn.init.constant_(m.weight, 1.)
+                nn.init.constant_(m.bias, 0.)
+
+    def initialize(self):
+        # Kaiming-uniform init. Irrelevant when you immediately load released
+        # weights over it; it matters if you build the model to train from scratch.
+        self.init_conv_IN(self.decoder.modules)
+        self.init_conv_IN(self.encoder.modules)
+
+    def forward(self, x):
+        out_encoder = self.encoder(x)
+        out_decoder = self.decoder(out_encoder)
+
+        # Output is a list: [Output]
+        return out_decoder
+
+
+class Model(nn.Module):
+    def __init__(self, in_ch, out_ch, list_ch_A, list_ch_B):
+        super(Model, self).__init__()
+
+        # list_ch records the number of channels in each stage, eg. [-1, 32, 64, 128, 256, 512]
+        self.net_A = BaseUNet(in_ch, list_ch_A)
+        self.net_B = BaseUNet(in_ch + list_ch_A[1], list_ch_B)
+
+        self.conv_out_A = nn.Conv3d(list_ch_A[1], out_ch, kernel_size=1, padding=0, bias=True)
+        self.conv_out_B = nn.Conv3d(list_ch_B[1], out_ch, kernel_size=1, padding=0, bias=True)
+
+    def forward(self, x):
+        out_net_A = self.net_A(x)
+        out_net_B = self.net_B(torch.cat((out_net_A, x), dim=1))
+
+        output_A = self.conv_out_A(out_net_A)
+        output_B = self.conv_out_B(out_net_B)
+        return [output_A, output_B]

src/toolkit_han.py

@@ -0,0 +1,117 @@
+"""
+Data-loading helpers for the HaN dose-prediction models.
+
+Trimmed from the original research toolkit: only the functions the released
+data loader and inference script actually call are kept, which drops the
+cv2 / matplotlib / SimpleITK plotting dependencies.
+
+Derived from the data pipeline of:
+    Riqiang Gao, Bin Lou, Zhoubing Xu, Dorin Comaniciu, Ali Kamen.
+    "Flexible-CM GAN: Towards Precise 3D Dose Prediction in Radiotherapy." CVPR 2023.
+"""
+
+import os
+
+import numpy as np
+import torch
+import nibabel as nib
+from monai.transforms import (
+    Compose,
+    Resized,
+    RandFlipd,
+    RandRotated,
+    SpatialPadd,
+    SpatialCropd,
+    RandSpatialCropd,
+)
+
+
+def combine_oar(tmp_dict, need_list,norm_oar = True, OAR_DICT = None):
+
+    '''
+    this function is used to support the data loader. 
+
+    tmp_dict: the dictionary of the data loaded from the npz file
+    need_list: the list of the OARs needed to be combined
+    norm_oar: if True, the OARs will be normalized to the same scale
+    OAR_DICT: the dictionary of the OARs, the key is the name of the OAR, the value is the index of the OAR in the combined
+    '''
+    
+    comb_oar = torch.zeros(tmp_dict['img'].shape)  
+    cat_oar = torch.zeros([len(OAR_DICT)] + list(tmp_dict['img'].shape)[1:])
+    for key in OAR_DICT.keys():
+        
+        if key not in need_list:
+            continue
+
+        if key in tmp_dict.keys():
+            single_oar = tmp_dict[key]
+        else:
+            single_oar = torch.zeros(tmp_dict['img'].shape)
+
+        cat_oar[OAR_DICT[key]-1: OAR_DICT[key]]  = single_oar
+
+        if norm_oar:
+            comb_oar = torch.maximum(comb_oar, single_oar.round() * (1.0 + 4.0 * OAR_DICT[key] / 30))
+        else:
+            comb_oar = torch.maximum(comb_oar, single_oar.round() * OAR_DICT[key])  # changed in this version
+
+    return comb_oar, cat_oar
+
+
+def combine_ptv(tmp_dict,  scaled_dose_dict):
+
+    prescribed_dose = []
+    
+    cat_ptv = torch.zeros([3] + list(tmp_dict['img'].shape)[1:])
+    prescribed_dose = [0] * 3
+
+    comb_ptv = torch.zeros(tmp_dict['img'].shape)
+
+    cnt = 0
+    for key in scaled_dose_dict.keys():
+       
+       tmp_ptv = tmp_dict[key] * scaled_dose_dict[key]  
+       
+       prescribed_dose[cnt] =  scaled_dose_dict[key] 
+       
+       cat_ptv[cnt] = tmp_ptv 
+       comb_ptv = torch.maximum(comb_ptv, tmp_ptv)
+
+       cnt += 1
+
+    # sort the cat_ptv according to the prescribed dose
+    paired = [(cat_ptv[i], prescribed_dose[i]) for i in range(len(prescribed_dose))]
+    paired_sorted = sorted(paired, key=lambda x: x[1], reverse=True)
+    cat_ptv = torch.stack([x[0] for x in paired_sorted])
+    prescribed_dose = [x[1] for x in paired_sorted]
+    
+    return comb_ptv, prescribed_dose, cat_ptv 
+
+
+def tr_augmentation(KEYS, in_size, out_size, crop_center):
+    return Compose([
+        SpatialCropd(keys = KEYS, roi_center = crop_center, roi_size = [int(in_size[0] * 1.2), int(in_size[1] * 1.2), int(in_size[2] * 1.2)], allow_missing_keys = True),
+        SpatialPadd(keys = KEYS, spatial_size = [int(in_size[0] * 1.2), int(in_size[1] * 1.2), int(in_size[2] * 1.2)], mode = 'constant', allow_missing_keys = True),
+        RandSpatialCropd(keys = KEYS, roi_size = [int(in_size[0] * 0.85), int(in_size[1] * 0.85), int(in_size[2] * 0.85)], max_roi_size = [int(in_size[0] * 1.2), int(in_size[1] * 1.2), int(in_size[2] * 1.2)], random_center = True, random_size = True, allow_missing_keys = True), 
+        RandRotated(keys = KEYS, prob=0.8, range_x= 1, range_y = 0.2, range_z = 0.2, allow_missing_keys = True),
+        RandFlipd(keys = KEYS, prob = 0.4, spatial_axis = 0, allow_missing_keys = True), 
+        RandFlipd(keys = KEYS, prob = 0.4, spatial_axis = 1, allow_missing_keys = True), 
+        RandFlipd(keys = KEYS, prob = 0.4, spatial_axis = 2, allow_missing_keys = True), 
+        Resized(keys = KEYS, spatial_size = out_size, allow_missing_keys = True), 
+    ])
+
+def tt_augmentation(KEYS, in_size, out_size, crop_center):
+    return Compose([
+        SpatialCropd(keys = KEYS, roi_center = crop_center, roi_size = in_size, allow_missing_keys = True),
+        SpatialPadd(keys = KEYS, spatial_size = in_size, mode = 'constant', allow_missing_keys = True),
+        Resized(keys = KEYS, spatial_size = out_size, allow_missing_keys = True), 
+    ])
+
+def load_nifti(path):
+    """
+    Load a .nii or .nii.gz file and return a numpy array.
+    torch shape: [B, C, Z, Y, X] where B=1, C=1, Z=depth, Y=height, X=width
+    """
+    nii = nib.load(path)
+    return np.transpose(nii.get_fdata(), (2, 1, 0)).astype(np.float32)

src/toolkit_pancreas.py

@@ -0,0 +1,225 @@
+"""
+Data-loading helpers for the pancreas (PancVMAT) dose-prediction model.
+
+Trimmed from the original research toolkit: only the functions the released
+data loader and inference script actually call are kept.
+
+Differs from toolkit_han.py in `combine_optptv`, which subtracts every
+overlapping OAR from the PTV before building the "optimisation PTV" channel.
+Keep the two files separate -- swapping them changes model inputs.
+"""
+
+import os
+
+import numpy as np
+import torch
+import nibabel as nib
+from monai.transforms import (
+    Compose,
+    Resized,
+    RandFlipd,
+    RandRotated,
+    SpatialPadd,
+    SpatialCropd,
+    RandSpatialCropd,
+)
+
+
+def combine_optptv(tmp_dict, opt_dose_dict, OAR_DICT):
+    '''
+    Combine the optimal PTV and the dose of the optimal PTV
+    从PTV mask中扣除与所有OAR重叠的部分
+    
+    这个修改的目的是解决放疗中的关键问题：
+    - 当PTV与OAR重叠时，重叠区域可能无法达到处方剂量
+    - 通过从PTV中扣除所有OAR重叠区域，可以更准确地表示实际可达到处方剂量的区域
+    - 使用OAR_DICT中的所有OAR
+    
+    Args:
+        tmp_dict: 包含所有mask的字典
+        opt_dose_dict: 包含处方剂量的字典
+        OAR_DICT: OAR索引字典
+    
+    Returns:
+        comb_optptv: 组合的优化PTV (扣除OAR重叠后)
+        prs_opt: 处方剂量列表
+        cat_optptv: 分别的优化PTV通道
+    '''
+    comb_optptv = torch.zeros(tmp_dict['img'].shape)
+    cat_optptv = torch.zeros([3] + list(tmp_dict['img'].shape)[1:])  # 假设最多3个PTV
+    prs_opt = []
+    
+    # 创建组合的所有OAR mask
+    # 使用OAR_DICT中的所有OAR
+    # 注意：OAR_DICT的key带.nii.gz后缀，但tmp_dict中的key可能不带后缀
+    combined_oar_mask = torch.zeros(tmp_dict['img'].shape)
+    for oar_name in OAR_DICT.keys():
+        # 尝试多种可能的key格式
+        oar_key = None
+        for possible_key in [oar_name, oar_name.replace('.nii.gz', ''), f"{oar_name}.nii.gz" if not oar_name.endswith('.nii.gz') else oar_name]:
+            if possible_key in tmp_dict:
+                oar_key = possible_key
+                break
+        
+        if oar_key is not None:
+            combined_oar_mask = torch.maximum(combined_oar_mask, tmp_dict[oar_key])
+    
+    cnt = 0
+    for key in opt_dose_dict.keys():
+        if key in tmp_dict:
+            original_ptv_mask = tmp_dict[key]
+            prescribed_dose = opt_dose_dict[key]
+            
+            # 从PTV mask中扣除与所有OAR重叠的部分
+            # 只保留不与任何OAR重叠的PTV区域
+            # 使用 > 0 来创建binary mask，确保OAR区域被完全排除
+            oar_binary_mask = (combined_oar_mask > 0).float()
+            modified_ptv_mask = original_ptv_mask * (1 - oar_binary_mask)
+            
+            # 创建优化的PTV（应用处方剂量）
+            tmp_optptv = modified_ptv_mask * prescribed_dose
+            
+            # 存储到cat_optptv中（如果有足够的通道）
+            if cnt < cat_optptv.shape[0]:
+                cat_optptv[cnt] = tmp_optptv
+            
+            # 更新组合的optptv
+            comb_optptv = torch.maximum(comb_optptv, tmp_optptv)
+            
+            # 记录处方剂量
+            prs_opt.append(prescribed_dose)
+            
+            cnt += 1
+    
+    return comb_optptv, prs_opt, cat_optptv  
+
+
+
+def combine_oar(tmp_dict, need_list, norm_oar=True, OAR_DICT=None):
+    '''
+    Revised to emphasize Limiting OARs (Stomach, Bowel) over General OARs
+    '''
+    comb_oar = torch.zeros(tmp_dict['img'].shape)
+    cat_oar = torch.zeros([len(OAR_DICT)] + list(tmp_dict['img'].shape)[1:])
+    
+    # Define Limiting OARs (need_list不带.nii.gz后缀，所以这里也不带后缀)
+    LIMITING_OARS = [
+        "Stomach", "Stomach_PRV",
+        "Bowel_Small", "Bowel_Small_PRV",
+        "Bowel_Large", "Bowel_Large_PRV"
+    ]
+
+
+    for key in OAR_DICT.keys():
+        # need_list来自oar_dict.json，不带.nii.gz后缀
+        # OAR_DICT的key带.nii.gz后缀（除了SpinalCord）
+        # 需要去掉.nii.gz后缀来匹配need_list
+        key_without_suffix = key.replace('.nii.gz', '')
+        key_in_need_list = (key_without_suffix in need_list)
+        
+        if not key_in_need_list:
+            continue
+
+        # 尝试在tmp_dict中找到数据
+        # tmp_dict中的key可能是带或不带.nii.gz的格式
+        single_oar = None
+        
+        # 尝试多种可能的key格式：原始key、去掉后缀、添加后缀
+        for possible_key in [key, key_without_suffix, f"{key_without_suffix}.nii.gz"]:
+            if possible_key in tmp_dict:
+                single_oar = tmp_dict[possible_key]
+                break
+        
+        if single_oar is None:
+            single_oar = torch.zeros(tmp_dict['img'].shape)
+
+        cat_oar[OAR_DICT[key]-1: OAR_DICT[key]] = single_oar
+
+        # --- Special Handling for Limiting OARs Start ---
+        if norm_oar:
+            # Check if current OAR is a Limiting OAR
+            # need_list不带.nii.gz，所以用key_without_suffix来检查
+            is_limiting = (key_without_suffix in LIMITING_OARS)
+            
+            if is_limiting:
+                # Limiting OARs: base value set to 2.0, with a small gradient to distinguish different bowel segments.  
+                # Value range: 2.0 ~ 2.5 (high enough, and significantly different from normal organs)
+                # The index weight is very small, only to distinguish slightly, not to significantly increase the value
+                base_val = 2.0  
+                scale_val = base_val + 0.5 * (OAR_DICT[key] / len(OAR_DICT))
+            else:
+                # Normal organs: value range 0.5 ~ 0.8
+                base_val = 0.5
+                scale_val = base_val + 0.3 * (OAR_DICT[key] / len(OAR_DICT))
+            
+            # Assign value
+            comb_oar = torch.maximum(comb_oar, single_oar.round() * scale_val)
+            
+        else:
+            # If not normalize, keep the original logic or modify according to needs
+            comb_oar = torch.maximum(comb_oar, single_oar.round() * OAR_DICT[key])
+        # --- Special Handling for Limiting OARs End ---
+
+    return comb_oar, cat_oar
+
+
+
+def combine_ptv(tmp_dict,  scaled_dose_dict):
+
+    prescribed_dose = []
+    
+    cat_ptv = torch.zeros([3] + list(tmp_dict['img'].shape)[1:])
+    prescribed_dose = [0] * 3
+
+    comb_ptv = torch.zeros(tmp_dict['img'].shape)
+
+    cnt = 0
+    for key in scaled_dose_dict.keys():
+       original_rx = scaled_dose_dict[key]
+       target_val = min(original_rx, 3.0)
+    #    tmp_ptv = tmp_dict[key] * scaled_dose_dict[key]
+       tmp_ptv = tmp_dict[key] * target_val   # v4: set the prescribed dose to 30 Gy
+       
+       prescribed_dose[cnt] =  scaled_dose_dict[key] 
+       
+       cat_ptv[cnt] = tmp_ptv 
+       comb_ptv = torch.maximum(comb_ptv, tmp_ptv)
+
+       cnt += 1
+
+    # sort the cat_ptv according to the prescribed dose
+    paired = [(cat_ptv[i], prescribed_dose[i]) for i in range(len(prescribed_dose))]
+    paired_sorted = sorted(paired, key=lambda x: x[1], reverse=True)
+    cat_ptv = torch.stack([x[0] for x in paired_sorted])
+    prescribed_dose = [x[1] for x in paired_sorted]
+    
+    return comb_ptv, prescribed_dose, cat_ptv 
+
+
+
+def tr_augmentation(KEYS, in_size, out_size, crop_center):
+    return Compose([
+        SpatialCropd(keys = KEYS, roi_center = crop_center, roi_size = [int(in_size[0] * 1.2), int(in_size[1] * 1.2), int(in_size[2] * 1.2)], allow_missing_keys = True),
+        SpatialPadd(keys = KEYS, spatial_size = [int(in_size[0] * 1.2), int(in_size[1] * 1.2), int(in_size[2] * 1.2)], mode = 'constant', allow_missing_keys = True),
+        RandSpatialCropd(keys = KEYS, roi_size = [int(in_size[0] * 0.85), int(in_size[1] * 0.85), int(in_size[2] * 0.85)], max_roi_size = [int(in_size[0] * 1.2), int(in_size[1] * 1.2), int(in_size[2] * 1.2)], random_center = True, random_size = True, allow_missing_keys = True), 
+        RandRotated(keys = KEYS, prob=0.8, range_x= 1, range_y = 0.2, range_z = 0.2, allow_missing_keys = True),
+        RandFlipd(keys = KEYS, prob = 0.4, spatial_axis = 0, allow_missing_keys = True), 
+        RandFlipd(keys = KEYS, prob = 0.4, spatial_axis = 1, allow_missing_keys = True), 
+        RandFlipd(keys = KEYS, prob = 0.4, spatial_axis = 2, allow_missing_keys = True), 
+        Resized(keys = KEYS, spatial_size = out_size, allow_missing_keys = True), 
+    ])
+
+def tt_augmentation(KEYS, in_size, out_size, crop_center):
+    return Compose([
+        SpatialCropd(keys = KEYS, roi_center = crop_center, roi_size = in_size, allow_missing_keys = True),
+        SpatialPadd(keys = KEYS, spatial_size = in_size, mode = 'constant', allow_missing_keys = True),
+        Resized(keys = KEYS, spatial_size = out_size, allow_missing_keys = True), 
+    ])
+
+def load_nifti(path):
+    """
+    Load a .nii or .nii.gz file and return a numpy array.
+    torch shape: [B, C, Z, Y, X] where B=1, C=1, Z=depth, Y=height, X=width
+    """
+    nii = nib.load(path)
+    return np.transpose(nii.get_fdata(), (2, 1, 0)).astype(np.float32)

src/transfer.py

@@ -0,0 +1,94 @@
+"""
+Warm-starting your own model from a released checkpoint.
+
+This is the piece most people actually want: the pretrained checkpoints take
+8 input channels, and almost certainly your data does not have the beam-geometry
+and plan-prompt channels the source domain had. `load_pretrained_into` copies
+every tensor whose shape matches and leaves the rest at their fresh
+initialisation, which for these three architectures means only the input stem is
+re-initialised:
+
+    C3D         170 / 172 tensors transferred (net_A + net_B first conv skipped)
+    MedNeXt     228 / 229 tensors transferred (stem.weight skipped)
+    SwinUNETR   164 / 167 tensors transferred (patch_embed.proj, encoder1 conv1/conv3)
+
+This is exactly how the released *_finetuned checkpoints were produced. No
+channel slicing, averaging or repetition was applied to the input stem -- it was
+simply retrained from scratch.
+
+Example
+-------
+    from build_model import build_model
+    from transfer import load_pretrained_into
+
+    model = build_model("c3d", in_channels=5)          # your channel count
+    report = load_pretrained_into(model, "weights/c3d_pretrained.pt")
+    print(report)
+    # ... then train as usual; a low LR (3e-5, cosine) worked best for us.
+"""
+
+from dataclasses import dataclass, field
+from typing import List
+
+import torch
+
+
+@dataclass
+class TransferReport:
+    transferred: List[str] = field(default_factory=list)
+    shape_mismatch: List[str] = field(default_factory=list)
+    missing_in_checkpoint: List[str] = field(default_factory=list)
+    unused_in_checkpoint: List[str] = field(default_factory=list)
+
+    def __str__(self):
+        n_ok = len(self.transferred)
+        n_total = n_ok + len(self.shape_mismatch) + len(self.missing_in_checkpoint)
+        lines = [f"transferred {n_ok}/{n_total} tensors"]
+        for label, items in (
+            ("re-initialised (shape mismatch)", self.shape_mismatch),
+            ("re-initialised (absent from checkpoint)", self.missing_in_checkpoint),
+            ("ignored (not in your model)", self.unused_in_checkpoint),
+        ):
+            if items:
+                lines.append(f"  {label}: {len(items)}")
+                lines.extend(f"    - {k}" for k in items)
+        return "\n".join(lines)
+
+
+def load_pretrained_into(model, ckpt_path, verbose=True):
+    """
+    Copy every shape-compatible tensor from a released checkpoint into `model`.
+
+    Tensors that do not match (different input-channel count, different output
+    head, ...) keep whatever `model` initialised them to. Returns a
+    TransferReport naming exactly what was and was not transferred -- read it,
+    do not assume.
+    """
+    ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=True)
+    src = ckpt["state_dict"] if "state_dict" in ckpt else ckpt
+    src = {k[len("module."):] if k.startswith("module.") else k: v
+           for k, v in src.items()}
+
+    own = model.state_dict()
+    report = TransferReport()
+    staged = {}
+
+    for name, tensor in own.items():
+        if name not in src:
+            report.missing_in_checkpoint.append(name)
+        elif src[name].shape != tensor.shape:
+            report.shape_mismatch.append(
+                f"{name}: checkpoint {tuple(src[name].shape)} vs model {tuple(tensor.shape)}")
+        else:
+            staged[name] = src[name]
+            report.transferred.append(name)
+
+    report.unused_in_checkpoint = [k for k in src if k not in own]
+
+    own.update(staged)
+    model.load_state_dict(own)
+
+    if verbose:
+        print(f"[transfer] {ckpt_path} -> {type(model).__name__}")
+        print(report)
+    return report

tools/convert_checkpoints.py

@@ -0,0 +1,195 @@
+"""
+Convert the raw training checkpoints into the released weights/*.pt files.
+
+The originals are of two kinds:
+
+  * ``Pretrained/*/best_val.pth``  -- already a bare state_dict.
+  * ``Output/*/best_val_evaluation_index.pkl`` -- a dict with the network
+    state_dict *plus* optimizer state, LR-scheduler state and a pickled
+    ``network_trainer.TrainerLog`` object. Those are 4-30x larger than the
+    weights and cannot be read without this repo's training module on the path.
+
+Both are normalised here into a small, self-describing, ``weights_only=True``-safe
+file. See src/checkpoint.py for the resulting layout.
+
+This script is kept for provenance -- you do not need to run it to use the
+released weights.
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+import types
+from collections import OrderedDict
+
+import torch
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "src"))
+from channels import CHANNEL_SPECS, names  # noqa: E402
+
+# The .pkl files pickle a TrainerLog instance. Stub the module out so we can
+# unpickle them without dragging in the training code (which we are not
+# releasing). We only ever read the 'network_state_dict' key.
+_stub = types.ModuleType("network_trainer")
+
+
+class _Placeholder:
+    def __setstate__(self, state):
+        self.__dict__.update(state if isinstance(state, dict) else {})
+
+
+for _name in ("TrainerLog", "TrainerSetting", "TrainerTime", "NetworkTrainer"):
+    setattr(_stub, _name, type(_name, (_Placeholder,), {}))
+sys.modules.setdefault("network_trainer", _stub)
+
+
+# (output name, source path, arch, in_channels, anatomy, regime, scale_out,
+#  eval_clip_factor, note)
+SPECS = [
+    # ---------------- head and neck: C3D ----------------
+    ("c3d_pretrained.pt", "Pretrained/C3D_128x128x160/best_val.pth",
+     "c3d", 8, "source-domain", "pretrained", 7.5, 1.1,
+     "Source-domain model trained on the public 8-channel dose dataset. "
+     "Starting point for c3d_finetuned.pt and pancreas_c3d_finetuned.pt."),
+    ("c3d_finetuned.pt", "Output/C3D/Finetune_v2/best_val_evaluation_index.pkl",
+     "c3d", 5, "han", "finetuned", 7.5, 1.1,
+     "Fine-tuned from c3d_pretrained.pt on head-and-neck data; Adam lr 3e-5, "
+     "cosine schedule, 275 epochs."),
+    ("c3d_fromscratch.pt", "Output/C3D/FromScratch/best_val_evaluation_index.pkl",
+     "c3d", 5, "han", "fromscratch", 7.5, 1.1,
+     "Same architecture and schedule trained from random init; Adam lr 1e-4. "
+     "The no-transfer baseline."),
+
+    # ---------------- head and neck: MedNeXt ----------------
+    ("mednext_pretrained.pt", "Pretrained/MedNeXt/best_val.pth",
+     "mednext", 8, "source-domain", "pretrained", 7.5, 1.2,
+     "Source-domain MedNeXt-B trained on the public 8-channel dose dataset."),
+    ("mednext_finetuned.pt", "Output/MedNeXt/Finetune/best_val_evaluation_index.pkl",
+     "mednext", 5, "han", "finetuned", 7.5, 1.2,
+     "Fine-tuned from mednext_pretrained.pt on head-and-neck data."),
+    ("mednext_fromscratch.pt", "Output/MedNeXt/FromScratch/best_val_evaluation_index.pkl",
+     "mednext", 5, "han", "fromscratch", 7.5, 1.2,
+     "MedNeXt-B trained from random init. The no-transfer baseline."),
+
+    # ---------------- head and neck: SwinUNETR ----------------
+    ("swinunetr_pretrained.pt", "Pretrained/SwinUNETR_L_128x128x160/best_val.pth",
+     "swinunetr", 8, "source-domain", "pretrained", 7.5, 1.2,
+     "Source-domain SwinUNETR-L trained on the public 8-channel dose dataset."),
+    ("swinunetr_finetuned.pt", "Output/SwinUNETR_L/Finetune/best_val_evaluation_index.pkl",
+     "swinunetr", 5, "han", "finetuned", 7.5, 1.2,
+     "Fine-tuned from swinunetr_pretrained.pt on head-and-neck data."),
+    ("swinunetr_fromscratch.pt", "Output/SwinUNETR_L/FromScratch/best_val_evaluation_index.pkl",
+     "swinunetr", 5, "han", "fromscratch", 7.5, 1.2,
+     "SwinUNETR-L trained from random init. The no-transfer baseline."),
+
+    # ---------------- pancreas: C3D ----------------
+    ("pancreas_c3d_pretrained.pt", "Pretrained/C3D_128x128x160/best_val.pth",
+     "c3d", 8, "source-domain", "pretrained", 5.5, 1.2,
+     "Byte-identical weights to c3d_pretrained.pt; duplicated so the pancreas "
+     "set is self-contained. Only scale_out differs (5.5 for pancreas)."),
+    ("pancreas_c3d_finetuned.pt",
+     "Output/Pancreas/PancC3D/FineTune_v5/best_val_evaluation_index.pkl",
+     "c3d", 5, "pancreas", "finetuned", 5.5, 1.2,
+     "Fine-tuned directly from the source-domain pretrained C3D onto pancreas "
+     "VMAT data -- NOT from the head-and-neck model."),
+    ("pancreas_c3d_fromscratch.pt",
+     "Output/Pancreas/PancC3D/FromScratch/best_val_evaluation_index.pkl",
+     "c3d", 5, "pancreas", "fromscratch", 5.5, 1.2,
+     "C3D trained from random init on pancreas VMAT data. The no-transfer baseline."),
+]
+
+
+def extract_state_dict(path):
+    raw = torch.load(path, map_location="cpu", weights_only=False)
+    if isinstance(raw, dict) and "network_state_dict" in raw:
+        raw = raw["network_state_dict"]
+    clean = OrderedDict()
+    for k, v in raw.items():
+        clean[k[len("module."):] if k.startswith("module.") else k] = v.cpu()
+    return clean
+
+
+def sha256(path, chunk=1 << 20):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(chunk), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--src_root", default="..",
+                   help="directory containing Pretrained/ and Output/")
+    p.add_argument("--out_dir", default="weights")
+    args = p.parse_args()
+
+    os.makedirs(args.out_dir, exist_ok=True)
+    manifest = []
+
+    for (name, rel, arch, in_ch, anatomy, regime,
+         scale_out, clip, note) in SPECS:
+        src = os.path.join(args.src_root, rel)
+        state_dict = extract_state_dict(src)
+
+        if in_ch == 8:
+            spec = "source_8ch"
+        elif anatomy == "pancreas":
+            spec = "pancreas_5ch"
+        else:
+            spec = "han_5ch"
+        assert len(CHANNEL_SPECS[spec]) == in_ch, (spec, in_ch)
+
+        ckpt = {
+            "state_dict": state_dict,
+            "arch": arch,
+            "in_channels": in_ch,
+            "channel_spec": spec,
+            "channel_names": names(spec),
+            "out_channels": 1,
+            "anatomy": anatomy,
+            "regime": regime,
+            "act_sig": True,
+            "scale_out": scale_out,
+            "dose_div_factor": 10,
+            "eval_clip_factor": clip,
+            "input_size_zyx": [128, 192, 192],
+            "source": rel,
+            "note": note,
+        }
+
+        dst = os.path.join(args.out_dir, name)
+        torch.save(ckpt, dst)
+
+        n_params = sum(v.numel() for v in state_dict.values())
+        entry = {
+            "file": name,
+            "arch": arch,
+            "anatomy": anatomy,
+            "regime": regime,
+            "in_channels": in_ch,
+            "channel_spec": spec,
+            "scale_out": scale_out,
+            "eval_clip_factor": clip,
+            "num_parameters": n_params,
+            "num_tensors": len(state_dict),
+            "size_bytes": os.path.getsize(dst),
+            "source": rel,
+            "source_size_bytes": os.path.getsize(src),
+            "sha256": sha256(dst),
+            "note": note,
+        }
+        manifest.append(entry)
+        print(f"{name:32s} {n_params/1e6:8.2f} M params  "
+              f"{entry['size_bytes']/1e6:8.1f} MB "
+              f"(from {entry['source_size_bytes']/1e6:.1f} MB)")
+
+    with open(os.path.join(args.out_dir, "MANIFEST.json"), "w") as f:
+        json.dump(manifest, f, indent=2)
+    print(f"\nWrote {os.path.join(args.out_dir, 'MANIFEST.json')}")
+
+
+if __name__ == "__main__":
+    main()

weights/MANIFEST.json

@@ -0,0 +1,206 @@
+[
+  {
+    "file": "c3d_pretrained.pt",
+    "arch": "c3d",
+    "anatomy": "source-domain",
+    "regime": "pretrained",
+    "in_channels": 8,
+    "channel_spec": "source_8ch",
+    "scale_out": 7.5,
+    "eval_clip_factor": 1.1,
+    "num_parameters": 32353106,
+    "num_tensors": 172,
+    "size_bytes": 129469738,
+    "source": "Pretrained/C3D_128x128x160/best_val.pth",
+    "source_size_bytes": 129481303,
+    "sha256": "b215969e57733cc6699d17a9d23f20dde8411971f2662fd114c66ee0c25befef",
+    "note": "Source-domain model trained on the public 8-channel dose dataset. Starting point for c3d_finetuned.pt and pancreas_c3d_finetuned.pt."
+  },
+  {
+    "file": "c3d_finetuned.pt",
+    "arch": "c3d",
+    "anatomy": "han",
+    "regime": "finetuned",
+    "in_channels": 5,
+    "channel_spec": "han_5ch",
+    "scale_out": 7.5,
+    "eval_clip_factor": 1.1,
+    "num_parameters": 32349218,
+    "num_tensors": 172,
+    "size_bytes": 129453946,
+    "source": "Output/C3D/Finetune_v2/best_val_evaluation_index.pkl",
+    "source_size_bytes": 517875237,
+    "sha256": "73679f45b10104d96b8a28f90024f3f92be9a40e8bc733fa02e18d31825f43be",
+    "note": "Fine-tuned from c3d_pretrained.pt on head-and-neck data; Adam lr 3e-5, cosine schedule, 275 epochs."
+  },
+  {
+    "file": "c3d_fromscratch.pt",
+    "arch": "c3d",
+    "anatomy": "han",
+    "regime": "fromscratch",
+    "in_channels": 5,
+    "channel_spec": "han_5ch",
+    "scale_out": 7.5,
+    "eval_clip_factor": 1.1,
+    "num_parameters": 32349218,
+    "num_tensors": 172,
+    "size_bytes": 129454298,
+    "source": "Output/C3D/FromScratch/best_val_evaluation_index.pkl",
+    "source_size_bytes": 517881381,
+    "sha256": "7e7df38af255dcb9b8621b058f1265a1c6946c32c51edf501e4c0b628e94208e",
+    "note": "Same architecture and schedule trained from random init; Adam lr 1e-4. The no-transfer baseline."
+  },
+  {
+    "file": "mednext_pretrained.pt",
+    "arch": "mednext",
+    "anatomy": "source-domain",
+    "regime": "pretrained",
+    "in_channels": 8,
+    "channel_spec": "source_8ch",
+    "scale_out": 7.5,
+    "eval_clip_factor": 1.2,
+    "num_parameters": 10526498,
+    "num_tensors": 229,
+    "size_bytes": 42178475,
+    "source": "Pretrained/MedNeXt/best_val.pth",
+    "source_size_bytes": 42184734,
+    "sha256": "75c971ae3a35e14fa6e1667b829f367f07b5d8c57404871d62610c38c86f1b70",
+    "note": "Source-domain MedNeXt-B trained on the public 8-channel dose dataset."
+  },
+  {
+    "file": "mednext_finetuned.pt",
+    "arch": "mednext",
+    "anatomy": "han",
+    "regime": "finetuned",
+    "in_channels": 5,
+    "channel_spec": "han_5ch",
+    "scale_out": 7.5,
+    "eval_clip_factor": 1.2,
+    "num_parameters": 10526402,
+    "num_tensors": 229,
+    "size_bytes": 42177794,
+    "source": "Output/MedNeXt/Finetune/best_val_evaluation_index.pkl",
+    "source_size_bytes": 168792326,
+    "sha256": "f397b9bc4ec257f07b798f55adf8143085fc3f236dccc2a043de084c9260694e",
+    "note": "Fine-tuned from mednext_pretrained.pt on head-and-neck data."
+  },
+  {
+    "file": "mednext_fromscratch.pt",
+    "arch": "mednext",
+    "anatomy": "han",
+    "regime": "fromscratch",
+    "in_channels": 5,
+    "channel_spec": "han_5ch",
+    "scale_out": 7.5,
+    "eval_clip_factor": 1.2,
+    "num_parameters": 10526402,
+    "num_tensors": 229,
+    "size_bytes": 42178260,
+    "source": "Output/MedNeXt/FromScratch/best_val_evaluation_index.pkl",
+    "source_size_bytes": 168793926,
+    "sha256": "e1e041424d496e1241b56f9b73b79fde0bb5c473e4299db5bf34609904ab463c",
+    "note": "MedNeXt-B trained from random init. The no-transfer baseline."
+  },
+  {
+    "file": "swinunetr_pretrained.pt",
+    "arch": "swinunetr",
+    "anatomy": "source-domain",
+    "regime": "pretrained",
+    "in_channels": 8,
+    "channel_spec": "source_8ch",
+    "scale_out": 7.5,
+    "eval_clip_factor": 1.2,
+    "num_parameters": 291356139,
+    "num_tensors": 167,
+    "size_bytes": 1169245779,
+    "source": "Pretrained/SwinUNETR_L_128x128x160/best_val.pth",
+    "source_size_bytes": 1169258908,
+    "sha256": "edca3e20d8a6f1a00b4d3c6dfbf19e67c4f89b3fbd769c2ed9bae7ce51520160",
+    "note": "Source-domain SwinUNETR-L trained on the public 8-channel dose dataset."
+  },
+  {
+    "file": "swinunetr_finetuned.pt",
+    "arch": "swinunetr",
+    "anatomy": "han",
+    "regime": "finetuned",
+    "in_channels": 5,
+    "channel_spec": "han_5ch",
+    "scale_out": 7.5,
+    "eval_clip_factor": 1.2,
+    "num_parameters": 291345771,
+    "num_tensors": 167,
+    "size_bytes": 1169204072,
+    "source": "Output/SwinUNETR_L/Finetune/best_val_evaluation_index.pkl",
+    "source_size_bytes": 4654279265,
+    "sha256": "e92c795b3792094fa881a8f7a7ef4a03a411454f78026351ea38fe5b0632204e",
+    "note": "Fine-tuned from swinunetr_pretrained.pt on head-and-neck data."
+  },
+  {
+    "file": "swinunetr_fromscratch.pt",
+    "arch": "swinunetr",
+    "anatomy": "han",
+    "regime": "fromscratch",
+    "in_channels": 5,
+    "channel_spec": "han_5ch",
+    "scale_out": 7.5,
+    "eval_clip_factor": 1.2,
+    "num_parameters": 291345771,
+    "num_tensors": 167,
+    "size_bytes": 1169204414,
+    "source": "Output/SwinUNETR_L/FromScratch/best_val_evaluation_index.pkl",
+    "source_size_bytes": 4654274081,
+    "sha256": "6981fa28668ab6efc1f5450eea8921b2c6477803eff8582911c6e4ff8ec4881f",
+    "note": "SwinUNETR-L trained from random init. The no-transfer baseline."
+  },
+  {
+    "file": "pancreas_c3d_pretrained.pt",
+    "arch": "c3d",
+    "anatomy": "source-domain",
+    "regime": "pretrained",
+    "in_channels": 8,
+    "channel_spec": "source_8ch",
+    "scale_out": 5.5,
+    "eval_clip_factor": 1.2,
+    "num_parameters": 32353106,
+    "num_tensors": 172,
+    "size_bytes": 129471450,
+    "source": "Pretrained/C3D_128x128x160/best_val.pth",
+    "source_size_bytes": 129481303,
+    "sha256": "aa51c8851a2eb0f74b0e59c8a202e57ceee1013abb2274bf7b52e1a623b926f4",
+    "note": "Byte-identical weights to c3d_pretrained.pt; duplicated so the pancreas set is self-contained. Only scale_out differs (5.5 for pancreas)."
+  },
+  {
+    "file": "pancreas_c3d_finetuned.pt",
+    "arch": "c3d",
+    "anatomy": "pancreas",
+    "regime": "finetuned",
+    "in_channels": 5,
+    "channel_spec": "pancreas_5ch",
+    "scale_out": 5.5,
+    "eval_clip_factor": 1.2,
+    "num_parameters": 32349218,
+    "num_tensors": 172,
+    "size_bytes": 129455658,
+    "source": "Output/Pancreas/PancC3D/FineTune_v5/best_val_evaluation_index.pkl",
+    "source_size_bytes": 517882405,
+    "sha256": "36d4b7369e4221cf86e3c06947c98fa8e96d1d50381d362933a13ec0fdca777f",
+    "note": "Fine-tuned directly from the source-domain pretrained C3D onto pancreas VMAT data -- NOT from the head-and-neck model."
+  },
+  {
+    "file": "pancreas_c3d_fromscratch.pt",
+    "arch": "c3d",
+    "anatomy": "pancreas",
+    "regime": "fromscratch",
+    "in_channels": 5,
+    "channel_spec": "pancreas_5ch",
+    "scale_out": 5.5,
+    "eval_clip_factor": 1.2,
+    "num_parameters": 32349218,
+    "num_tensors": 172,
+    "size_bytes": 129455946,
+    "source": "Output/Pancreas/PancC3D/FromScratch/best_val_evaluation_index.pkl",
+    "source_size_bytes": 517899237,
+    "sha256": "e80eb22116f022fb170094f5eae29529275838098fe2d0490f92d721f3a98436",
+    "note": "C3D trained from random init on pancreas VMAT data. The no-transfer baseline."
+  }
+]

weights/c3d_finetuned.pt

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

weights/c3d_fromscratch.pt

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

weights/c3d_pretrained.pt

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

weights/mednext_finetuned.pt

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

weights/mednext_fromscratch.pt

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

weights/mednext_pretrained.pt

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

weights/pancreas_c3d_finetuned.pt

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

weights/pancreas_c3d_fromscratch.pt

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

weights/pancreas_c3d_pretrained.pt

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

weights/swinunetr_finetuned.pt

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

weights/swinunetr_fromscratch.pt

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

weights/swinunetr_pretrained.pt

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