DeepBranchAI: a transferable 3D segmentation model for branching networks

Abstract

Three-dimensional branching networks exist throughout biological, natural, and engineered systems as pathways through volumetric space. Segmentation is required to reconstruct these networks for analysis, but minor voxel misclassifications can alter connectivity by falsely disconnecting continuous structures or amplifying spurious branches. Addressing this topological vulnerability requires true 3D segmentation models, since 2D slice-by-slice approaches cannot maintain connectivity across x, y, and z axes. Here, we present DeepBranchAI, a 3D nnU-Net model trained on expert-refined mitochondrial FIB-SEM reference labels as a transferable checkpoint for topology-sensitive segmentation of branching networks. Skeletal-muscle mitochondrial reticulum provides a dense and heterogeneous branching-network training target, and FIB-SEM captures this structure with isotropic nanometer-scale detail. Training on this dataset produced a 3D checkpoint with DSC = 0.942 ± 0.020 across five-fold mitochondrial FIB-SEM validation, providing the basis for subsequent transfer-learning experiments. Transfer learning was evaluated with five-fold cross-validation on paired image/reference-label datasets from 3D-IRCADb venous segmentation, Plant CT roots, and AeroPath airway CT, using continuity-sensitive measures including clDice and absolute connected-component error. Across the external datasets, DeepBranchAI-pretrained fine-tuning had higher mean clDice than scratch nnU-Net. Relative differences in mean clDice were 11.7% for 3D-IRCADb, 5.5% for Plant CT roots, and 1.9% for AeroPath. Mean absolute connected-component error was 25.0% lower for Plant CT roots and 11.7% lower for AeroPath. In 3D-IRCADb, DeepBranchAI-pretrained fine-tuning also had higher mean Dice and clDice than VesselFM, 0.679 versus 0.464 and 0.629 versus 0.360, respectively. The transfer results suggest that training on structurally heterogeneous skeletal-muscle mitochondrial networks can produce 3D features useful beyond the original FIB-SEM domain. Code, trained weights, external-transfer scripts, and validation tables are provided as open-source resources.

1. Introduction

Branching structures appear throughout biological, natural, and engineered systems. Examples include airways (Zhang et al., 2023), porous structures (Nair et al., 2020), root systems (Metzner et al., 2015), 3D-printed lattices (Yang et al., 2022), mitochondria in skeletal muscle (Glancy et al., 2015), vasculature in 3D angiographic volumes (Tetteh et al., 2020), and efficient transportation or resource-distribution networks (Banavar et al., 1999). Mapping the connectivity of 3D branching networks is fundamental to understanding their function and integrity, but achieving topologically accurate segmentation is challenging and continues to be an active focus of 3D segmentation research (Shit et al., 2021; Li et al., 2022). Whether naturally occurring or engineered, these networks typically solve a universal challenge: to efficiently distribute resources throughout space while minimizing costs to the system (Banavar et al., 1999; West et al., 1997). The essential first step for measuring relationships in any such system is to determine which components connect and how these relationships are arranged in space. Volumetric imaging requires segmentation, identifying which voxels belong to network structures versus background. Convolutional neural networks (CNNs) provide sophisticated computer-automated support for volumetric segmentation (Ronneberger et al., 2015; Çiçek et al., 2016; Isensee et al., 2021), but branching networks require models that preserve topology as well as voxel-level accuracy (Shit et al., 2021; Li et al., 2022; Clough et al., 2022). Small local errors in complex 3D volumes can disconnect thin branches, merge neighboring structures, or create spurious paths, changing the measured architecture of the network (Shit et al., 2021; Li et al., 2022; Funke et al., 2019).

Several methods and metrics have been developed to address these errors. Some act during neural-network training, while others evaluate whether the final segmentation preserved the network. When a segmentation model is trained, it is adjusted to reduce a loss function, which is a numerical penalty assigned to its mistakes. Topology-aware losses add penalties for broken branches or false merges, rather than judging only whether individual voxels were labeled correctly. In connectomics, maximin affinity learning of image segmentation (MALIS) was introduced for affinity-based neuron segmentation. Instead of only penalizing mislabeled voxels, MALIS penalizes affinity errors that would split one object or merge two objects in the reconstructed network (Funke et al., 2019). Other topology-aware losses use mathematical descriptions of shape to penalize mistakes in connected pieces and loops (Clough et al., 2022). A related strategy is to encode connectivity as a model prior, as in graph-connectivity constrained networks for 3D vessel segmentation (Li et al., 2022).

Connectivity errors have also changed how segmentation performance is measured. Evaluation metrics score the final prediction after training. Segmentation accuracy is often summarized with Dice, a score that measures voxel overlap between the predicted mask and the reference mask. clDice is a related score developed for tubular and branching structures. Instead of measuring only volumetric overlap, clDice compares the skeletonized centerlines of the predicted and reference structures, so missing or disconnected branches are penalized more directly (Shit et al., 2021). These methods improve how segmentation networks are trained and evaluated, but accurate branching-network segmentation also depends on what model is being trained and fine-tuned in the first place.

Reusable 3D segmentation models address this question in related settings. TotalSegmentator is an example of an nnU-Net-trained model that can be applied directly across many CT anatomical structures (Wasserthal et al., 2023). Transfer-learning studies in medical imaging showed that pretrained CNNs can match or outperform models trained from scratch when adapted to new data (Tajbakhsh et al., 2016). Volumetric pretraining extended this idea into 3D, with Med3D co-training 3D models across heterogeneous medical segmentation tasks (Chen et al., 2019) and Models Genesis using self-supervised 3D pretraining to create source models for downstream medical image analysis (Zhou et al., 2021). VesselFM is more directly relevant to branching anatomy because it uses heterogeneous real and synthetic vascular data to build a foundation-model checkpoint for 3D blood-vessel segmentation (Wittmann et al., 2024). These studies show that reusable 3D representations can support segmentation across datasets, motivating a more specific test of whether a checkpoint trained on dense, structurally heterogeneous 3D branching structure can improve fine-tuning on new branching-network datasets.

We imaged mitochondrial networks using focused ion beam scanning electron microscopy (FIB-SEM), which provides nanometer-scale 3D resolution (15 nm isotropic voxels) sufficient to capture the structural details relevant to this study (Xu et al., 2017; Peddie & Collinson, 2014). These mitochondrial networks form dense reticular structures in skeletal muscle and have been mapped previously with volumetric FIB-SEM (Glancy et al., 2015; Caffrey et al., 2019; Vincent et al., 2019). They also exhibit difficulties that recur across 3D branching-network segmentation, including thin interconnections that can be broken apart or falsely amplified by voxel misclassification, variable contrast across imaging volumes, complex branch points, and topological vulnerability (Zhang et al., 2023; Tetteh et al., 2020; Shit et al., 2021; Li et al., 2022; Rudyanto et al., 2014). To generate reference labels for this source domain, we used sparsely trained conventional machine-learning models to bootstrap preliminary mitochondrial segmentations, then manually refined those drafts into an expert-corrected reference-label set for 3D model training. DeepBranchAI is the resulting 3D nnU-Net checkpoint trained on these expert-refined mitochondrial FIB-SEM labels. We evaluate it first in the source domain using five-fold mitochondrial cross-validation and topology-sensitive metrics, then test whether the learned checkpoint can serve as a transferable initialization for other 3D branching-network segmentation tasks.

The three external branching-network datasets with distinct imaging modalities and structures used here were 3D-IRCADb venous-system CT (Soler et al., 2010), Plant CT roots (Harwood, 2024), and AeroPath airway CT (Støverud et al., 2024). DeepBranchAI-pretrained fine-tuning is compared with scratch nnU-Net training and with a domain-relevant comparator for each external dataset, including VesselFM for venous CT, a 3D U-Net root-segmentation baseline informed by prior root-system work, and an airway-specific, cross-modality MurineAirwaySegmentation checkpoint adapted to AeroPath airway CT (Wittmann et al., 2024; Selzner et al., 2023; Isensee et al., 2023). Performance is evaluated with voxel-overlap and continuity-sensitive measures, including Dice, clDice, and absolute connected-component error. DeepBranchAI-pretrained fine-tuning had higher mean clDice than scratch nnU-Net in all three datasets and had lower mean absolute connected-component error in the Plant CT root and AeroPath airway CT tasks.

2. Related work

Deep learning has become a standard approach for volumetric biomedical segmentation, building from U-Net and 3D U-Net to the self-configuring nnU-Net framework (Ronneberger et al., 2015; Çiçek et al., 2016; Isensee et al., 2021). This has also enabled reusable 3D segmentation systems and pretrained models. TotalSegmentator is an nnU-Net-trained model developed for out-of-the-box CT segmentation across many anatomical structures (Wasserthal et al., 2023), while Med3D and Models Genesis explored reusable 3D source models through supervised and self-supervised volumetric pretraining (Chen et al., 2019; Zhou et al., 2021). Several models have targeted tubular or branching anatomy, including DeepVesselNet, graph-connectivity constrained networks, VesselFM, VesselNN for multiphoton microscopy vasculature segmentation, and CS2-Net (Tetteh et al., 2020; Li et al., 2022; Wittmann et al., 2024; Teikari et al., 2016; Mou et al., 2021). General architecture work such as TransUNet-style transformer U-Net designs has also influenced biomedical segmentation (Chen et al., 2024), and additional vessel-focused systems include 3DVascNet, D2-RD-UNet, Ori-Net, and coronary-geometric refinement methods (Narotamo et al., 2024; Cavicchioli et al., 2025; Jiang et al., 2024; Jiang et al., 2024). Together, these studies show that the field has moved from isolated segmentation models toward reusable 3D representations and architecture designs for branching structures.

Topology-aware losses and metrics are especially important for branching networks because strong voxel overlap can still hide broken or falsely merged structures. clDice measures centerline overlaps for tubular structures, persistent-homology losses describe connected components and loops, and graph-connectivity constrained networks explicitly encode vascular connectedness (Shit et al., 2021; Li et al., 2022; Clough et al., 2022). Related efforts address the label-generation side of the problem, including cross-model self-correction approaches such as AIDE, human-in-the-loop tools such as MONAI Label and Cellpose 2.0, and GAN-generated TOF-MRA image/label pairs (Wang et al., 2021; Diaz-Pinto et al., 2024; Pachitariu & Stringer, 2022; Subramaniam et al., 2022). Public datasets are also essential for training and evaluating models on continuous volumetric networks. Examples include MitoEM for 3D mitochondrial instance segmentation (Wei et al., 2020), 3D-IRCADb for abdominal CT with expert segmentations used here for venous-system segmentation (Soler et al., 2010), MIDAS TOF-MRA brain MRA data used in cerebrovascular-segmentation studies (Marron, n.d.), VESSEL12 for pulmonary-vessel CT (Rudyanto et al., 2014), and SMILE-UHURA for small-vessel segmentation (Chatterjee et al., 2024). DeepBranchAI builds on this background by evaluating whether a 3D nnU-Net checkpoint trained on expert-refined, structurally heterogeneous mitochondrial FIB-SEM labels can serve as a transferable initialization for continuity-preserving segmentation across independent branching-network domains. The evaluation datasets are summarized in Table 1.

Table 1.

Datasets used in the DeepBranchAI evaluation.

Dataset	Structure	Branching style	Study role
Skeletal-muscle mitochondrial dataset (FIB-SEM)	Human skeletal-muscle mitochondrial reticulum	Dense intracellular branching network with heterogeneous surrounding ultrastructure	Source-domain training and 5-fold validation
3D-IRCADb venous system (CT) (Soler et al., 2010)	Abdominal venous system	Clinical vascular network with elongated tubular anatomy	External fine-tuning
3D plant-root dataset (CT) (Harwood, 2024)	Plant root systems	Non-animal biological branching network with thin continuous roots	External fine-tuning
AeroPath airway dataset (CT) (Støverud et al., 2024)	Pulmonary airway trees	Clinical airway network with distal branches and pathological variation	External fine-tuning

3. Methods

3.1. Overview of DeepBranchAI model development

DeepBranchAI was developed through three stages (Figure 1). Stage 1 (Preprocessing and Training Set Curation) prepared a heterogeneous training set from our FIB-SEM image volumes. Stage 2 (Training Set Generation) iteratively built and refined reference labels through a label-generation process, beginning with conventional machine learning for preliminary segmentation and continuing through expert refinement cycles that transitioned to deep learning. Stage 3 trained the DeepBranchAI 3D nnU-Net checkpoint evaluated in the mitochondrial validation and transfer experiments.

Figure 1.

DeepBranchAI model development Stage 1: Volume preparation. (A) Schematic showing mitochondria interspersed between myofibrils in human skeletal muscle. Many of them are in contact with each other, forming a nearly continuous branching network. (B) Preprocessing includes cross-correlation alignment to ensure 3D continuity and artifact removal to prevent spurious training signals. Optional frequency-domain denoising improves signal-to-noise ratio (SNR) while preserving edges. The training set was curated to capture topological diversity. It is visually evident that densely packed mitochondria near capillaries (purple) are organized differently from regions with more linear, sparse arrangements (yellow). Capturing this diversity supports 3D contextual learning and balanced representation that helps reduce class bias.

3.2. Software and environment

Segmentation was performed using the following software environment:

• Python: 3.12.2

• PyTorch: 2.2.1 with CUDA 11.8

• nnU-Net: v2.3.1

• ORS Dragonfly: 4.0 (for manual annotation and refinement, https://dragonfly.comet.tech/)

• ImageJ/Fiji: with Trainable Weka Segmentation plugin (for initial 2D segmentation)

• Python packages: nibabel, tifffile, numpy, multiprocessing

• Destriping: aind-smartspim-destripe package (https://github.com/AllenNeuralDynamics/aind-smartspim-destripe)

3.3. Preprocessing and training set curation

We built the training set to be deliberately heterogeneous. It includes image volumes from processed samples of skeletal muscle biopsies from 10 participants. Images were obtained as TIFF stacks using FIB-SEM, then aligned and binned to produce volumes with 15 nm isotropic resolution (Xu et al., 2017; Caffrey et al., 2019). Both images and labels were converted to NIfTI format (.nii.gz) using the Python nibabel library, with segmentation labels stored as binary masks.

3.3.1. Preprocessing steps

Raw stacks undergo three preprocessing operations (Figure 1):

• 1 Cross-correlation and volume alignment correct spatial misalignments between slices, ensuring structures remain continuous throughout the volume rather than identifying false positives or false negatives.

• 2 Interference slice removal identifies and removes erroneous TIFF slices that disrupt continuity through automated detection of intensity anomalies or manual inspection.

• 3 Denoising optionally applies wavelet-FFT filtering to remove stripe artifacts common in scanning microscopy (Münch et al., 2009). The filter uses a Daubechies-3 wavelet with two parameter configurations: cellular images (sigma = 64, max_threshold = 3) and non-cellular regions (sigma = 128, max_threshold = 12). Implementation is provided in Demo_Destripe.ipynb in the GitHub repo.

3.3.2. Training set balancing

This curation phase creates a balanced dataset focusing on continuous 3D branching structures (Figure 1):

• 4 Sub-structure verification ensures that features are correctly identified through expert visual inspection. For branching networks, this means including different topological configurations (clustered vs. distributed patterns, peripheral vs. central locations).

• 5 Depth requirement establishes a minimum threshold of 128 Z-slices (~10% of the maximum z depth of our volume), providing sufficient volumetric context for learning 3D topology (Figure 1B).

• 6 Class balancing provides approximately equal representation of structural sub-types by cropping more training patches from underrepresented regions.

3.4. Mitochondrial reference label generation

The label-generation process leverages conventional machine learning and deep learning in complementary roles. Conventional ML algorithms achieve reasonable accuracy with limited training data by training with globally effective pre-defined image features, while deep learning requires more initial input but scales better once enough corrected labels exist (Breiman, 2001; Litjens et al., 2017).

3.4.1. Initial conventional ML stage

• 7 Preliminary segmentation uses the 2D Weka Trainable Segmentation algorithm (Arganda-Carreras et al., 2017) (ImageJ implementation). Training regions are marked by drawing on representative target and background regions. This stage used conventional ML to generalize from sparse labels.

• 8 Expert refinement corrects obvious errors through manual editing using ORS Dragonfly 4.0. Corrections are saved as overlays and converted to binary masks. Refinement and segmentation were performed in three dimensions because different axes can reveal different branching morphology.

• 9 Iterative retraining repeats steps 7–8 until reaching saturation, determined through expert validation when visual inspection shows no obvious errors remaining. In this study, 2–3 iterations were sufficient.

• 10 High-quality extraction identifies the most accurate segments through expert visual inspection. The goal is to identify at least 32 consecutive XY slices with high-quality annotations to begin 2D deep learning training.

3.4.2. Transition to deep learning

• 11 2D neural network training uses the extracted segments to train a 2D nnU-Net model, marking the transition from conventional ML to deep learning.

• 12 Inference on full dataset applies the trained 2D network to generate probability maps across the entire dataset. These maps guide experts to focus on ambiguous regions.

• 13 Final expert refinement uses a 0.50 threshold on probability maps to produce initial binary predictions, which experts further corrected to create reference labels for the 3D neural network.

The full Stage 2 reference-label construction process is summarized in Figure 2.

Figure 2.

DeepBranchAI model development Stage 2: Iterative reference label Construction. (A) The process starts with a 2D Weka random forest classifier trained on minimal annotations. Experts correct the output and retrain iteratively until accuracy plateaus. (B) The refined segments are then used to train a 2D nnU-Net, which generates probability maps across full volumes. Experts do a final refinement pass on these maps, producing reference-label volumes that feed back into further training.

3.5. Training the DeepBranchAI 3D checkpoint

In Stage 3, the 3D nnU-Net is trained using a chunk size of 352 × 352 × 128 voxels. We refer to the resulting model as DeepBranchAI (Figure 3). This chunk size captures both broad contextual information and fine-grained features necessary for topology preservation.

Figure 3.

DeepBranchAI model development Stage 3: DeepBranchAI training and inference. The 3D nnU-Net model, referred to here as DeepBranchAI, is trained using high-quality reference labels with chunk sizes large enough to capture local details and long-range topological relationships. Trained models segment new volumes through chunk-wise processing, generating probability maps that are stitched and thresholded to produce final segmentations.

3.5.1. Training and inference

• 14 3D neural-network training uses the automatic hyperparameter configuration from nnU-Net (Isensee et al., 2021) for 100 epochs with 5-fold cross-validation. The reference-label set contained 20 volumes, with 4 volumes held out for validation in each fold. The reported chunk size was selected for the 48 GB VRAM workstation used here. A 24 GB VRAM workstation would accommodate approximately half of this patch volume, with nnU-Net automatically adapting patch size to available memory.

• 15 Automated inference applies each fold’s held-out model to that fold’s validation volumes using nnU-Net inference algorithms, which handle chunk-wise processing with overlapping 3D patches. The final segmentation volume is assembled via stitching and weighted averaging.

• 16 Thresholding applies a 0.50 cutoff to the merged probability map to generate the final binary segmentation.

• 17 Post-processing for reported metrics used the nnU-Net validation outputs directly after thresholding. No optional connected-component filtering or manual refinement was applied to the predictions used in the quantitative validation tables.

3.6. Code availability and implementation resources

The complete codebase is provided through Jupyter notebooks: Data Preprocessing

• Demo_Destripe.ipynb: Wavelet-FFT filtering for stripe artifact removal with parallelized processing.

• Training Data Preprocessing.ipynb: Quality control including dimension verification and intensity statistics.

Model Training and Evaluation

• nnUNET 3D Train.ipynb: End-to-end training for 3D nnU-Net models

• nnUNET 3D Inference.ipynb: Batch inference for generating 3D segmentation predictions.

• Validate 3D DeepBranchAI.ipynb: Evaluation metrics for 3D models with volumetric analysis.

Transfer Learning Validation

• External-transfer scripts: Plant CT root, AeroPath airway CT, and 3D-IRCADb venous-system fine-tuning and metric-generation scripts, including scratch versus DeepBranchAI-pretrained comparisons and topology/continuity metric summaries.

All notebooks and trained model weights are available at https://github.com/alexmaltsev/DeepBranchAI.

3.7. Evaluation metrics

We used overlap, agreement, class-balance, and topology-sensitive metrics to assess segmentation performance (Shit et al., 2021; Taha & Hanbury, 2015). The mitochondria reference labels are the expert-refined Stage 2 annotations used for Stage 3 training and validation. Let TP, TN, FP, and FN denote true positives, true negatives, false positives, and false negatives, respectively:

Precision measures the fraction of predicted target voxels that are true target voxels:

$$\text{Precision}=\frac{\mathrm{TP}}{\mathrm{TP}+\mathrm{FP}}$$

Sensitivity (Recall) measures the proportion of actual target voxels correctly identified:

$$\text{Sensitivity}=\frac{\mathrm{TP}}{\mathrm{TP}+\mathrm{FN}}$$

Specificity measures the proportion of background voxels correctly identified:

$$\text{Specificity}=\frac{\mathrm{TN}}{\mathrm{TN}+\mathrm{FP}}$$

Accuracy measures the overall proportion of correctly classified voxels:

$$\text{Accuracy}=\frac{\mathrm{TP}+\mathrm{TN}}{\mathrm{TP}+\mathrm{TN}+\mathrm{FP}+\mathrm{FN}}$$

Dice Similarity Coefficient (DSC) measures overlap between predicted and reference segmentations (Taha & Hanbury, 2015):

$$\mathrm{DSC}=\frac{2\times \mathrm{TP}}{2\times \mathrm{TP}+\mathrm{FP}+\mathrm{FN}}$$

Absolute Volume Difference (AVD) quantifies relative difference in total segmented volume:

$$\mathrm{AVD}=\mid \frac{V_{\text{pred}}-V_{\mathrm{GT}}}{V_{\mathrm{GT}}}\mid \times 100\%$$

where $V_{\text{pred}}$ and $V_{\mathrm{GT}}$ represent the predicted and reference volumes, respectively.

Cohen’s Kappa measures agreement while accounting for chance:

$$\kappa =\frac{p_o-p_e}{1-p_e}$$

where $p_o$ is observed agreement and $p_e$ is expected agreement by chance. Values above 0.8 indicate excellent agreement.

clDice measures branch-continuity agreement between predicted and reference segmentations by comparing their skeletonized centerlines. The clDice formula follows Shit et al. (Shit et al., 2021). Let $P$ be the predicted binary mask, $R$ be the reference binary mask, $S\left(P\right)$ be the skeleton of the prediction, and $S\left(R\right)$ be the skeleton of the reference:

Topology precision is:

$$T_{\text{prec}}=\frac{\mid S\left(P\right)\cap R\mid }{\mid S\left(P\right)\mid }$$

Topology sensitivity is:

$$T_{\text{sens}}=\frac{\mid S\left(R\right)\cap P\mid }{\mid S\left(R\right)\mid }$$

clDice is the harmonic mean of topology precision and topology sensitivity:

$$\text{clDice}=\frac{2T_{\text{prec}}{T}_{\text{sens}}}{T_{\text{prec}}+T_{\text{sens}}}$$

Absolute connected-component error measures absolute component-count discrepancy by comparing the absolute difference between the number of predicted and reference connected objects. Connected components were computed using 26-connectivity. Let $C\left(P_i\right)$ be the number of connected components in the predicted mask for validation case $i$ and let $C\left(R_i\right)$ be the number of connected components in the reference mask for the same case.

Per-case absolute connected-component error is:

$$E_{\mathrm{CC},i}=\mid C\left(P_i\right)-C\left(R_i\right)\mid$$

Mean absolute connected-component error across (N) validation cases is:

$${\overline{E}}_{\mathrm{CC}}=\frac{1}{N}\sum _{i=1}^N\mid C\left(P_i\right)-C\left(R_i\right)\mid$$

Summary values in Tables 2–5 are reported as the unweighted mean ± sample standard deviation across folds 0–4. Standard deviations were calculated from the unrounded fold-level values. The primary statistical analysis compared DeepBranchAI-pretrained fine-tuning with scratch nnU-Net using paired out-of-fold values for each held-out volume. Two-sided Wilcoxon signed-rank tests were performed separately for Dice, clDice, and absolute connected-component error in each external dataset. Holm correction was applied across the nine comparisons, with adjusted p < 0.05 considered significant. For two Plant CT cases with nonempty reference segmentations but zero predicted centerline overlap, clDice was assigned 0 rather than treated as undefined. All 29 Plant CT volumes were retained.

Table 2.

Expanded volume-wise 5-fold mitochondrial validation for DeepBranchAI 3D nnU-Net.

Metric	Fold 0	Fold 1	Fold 2	Fold 3	Fold 4	Mean ± SD
Dice	0.956	0.920	0.962	0.920	0.951	0.942 ± 0.020
Precision	0.948	0.988	0.953	0.966	0.956	0.962 ± 0.016
Sensitivity	0.964	0.863	0.972	0.880	0.946	0.925 ± 0.050
Specificity	0.994	0.999	0.995	0.996	0.994	0.996 ± 0.002
clDice	0.944	0.904	0.961	0.948	0.943	0.940 ± 0.021
Abs. CC error	196	186	59	398	232	214 ± 122
AVD (%)	2.644	12.634	1.957	8.841	4.083	6.032 ± 4.565
Kappa	0.951	0.914	0.958	0.910	0.944	0.935 ± 0.022

The final column reports the unweighted mean +/- sample SD across folds 0-4.

Table 5.

External transfer validation on paired image/reference-label datasets.

Dataset	Model	Dice (mean ± SD)	clDice (mean ± SD)	Abs. CC error (mean ± SD)
3D-IRCADb venous system (Soler et al., 2010) (n = 12)	VesselFM fine-tune (Wittmann et al., 2024)	0.464 ± 0.056	0.360 ± 0.098	111.47 ± 45.91
	Scratch nnU-Net	0.638 ± 0.093	0.563 ± 0.100	25.60 ± 3.24
	DeepBranchAI-pretrained fine-tune	0.679 ± 0.080	0.629 ± 0.100	27.17 ± 5.06
	% difference over best	+6.43%	+11.72%	−6.13%
Plant root CT (Harwood, 2024) (n = 29)	3D U-Net root baseline	0.459 ± 0.066	0.403 ± 0.079	97.95 ± 27.80
	Scratch nnU-Net	0.557 ± 0.023	0.568 ± 0.060	25.47 ± 17.05
	DeepBranchAI-pretrained fine-tune	0.611 ± 0.053	0.599 ± 0.062	19.11 ± 13.07
	% difference over best	+9.69%	+5.46%	+24.97%
AeroPath airway CT (Støverud et al., 2024) (n = 27)	MurineAirwaySegmentation cross-modality fine-tune (Isensee et al., 2023)	0.831 ± 0.043	0.768 ± 0.031	76.13 ± 18.72
	Scratch nnU-Net	0.879 ± 0.031	0.824 ± 0.019	56.12 ± 14.23
	DeepBranchAI-pretrained fine-tune	0.880 ± 0.033	0.840 ± 0.014	49.57 ± 15.77
	% difference over best	+0.11%	+1.94%	+11.67%

Standard deviations were calculated from the unrounded fold-level values. Percentage rows were calculated from the displayed mean values.

3.8. Computational requirements

All procedures were performed on a workstation with an NVIDIA RTX A6000 (48 GB VRAM), 128 GB RAM, and 24 logical processors running Ubuntu 24. Typical training times: approximately 30 min per iteration for 2D Weka segmentation, 4–6 h for 2D nnU-Net training, and 2–3 days per fold for 3D nnU-Net five-fold cross-validation training.

4. Results

We evaluate the trained DeepBranchAI 3D checkpoint in five ways. First, validation on the skeletal-muscle mitochondrial FIB-SEM dataset is reported with overlap, class-balance, and topology-sensitive metrics. Second, Stage 3 model comparisons test whether the final 3D nnU-Net checkpoint improves segmentation relative to 2D and standard 3D U-Net alternatives. Third, a controlled clDice-loss ablation tests a topology-aware loss. Fourth, a five-fold Z-depth ablation tests whether reducing the axial context from 128 slices to 64 or 32 slices degrades continuity-sensitive performance. Fifth, external fine-tuning evaluates transfer on paired public image/reference-label datasets.

4.1. Quantitative evaluation of DeepBranchAI

DeepBranchAI demonstrated strong performance in segmenting complex branching networks from FIB-SEM volumetric data with fold Dice ranging from 0.920 to 0.962 (Table 2).

4.1.1. Cross-validation performance

We used five-fold cross-validation with an 80/20 train-validation split, grouping volumes by subject so that no subject appeared in both sets within a fold. Metrics were computed volume-wise on the full 128-slice held-out validation volumes after prediction stitching or assembly. Across all 20 held-out volumes, foreground mitochondria represented 10.2% of voxels in the reference labels and background represented 89.8%. Precision was therefore reported alongside sensitivity and specificity to avoid relying on specificity alone in this background-dominant setting. Across the five folds, the unweighted mean ± sample SD was 0.942 ± 0.020 for Dice, 0.962 ± 0.016 for precision, 0.925 ± 0.050 for sensitivity, 0.996 ± 0.002 for specificity, and 0.940 ± 0.021 for clDice. Mean absolute connected-component error was 214 ± 122 components per validation volume, AVD was 6.032 ± 4.565%, and Kappa was 0.935 ± 0.022 (Table 2). Volume-level metric manifests are included with the results package to link each measurement to its reconstructed source stack.

4.1.2. Comparison with 2D and 3D architectures

Below we compare DeepBranchAI against 2D and 3D U-Net (Ronneberger et al., 2015; Çiçek et al., 2016; Isensee et al., 2021) and 2D nnU-Net (Table 3). This is a Stage 3 segmentation-model comparison using the same expert-refined label source where available. It is not an annotation-strategy benchmark. For the reported metrics, each model was trained for 100 epochs using the same subject-rooted 5-fold validation groups defined at the original-volume level, with preprocessing, label generation, and expert refinement held fixed. Metrics were computed volume-wise on full 128-slice held-out volumes, with 2D predictions stitched into 3D volumes and 3D predictions assembled as full-volume masks before evaluation. Stage 1 and Stage 2 label generation were held fixed, so the comparison replaces the Stage 3 segmentation model rather than the label-generation strategy.

Table 3.

Stage 3 mitochondrial segmentation-model comparison and clDice-loss training.

Metric	2D U-Net	3D U-Net	2D nnU-Net	DeepBranchAI (CE + Dice)	DeepBranchAI (CE + Dice + clDice)
Dice	0.789 ± 0.051	0.907 ± 0.047	0.890 ± 0.046	0.942 ± 0.020	0.941 ± 0.019
Precision	0.796 ± 0.084	0.948 ± 0.012	0.910 ± 0.050	0.962 ± 0.016	0.953 ± 0.017
Sensitivity	0.794 ± 0.035	0.877 ± 0.083	0.874 ± 0.067	0.925 ± 0.050	0.932 ± 0.052
Specificity	0.978 ± 0.011	0.994 ± 0.002	0.990 ± 0.006	0.996 ± 0.002	0.995 ± 0.003
clDice	0.735 ± 0.095	0.879 ± 0.068	0.879 ± 0.041	0.940 ± 0.021	0.941 ± 0.028
Abs. CC error	7,565 ± 3,790	1,267 ± 648	1,373 ± 577	214 ± 122	183 ± 108
AVD (%)	14.554 ± 5.404	9.465 ± 7.949	7.820 ± 3.665	6.032 ± 4.565	6.267 ± 3.456
Kappa	0.766 ± 0.057	0.898 ± 0.051	0.878 ± 0.057	0.935 ± 0.022	0.934 ± 0.021

Values are unweighted mean ± sample SD across folds 0–4.

Volume-wise evaluation allows clDice and absolute connected-component error to be measured on assembled 3D predictions rather than isolated patches. Across the architecture-comparison rows, DeepBranchAI scored highest on Dice, specificity, and Kappa, while the 2D U-Net had the lowest Dice because it cannot use through-plane context. The 3D U-Net improved substantially, and 2D nnU-Net improved over standard 2D U-Net through automatic configuration, but both remained below DeepBranchAI on the primary overlap and agreement measures.

Because clDice is directly relevant to branching topology, we also trained a controlled five-fold comparison with the same subject-rooted validation groups, architecture, patch size, batch size, training length, and reference-label source as the standard CE + Dice nnU-Net. Across folds, adding clDice to the training objective had only marginal effects on most metrics. Mean Dice changed from 0.942 to 0.941 and mean clDice changed from 0.940 to 0.941. The clearest difference was lower mean absolute connected-component error, from 214 to 183, while the remaining metrics changed only slightly (Table 3). We therefore retained the CE + Dice model as the primary released mitochondrial checkpoint and report clDice as an evaluation metric. A representative DeepBranchAI segmentation compared with its reference label is shown in Figure 4.

Figure 4.

DeepBranchAI segmentation performance. Representative 3D pixel-to-pixel comparison between DeepBranchAI segmentation (green) and reference label (red) showing high overlap and discrepancies primarily contained in highly dense regions near the capillary.

4.1.3. Reduced Z-context ablation

We also tested whether reducing the axial context from the released 352 × 352 × 128 patch size to 352 × 352 × 64 or 352 × 352 × 32 affected segmentation performance. Across five folds, the 128-slice setting had the highest mean Dice, precision, sensitivity, specificity, clDice, and Kappa and the lowest mean AVD. The 64-slice setting had the lowest mean absolute connected-component error, 203 compared with 214 for the 128-slice setting, whereas the 32-slice model had the lowest mean sensitivity and the highest mean absolute connected-component error. Overall, the 128-slice setting provided the strongest balance across the reported metrics and was retained as the final configuration (Table 4). Table 4 reports the unweighted mean ± sample SD across folds 0–4.

Table 4.

Five-fold Z-depth ablation for 352 × 352 × Z patches.

Metric	32 Z-depth	64 Z-depth	128 Z-depth
Precision	0.954 ± 0.020	0.955 ± 0.014	0.962 ± 0.016
Sensitivity	0.917 ± 0.067	0.922 ± 0.057	0.925 ± 0.050
Specificity	0.995 ± 0.003	0.995 ± 0.002	0.996 ± 0.002
Dice	0.933 ± 0.035	0.936 ± 0.025	0.942 ± 0.020
clDice	0.931 ± 0.033	0.936 ± 0.029	0.940 ± 0.021
Abs. CC error	230 ± 226	203 ± 96	214 ± 122
AVD (%)	6.664 ± 5.076	6.718 ± 4.375	6.032 ± 4.565
Kappa	0.926 ± 0.039	0.930 ± 0.027	0.935 ± 0.022

Values are unweighted mean ± sample SD across folds 0–4.

4.2. External transfer validation

External transfer was evaluated on paired image/reference-label datasets: 3D-IRCADb venous-system segmentation (Soler et al., 2010), Plant CT root segmentation (Harwood, 2024), and AeroPath airway CT (Støverud et al., 2024). We evaluate DeepBranchAI as a pretrained initialization for fine-tuning and compare it with scratch nnU-Net for each dataset. Domain-relevant comparator rows were also included: VesselFM for 3D-IRCADb venous-system CT, a 3D U-Net root-segmentation baseline informed by prior root-system 3D U-Network, and an airway-specific, cross-modality MurineAirwaySegmentation checkpoint adapted to AeroPath airway CT (Wittmann et al., 2024; Selzner et al., 2023; Isensee et al., 2023).

4.2.1. Transfer learning strategy

External transfer experiments used the same paired image/reference-label folds for scratch and DeepBranchAI-pretrained fine-tuning within each dataset. 3D-IRCADb included 12 venous-system CT cases split across five folds, Plant CT included 29 root volumes split across five folds, and AeroPath included 27 airway CT volumes split across five folds. Target labels were the reference labels provided with each dataset or derived from the dataset. All nnU-Net transfer experiments used nnU-Net v2 preprocessing and planning, including dataset-specific resampling, normalization, patch-size selection, default augmentation, CE + Dice loss, and the nnUNetTrainer 100 epochs schedule. The nnU-Net experiments used the default nnU-Net v2 training configuration, including stochastic gradient descent with Nesterov momentum, momentum of 0.99, weight decay of 3 × 10⁻⁵, and polynomial learning-rate decay from an initial learning rate of 0.01.

Scratch models were trained from random initialization, while DeepBranchAI-pretrained models were initialized from the DeepBranchAI fold-0 mitochondrial checkpoint and all weights were allowed to update during fine-tuning. Comparator rows were generated by us using the same target-dataset folds and evaluated volume-wise with the same metric implementation. VesselFM and MurineAirwaySegmentation were initialized from public checkpoints and fine-tuned on the corresponding target data, while the 3D U-Net root baseline was trained from random initialization using the same Plant CT fold definitions.

VesselFM was fully fine-tuned for 10,000 optimizer steps, with all 31.4 million parameters updated. It used DiceCE loss weighted 0.9 for Dice and 0.1 for cross-entropy, AdamW with an initial learning rate of 1 × 10⁻⁵ and weight decay of 0.1, and cosine-annealing learning-rate decay to 1 × 10⁻⁷. The 3D U-Net root baseline was trained for 100 epochs with all weights updated. It used BCE-with-logits plus soft Dice loss, AdamW with an initial learning rate of 0.001 and weight decay of 1 × 10⁻⁵, and a constant learning rate. MurineAirwaySegmentation was initialized from the public Task145 fold-0 checkpoint and fully fine-tuned for 100 epochs on each AeroPath fold. It used Dice plus cross-entropy loss, stochastic gradient descent with Nesterov momentum, an initial learning rate of 0.01, momentum of 0.99, weight decay of 3 × 10⁻⁵, and polynomial learning-rate decay. VesselFM retained its native step-based training budget and was therefore not strictly epoch-matched to the 100-epoch models.

For each external dataset, nnU-Net was initialized either from scratch or from the DeepBranchAI fold-0 mitochondrial checkpoint and then fine-tuned on the target training folds. Metrics were computed against the provided reference labels. This design tests whether mitochondrial pretraining gives a useful initialization for other 3D branching-network tasks rather than assessing zero-shot generalization.

4.2.2. Validation results

DeepBranchAI-pretrained fine-tuning had higher mean clDice than scratch nnU-Net in all three external datasets (Table 5). Paired out-of-fold analysis showed that the clDice difference was statistically significant in 3D-IRCADb venous CT after Holm correction (p = 0.010) and in AeroPath airway CT (p < 0.001), but not in Plant CT roots (p = 0.309). The Dice difference was significant in 3D-IRCADb (p = 0.004) and Plant CT roots (p = 0.038), but not in AeroPath (p = 0.672). Absolute connected-component error was significantly lower in AeroPath (p = 0.038). The differences in Plant CT roots (p = 0.309) and 3D-IRCADb (p = 0.791) were not significant. The adjusted p values and paired sample sizes are summarized in Table 6.

Table 6.

Paired statistical comparison of DeepBranchAI-pretrained and scratch nnU-Net predictions.

Dataset	Paired volumes	Dice adjusted p	clDice adjusted p	Abs. CC error adjusted p
3D-IRCADb venous CT	12	0.004	0.010	0.791
Plant CT roots	29	0.038	0.309	0.309
AeroPath airway CT	27	0.672	<0.001	0.038

Values are Holm-adjusted two-sided Wilcoxon signed-rank test results calculated from held-out per-volume metrics.

Table 5 reports the unweighted mean ± sample standard deviation across folds 0–4. Standard deviations were calculated from the unrounded fold-level values, and percentage rows were calculated from the displayed mean values. For higher-is-better metrics, percentage difference was calculated as (DeepBranchAI − best non-DeepBranchAI comparator)/best comparator × 100. For absolute connected-component error, which is lower-is-better, the direction was reversed. Positive percentages therefore indicate a higher mean score or lower mean error for DeepBranchAI, depending on the metric. Inferential testing was restricted to the primary comparison between DeepBranchAI-pretrained and scratch nnU-Net because these conditions used the same architecture, target folds, and training procedure and differed only in model initialization. Figure 5 shows representative successful and challenging 3D-IRCADb transfer cases alongside scratch nnU-Net and VesselFM predictions. In panel A, the DeepBranchAI prediction is visibly more continuous than both comparators. Panel B is more challenging. Although the DeepBranchAI prediction is also visually more continuous, several branches remain disconnected or absent relative to the reference segmentation.

Figure 5.

Qualitative external-transfer comparison on 3D-IRCADb venous CT. From left to right, columns show the reference segmentation, scratch nnU-Net prediction, VesselFM fine-tuned prediction, and DeepBranchAI fine-tuned prediction. Predictions are shown in teal with the reference segmentation overlaid in translucent gray. Views and display settings are matched within each row. (A) Successful case, 3D-IRCADb 1.15 (fold 4). (B) Challenging case, 3D-IRCADb 1.1 (fold 1). DeepBranchAI is visually more continuous than the comparator predictions in both cases.

5. Discussion

This study supports DeepBranchAI as a transferable 3D checkpoint for continuity-preserving segmentation of branching networks. DeepBranchAI was trained on expert-refined FIB-SEM labels of skeletal-muscle mitochondria and performed well in five-fold validation on the mitochondrial source task. This result shows that the model can learn the dense reticular architecture of skeletal-muscle mitochondria from volumetric reference labels (Glancy et al., 2015; Caffrey et al., 2019; Vincent et al., 2019). The broader test was whether the same checkpoint provided a useful pretrained initialization for external branching-network datasets. Across 3D-IRCADb venous CT, Plant CT roots, and AeroPath airway CT, DeepBranchAI-pretrained fine-tuning had higher mean clDice than scratch nnU-Net in all three datasets. Paired analysis supported the Dice and clDice differences in 3D-IRCADb, the Dice difference in Plant CT roots, and the clDice and absolute connected-component error differences in AeroPath. The remaining mean differences were not statistically significant after Holm correction.

The transfer results suggest that DeepBranchAI learned broader features than just mitochondrial image texture, including branch continuity and boundary discrimination. Skeletal-muscle FIB-SEM is a demanding setting for learning those broader features because mitochondria thread through a crowded cellular landscape that includes myofibrils, Z-disks, lipid droplets, nuclei, and other organelles (Glancy et al., 2015; Caffrey et al., 2019; Vincent et al., 2019). The model must separate a continuous reticular target from neighboring structures with similar local contrast, repeated boundaries, and thin interfaces between objects. This interpretation is consistent with recent volumetric electron-microscopy transfer-learning work showing that features learned from one organelle or tissue segmentation task can improve segmentation after fine-tuning on another (Xie et al., 2025). DeepBranchAI extends this idea across a larger modality and scale gap, where mitochondrial FIB-SEM pretraining remained useful after fine-tuning on CT roots, airways, and veins. DeepBranchAI-pretrained fine-tuning had higher mean clDice than scratch nnU-Net across all three external datasets and had lower mean absolute connected-component error in the plant-root and airway experiments.

The source dataset contained 20 volumes, while the 3D-IRCADb, Plant CT, and AeroPath datasets contained 12, 29, and 27 volumes, respectively. Five-fold cross-validation allowed every volume to contribute to held-out evaluation, but it does not replace validation in larger independent cohorts. The observed transfer performance may therefore depend on anatomical, acquisition, and pathological variation that is not fully represented in these datasets. Evaluation on larger and more diverse datasets would provide narrower uncertainty estimates and establish how consistently the learned representation transfers across populations and imaging settings.

Since the strongest transfer signal appeared in continuity-sensitive metrics, we also tested whether the mitochondrial source model should be trained directly with a topology-aware loss. In the five-fold loss-function comparison, adding clDice to the training objective had little effect on most metrics. Mean Dice changed from 0.942 to 0.941, while mean clDice changed from 0.940 to 0.941. Precision, sensitivity, specificity, AVD, and Kappa also differed only slightly. The clearest difference was in mean absolute connected-component error, which decreased from 214 to 183 components per validation volume. Prior work similarly treats topology-aware and overlap-based objectives as complementary. Shit et al. introduced clDice as a centerline-based score and soft loss for tubular segmentation but combined soft-clDice with soft-Dice rather than replacing volumetric overlap entirely (Shit et al., 2021). Acebes et al. noted that clDice loss can preserve topology while affecting segmentation accuracy and robustness to noisy annotations (Acebes et al., 2024). Shi et al. also described limitations in geometric detail and vessel-diameter balance (Shi et al., 2024). We therefore retained the standard CE + Dice nnU-Net as the released DeepBranchAI checkpoint and used clDice and absolute connected-component error as continuity-sensitive evaluation metrics.

These results also connect to a larger shift in biomedical segmentation. The field is moving from isolated task-specific models toward reusable 3D source models, out-of-the-box segmenters, and foundation checkpoints. nnU-Net made this shift practical by showing how much can be gained from standardizing preprocessing, architecture selection, training, and validation (Isensee et al., 2021). TotalSegmentator extended this logic into an out-of-the-box nnU-Net-trained CT segmentation model across many anatomical structures (Wasserthal et al., 2023). Models Genesis and Med3D made the related argument that 3D image structure itself can support reusable representations (Chen et al., 2019; Zhou et al., 2021). VesselFM pushed this idea in a specialized direction by training on heterogeneous vascular data to support vessel segmentation across modalities (Wittmann et al., 2024). This success aligns with findings by Tetteh et al., who showed that deep networks trained on tubular vessel structures can learn generalizable features rather than domain-specific textures (Tetteh et al., 2020). DeepBranchAI follows the same general direction, but from a different source domain. Instead of beginning with a broad medical-image corpus or a vessel-only corpus, it uses a structurally crowded mitochondrial FIB-SEM task as the pretraining problem. The use of nnU-Net keeps the checkpoint in a standardized framework that can be fine-tuned across the source task and the external CT datasets, while continuity is evaluated with clDice, connected-component error, the clDice-loss comparison, and external transfer performance. The results suggest that source-domain richness can matter even when source and target images are different.

Promptable foundation models such as MedSAM and SAM-Med3D provide complementary approaches to reusable medical segmentation (Ma et al., 2024; Wang et al., 2023). They were not included as Table 5 comparators because their prompt-based inference and adaptation procedures are not directly matched to the fully automated five-fold fine-tuning design evaluated here. A controlled comparison would require standardized prompts, adaptation rules, and training budgets across every target fold. The present comparison therefore focuses on scratch nnU-Net and pretrained checkpoints that can be adapted through fully automated target-domain fine-tuning.

6. Conclusion

DeepBranchAI provides a 3D nnU-Net checkpoint trained on expert-refined skeletal-muscle mitochondrial FIB-SEM labels for topology-sensitive segmentation of branching networks. Source-domain validation showed strong mitochondrial segmentation performance, and external fine-tuning had higher mean clDice than scratch nnU-Net in all three target datasets. Paired analysis supported differences in venous Dice and clDice, Plant CT Dice, and airway clDice and absolute connected-component error, while the remaining mean differences were not statistically significant after correction. These results support the use of structurally heterogeneous mitochondrial FIB-SEM data as a source domain for transferable 3D branching-network segmentation. Code, trained weights, preprocessing scripts, external-transfer scripts, validation scripts, and result tables are provided with the DeepBranchAI repository.

7. Future developments

Future work should move from single-source checkpoints toward shared 3D pretraining resources for branching-network segmentation. TotalSegmentator shows the value of organizing many CT anatomical labels into one reusable nnU-Net system (Wasserthal et al., 2023). MedSAM and SAM-Med3D show a related route, where large image-mask collections support reusable medical segmentation models (Ma et al., 2024; Wang et al., 2023). A branching-network equivalent would curate vascular, airway, root, mitochondrial, and porous-network volumes with explicit label definitions and continuity-sensitive metrics. Strong feature construction tailored to complex topologies may also be important for maximizing accuracy. Classical U-Net variants remain effective, but dense 3D volumes create heavy memory and parameter demands. Emerging quantum and quantum-inspired convolutional models offer one possible direction because resource-efficient QCNN layers and quantum 3D CNNs have been proposed as lower-resource ways to process structured image data (Song et al., 2024; Blekos & Kosmopoulos, 2021).

A second direction is topology-specific transfer learning beyond branching networks. DeepBranchAI tests this idea for continuous branching structures. Other structural classes raise different problems, such as loop-rich endoplasmic-reticulum networks and ER sheets (Lu et al., 2023), cardiac cavities and ring-like myocardium (Byrne et al., 2023), and porous materials where pore-space topology affects network extraction and physical measurements (Zubov et al., 2022; Wang et al., 2021). Checkpoints trained on dense examples of these structural classes could help models learn the relevant 3D geometry before fine-tuning on smaller target datasets.

Glossary

Glossary

DSC

dice similarity coefficient

FIB-SEM

focused ion beam scanning electron microscopy

CNN

convolutional neural network

ML

machine learning

nnU-Net

no-new-U-net (self-configuring neural network framework)

RF

random forest

IoU

intersection over union

AVD

absolute volume difference

Key terms

Segmentation

The process of partitioning volumetric image data into regions corresponding to distinct structures or objects of interest.

Voxel

A three-dimensional pixel; the smallest distinguishable unit in volumetric imaging data.

Topological fragility

The vulnerability of branching networks where minor voxel misclassifications can break connectivity and fragment continuous structures.

Annotation

The process of manually labeling structures in images to create training data for machine learning models.

Reference-label generation

A multi-stage process in which conventional machine learning generates initial draft labels, which are then refined using deep learning and expert correction.

Ground truth

Expert-annotated reference data used as the correct answer for training and evaluating segmentation models.

Transfer learning

A technique where a model trained on one dataset or task is adapted to perform well on a different but related dataset or task.

Volumetric data

Three-dimensional image data composed of voxels (3D pixels) arranged in a regular grid.

Probability map

A grayscale image where each voxel’s intensity (0–1) represents the model’s confidence that the voxel belongs to the target structure.

Inference

The process of applying a trained model to new data to generate predictions or segmentations.

Patch size

The three-dimensional dimensions (in voxels) of image chunks processed by the neural network during training and inference.

Epoch

One complete pass through the entire training dataset during neural network training, after which model weights are updated based on cumulative learning.

Fine-tuning

The process of adapting a pre-trained neural network to a new task by continuing training on task-specific data.

Funding Statement

The author(s) declared that financial support was received for this work and/or its publication. This research was supported by the Intramural Research Program of the National Institutes of Health (NIH). The contributions of the NIH author(s) are considered works of the United States Government. The findings and conclusions presented in this paper are those of the author(s) and do not necessarily reflect the views of the NIH or the U.S. Department of Health and Human Services.

Data availability statement

The datasets presented in this study can be found in online repositories. The names of the repository/repositories and accession number(s) can be found at: https://github.com/alexmaltsev/DeepBranchAI.

Ethics statement

The studies involving humans were approved by National Institutes of Health Intramural Research Program Institutional Review Board. The studies were conducted in accordance with the local legislation and institutional requirements. The participants provided their written informed consent to participate in this study.

Author contributions

AM: Conceptualization, Methodology, Software, Writing – original draft. LH: Conceptualization, Data curation, Methodology, Writing – original draft. LF: Conceptualization, Project administration, Resources, Supervision, Writing – review & editing.

Conflict of interest

The author(s) declared that this work was conducted in the absence of any commercial or financial relationships that could be construed as a potential conflict of interest.

Generative AI statement

The author(s) declared that Generative AI was not used in the creation of this manuscript.

Any alternative text (alt text) provided alongside figures in this article has been generated by Frontiers with the support of artificial intelligence and reasonable efforts have been made to ensure accuracy, including review by the authors wherever possible. If you identify any issues, please contact us.

Publisher’s note

All claims expressed in this article are solely those of the authors and do not necessarily represent those of their affiliated organizations, or those of the publisher, the editors and the reviewers. Any product that may be evaluated in this article, or claim that may be made by its manufacturer, is not guaranteed or endorsed by the publisher.