While recent semantic segmentation methods achieve impressive results [6, 15, 16, 42], they require very deep networks and their architectures tend to focus on high-resolution and large-scale datasets and to rely on pre-trained backbones. For instance, state-of-the-art models, such as Deeplab [5, 6], PSPnet  and RefineNet , use a ResNet101  as their backbone. This results in high GPU memory usage and inference time, and makes them less than ideal for operation in power-limited environments where real-time performance is nevertheless required, such as when segmenting hands using the onboard resources of an Augmented Reality headset. This has been addressed by architectures such as the ICNet 
at the cost of a substantial performance drop. Perhaps even more importantly, training very deep networks usually requires either massive amounts of training data or image statistics close to that of ImageNet, which may not be appropriate in fields such as biomedical image segmentation where the more compact U-Net architecture remains prevalent .
In this paper, we argue that these state-of-the-art methods do not naturally generalize to resource-constrained situations and introduce a novel recurrent U-Net architecture that preserves the compactness of the original U-Net , while substantially increasing its performance to the point where it outperforms the current state of the art on 5 hand-segmentation datasets, one of which is showcased in Fig. 1, and a retina vessel segmentation one. With only 0.3 million parameters, our model is much smaller than the ResNet101-based DeepLabv3+  and RefineNet , with 40 and 118 million weights, respectively. This helps explain why we can outperform state-of-the-art networks on speclalized tasks: The pre-trained ImageNet features are not necessarily the best and training sets are not quite as large as CityScapes . As a result, the large networks tend to overfit and do not perform as well as compact models trained from scratch.
The standard U-Net takes the image as input, processes it, and directly returns an output. By contrast, our recurrent architecture iteratively refines both the segmentation mask and the network’s internal state. This mimics human perception as in the influential AutoContext paper : When we observe a scene, our eyes undergo saccadic movements, and we accumulate knowledge about the scene and continuously refine our perception . To this end we retain the overall structure of the U-Net, but build a recurrent unit over some of its inner layers for internal state update. By contrast with the simple CNN+RNN architecture of Fig. 2(b), often used for video or volumetric segmentation [37, 24, 3], this enables the network to keep track of and to iteratively update more than just a single-layer internal state. This gives us the flexibility to choose the portion of the internal state that we exploit for recursion purposes and to explore variations of our scheme.
We demonstrate the benefits of our recurrent U-Net on several tasks, including hand segmentation, retina vessel segmentation and road segmentation. Our approach consistently outperforms earlier and simpler approaches to recursive segmentation [19, 24, 37]. For retina vessel segmentation, it also outperforms the state-of-the-art method of  on the DRIVE  dataset, and for hand segmentation, the state-of-the-art RefinetNet-based method of  on several modern benchmarks [11, 4, 36]. As these publicly available hand segmentation datasets are relatively small, with at most 4.8K annotated images, we demonstrate the scalability of our approach, along with its applicability in a keyboard typing scenario, by introducing a larger dataset containing 12.5K annotated images. It is the one we used to produce the results shown in Fig. 1. We will make it publicly available along with our code upon acceptance of the paper.
Our contribution is therefore an effective recurrent approach to semantic segmentation that can operate in environments where the amount of training data and computational power are limited. It does not require more memory than the standard U-Net thanks to parameter sharing and does not require training datasets as large as other state-of-the-art networks do. It is practical for real-time application, reaching 55 frames-per-second (fps) to segment images on an NVIDIA TITAN X with 12G memory. Furthermore, as shown in Fig. 1, we can trade some accuracy for speed by reducing the number of iterations. Finally, while we focus on resource-constrained applications, our model can easily be made competitive on standard benchmarks such as Cityscapes by modifying its backbone architecture. We will show that replacing the U-Net encoder by a VGG16 backbone yields performance numbers comparable to the state of the art on this dataset.
2 Related Work
Compact Semantic Segmentation Models.
State-of-the-art semantic segmentation techniques [6, 15, 16, 42] rely on very deep networks, which makes them ill-suited in resource-constrained scenarios, such as real-time applications and when there are only limited amounts of training data. In such cases, more compact networks are preferable. Such networks fall under two main categories.
The first group features encoder-decoder architectures [30, 25, 2, 28, 22, 31, 12]. Among those, U-Net  has demonstrated its effectiveness and versatility on many tasks, in particular for biomedical image analysis where it remains a favorite. For example, a U-net like architecture was recently used to implement the flood-filling networks of 
and to segment densely interwoven neurons and neurites in teravoxel-scale 3D electron-microscopy image stacks. This work took advantage of the immense amount of computing power that Google can muster but, even then, it is unlikely that this could have been accomplished with much heavier architectures.
The second type involves multi-branch structures [23, 40, 41] to fuse low-level and high-level features at different resolutions. These require careful design to balance speed against performance. By contrast, the U-Net relies on simpler skip connections and, thus, does not require a specific design, which has greatly contributed to its popularity.
Recurrent Networks for Segmentation.
The idea of recurrent segmentation predates the deep learning era and was first proposed in AutoContext
, and recurrent random forest. It has inspired many recent approaches, including several that rely on deep networks. For example, in , the segmentation mask produced by a modified U-Net was passed back as input to it along with the original image, which resulted in a progressive refinement of the segmentation mask. Fig. 2(a) illustrates this approach. A similar one was followed in the earlier work of , where the resolution of the input image patch varied across the iterations of the refinement process.
Instead of including the entire network in the recursive procedure, a standard recurrent unit can be added at the output of the segmentation network, as shown in Fig. 2(b). This was done in  to iteratively produce individual segmentation masks for scene objects. In principle, such a convolutional recurrent unit [3, 24, 37]
could also be applied for iterative segmentation of a single object and we will evaluate this approach in our experiments. We depart from this strategy by introducing gated recurrent units that encompass several U-Net layers. Furthermore, we leverage the previous segmentation results as input, not just the same image at every iteration.
Iterative refinement has also been used for pose estimation[27, 38, 20]
. The resulting methods all involve consecutive modules to refine the predictions with a loss function evaluated on the output of each module, which makes them similar in spirit to the model depicted by Fig.2(a). Unlike in our approach, these methods do not share the parameters across the consecutive modules, thus requiring more parameters and moving away from our aim to obtain a compact network. Furthermore, they do not involve RNN-inspired memory units to track the internal hidden state.
We now introduce our novel recurrent semantic segmentation architecture. To this end, we first discuss the overall structure of our framework, and then provide the details of the recurrent unit it relies on. Finally, we briefly discuss the training strategy for our approach.
3.1 Recurrent U-Net
(a), the U-Net has an encoder-decoder structure, with skip connections between the corresponding encoding and decoding layers that allow the network to retain low-level features for the final prediction. Our goal being to operate in resource-constrained environments, we want to keep the model relatively simple. We therefore rely on a U-Net design where the first convolutional unit has 8 feature channels, and, following the original U-Net strategy, the channel number doubles after every pooling layer in the encoder. The decoder relies on transposed convolutions to increase the model’s representation power compared to bilinear interpolation. We use group-normalization in all convolutional layers since we usually rely on very small batch sizes.
Our contributions are to integrate recursions on 1) the predicted segmentation mask and 2) multiple internal states of the network. The former can be achieved by simply concatenating, at each recurrent iteration , the previous segmentation mask
to the input image, and passing the resulting concatenated tensor through the network. For the latter, we propose to replace a subset of the encoding and decoding layers of the U-Net with a recurrent unit. Below, we first formalize this unit, and then discuss two variants of its internal mechanism.
To formalize our recurrent unit, let us consider the process at iteration of the recurrence. At this point, the network takes as input an image concatenated with the previously-predicted segmentation mask . Let us then denote by the activations of the encoding layer, and by those of the corresponding decoding layer. Our recurrent unit takes as input , together with its own previous hidden tensor , and outputs the corresponding activations , along with the new hidden tensor . Note that, to mimic the computation of the U-Net, we use multiple encoding and decoding layers within the recurrent unit.
In practice, one can choose the specific level at which the recurrent unit kicks in. In Fig. 3 (b), we illustrate the whole process for . When , the entire U-Net is included in the recurrent unit, which then takes the concatenation of the segmentation mask and the image as input. Note that, for , the recurrent unit still contains several layers because the central portion of the U-Net in Fig. 3(a) corresponds to a convolutional block. In our experiments, we evaluate two different structures for the recurrent units, which we discuss below.
3.2 Dual-gated Recurrent Unit
As a first recurrent architecture, we draw inspiration from the Gated Recurrent Unit (GRU) . As noted above, however, our recurrent unit replaces multiple encoding and decoding layers of the segmentation network. We therefore modify the equations accordingly, but preserve the underlying motivation of GRUs. Our architecture is shown in Fig. 3(c).
Specifically, at iteration , given the activations and the previous hidden state , we aim to produce a candidate update for the hidden state and combine it with the previous one according to how reliable the different elements of this previous hidden state tensor are. To determine this reliability, we use an update gate defined by a tensor
where denotes an encoder-decoder network with the same architecture as the portion of the U-Net that we replace with our recurrent unit.
Similarly, we obtain the candidate update as
where is a network with the same architecture as , but a separate set of parameters, denotes the element-wise product, and is a reset tensor allowing us to mask parts of the input used to compute . It is computed as
where is again a network with the same encoder-decoder architecture as before.
Given these different tensors, the new hidden state is computed as
Finally, we predict the output of the recurrent unit, which corresponds to the activations of the decoding layer as
where, as shown in Fig. 3(c), is a simple convolutional block. Since it relies on two gates, and , we dub this recurrent architecture Dual-gated Recurrent Unit (DRU). One main difference with GRUs is the fact that we use multi-layer encoder-decoder networks in the inner operations instead of simple linear layers. Furthermore, in contrast to GRUs, we do not directly make use of the hidden state in these inner computations. This allows us not to have to increase the number of channels in the encoding and decoding layers compared to the original U-Net. Nevertheless, the hidden state is indirectly employed, since, via the recursion, depends on , which is computed from .
3.3 Single-Gated Recurrent Unit
As evidenced by our experiments, the DRU described above is effective at iteratively refining a segmentation. However, it suffers from the drawback that it incorporates three encoder-decoder networks, which may become memory-intensive depending on the choice of . To decrease this cost, we therefore introduce a simplified recurrent unit, which relies on a single gate, thus dubbed Single-gated Recurrent Unit (SRU).
Specifically, as illustrated in Fig. 3(d), our SRU has a structure similar to that of the DRU, but without the reset tensor . As such, the equations remain mostly the same as above, with the exception of the candidate hidden state, which we now express as
This simple modification allows us to remove one of the encoder-decoder networks from the recurrent unit, which, as shown by our results, comes at very little loss in segmentation accuracy.
To train our recurrent U-Net, we use the cross-entropy loss. More specifically, we introduce supervision at each iteration of the recurrence. To this end, we write our overall loss as
where represents the number of recursions, set to 3 in this paper, and denotes the cross-entropy loss at iteration , which is weighted by .
The weight, by setting , increases monotonically with the iterations. In our experiments, we either set , so that all iterations have equal importance, or , thus encoding the intuition that we seek to put more emphasis on the final prediction. A study of the influence of is provided in supplementary material, where we also discuss our training protocol in detail.
We compare the two versions of our Recurrent U-Net against the state of the art on several tasks including hand segmentation, retina vessel segmentation and road delineation. The hyper-parameters of our models were obtained by validation, as discussed in the supplementary material. We further demonstrate that the core idea behind our idea also applies to non-resource-constrained scenarios, such as Cityscapes, by increasing the size of the U-Net encoder.
We report the performance of our approach on standard hand-segmentation benchmarks, such as GTEA , EYTH , EgoHand , and HOF . These, however, are relatively small, with at most 4,800 images in total, as can be seen in Table 1. To evaluate our approach on a larger dataset, we therefore acquired our own. Because this work was initially motivated by an augmented virtuality project whose goal is to allow someone to type on a keyboard while wearing a head-mounted display, we asked 50 people to type on 9 keyboards while wearing an HTC Vive . To make this easier, we created a mixed-reality application to allow the users to see both the camera view and a virtual browser showing the text being typed. To ensure diversity, we varied the keyboard types, lighting conditions, desk colors, and objects lying on them, as can be seen in Fig. 4. We provide additional details in Table 2.
We then recorded 161 hand sequences with the device’s camera. We split them as 20/ 20/ 60% for train/ validation/ test to set up a challenging scenario in which the training data is not overabundant and to test the scalability and generalizability of the trained models. We guaranteed that the same person never appears in more than one of these splits by using people’s IDs during partitioning. In other words, our splits resulted in three groups of 30, 30, and 101 separate videos, respectively. We annotated about the same number of frames in each one of the videos, resulting in a total of 12,536 annotated frames.
We used the popular DRIVE dataset . It contains 40 retina images used for making clinical diagnoses, among which 33 do not show any sign of diabetic retinopathy and 7 show signs of mild early diabetic retinopathy. The images have been divided into a training and a test set with 20 images for each set.
We used the Massachusetts Roads dataset . It is one of the largest publicly available collections of aerial road images, containing both urban and rural neighborhoods, with many different kinds of roads ranging from small paths to highways. The data is split into 1108 training and 49 test images, one of which is shown in Fig. 6.
We employed the recent Cityscapes dataset. It is a very challenging dataset with high-resolution images. It has 5,000 finely annotated images which are split into training/validation/test sets with 2975/500/1525 images. 30 classes are annotated, and 19 of them are used in training and testing.
4.2 Experimental Setup
We refer to the versions of our approach that rely on the dual gated unit of Section 3.2 and the single gated unit of Section 3.3 as Ours-SRU and Ours-DRU, respectively, with, e.g., Ours-SRU(3) denoting the case where in Fig. 3. We compare them against the state-of-the-art model for each task, i.e., RefineNet  for hand segmentation,  for retina vessel segmentation and  for road delineation, the general purpose DeepLab V3+ , the real-time ICNet , and the following baselines.
Rec-Last. It has been proposed to add a recurrent unit after a convolutional segmentation network to process sequential data, such as video . The corresponding U-Net-based architecture can be directly applied to segmentation by inputing the same image at all time steps, as shown in Fig. 2(b). The output then evolves as the hidden state is updated.
Rec-Middle. Similarly, the recurrent unit can replace the bottleneck between the U-Net encoder and decoder, instead of being added at the end of the network. This has been demonstrated to handle volumetric data . Here we test it for segmentation. The hidden state then is of the same size as the inner feature backbone, that is, 128 in our experimental setup.
Rec-Simple . We perform a recursive refinement process, that is, we concatenate the segmentation mask with the input image and feed it into the network. Note that the original method of  relies on a VGG-19 pre-trained on ImageNet , which is far larger than our U-Net. To make the comparison fair, we therefore implement this baseline with the same U-Net backbone as in our approach.
Scaling Up using Pretrained Deep Networks as Encoder
While our goal is resource-constrained segmentation, our method extends to the general setting. In this case, to further boost its performance, we replace the U-Net encoder with a pretrained VGG-16 backbone. This process is explained in the supplementary material. We refer to the corresponding models as U-Net-VGG16 and DRU-VGG16.
We report the mean intersection over union (mIoU), mean recall (mRec) and mean precision (mPrec).
|Model||EYTH ||GTEA ||EgoHand ||HOF ||KBH|
|Ours at layer ()|
|Deeplab V3+ ||0.757||0.819||0.875||0.907||0.928||0.976||0.870||0.909||0.958||0.722||0.822||0.816||0.856||0.901||0.935|
4.3 Comparison to the State of the Art
We now compare the two versions of our approach to the state of the art and to the baselines introduced above on the tasks of hand segmentation, retina vessel segmentation and road delineation. We split the methods into the light ones and the heavy ones. The light models contain fewer parameters and are trained from scratch, whereas the heavy ones use a pretrained deep model as backbone.
As discussed in Section 4.1, we tested our approach using 4 publicly available datasets and our own large-scale one. We compare it against the baselines in Table 3 quantitatively and in Fig. 5 qualitatively.
Overall, among the light models, the recurrent methods usually outperform the one-shot ones, i.e, ICNet  and U-Net. Besides, among the recurrent ones, Ours-DRU(4) and Ours-SRU(0) clearly dominate with Ours-DRU(4) usually outperforming Ours-SRU(0) by a small margin. Note that, even though Ours-DRU(4) as depicted by Fig. 3(a) looks superficially similar to Rec-Middle, they are quite different because Ours-DRU takes the segmentation mask as input and relies on our new DRU gate, as discussed at the end of Section 3.1 and in Section 3.2. To confirm this, we evaluated a simplified version of Ours-DRU(4) in which we removed the segmentation mask from the input. The validation mIOU on EYTH decreased from 0.836 to 0.826 but remained better than that of Rec-Middle which is 0.814.
Note that Ours-DRU(4) is better than the heavy RefineNet model on 4 out of the 5 datasets, despite RefineNet representing the current state of the art. The exception is HOF, and we believe that this can be attributed to HOF being the smallest dataset, with only 198 training images. Under such conditions, RefineNet strongly benefits from exploiting a ResNet-101 backbone that was pre-trained on PASCAL person parts , instead of training from scratch as we do. This intuition is confirmed by looking at the results of our DRU-VGG16 model, which, by using a pretrained deep backbone, yields the overall best performance.
Model Performance, Size and Speed.
Table 3 shows that DRU-VGG16 outperforms Ours-DRU, e.g., by 0.02 mIoU points on KBH. This, however, comes at a cost. To be precise, DRU-VGG16 has 41.38M parameters. This is 100 times larger than Ours-DRU(4), which has only 0.36M parameters. Moreover, DRU-VGG16 runs only at 18 fps, while Ours-DRU(4) reaches 61 fps. This makes DRU-VGG16, and the other heavy models, ill-suited to embedded systems, such as a VR camera, while Ours-DRU can more easily be exploited in resource-constrained environments.
|DeepLab V3+ ||0.756||0.875||0.828||0.851|
We report our results in Table 4. Our DRU yields the best mIOU, mPrec and mF1 scores. Interestingly, on this dataset, it even outperforms the larger DRU-VGG16 and DeepLab V3+, which performs comparatively poorly on this task. This, we believe, is due to the availability of only limited data, which leads to overfitting for such a very deep network. Note also that retina images significantly differ from the ImageNet ones, thus reducing the impact of relying on pretrained backbones. On this dataset,  constitutes the state of the art, reporting an F1 score on the vessel class only of 0.822. According to this metric, Ours-DRU(4) achieves 0.92, thus significantly outperforming the state of the art.
Our results on road segmentation are provided in Table 5. We also outperform all the baselines by a clear margin on this task, with or without ImageNet pre-training. In particular, Ours-DRU(4) yields an mIoU 8 percentage point (pp) higher than U-Net-G, and DRU-VGG16 5pp higher than U-Net-VGG16. This verifies that our recurrent strategy helps. Furthermore, Ours-DRU(4) also achieves a better performance than DeepLab V3+ and U-Net-VGG16. Note that, here, we also report two additional metrics: Precision-recall breaking point (P/R) and F1-score. The cutting threshold for all metrics is set to 0.5 except for P/R. For this experiment, we did not report the results of U-Net-B because U-Net-G is consistently better.
Note that a P/R value of 0.778 has been reported on this dataset in . However, this required using an additional topology-aware loss and a U-Net much larger than ours, that is, based on 3 layers of a VGG19 pre-trained on ImageNet. Rec-Simple duplicates the approach of  without the topology-aware loss and with the same U-Net as Ours-DRU. Their mIoU of 0.723, inferior to ours of 0.757, shows our approach to recursion to be beneficial.
|Deeplab V3+ ||0.529||0.763||0.555||0.710||0.643|
|ICNet||0.695||DeepLab V3 ||0.778|
The segmentation results on the Cityscapes validation set are shown in Table 6. Note that Ours-DRU is consistently better than U-Net-G and than the best recurrent baseline, i.e., Rec-Last. Furthermore, doubling the number of channels of the U-Net backbone increases accuracy, and so does using a pretrained VGG-16 as encoder. Ultimately, our DRU-VGG16 model yields comparable accuracy with the state-of-the-art DeepLab V3 one, despite its use of a ResNet101 backbone.
We have introduced a novel recurrent U-Net architecture that preserves the compactness of the original one, while substantially increasing its performance. At its heart is the fact that the recurrent units encompass several encoding and decoding layers of the segmentation network. In the supplementary material we demonstrate it running in real-time on a virtual reality device. We also introduced a new hand segmentation dataset that is larger than existing ones.
In future work, we will extend our approach of recurrent unit to other backbones than U-Net and to multi-scale recurrent architectures.
-  HTC Vive Virtual Reality Toolkit. https://www.vive.com/.
-  V. Badrinarayanan, A. Kendall, and R. Cipolla. Segnet: A Deep Convolutional Encoder-Decoder Architecture for Image Segmentation. arXiv Preprint, 2015.
-  N. Ballas, L. Yao, C. Pal, and A. Courville. Delving deeper into convolutional networks for learning video representations. International Conference on Learning Representations, 2016.
S. Bambach, S. Lee, D. J. Crandall, and C. Yu.
Lending a hand: Detecting hands and recognizing activities in complex
International Conference on Computer Vision, pages 1949–1957, 2015.
-  L. Chen, G. Papandreou, F. Schroff, and H. Adam. Rethinking Atrous Convolution for Semantic Image Segmentation. arXiv Preprint, abs/1706.05587, 2017.
-  L. Chen, Y. Zhu, G. Papandreou, F. Schroff, and H. Adam. Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation. arXiv Preprint, abs/1802.02611, 2018.
X. Chen, R. Mottaghi, X. Liu, S. Fidler, R. Urtasun, and A. Yuille.
Detect what you can: Detecting and representing objects using
holistic models and body parts.
Conference on Computer Vision and Pattern Recognition, 2014.
K. Cho, B. van Merrienboer, D. Bahdanau, and Y. Bengio.
On the properties of neural machine translation: Encoder-decoder approaches.arXiv Preprint, 2014.
M. Cordts, M. Omran, S. Ramos, T. Rehfeld, M. Enzweiler, R. Benenson,
U. Franke, S. Roth, and B. Schiele.
The cityscapes dataset for semantic urban scene understanding.In Conference on Computer Vision and Pattern Recognition, 2016.
-  J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. Imagenet: A Large-Scale Hierarchical Image Database. In Conference on Computer Vision and Pattern Recognition, 2009.
-  A. Fathi, A. Farhadi, and J. M. Rehg. Understanding egocentric activities. In International Conference on Computer Vision, pages 407–414, 2011.
-  D. Fourure, R. Emonet, E. Fromont, D. Muselet, A. Tremeau, and C. Wolf. Residual conv-deconv grid network for semantic segmentation. In British Machine Vision Conference, 2017.
-  K. He, X. Zhang, S. Ren, and J. Sun. Deep Residual Learning for Image Recognition. In Conference on Computer Vision and Pattern Recognition, pages 770–778, 2016.
-  M. Januszewski, J. Kornfeld, P. H. Li, A. Pope, T. Blakely, L. Lindsey, J. Maitin-Shepard, M. Tyka, W. Denk, and V. Jain. High-precision automated reconstruction of neurons with flood-filling networks. Nature methods, 15(8):605, 2018.
-  G. Lin, A. Milan, C. Shen, and I. Reid. Refinenet: Multi-path refinement networks for high-resolution semantic segmentation. In Conference on Computer Vision and Pattern Recognition, 2017.
-  J. Long, E. Shelhamer, and T. Darrell. Fully Convolutional Networks for Semantic Segmentation. In Conference on Computer Vision and Pattern Recognition, 2015.
-  K.-K. Maninis, J. Pont-Tuset, P. Arbeláez, and L. Van Gool. Deep retinal image understanding. In Conference on Medical Image Computing and Computer Assisted Intervention, 2016.
-  V. Mnih. Machine Learning for Aerial Image Labeling. PhD thesis, University of Toronto, 2013.
-  A. Mosinska, P. Marquez-Neila, M. Kozinski, and P. Fua. Beyond the Pixel-Wise Loss for Topology-Aware Delineation. In Conference on Computer Vision and Pattern Recognition, 2018.
-  A. Newell, K. Yang, and J. Deng. Stacked hourglass networks for human pose estimation. In European Conference on Computer Vision, 2016.
-  P. Pinheiro and R. Collobert. Recurrent Neural Networks for Scene Labelling. In International Conference on Machine Learning, 2014.
-  T. Pohlen, A. Hermans, M. Mathias, and B. Leibe. Full-resolution residual networks for semantic segmentation in street scenes. In Conference on Computer Vision and Pattern Recognition, 2017.
-  R. P. Poudel, U. Bonde, S. Liwicki, and C. Zach. Contextnet: Exploring context and detail for semantic segmentation in real-time. British Machine Vision Conference, 2018.
R. P. Poudel, P. Lamata, and G. Montana.
Recurrent fully convolutional neural networks for multi-slice mri cardiac segmentation.In Reconstruction, Segmentation, and Analysis of Medical Images, pages 83–94. Springer, 2016.
-  R. P. Poudel, S. Liwicki, and R. Cipolla. Fast-scnn: Fast semantic segmentation network. arXiv preprint arXiv:1902.04502, 2019.
-  D. Purves, G. J. Augustine, D. Fitzpatrick, L. C. Katz, A.-S. LaMantia, J. O. McNamara, and S. M. Williams. Types of eye movements and their functions. In Neuroscience, 2011.
-  V. Ramakrishna, D. Munoz, M. Hebert, J. A. Bagnell, and Y. Sheikh. Pose machines: Articulated pose estimation via inference machines. In European Conference on Computer Vision, 2014.
-  E. Romera, J. M. Alvarez, L. M. Bergasa, and R. Arroyo. Erfnet: Efficient residual factorized convnet for real-time semantic segmentation. IEEE Transactions on Intelligent Transportation Systems, 19(1):263–272, 2018.
-  B. Romera-Paredes and P. H. S. Torr. Recurrent instance segmentation. In European Conference on Computer Vision, pages 312–329, 2016.
-  O. Ronneberger, P. Fischer, and T. Brox. U-net: Convolutional networks for biomedical image segmentation. In Conference on Medical Image Computing and Computer Assisted Intervention, 2015.
-  S. Saxena and J. Verbeek. Convolutional neural fabrics. In Advances in Neural Information Processing Systems, 2016.
-  J. Shotton, M. Johnson, and R. Cipolla. Semantic texton forests for image categorization and segmentation. In Conference on Computer Vision and Pattern Recognition, 2008.
-  K. Simonyan and A. Zisserman. Very Deep Convolutional Networks for Large-Scale Image Recognition. In International Conference on Learning Representations, 2015.
-  J. Staal, M. Abramoff, M. Niemeijer, M. Viergever, and B. van Ginneken. Ridge based vessel segmentation in color images of the retina. IEEE Transactions on Medical Imaging, 23(4):501–509, 2004.
-  Z. Tu and X. Bai. Auto-Context and Its Applications to High-Level Vision Tasks and 3D Brain Image Segmentation. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2009.
-  A. Urooj and A. Borji. Analysis of hand segmentation in the wild. In Conference on Computer Vision and Pattern Recognition, 2018.
-  S. Valipour, M. Siam, M. Jagersand, and N. Ray. Recurrent fully convolutional networks for video segmentation. In IEEE Winter Conference on Applications of Computer Vision, 2017.
-  S.-E. Wei, V. Ramakrishna, T. Kanade, and Y. Sheikh. Convolutional pose machines. In Conference on Computer Vision and Pattern Recognition, 2016.
-  Y. Wu and K. He. Group normalization. In European Conference on Computer Vision, 2018.
-  C. Yu, J. Wang, C. Peng, C. Gao, G. Yu, and N. Sang. Bisenet: Bilateral segmentation network for real-time semantic segmentation. In European Conference on Computer Vision, 2018.
-  H. Zhao, X. Qi, X. Shen, J. Shi, and J. Jia. Icnet for real-time semantic segmentation on high-resolution images. In European Conference on Computer Vision, pages 405–420, 2018.
-  H. Zhao, J. Shi, X. Qi, X. Wang, and J. Jia. Pyramid Scene Parsing Network. In Conference on Computer Vision and Pattern Recognition, 2017.