Read the usage disclaimer before requesting access

GEPAR3D is a research artifact, not a production-ready or clinically validated system. Earlier versions of this repository withheld these final weights for exactly that reason: the coarse ROI segmentation weights, class-weighting parameters, and SSM-derived Wasserstein penalty matrix were released so the results could be fully reproduced by retraining from scratch, without enabling unsupervised deployment of a finished model. We are now releasing the trained weights as well, under CC-BY-NC-4.0 (to prevent uncredited or unlicensed commercial reuse) and behind manual access review (so we retain some visibility into who is using them and for what purpose). By requesting access you confirm you understand this model is NOT a certified medical device, has NOT been validated for clinical decision-making, and must NOT be used as the sole basis for diagnosis, treatment planning, or any patient-facing decision, and that you have read the "Bias, Risks, and Limitations" and "Out-of-Scope Use" sections of the model card below.

The GEPAR3D weights are provided for non-commercial research reproducibility and reuse only. They are shared "as is," with no warranty, are not a certified medical device, and must not be integrated into any clinical, diagnostic, or commercial product without independent validation and proper licensing. Please state your intended research use below.

Model Card for GEPAR3D

GEPAR3D (GEometric Prior-Assisted LeaRning for 3D) is a 3D deep-learning model for instance-aware, multi-class (32-class) tooth segmentation in Cone-Beam Computed Tomography (CBCT), with a particular focus on accurate segmentation of tooth root apices to support root resorption research in orthodontics. It unifies instance detection and semantic segmentation in a single model by combining a Statistical Shape Model (SSM) geometric prior with a 3D deep watershed instance-regression head. GEPAR3D was published at MICCAI 2025.

📄 Paper (arXiv): https://arxiv.org/abs/2508.00155
📄 Paper (MICCAI proceedings, open access): https://papers.miccai.org/miccai-2025/0375-Paper1833.html
💻 Code: https://github.com/tomek1911/GEPAR3D
🌐 Project page: https://tomek1911.github.io/GEPAR3D/
🗄️ Training/eval data (gated, non-commercial license, hosted on Zenodo — not mirrored here): https://zenodo.org/records/15739014

Model Details

Model Description

GEPAR3D is an encoder-decoder network with two decoders that are optimized jointly:

A segmentation decoder that classifies each voxel into one of 32 tooth classes (Universal Numbering System) plus background. It is regularized with a Geometric Wasserstein Dice Loss (GeoWDL): a Generalized Wasserstein Dice loss whose penalty matrix is derived from inter-tooth distances in a Statistical Shape Model (SSM) of normal adult dentition, instead of from empirical/label-derived penalties. This lets the model use anatomical structure (e.g., which teeth are geometrically and morphologically close) without hard-coding adjacency rules.
An instance-regression decoder, adapting the "Deep Watershed Transform" to 3D: it regresses a continuous energy map (voxel-wise distance to the instance boundary) plus a 3-channel direction field describing the local energy-descent gradient. A watershed algorithm run on these maps at inference time separates individual tooth instances; each instance is then assigned a class label by majority vote over the segmentation decoder's per-voxel predictions inside that instance.

At inference time, a separate lightweight 4-stage 3D U-Net (strided/transposed convolutions, ReLU, Instance Normalization, additive skip connections) first performs coarse binary segmentation of the raw CBCT scan to localize a tooth Region of Interest (ROI); GEPAR3D itself then runs on the cropped ROI. Both networks (the coarse ROI U-Net and the main GEPAR3D network) are required for the full pipeline — see the "How to Get Started" section.

A note on this release. The GitHub repository initially released the code, data splits, class-weighting parameters, coarse ROI U-Net weights, and the SSM-derived Wasserstein penalty matrix, but withheld the final GEPAR3D weights — the pipeline was fully reproducible by retraining from scratch, and we wanted to avoid enabling unsupervised, unreviewed deployment of a finished model before proper safeguards were in place (see discussion). We have since decided that releasing the trained weights benefits the community more than it costs, provided it comes with a clear non-commercial license, a gated/reviewed download, and the disclaimers throughout this card.

Developed by: Tomasz Szczepański, Szymon Płotka, Michal K. Grzeszczyk, Arleta Adamowicz, Piotr Fudalej, Przemysław Korzeniowski, Tomasz Trzciński, Arkadiusz Sitek
Affiliations: Sano Centre for Computational Personalised Medicine (Poland); Jagiellonian University / Jagiellonian University Medical College (Poland); Warsaw University of Technology & IDEAS NCBR (Poland); University of Amsterdam & Amsterdam UMC (Netherlands); University of Bern (Switzerland); Palacký University Olomouc (Czechia); Imperial College London (UK); Massachusetts General Hospital, Harvard Medical School (USA)
Funded by: EU Horizon 2020 programme (grant no. 857533, Sano); Foundation for Polish Science International Research Agendas programme (MAB PLUS/2019/13), co-financed by the EU European Regional Development Fund and the Polish Ministry of Science and Higher Education (contract no. MEiN/2023/DIR/3796); National Science Centre, Poland (2023/49/N/ST6/01841)
Shared by: Tomasz Szczepański (@tomek1911)
Model type: 3D CNN, dual-decoder encoder-decoder architecture for joint multi-class semantic segmentation + instance detection (plus an auxiliary lightweight 3D U-Net for ROI localization)
Language(s): Not applicable (volumetric medical imaging model, not NLP)
License: CC-BY-NC-4.0 — non-commercial research use only. See "Bias, Risks, and Limitations" and the gating disclaimer above before use. (Confirm — see open items in chat.)
Finetuned from model: Not applicable — trained from scratch (not derived from a pretrained checkpoint)

Model Sources

Repository: https://github.com/tomek1911/GEPAR3D
Paper: Szczepański et al., "GEPAR3D: Geometry Prior-Assisted Learning for 3D Tooth Segmentation," MICCAI 2025, LNCS 15961, pp. 216–226. https://arxiv.org/abs/2508.00155
Project page / qualitative demo (static, browser-based 3D viewer): https://tomek1911.github.io/GEPAR3D/

Uses

Direct Use

Research use for automated, instance-aware, 32-class segmentation of adult permanent dentition (crowns and roots) from CBCT scans, intended to support:

Methodological research on tooth/root segmentation
Research into automated root resorption assessment pipelines (as a segmentation backbone — the model itself does not diagnose resorption)
Benchmarking against other CBCT tooth-segmentation methods

Downstream Use

As a component in a larger research pipeline (e.g., feeding root/crown masks into a downstream resorption-quantification or treatment-planning research tool)
As a starting point for further fine-tuning on other CBCT cohorts for non-commercial research (e.g., adapting to a new scanner or population), subject to the license terms above

Out-of-Scope Use

Clinical diagnosis, treatment planning, or any patient-facing decision without independent validation and oversight by a qualified clinician. This model is not a certified medical device (no CE marking, no FDA clearance) and has not undergone prospective clinical validation.
Pediatric or mixed/deciduous dentition. Training data and preprocessing explicitly excluded deciduous teeth; the model targets adult permanent dentition only.
Assessment of already-resorbed roots as a validated clinical measurement. The paper validates apex segmentation accuracy on non-pathological roots — no public CBCT dataset with resorbed-root ground truth existed at the time of the study, so accuracy on genuinely resorbed roots (the eventual target use case) is not directly verified.
Commercial products or services, per the license.
Use on imaging modalities other than CBCT, or on scans acquired far outside the preprocessing assumptions below (e.g., extreme metal artifact load, non-standard orientation) without independent revalidation.

Bias, Risks, and Limitations

Limited training/validation population. The model is trained on 98 CBCT scans from a single original source cohort (Cui et al., Nature Communications, 2022), re-annotated into 32 classes, and evaluated on 46 external scans from four centers (two public, two in-house Polish centers). This is a research-scale dataset, not a large, demographically diverse clinical dataset.
Statistical Shape Model bias. The geometric prior is built from a Statistical Shape Model of "normal" adult dentition (Kim et al., 2022), constructed from a Korean cohort aged 15–30 with complete permanent dentition, no prosthetics/orthodontic history, and minimal crowding. Patients with significantly different arch morphology, ethnicity-linked dental morphology variation, severe crowding, extensive tooth loss, or prosthetics/implants may fall outside what the prior was built to represent.
Third molars are underrepresented in the training data (class imbalance), so third-molar segmentation accuracy is expected to be lower than for other tooth classes.
Adult dentition only — explicitly excludes deciduous/pediatric teeth.
Not evaluated on pathologically resorbed roots — see "Out-of-Scope Use" above.
No prospective or multi-reader clinical validation; ground truth for the external test set was produced by two orthodontists (5 and 25 years of experience) at a single annotation protocol, which is standard for a MICCAI methods paper but is not equivalent to a clinical-validation study.

Recommendations

Users (direct and downstream) should:

Treat outputs as a research aid, always reviewed by a qualified dental/orthodontic professional — never as a stand-alone diagnostic result.
Independently validate performance on their own imaging protocol, scanner, and patient population before any research pilot that could influence care.
Pay particular attention to (i.e., manually review) predictions for third molars, pediatric/mixed dentition (out of scope — should not be run at all), and any anatomically atypical case.

How to Get Started with the Model

Two checkpoints are provided in this repository, both in the safe .safetensors format, each containing a flat state_dict (the tensors are the model weights directly — no wrapper key):

coarse_unet.safetensors — the lightweight 4-stage 3D U-Net (MONAI's UNet) used for coarse binary ROI localization
gepar3d.safetensors — the main GEPAR3D dual-decoder model

This model card intentionally does not ship a full end-to-end inference.py (preprocessing, ROI cropping, sliding-window inference, deep-watershed instance separation). That pipeline is dataset/preprocessing-dependent and already maintained as the reference implementation in the GitHub repository (scripts/ablation_study/inference.py) — please use that as your starting point and adapt it to your own data.

Prerequisites

Miniconda or Anaconda
NVIDIA GPU with CUDA 11 support (or CPU — see inference hardware notes below)
Python 3.9

git clone https://github.com/tomek1911/GEPAR3D.git
cd GEPAR3D
conda env create -f requirements.yaml -n gepar3d
conda activate gepar3d
pip install huggingface_hub safetensors

Loading the released weights

The exact architecture hyperparameters (n_features, unet_depth, number of binary classes for the coarse model; classes and configuration for the main model) are defined in the repo's own config files — configs/roi_binary_coarse_segmentation.yaml and configs/geometric_prior_multitask.yaml — and should be loaded from there.

import torch
from safetensors.torch import load_file
from huggingface_hub import hf_hub_download
from monai.networks.nets import UNet
# from <path in repo> import GEPAR3D   # see repo for exact import path

device = "cuda" if torch.cuda.is_available() else "cpu"

# --- 1. Coarse binary ROI U-Net (MONAI UNet) ---
# args_binary below = values from configs/roi_binary_coarse_segmentation.yaml
feature_maps = tuple(2**i * args_binary.n_features for i in range(0, args_binary.unet_depth))
strides = list((args_binary.unet_depth - 1) * (2,))

coarse_model = UNet(
    spatial_dims=3, in_channels=1, out_channels=args_binary.classes,
    channels=feature_maps, strides=strides,
    act="relu", norm="instance", bias=False,
)
coarse_ckpt_path = hf_hub_download(repo_id="tomek1911/GEPAR3D", filename="coarse_unet.safetensors")
coarse_model.load_state_dict(load_file(coarse_ckpt_path), strict=True)
coarse_model = coarse_model.to(device).eval()

# --- 2. Main GEPAR3D model ---
# classes / configuration_name below = values from configs/geometric_prior_multitask.yaml
gepar3d_model = GEPAR3D(
    spatial_dims=3, in_channels=1, out_channels=classes,
    act="relu", norm="instance", bias=False,
    backbone_name="resnet34", inference_mode=True,
    configuration=configuration_name,
)
gepar3d_ckpt_path = hf_hub_download(repo_id="tomek1911/GEPAR3D", filename="gepar3d.safetensors")
gepar3d_model.load_state_dict(load_file(gepar3d_ckpt_path), strict=True)
gepar3d_model = gepar3d_model.to(device).eval()

Expected input for the full pipeline: CBCT volume, reoriented to RAS, resampled to isotropic 0.4 × 0.4 × 0.4 mm³ spacing, Hounsfield Units clipped to [0, 5000] and normalized to [0, 1] — see the GitHub repo's preprocessing scripts (src/generate_data) for the exact implementation, since this is the step most likely to need adapting to your own data.

Expected output: a 32-class + background voxel-wise segmentation mask (Universal Numbering System), plus (optionally) an instance-separated mask after the deep-watershed step implemented in the GitHub repo's inference script.

Training: to retrain from scratch, obtain the annotated labels from the GEPAR3D Zenodo record and the corresponding raw scans from Z. Cui et al., structure the data as described in the GitHub repo, generate required assets with src/generate_data, then run scripts/ablation_study/train.py (default configs are the proposed solution).

Expected input: CBCT volume, reoriented to RAS, resampled to isotropic 0.4 × 0.4 × 0.4 mm³ spacing, Hounsfield Units clipped to [0, 5000] and normalized to [0, 1] (the repository's preprocessing scripts handle this).

Expected output: a 32-class + background voxel-wise segmentation mask (Universal Numbering System), plus (optionally) an instance-separated mask after the deep-watershed step.

Training Details

Training Data

Training/validation set: 98 CBCT scans, originally released by Cui et al. ("A fully automatic AI system for tooth and alveolar bone segmentation from cone-beam CT images," Nature Communications, 2022), re-annotated by the GEPAR3D authors into 32 semantic classes (Universal Numbering System). These re-annotated labels (not the raw CBCT scans) are released on Zenodo: https://zenodo.org/records/15739014, under a Non-Commercial Academic Research Use – Redistribution Prohibited (NCRU-NR) license, owned by Sano Centre for Computational Personalised Medicine. Access is gated; researchers must request the raw CBCT imaging from the original providers (Cui et al.) separately.
This Hugging Face repository does not host or redistribute the training data — only the trained model weights are provided here. Anyone wanting to inspect, retrain, or extend training on this data must request access through Zenodo directly and agree to Sano Centre's license terms.

Training Procedure

Preprocessing

Reorient volumes to RAS (Right-Anterior-Superior) coordinate convention.
Resample to isotropic 0.4 × 0.4 × 0.4 mm³ spacing.
Clip Hounsfield Unit intensities to [0, 5000] (deliberately extended beyond typical dental-tissue HU range to improve robustness to metallic artifacts), then min-max normalize to [0, 1].
A lightweight coarse 3D U-Net performs binary ROI segmentation (trained on random 256³ patches; Gaussian sliding-window inference over the full scan) to crop the tooth-bearing region for the main model.
The main GEPAR3D model is trained on randomly cropped 128³ patches taken from within the extracted ROI.

Training Hyperparameters

Optimizer: AdamW, initial learning rate 1e-3, weight decay 1e-4
Schedule: cosine annealing
Epochs: 1000
Batch size: 2
Loss: L = Λ₁·L_EDT + Λ₂·L_seg + Λ₃·L_dir, with Λ₁ = 10 (energy-map/EDT regression), Λ₂ = 0.1 (GeoWDL + inverse-class-frequency-weighted cross-entropy segmentation loss), Λ₃ = 1e-6 (energy-direction loss)
Training regime: fp32 (full precision)

Speeds, Sizes, Times

Hardware used for the reported training run: single NVIDIA A100 GPU
Total training wall-clock time: ~48 hours
Checkpoint file size: 284 MB
Parameter count: 70.86M (main GEPAR3D model)

Evaluation

Testing Data, Factors & Metrics

Testing Data

46 external CBCT scans from four medical centers, never seen during training:

Cui et al. (public) — held-out subset
ToothFairy2 / ToothFairy challenge dataset (public)
In-house Center A, Warsaw, Poland (11 scans, Carestream CS 9600 scanner)
In-house Center B, Warsaw, Poland (9 scans, i-CAT 17-19 scanner)

Use of the in-house data was approved under IRB Approval ID OKW-623/2022. Ground truth for the external set was produced by a board-certified orthodontist (5 years' experience) and independently verified by a senior orthodontist (25 years' experience).

Factors

Center/scanner (4 distinct acquisition sources), tooth class (32 classes with known class imbalance for third molars).

Metrics

DSC — Dice Similarity Coefficient (multi-class)
RC — Recall (multi-class)
HD — Hausdorff Distance (mm)
NSD₁ — Normalized Surface Dice within 1-voxel boundary (binary, tooth-tissue completeness)
RC_B — Binary Recall
DA — instance Detection Accuracy at IoU > 0.5
F1 — instance classification F1

Results

Averaged across all external test centers, compared against 5 state-of-the-art general and tooth-specific segmentation baselines (U-Net, Swin SMT, Swin UNETR(v2), ResUNet34, VSmTrans, V-Net, and tooth-specific methods Jang et al., MWTNet, TSG-GCN, ToothSeg, SGANet):

Metric	GEPAR3D	Δ vs. 2nd-best
DSC (%) ↑	95.0 ± 1.4	+2.8 (vs. SGANet)
RC (%) ↑	93.9 ± 3.2	—
HD (mm) ↓	1.44 ± 0.70	lowest reported
NSD₁ (%) ↑	97.6 ± 1.9	+3.3 (vs. SGANet)
RC_B (%) ↑	95.2 ± 2.1	+9.5 (vs. TSG-GCN)
DA (%) ↑	99.2 ± 2.4	+3.2 (vs. Jang et al.)
F1 (%) ↑	98.0 ± 3.7	+7.2 (vs. SGANet)

GEPAR3D achieved the best score on every reported metric across the four external test centers. Full per-center breakdowns, ablations, and qualitative comparisons are in the paper (Table 1, Table 2, and Appendix).

Summary

GEPAR3D generalizes across four independent CBCT sources (two public, two in-house, two countries/scanner types) without retraining, and shows its largest relative gains on recall and boundary-sensitive metrics (NSD₁, RC_B) — consistent with its design goal of improving root-apex sensitivity rather than only average-case accuracy.

Model Examination

Qualitative analyses (surface Hausdorff-distance heatmaps overlaid on ground truth) show improved sensitivity specifically at root apices compared to the two next-best baselines. See Figures 2 and F.1–F.2 in the paper, and the interactive 3D viewer on the project page.

Environmental Impact

Hardware Type: NVIDIA A100 GPU (single GPU)
Hours used: ~48 hours
Cloud Provider: Not applicable — private/institutional infrastructure
Compute Region: EU (Poland)
Carbon Emitted: ~5.18 kg CO2eq (estimated via the ML CO2 Impact calculator)

Technical Specifications

Model Architecture and Objective

Two networks make up the full pipeline:

A lightweight 4-stage 3D U-Net for coarse binary ROI localization (strided/transposed convolutions, ReLU activations, Instance Normalization, additive skip connections).
GEPAR3D proper: a shared 3D encoder feeding two decoders — (a) a 32-class + background segmentation decoder regularized with the Geometric Wasserstein Dice Loss (GeoWDL), built from a Statistical Shape Model-derived inter-tooth distance prior, combined with inverse-class-frequency-weighted cross-entropy; and (b) an instance-regression decoder producing a continuous energy (distance-to-boundary) map and a 3-channel energy-direction field, consumed by a 3D deep-watershed step at inference to separate tooth instances, which are then class-labeled via majority voting from decoder (a).

Parameter count: 70.86M (main GEPAR3D model; checkpoint size 284 MB). Parameter count for the separate coarse ROI U-Net, and exact channel/stage configuration for both networks, is available in configs/geometric_prior_multitask.yaml and configs/roi_binary_coarse_segmentation.yaml in the GitHub repo.

Compute Infrastructure

Hardware

Minimum inference hardware: ~22 GB GPU memory (measured on an NVIDIA A100), with inference taking ~3.5 seconds per scan. CPU-only inference is practical but much slower: ~8 minutes per scan on an Intel Xeon Gold 5220R @ 2.20GHz, requiring ~22 GB of system RAM.

Software

Python 3.9
PyTorch 1.13.1
MONAI 1.3.0
Full environment: requirements.yaml in the GitHub repository

Citation

BibTeX:

@InProceedings{Szczepanski2025MICCAI_GEPAR3D,
    author    = {Szczepański, Tomasz and Płotka, Szymon and Grzeszczyk, Michal K. and Adamowicz, Arleta and Fudalej, Piotr and Korzeniowski, Przemysław and Trzciński, Tomasz and Sitek, Arkadiusz},
    title     = {{GEPAR3D: Geometry Prior-Assisted Learning for 3D Tooth Segmentation}},
    booktitle = {Proceedings of Medical Image Computing and Computer Assisted Intervention -- MICCAI 2025},
    year      = {2025},
    publisher = {Springer Nature Switzerland},
    volume    = {LNCS 15961},
    month     = {September},
    pages     = {216--226}
}

APA:

Szczepański, T., Płotka, S., Grzeszczyk, M. K., Adamowicz, A., Fudalej, P., Korzeniowski, P., Trzciński, T., & Sitek, A. (2025). GEPAR3D: Geometry prior-assisted learning for 3D tooth segmentation. In Proceedings of Medical Image Computing and Computer Assisted Intervention – MICCAI 2025 (LNCS 15961, pp. 216–226). Springer Nature Switzerland.

Glossary

CBCT — Cone-Beam Computed Tomography, a 3D dental/maxillofacial imaging modality.
SSM — Statistical Shape Model: a population-derived 3D anatomical atlas (here, of normal adult dentition) used to encode expected tooth geometry/position as a geometric prior.
GeoWDL — Geometric Wasserstein Dice Loss: a Generalized Wasserstein Dice loss whose class-confusion penalty matrix is derived from the SSM's inter-tooth distances.
Deep watershed — a technique that turns instance segmentation into predicting an energy landscape (distance-to-boundary) whose local maxima/minima are used as instance seeds for a classical watershed algorithm.
DSC / RC / HD / NSD / DA — standard segmentation/detection metrics; see "Metrics" above.

More Information

Discussion of the weight-release rationale and disclaimers: https://github.com/tomek1911/GEPAR3D/issues/3
Related public datasets referenced in the paper: Cui et al. (Nature Communications, 2022) — https://www.nature.com/articles/s41467-022-29637-2; ToothFairy2 — https://ditto.ing.unimore.it/toothfairy2/

Model Card Authors

Tomasz Szczepański (@tomek1911), on behalf of the GEPAR3D authors.

Model Card Contact

t.szczepanski@sanoscience.org / tmk.szczepanski@gmail.com

Downloads last month: -; Downloads are not tracked for this model. How to track

Paper for tomek1911/GEPAR3D

GEPAR3D: Geometry Prior-Assisted Learning for 3D Tooth Segmentation

Paper • 2508.00155 • Published Jul 31, 2025