Hugging Face's logo

Datasets:
eltzanis
/
DosePET

Modalities:
Tabular
Text
Formats:
parquet
Size:
100K - 1M
Tags:
medical-imaging
dosimetry
pet-ct
monte-carlo
nuclear-medicine
radiation-dose
Libraries:
Datasets
pandas
Polars
License:
Dataset card Data Studio Files
xet
 Community
1
DosePET / README.md
eltzanis's picture
eltzanis
DosePET v1.0 — initial public release
f487fa5
preview code
|
Raw History Blame Contribute Delete
16.7 kB
metadata 
license: cc-by-nc-4.0
pretty_name: DosePET - An Open-Source Dataset with 2100 Radiation Dose Maps for PET/CT
tags:
  - medical-imaging
  - dosimetry
  - pet-ct
  - monte-carlo
  - nuclear-medicine
  - radiation-dose
size_categories:
  - 1K<n<10K
configs:
  - config_name: organ_doses
    data_files: metadata/dose_reports.parquet

DosePET: An Open-Source Dataset with 2100 Radiation Dose Maps for PET/CT

Voxel-level absorbed dose maps for 2100 whole-body and total-body PET/CT studies, computed with GATE Monte Carlo simulation, together with 117 TotalSegmentator organ masks and per-organ dose statistics for every study.

studies 2100 (1503 [18F]FDG, 597 PSMA)
isotopes F-18 (1872), Ga-68 (228)
organs per study 117
organ dose rows 245,700
unpacked size 509 GB
download size 383 GB (all), 32 MB for the organ dose tables alone

The per-organ dose statistics for all 2100 studies are a 32 MB download, and are also browsable in the Dataset Viewer above. See Quick start.

Quick start 

pip install huggingface_hub                       # recommended, not required
wget https://huggingface.co/datasets/eltzanis/DosePET/resolve/main/download_dataset.py

python3 download_dataset.py list                  # what's available

python3 download_dataset.py get --content tables --out ./petct   # 32 MB
python3 download_dataset.py get --sample 5        --out ./petct  # 5 full studies
python3 download_dataset.py get --subset PSMA     --out ./petct  # one tracer
python3 download_dataset.py get --all             --out ./petct  # everything

python3 download_dataset.py get --all --dry-run   # size check, no download

Every selection extracts into the same layout, so you can start small and add more later without reorganising anything.

Downloading exactly what you need

1. Only the organ dose tables — 32 MB

Every dose_report.csv, metadata.json, dosimetry_config.json and segmentation/statistics.json, for all 2100 studies. No dose images, no masks.

python3 download_dataset.py get --content tables --out ./petct

The same data is in metadata/dose_reports.parquet (24 MB, 245,700 rows) if you would rather have one table than 2100 files:

import pandas as pd
df = pd.read_parquet("hf://datasets/eltzanis/DosePET/metadata/dose_reports.parquet")
df[df.organ == "liver"].groupby("isotope_key").mean_dose_rate_at_scan_mGy_per_h.describe()

2. Named studies — only their bytes are fetched 

# find the ids
python3 download_dataset.py list --cases

# fetch three of them, from three different shards
python3 download_dataset.py get \
    --cases FDG/0001,FDG/0500,PSMA/PSMA_0179419e313f7d8c/05-03-2002-NA-PETCT_whole-body_PSMA-40379 \
    --out ./petct

The dose shards are uncompressed tars and the manifest records each study's byte offset, so the script issues HTTP Range requests and pulls only what you asked for:

range-fetching 1 case(s), 144.04 MB of 9.91 GB
range-fetching 1 case(s), 133.40 MB of 9.94 GB
range-fetching 1 case(s), 105.14 MB of 9.94 GB
done: 366 files

For a long list use a file:

printf 'FDG/0001\nFDG/0002\nFDG/0500\n' > my_cases.txt
python3 download_dataset.py get --case-list my_cases.txt --out ./petct

Add --no-range to download whole shards instead (useful behind a proxy that strips Range headers; the script falls back to this automatically anyway).

3. A representative sample 

python3 download_dataset.py get --sample 10 --out ./petct

Ten studies spread evenly across the dataset rather than ten consecutive ids. Combine with --subset to sample one tracer:

python3 download_dataset.py get --sample 10 --subset PSMA --out ./petct

4. Masks and tables but no dose images 

python3 download_dataset.py get --content tables,seg --out ./petct

All 245,700 AI generted organ masks for all 2100 studies: 5.3 GB

5. One tracer 

python3 download_dataset.py get --subset FDG  --out ./petct    # 1503 studies
python3 download_dataset.py get --subset PSMA --out ./petct    #  597 studies

6. By shard, for batching a big transfer 

python3 download_dataset.py get --subset FDG --shards 0-3  --out ./petct
python3 download_dataset.py get --subset FDG --shards 4-7  --out ./petct

FDG_dose_007.tar and FDG_seg_007.tar.gz hold exactly the same studies, so a shard index always gives you complete studies.

7. Everything 

python3 download_dataset.py get --all --out ./petct

Always check first 

python3 download_dataset.py get --all --dry-run
python3 download_dataset.py get --cases FDG/0001,FDG/0002 --dry-run

--dry-run prints the exact download size and the shards involved, and downloads nothing.

Measured download sizes

what you ask for download
--content tables 32 MB
one named study 333 MB
--sample 5 1.46 GB
--sample 10 2.80 GB
--sample 50 13.5 GB
--content tables,seg (all masks, no dose) 5.32 GB
--subset PSMA 68.2 GB
--subset FDG 314.7 GB
--all 382.8 GB

A named study costs more than its dose image alone (175 MB) because the masks for its shard arrive as one 150 MB gzipped archive and the 32 MB tables shard comes with it.

Coming back for more later

Point --out at the same directory and the dataset grows in place. Nothing is re-downloaded, nothing already on disk is touched.

python3 download_dataset.py get --content tables --out ./petct   # today:   32 MB
python3 download_dataset.py get --cases FDG/0001 --out ./petct   # later:  333 MB
python3 download_dataset.py get --sample 50      --out ./petct   # later: 13.5 GB
python3 download_dataset.py get --all            --out ./petct   # finally: 383 GB

Two things worth knowing:

  • Each archive is deleted after it is extracted, to save disk. If a download is interrupted mid-shard it restarts that shard; pass --keep-archives to keep them and make interruptions cheaper.
  • The tables shard (32 MB) covers all 2100 studies, so it comes down again with each new batch. Harmless, but it is why a "three more studies" batch reports ~867 MB rather than ~836 MB.

What you end up with

The extracted tree is identical to the source dataset — same directory structure, same filenames, same bytes. Verified by extracting a complete shard pair and diffing it against the original:

directory tree : IDENTICAL - 2976 paths, same names, same nesting
file contents  : ALL 2928 FILES BYTE-IDENTICAL

Partial downloads give you a correct subtree: take only the tables and you get FDG/0001/dose_report.csv in its proper place with dose_image.nii.gz simply absent. Add masks or dose images later and they land in the same tree.

The one thing not preserved is file modification times — they are set to when you extracted, not when the data was produced. File contents are bit-for-bit identical.

Integrity

Every archive's SHA-256 is checked against shards.json before extraction, and the download aborts on a mismatch rather than extracting corrupt data. To re-check archives you kept with --keep-archives:

python3 download_dataset.py verify --cache ./petct_cache

What each study contains 

FDG/0001/
    dose_image.nii.gz            total absorbed dose, Gy, uint16 + scl_slope
    dose_report.csv              117 rows, per-organ dose statistics
    metadata.json                isotope, half-life, injected activity, timings
    dosimetry_config.json        cumulated activity, primaries, integration mode
    segmentation/
        liver.nii.gz  ...        117 binary organ masks (TotalSegmentator)
        statistics.json          mask volumes

PSMA/<patient>/<scan>/           same files, one extra directory level

dose_image.nii.gz

Each voxel is the total absorbed dose in Gy, integrated from the start of the scan to infinity assuming physical decay only — the activity distribution is frozen in space, with no biological clearance and no redistribution.

Stored as uint16 with a scl_slope in the NIfTI header (quantisation step = max_dose / 65535, about 1.5e-5 relative). You must apply scl_slope. nibabel and SimpleITK do this automatically:

import nibabel as nib, numpy as np
dose_Gy = np.asanyarray(nib.load("FDG/0001/dose_image.nii.gz").dataobj)  # Gy

dose_report.csv

One row per organ, alphabetical:

column meaning
organ TotalSegmentator label
mean_dose_Gy, max_dose_Gy, min_dose_Gy, dose_std_Gy dose in the mask
mean_dose_injection_Gy, max_dose_injection_Gy back-extrapolated to injection time
volume_cm3, mass_g, num_voxels mask geometry
dcf_Gy_per_Bqs dose conversion factor, Gy per decay in the FOV
mean_dose_rate_at_scan_mGy_per_s, mean_dose_rate_at_scan_mGy_per_h dose rate at scan start

All 245,700 rows are also published as metadata/dose_reports.parquet for the Dataset Viewer, joined with each study's isotope, half-life, injected activity and cumulated activity.

In the Parquet table the dose conversion factor is given as dcf_fGy_per_Bqs — the same quantity as the CSVs' dcf_Gy_per_Bqs, in femtogray (multiplied by 10^15^). Doses back-extrapolated to injection time are provided in each study's dose_report.csv, and simulation parameters in its dosimetry_config.json.

A zero in dcf_fGy_per_Bqs (8857 rows) means the organ mask is empty because the structure lies outside the acquired field of view, not that the value is missing.

Deriving dose rate and Gy-per-decay

Because the only time dependence is a single exponential shared by every voxel, both quantities are the dose image times one scalar per study:

lambda   = ln2 / T_half                                  T_half from metadata.json
rate     = D * 3.6e6 * lambda      [mGy/h]  at scan start
DCF      = D / A_tilde             [Gy per decay]        A_tilde = cumulated_from_scan

import json, math, numpy as np, nibabel as nib
case = "FDG/0001"
cfg  = json.load(open(f"{case}/dosimetry_config.json"))
meta = json.load(open(f"{case}/metadata.json"))
T_half  = cfg.get("half_life_seconds") or meta["isotope"]["half_life_seconds"]
A_tilde = cfg["cumulated_from_scan"]

D = np.asanyarray(nib.load(f"{case}/dose_image.nii.gz").dataobj)   # Gy
rate_mGy_per_h = D * 3.6e6 * math.log(2) / T_half
dcf_Gy_per_dec = D / A_tilde

For organ-level numbers you need none of this — the columns are already in dose_report.csv.

tools/convert_dose_images.py

It does the conversions above for you, and can independently re-verify the published tables.

DATA=./petct            # where you extracted the dataset

# voxel-wise dose-rate maps, mGy/h at scan start
python3 tools/convert_dose_images.py rate --root $DATA/FDG --out ./rate_maps

# voxel-wise Gy-per-decay maps
python3 tools/convert_dose_images.py dcf  --root $DATA/PSMA --out ./dcf_maps

# per-organ table straight from the image + masks, in the same column
# order as dose_report.csv so the two can be diffed
python3 tools/convert_dose_images.py organs --case $DATA/FDG/0001 --out table.csv

# recompute every reproducible column and compare against the published CSV
python3 tools/convert_dose_images.py check --root $DATA/FDG

Other time points are opt-in: --at injection (uses the stored injection correction factor) or --at +3600 for one hour after the scan. Units via --unit mGy_per_h | mGy_per_s | Gy_per_s.

The conversion is lossless. By default the tool copies the uint16 payload byte for byte and multiplies only the NIfTI scl_slope, so the output carries no extra quantisation and is the same size as the input. Use --mode float32 if your software ignores scl_slope.

check is the reproducibility anchor: it recomputes organ means from the dose image and the masks, applies the scale factor, and diffs against the shipped dose_report.csv, printing PASS/FAIL per study:

[1/2] PASS  0001  117 organs, 1283 values, worst 0.499 x tolerance

Full usage in tools/README.md. Requires numpy, nibabel, and SimpleITK for the mask-based commands.

Converting a whole subset duplicates it on disk (hundreds of GB). Unless you need the files on disk, apply the scalar on the fly with the six lines above.

How the release is packaged

Three kinds of shard, all tar archives whose members keep their original relative paths:

shard contents compression why
data/tables.tar.gz every .csv / .json, all 2100 studies gzip 32 MB, so table-only users download almost nothing
data/<subset>/<subset>_dose_NNN.tar dose_image.nii.gz none already gzipped NIfTI
data/<subset>/<subset>_seg_NNN.tar.gz organ masks gzip masks compress about 23:1 (115 GB → 5 GB)

*_dose_NNN and *_seg_NNN with the same NNN hold exactly the same studies, so a complete slice of the dataset is two downloads.

Alongside the data:

path what
download_dataset.py the download script
shards.json manifest: sizes, SHA-256, case lists, per-case byte offsets
metadata/dose_reports.parquet all 245,700 organ rows, for the Dataset Viewer
tools/convert_dose_images.py dose-rate / Gy-per-decay conversion + verification
tools/README.md usage guide for the conversion tool
skills/dosepet-research/ agent skill: instructions for AI agents working with the dataset

shards.json lists every shard with its size, SHA-256 and case list, and maps each case id to its shards. The download script verifies every archive against that checksum before extracting.

Using DosePET with AI agents

skills/dosepet-research/ is an agent skill — a set of instructions that an agentic AI system (for example Claude Code or OpenAI Codex) can load to work with this dataset correctly. It covers selective downloading, retrieving and matching the source PET/CT examinations from ENHANCE.PET and PSMA-PET-CT-Lesions, verifying spatial correspondence before use, and the physical meaning and units of the dose quantities.

hf download eltzanis/DosePET --repo-type dataset --include "skills/*" --local-dir .

Then make the skills/dosepet-research folder available to your agent (for Claude Code, copy it into ~/.claude/skills/ or the project's .claude/skills/).

Assumptions and caveats

  1. Physical decay only. No biological clearance or redistribution.
  2. Time zero is scan start.
  3. dcf_Gy_per_Bqs is normalised to decays in the imaged FOV, with that patient's own tracer distribution as the source. It is a FOV-normalised S-value, not dose per decay in a specific source organ, and should not be compared directly with MIRD/OLINDA organ-to-organ S-values.
  4. Apply scl_slope (if it is not applied automatically) when reading the dose images.
  5. Four FDG studies (0718, 1022, 1195, 1289) have no injection correction factor, because the acquisition time is missing upstream. Their dose_report.csv therefore omits mean_dose_injection_Gy and max_dose_injection_Gy. Scan-time dose, dose rate and DCF are unaffected.

Citation

If you use DosePET in your research, please cite:

@article{Tzanis2026DosePET,
  title  = {DosePET: An Open-Source Dataset with 2100 Radiation Dose Maps for PET/CT},
  author = {Eleftherios Tzanis and Antonios Tzortzakakis and Michail E. Klontzas},
  year   = {2026},
  note   = {Manuscript under review}
}

License

CC BY-NC 4.0 — Creative Commons Attribution-NonCommercial 4.0 International. You may share and adapt this dataset for non-commercial purposes with attribution. See https://creativecommons.org/licenses/by-nc/4.0/

The underlying PET/CT images come from their respective source collections; please also honour their terms and cite them.

  • FDG subset — ENHANCE.PET whole-/total-body [18F]FDG-PET/CT dataset:

    Ferrara D, Pires M, Gutschmayer S, et al. Sharing a whole-/total-body [18F]FDG-PET/CT dataset with CT-derived segmentations: an ENHANCE.PET initiative. Sci Data 13, 869 (2026). https://doi.org/10.1038/s41597-026-07218-y

  • PSMA subset — LMU Munich whole-body PSMA-PET/CT dataset:

    Jeblick K, Schachtner B, Mittermeier A, et al. A Whole-Body PSMA-PET/CT dataset with manually annotated tumor lesions. Sci Data 13, 1023 (2026). https://doi.org/10.1038/s41597-026-07821-z