A 3D Coarse-to-Fine Framework for Volumetric Medical Image Segmentation

Introduction

Driven by the huge demands for computer-aided diagnosis systems, automatic organ segmentation from medical images, such as computed tomography (CT) and magnetic resonance imaging (MRI), has become an active research topic in both the medical image processing and computer vision communities. It is a prerequisite step for many clinical applications, such as diabetes inspection, organic cancer diagnosis, and surgical planning. Therefore, it is well worth exploring automatic segmentation systems to accelerate the computer-aided diagnosis in medical image analysis.

In this paper, we focus on pancreas segmentation from CT scans, one of the most challenging organ segmentation problems . As shown in Fig. 1, the main difficulties stem from three aspects: 1) the small size of the pancreas in the whole abdominal CT volume; 2) the large variations in texture, location, shape and size of the pancreas; 3) the abnormalities, like pancreatic cysts, can alter the appearance of pancreases a lot.

Following the rapid development of deep neural networks and their successes in many computer vision tasks, such as semantic segmentation , edge detection and 3D shape retrieval , many deep learning based methods have been proposed for pancreas segmentation and achieved considerable progress . However, these methods are based on 2D fully convolutional networks (FCNs) , which perform segmentation slice by slice while CT volumes are indeed 3D data. Although these 2D methods use strategies to fuse the output from different 2D views to obtain 3D segmentation results, they inevitably lose some 3D context, which is important for capturing the discriminative features of the pancreas with respect to background regions.

Using 3D deep networks for organ segmentation is a recent trend but not yet applied to the pancreas. An obstacle is that training 3D deep networks suffers from the “out of memory” problem. 2D FCNs can accept a whole 2D slice as input, but 3D FCNs cannot be fed a whole 3D volume due to the limited GPU memory size. A common solution is to train 3D FCNs from small sub-volumes and test them in a sliding-window manner , i.e., performing 3D segmentation on densely and uniformly sampled sub-volumes one by one. Usually, these neighboring sampled sub-volumes overlap with each other to improve the robustness of the final 3D results. It is worth noting that the overlap size is a trade-off between the segmentation accuracy and the time cost. Setting a larger/smaller overlap size generally leads to a better/worse segmentation accuracy but takes more/less time during testing.

To address these issues, we propose a concise and effective framework based on 3D deep networks for pancreas segmentation, which can simultaneously achieve high segmentation accuracy and low time cost. Our framework is formulated in a coarse-to-fine manner. In the training stage, we first train a 3D FCN from the sub-volumes sampled from an entire CT volume. We call this ResDSN Coarse model, which aims to obtain the rough location of the target pancreas from the whole CT volume by making full use of the overall 3D context. Then, we train another 3D FCN from the sub-volumes sampled only from the ground truth bounding boxes of the target pancreas. We call this the ResDSN Fine model, which can refine the segmentation based on the coarse result. In the testing stage, we first apply the coarse model in the sliding-window manner to a whole CT volume to extract the most probable location of the pancreas. Since we only need a rough location for the target pancreas in this step, the overlap size is set to a small value. Afterwards, we apply the fine model in the sliding-window manner to the coarse pancreas region, but by setting a larger overlap size. Thus, we can efficiently obtain a fine segmentation result and we call the coarse-to-fine framework by ResDSN C2F.

Note that, the meaning of “coarse-to-fine” in our framework is twofold. First, it means the input region of interests (RoIs) for ResDSN Coarse model and ResDSN Fine model are different, i.e., a whole CT volume for the former one and a rough bounding box of the target pancreas for the latter one. We refer to this as coarse-to-fine RoIs, which is designed to achieve better segmentation performance. The coarse step removes a large amount of the unrelated background region, then with a relatively smaller region to be sampled as input, the fine step can much more easily learn cues which distinguish the pancreas from the local background, i.e., exploit local context which makes it easier to obtain a more accurate segmentation result. Second, it means the overlap sizes used for ResDSN Coarse model and ResDSN Fine model during inference are different, i.e., small and large overlap sizes for them, respectively. We refer to this as coarse-to-fine overlap sizes, which is designed for efficient 3D inference.

To our best knowledge, we are one of the first studies to segment the challenging normal and abnormal pancreases using 3D networks which leverage the rich spatial information. The effectiveness and efficiency of the proposed 3D coarse-to-fine framework are demonstrated on two pancreas segmentation datasets where we achieve the state-of-the-art with relative low time cost. It is worth mentioning that, although our focus is pancrease segmentation, our framework is generic and can be directly applied to segmenting other medical organs.

Related Work

The medical image analysis community is facing a revolution brought by the fast development of deep networks . Deep Convolutional Neural Networks (CNNs) based methods have dominated the research area of volumetric medical image segmentation in the last few years. Generally speaking, CNN-based methods for volumetric medical image segmentation can be divided into two major categories: 2D CNNs based and 3D CNNs based.

2D CNNs based methods performed volumetric segmentation slice by slice from different views, and then fused the 2D segmentation results to obtain a 3D Volumetric Segmentation result. In the early stage, the 2D segmentation based models were trained from image patches and tested in a patch by patch manner , which is time consuming. Since the introduction of fully convolution networks (FCNs) , almost all the 2D segmentation methods are built upon 2D FCNs to perform holistic slice segmentation during both training and testing. Havaei et al proposed a two-pathway FCN architecture, which exploited both local features as well as more global contextual features simultaneously by the two pathways. Roth et al performed Pancreas segmentation by a holistic learning approach, which first segment pancreas regions by holistically-nested networks and then refine them by the boundary maps obtained by robust spatial aggregation using random forest. The U-Net is one of the most popular FCN architectures for medical image segmentation, which is a encoder-decoder network, but with additional short connection between encoder and decoder paths. Based on the fact that a pancreas only takes up a small fraction of the whole scan, Zhou et al. proposed to find the rough pancreas region and then learn a FCN based fixed-point model to refine the pancreas region iteratively. Their method is also based on a coarse-to-fine framework, but it only considered coarse-to-fine RoIs. Besides coarse-to-fine RoIs, our coarse-to-fine method also takes coarse-to-fine overlap sizes into account, which is designed specifically for efficient 3D inference.

2 3D CNNs for Volumetric Segmentation

Although 2D CNNs based methods achieved considerable progresses, they are not optimal for medical image segmentation, as they cannot make full use of the 3D context encoded in volumetric data. Several 3D CNNs based segmentation methods have been proposed. The 3D U-Net extended the previous 2D U-Net architecture by replacing all 2D operations with their 3D counterparts. Based on the architecture of the 3D U-Net, the V-Net introduced residual structures (short term skip connection) into each stage of the network. Chen et al proposed a deep voxel-wise residual network for 3D brain segmentation. Both I2I-3D and 3D-DSN included auxiliary supervision via side outputs into their 3D deep networks. Despite the success of 3D CNNs as a technique for segmenting the target organs, such as prostate and kidney , very few techniques have been developed for leveraging 3D spatial information on the challenging pancreas segmentation. Gibson et al. proposed the DenseVNet which is however constrained to have shallow encoders due to the computationally demanding dense connections. Roth et al. extended 3D U-Net to segment pancreas, which has the following shortcomings, 1) the input of their networks is fixed to $120\times 120\times 120$, which is very computationally demanding due to this large volume size, 2) the rough pancreas bounding box is resampled to a fixed size as their networks input, which loses information and flexibility, and cannot deal with the intrinsic large variations of pancreas in shape and size. Therefore, we propose our 3D coarse-to-fine framework that works on both normal and abnormal to ensure both low computation cost and high pancreas segmentation accuracy.

Method

In this section, we elaborate our proposed 3D coarse-to-fine framework which includes a coarse stage and a fine stage afterwards. We first formulate a segmentation model that can be generalized to both coarse stage and fine stage. Later in Sec. 3.1 and Sec. 3.2, we will customize the segmentation model to these two stages, separately.

It is also known as the cross entropy loss in our binary segmentation setting. By thresholding $p(y_{i}|x_{i};\bm{\Theta})$, we can obtain the binary segmentation mask $\mathbf{P}$.

We also add some auxiliary layers to such a neural network (will be called mainstream network in the rest of the paper), which produces side outputs under deep supervision . These auxiliary layers form a branch network and facilitate the feature learning at lower layer of the mainstream network. Each branch network shares the weights of the first $d$ layers from the mainstream network, which is denoted by $\bm{\Theta}_{d}=\{\mathcal{W}_{d},\mathcal{B}_{d}\}$. Apart from the shared weights, it owns weights $\widehat{\bm{\Theta}}_{d}$ to output the per-voxel prediction. Similarly, the loss of an auxiliary network can be formulated as:

which is abbreviated as $\mathcal{L}_{d}$. Finally, stochastic gradient descent is applied to minimize the negative log-likelihood, which is given by following regularized objective function:

where $\otimes$ means an element-wise product. The function $\textrm{Crop}[\mathbf{X};\mathbf{P},m]$ denotes cropping $\mathbf{X}$ via a rectangular cube that covers all the $1$’s voxels of a binary volume $\mathbf{P}$ added by a padding margin $m$ along three axes. Given $\mathbf{P}$, the functional constraint imposed on $\mathbf{X}$ is that they have exactly the same dimensionality in 3D space. The padding parameter $m$ is empirically determined in experiments, where it is used to better segment the boundary voxels of pancreas during the fine stage. The Crop operation acts as a dimensionality reduction to facilitate the fine segmentation, which is crucial to cut down the consuming time of segmentation. It is well-worth noting that the 3D locations of the rectangular cube which specifies where to crop $\mathbf{X}^{\textrm{F}}$ from $\mathbf{X}^{\textrm{C}}$ is recorded to map the fine segmentation results back their positions in the full CT scan.

2 Fine Stage

3 Coarse-to-Fine Segmentation

Our segmentation task is to give a volumetric prediction on every voxel of $\mathbf{X}^{\textrm{C}}$, so we need to map the $\mathbf{P}^{\textrm{F}}$ back to exactly the same size of $\mathbf{X}^{\textrm{C}}$ given by:

where $\mathbf{P}^{\textrm{C2F}}$ denotes the final volumetric segmentation, and $\odot$ means an element-wise replacement, and DeCrop operation defined on $\mathbf{P}^{\textrm{F}},\mathbf{P}^{\textrm{C}},\mathbf{X}^{\textrm{F}}\textrm{ and }\mathbf{X}^{\textrm{C}}$ is to replace a pre-defined rectangular cube inside $\mathbf{P}^{\textrm{C}}$ by $\mathbf{P}^{\textrm{F}}$, where the replacement locations are given by the definition of cropping $\mathbf{X}^{\textrm{F}}$ from $\mathbf{X}^{\textrm{C}}$ given in Eq. 4.

All in all, our entire 3D-based coarse-to-fine segmentation framework during testing is illustrated in Fig 2.

4 Network Architecture

As shown in Fig. 3, we provide an illustration of our convolutional network architecture. Inspired by V-Net , 3D U-Net , and VoxResNet , we have an encoder path followed by a decoder path each with four resolution steps. The left part of network acts as a feature extractor to learn higher and higher level of representations while the right part of network decompresses compact features into finer and finer resolution to predict the per-voxel segmentation. The padding and stride of each layer (Conv, Pooling, DeConv) are carefully designed to make sure the densely predicted output is the same size as the input.

The encoder sub-network on the left is divided into different steps that work on different resolutions. Each step consists of one to two convolutions, where each convolution is composed of $3\times 3\times 3$ convolution followed by a batch normalization (BN ) and a rectified linear unit (ReLU ) to reach better convergence, and then a max pooling layer with a kernel size of $2\times 2\times 2$ and strides of two to reduce resolutions and learn more compact features. The downsampling operation implemented by max-pooling can reduce the size of the intermediate feature maps while increasing the size of the receptive fields. Having fewer size of activations makes it possible to double the number of channels during feature aggregation given the limited computational resource.

The decoder sub-network on the right is composed of several steps that operate on different resolutions as well. Each step has two convolutions with each one followed by a BatchNorm and a ReLU, and afterwards a Deconvolution with a kernel size of $4\times 4\times 4$ and strides of two is connected to expand the feature maps and finally predict the segmentation mask at the last layer. The upsampling operation that is carried out by deconvolution enlarges the resolution between each step, which increases the size of the intermediate activations so that we need to halve the number of channels due to the limited memory of the GPU card.

Apart from the left and right sub-networks, we impose a residual connection to bridge short-cut connections of features between low-level layers and high-level layers. During the forward phase, the low-level cues extracted by networks are directly added to the high-level cues, which can help elaborate the fine-scaled segmentation, e.g., small parts close to the boundary which may be ignored during the feature aggregation due to the large size of receptive field at high-level layers. As for the backward phase, the supervision cues at high-level layers can be back-propagated through the short-cut way via the residual connections. This type of mechanism can prevent networks from gradient vanishing and exploding , which hampers network convergence during training.

We have one mainstream loss layer connected from “Res/Conv1b” and another two auxiliary loss layers connected from “Conv2b” and “Conv3b” to the ground truth label, respectively. For the mainstream loss in “Res/Conv1b” as the last layer which has the same size of data flow as one of the input, a $1\times 1\times 1$ convolution is followed to reduce the number of channels to the number of label classes which is $2$ in our case. As for the two auxiliary loss layers, deconvolution layers are connected to upsample feature maps to be the same as input.

The deep supervision imposed by auxiliary losses provides robustness to hyper-parameters choice, in that the low-level layers are guided by the direct segmentation loss, leading to faster convergence rate. Throughout this work, we have two auxiliary branches where the default parameters are $\xi_{1}=0.2$ and $\xi_{2}=0.4$ in Eq. 3 to control the importance of deep supervisions compared with the major supervision from the mainstream loss for all segmentation networks.

As shown in Table 1, we give the detailed comparisons of network configurations in terms of four aspects: long residual connection, short residual connection, deep supervision and loss function. Our backbone network architecture, named as “ResDSN”, is proposed with different strategies in terms of combinations of long residual connection and short residual connection compared with VoxResNet , 3D HED , 3D DSN and MixedResNet . In this table, we also depict “FResDSN” and “SResDSN”, where “FResDSN” and “SResDSN” are similar to MixedResNet and VoxResNet , respectively. As confirmed by our quantitative experiments in Sec. 5.1, instead of adding short residual connections to the network, e.g., “FResDSN” and “SResDSN”, we only choose the long residual element-wise sum, which can be more computationally efficient while even performing better than the “FResDSN” architecture which is equipped with both long and short residual connections. Moreover, ResDSN has noticeable differences with respect to the V-Net and 3D U-Net . On the one hand, compared with 3D U-Net and V-Net which concatenate the lower-level local features to higher-level global features, we adopt the element-wise sum between these features, which outputs less number of channels for efficient computation. On the other hand, we introduce deep supervision via auxiliary losses into the network to yield better convergence.

Experiments

In this section, we first describe in detail how we conduct training and testing in the coarse and fine stages, respectively. Then we are going to compare our proposed method with previous state-of-the-art on two pancreas datasets: NIH pancreas dataset and JHMI pathological pancreas dataset .

All our experiments were run on a desktop equipped with the NVIDIA TITAN X (Pascal) GPU and deep neural networks were implemented based on the CAFFE platform customized to support 3D operations for all necessary layers, e.g., “convolution”, “deconvolution” and “pooling”, etc. For the data pre-processing, we simply truncated the raw intensity values to be in $$and then normalized each raw CT case to have zero mean and unit variance to decrease the data variance caused by the physical processes of medical images. As for the data augmentation in the training phase, unlike sophisticated processing used by others, e.g., elastic deformation , we utilized simple but effective augmentations on all training patches, i.e., rotation ($90\degree,180\degree,\textrm{ and }270\degree$) and flip in all three axes (axial, sagittal and coronal), to increase the number of 3D training samples which can alleviate the scarce of CT scans with expensive human annotations. Note that different CT cases have different physical resolutions, but we keep their resolutions unchanged. The input size of all our networks is denoted by$W_{I}\times H_{I}\times D_{I}$, where$W_{I}=H_{I}=D_{I}=64$.

For the coarse stage, we randomly sampled $64\times 64\times 64$ sub-volumes from the whole CT scan in the training phase. In this case, a sub-volume can either cover a portion of pancreas voxels or be cropped from regions with non-pancreas voxels at all, which acts as a hard negative mining to reduce the false positive. In the testing phase, a sliding window was carried out to the whole CT volume with a coarse stepsize that has small overlaps within each neighboring sub-volume. Specifically, for a testing volume with a size of $W\times H\times D$, we have a total number of $(\lfloor\frac{W}{W_{I}}\rfloor+n)\times(\lfloor\frac{H}{H_{I}}\rfloor+n)\times(\lfloor\frac{D}{D_{I}}\rfloor+n)$ sub-volumes to be fed into the network and then combined to obtain the final prediction, where $n$ is a parameter to control the sliding overlaps that a larger $n$ results in a larger overlap and vice versa. In the coarse stage for the low time cost concern, we set $n=6$ to efficiently locate the rough region of pancreas $\mathbf{X}^{\textrm{F}}$ defined in Eq. 4 from the whole CT scan $\mathbf{X}^{\textrm{C}}$.

For the fine stage, we randomly cropped $64\times 64\times 64$ sub-volumes constrained to be from the pancreas regions defined by ground-truth labels during training. In this case, a training sub-volume was assured to cover pancreatic voxels, which was specifically designed to be capable of segmentation refinement. In the testing phase, we only applied the sliding window on $\mathbf{X}^{\textrm{F}}$ with a size of $W_{F}\times H_{F}\times D_{F}$. The total number of sub-volumes to be tested is $(\lfloor\frac{W_{F}}{W_{I}}\rfloor+n)\times(\lfloor\frac{H_{F}}{H_{I}}\rfloor+n)\times(\lfloor\frac{D_{F}}{D_{I}}\rfloor+n)$. In the fine stage for the high accuracy performance concern, we set $n=12$ to accurately estimate the pancreatic mask $\mathbf{P}^{\textrm{F}}$ from the rough segmentation volume $\mathbf{X}^{\textrm{F}}$. In the end, we mapped the $\mathbf{P}^{\textrm{F}}$ back to $\mathbf{P}^{\textrm{C}}$ to obtain $\mathbf{P}^{\textrm{C2F}}$ for the final pancreas segmentation as given in Eq. 5, where the mapping location is given by the cropped location of $\mathbf{X}^{\textrm{F}}$ from $\mathbf{X}^{\textrm{C}}$.

After we get the final binary segmentation mask, we denote $\mathcal{P}$ and $\mathcal{Y}$ to be the set of pancreas voxels in the prediction and ground truth, separately, i.e., $\mathcal{P}=\{i|p_{i}=1\}$ and $\mathcal{Y}=\{i|y_{i}=1\}$. The evaluation metric is defined by the Dice-Sørensen Coefficient (DSC) formulated as $\text{DSC}(\mathcal{P},\mathcal{Y})=\frac{2\times|\mathcal{P}\cap\mathcal{Y}|}{|\mathcal{P}|+|\mathcal{Y}|}$. This evaluation measurement ranges in $$where$1$ means a perfect prediction.

2 NIH Pancreas Dataset

We conduct experiments on the NIH pancreas segmentation dataset , which contains $82$ contrast-enhanced abdominal CT volumes provided by an experienced radiologist. The size of CT volumes is $512\times 512\times D$, where $D\in$ and their spatial resolutions are $w\times h\times d$, where $d=1.0\textrm{mm}$ and $w=h$ that ranges from $0.5\textrm{mm}$ to $1.0\textrm{mm}$. Data pre-processing and data augmentation were described in Sec. 4.1. Note that we did not normalize the spatial resolution into the same one since we wanted to impose the networks to learn to deal with the variations between different volumetric cases. Following the training protocol , we perform $4$-fold cross-validation in a random split from $82$ patients for training and testing folds, where each testing fold has $21,21,20$ and $20$ cases, respectively. We trained networks illustrated in Fig. 3 by SGD optimizer with a $16$ mini-batch, a $0.9$ momentum, a base learning rate to be $0.01$ via polynomial decay (the power is $0.9$) in a total of $80\rm{,}000$ iterations, and the weight decay $0.0005$. Both training networks in the coarse and fine stages shared the same training parameter settings except that they took a $64\times 64\times 64$ input sampled from different underlying distributions described in Sec. 4.1, which included the details of testing settings as well. We average the score map of overlapped regions from the sliding window and throw away small isolated predictions whose portions are smaller than $0.2$ of the total prediction, which can remove small false positives. For DSC evaluation, we report the average with standard deviation, max and min statistics over all $82$ testing cases as shown in Table 2.

First of all, our overall coarse-to-fine framework outperforms previous state-of-the-art by nearly $2.2\%$ (Cai et al. and Zhou et al. ) in terms of average DSC, which is a large improvement. The lower standard deviation of DSC shows that our method is the most stable and robust across all different CT cases. Although the enhancement of max DSC of our framework is small due to the saturation, the improvement of min DSC over the second best (Dou et al. ) is from $62.53\%$ to $69.62\%$, which is a more than $7\%$ advancement. The worst case almost reaches $70\%$, which is a reasonable and acceptable segmentation result. After coarse-to-fine, the segmentation result of the worst case is improved by more than $11\%$ after the 3D-based refinement from the 3D-based coarse result. The overall average DSC was also improved by $1.41\%$, which proves the effectiveness of our framework.

s shown in Fig 4, we report the segmentation results by “ResDSN Coarse” and “ResDSN C2F” on the same slice for comparison. Note that yellow regions are the correctly predicted pancreas. For the NIH case $\#33$, which is the min DSC case reported by both “ResDSN Coarse” and “ResDSN C2F”, the “ResDSN C2F” successfully predict more correct pancreas regions at the bottom, which is obviously missed by “ResDSN Coarse”. If the coarse segmentation is bad, e.g., case $\#33$ and $\#63$, our 3D coarse-to-fine can significantly improve the segmentation results by as much as $10\%$ in DSC. However, if the coarse segmentation is already very good, e.g., case $\#74$, our proposed method cannot improve too much. We conclude that our proposed “ResDSN C2F” shows its advancement over 2D methods by aggregating rich spatial information and is more powerful than other 3D methods on the challenging pancreas segmentation task.

3 JHMI Pathological Pancreas Dataset

We verified our proposed idea on the JHMI pathological cyst dataset of abdominal CT scans as well. Different from the NIH healthy pancreas dataset, this dataset includes pathological cysts where some can be or can become cancerous. The pancreatic cancer stage largely influences the morphology of the pancreas that makes this dataset extremely challenging for considering the large variants.

This dataset has a total number of $131$ contrast-enhanced abdominal CT volumes with human-labeled pancreas annotations. The size of CT volumes is $512\times 512\times D$, where $D\in$ that spans a wider variety of thickness than one of the NIH dataset. Following the training protocol , we conducted $4$-fold cross validation on this dataset where each testing fold has $33,33,32$ and $33$ cases, respectively. We trained networks illustrated in Fig. 3 in both the coarse and fine stage with the same training settings as on the NIH except that we trained a total of $300\rm{,}000$ iterations on this pathological dataset since a pancreas with cysts is more difficult to segment than a normal case. In the testing phase, we vote the prediction map of overlapped regions from the sliding window and ignore small isolated pancreas predictions whose portions are smaller than $0.05$ of the total prediction. As shown in Table. 3, we compare our framework with only one available published results on this dataset. “ResDSN C2F” achieves an average ${80.56\%}$ DSC that consistently outperforms the 2D based coarse-to-fine method , which confirms the advantage of leveraging the rich spatial information along three axes. What’s more, the “ResDSN C2F” improves the “ResDSN Coarse” by ${2.60\%}$ in terms of the mean DSC, which is a remarkable improvement that proves the effectiveness of the proposed 3D coarse-to-fine framework. Both and our method have multiple failure cases whose testing DSC are , which indicates the segmentation of pathological organs is a more tough task. Due to these failure cases, we observe a large deviation on this pathological pancreas dataset compared with results on the NIH healthy pancreas dataset.

Discussion

In this section, we conduct the ablation studies about residual connection, time efficiency and deep supervision to further investigate the effectiveness and efficiency of our proposed framework for pancreas segmentation.

We discuss how different combinations of residual connections contribute to the pancreas segmentation task on the NIH dataset. All the residual connections are implemented in the element-wise sum and they shared exactly the same deep supervision connections, cross-validation splits, data input, training and testing settings except that the residual structure is different from each other. As given in Table. 4, we compare four configurations of residual connections of 3D based networks only in the coarse stage. The major differences between our backbone network “ResDSN” with respect to “FResDSN”, “SResDSN” and “DSN” are depicted in Table. 1. “ResDSN” outperforms other network architectures in terms of average DSC and a small standard deviation even through the network is not as sophisticated as “FResDSN”, which is the reason we adopt “ResDSN” for efficiency concerns in the coarse stage.

2 Time Efficiency

We discuss the time efficiency of the proposed coarse-to-fine framework with a smaller overlap in the coarse stage for the low consuming time concern while a larger one in the fine stage for the high prediction accuracy concern. The overlap size depends on how large we choose $n$ defined in Sec 4.1. We choose $n=6$ during the coarse stage while $n=12$ during the fine stage. Experimental results are shown in Table 5. “ResDSN Coarse” is the most efficient while the accuracy is the worst among three methods, which makes sense that we care more of the efficiency to obtain a rough pancreas segmentation. “ResDSN Fine” is to use a large overlap on an entire CT scan to do the segmentation which is the most time-consuming. In our coarse-to-fine framework, we combine the two advantages together to propose “ResDSN C2F” which can achieve the best segmentation results while the average testing time cost for each case is reduced by $36\%$ from $382$s to $245$s compared with “ResDSN Fine”. In comparison, it takes an experienced board certified Abdominal Radiologist 20 mins for one case, which verifies the clinical use of our framework.

3 Deep Supervision

We discuss how effective of the auxiliary losses to demonstrate the impact of the deep supervision on our 3D coarse-to-fine framework. Basically, we train our mainstream networks without any auxiliary losses for both coarse and fine stages, denoted as “Res C2F”, while keeping all other settings as the same, e.g., cross-validation splits, data pre-processing and post-processing. As shown in Table 6, “ResDSN C2F” outperforms “Res C2F” by $17.79\%$ to a large extent on min DSC and $0.53\%$ better on average DSC though it’s a little bit worse on max DSC. We conclude that 3D coarse-to-fine with deep supervisions performs better and especially more stable on the pancreas segmentation.

Conclusion

In this work, we propose a novel 3D network called “ResDSN” integrated with a coarse-to-fine framework to simultaneously achieve high segmentation accuracy and low time cost. The backbone network “ResDSN” is carefully designed to only have long residual connections for efficient inference. To our best knowledge, we are one of the first works to segment the challenging pancreas using 3D networks which leverage the rich spatial information to achieve the state-of-the-art. On widely-used datasets, the worst segmentation case is experimentally improved a lot by our coarse-to-fine framework. What’s more, our coarse-to-fine framework can work on both normal and abnormal pancreases to achieve good segmentation accuracy.

Though this work mainly focuses on segmentation for the pancreas, we can naturally apply the proposed idea to other small organs, e.g., spleen, duodenum and gallbladder, etc, In the future, we will target on error causes that lead to inaccurate segmentation to make our framework more stable, and extend our 3D coarse-to-fine framework to cyst segmentation which can cause cancerous tumors, and the very important tumor segmentation task. Acknowledgements This work was supported by the Lustgarten Foundation for Pancreatic Cancer Research, and National Natural Science Foundation of China No. 61672336. We appreciate enormous help from Seyoun Park, Lingxi Xie, Yuyin Zhou, Yan Wang, Fengze Liu, and valuable discussions from Qing Liu, Yan Zheng, Chenxi Liu, Zhe Ren.

References