Real-time Semantic Image Segmentation via Spatial Sparsity

by   Zifeng Wu, et al.

We propose an approach to semantic (image) segmentation that reduces the computational costs by a factor of 25 with limited impact on the quality of results. Semantic segmentation has a number of practical applications, and for most such applications the computational costs are critical. The method follows a typical two-column network structure, where one column accepts an input image, while the other accepts a half-resolution version of that image. By identifying specific regions in the full-resolution image that can be safely ignored, as well as carefully tailoring the network structure, we can process approximately 15 highresolution Cityscapes images (1024x2048) per second using a single GTX 980 video card, while achieving a mean intersection-over-union score of 72.9



page 2

page 9


Bridging Category-level and Instance-level Semantic Image Segmentation

We propose an approach to instance-level image segmentation that is buil...

Fast-SCNN: Fast Semantic Segmentation Network

The encoder-decoder framework is state-of-the-art for offline semantic i...

A Network Structure to Explicitly Reduce Confusion Errors in Semantic Segmentation

Confusing classes that are ubiquitous in real world often degrade perfor...

Automated Resolution Selection for Image Segmentation

It is well-known in image processing that computational cost increases r...

Recurrent Segmentation for Variable Computational Budgets

State-of-the-art systems for semantic image segmentation utilize feed-fo...

Fair Latency-Aware Metric for real-time video segmentation networks

As supervised semantic segmentation is reaching satisfying results, many...

Online panoptic 3D reconstruction as a Linear Assignment Problem

Real-time holistic scene understanding would allow machines to interpret...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Semantic (image) segmentation amounts to predicting the category of each pixel in a given image. Take the task illustrated in Fig. 1

for example, we are supposed to classify the pixels in an image recorded by a car-carried camera into 19 categories, which include

road, car, pedestrian, bicycle, etc. Currently, most of the state-of-the-art approaches to this end are based on fully-convolutional networks (FCNs) [15]. A typical FCN-based method is usually equivalent to crop a local region for each pixel, and then predict the category of that pixel using a fine-tuned backbone network. However, FCNs can save computational costs largely by reusing the feature maps for adjacent image crops, and so for their corresponding pixels.

Furthermore, two-column FCNs [4] can capture the context of a pixel within local regions of different sizes. Besides the regular full-resolution column, for example in Fig. 1, the model has an additional column with a half-resolution input. To make the final prediction, we can calculate the element-wise sum/max of the score maps respectively generated from the two columns. Or instead, we can first generate scale-aware weights and then calculate the weighted element-wise sum [4].

Figure 1: The inference pipeline of our proposed method. Depending on the spatially sparse weights generated by the half-resolution column, we skip part of the local regions in the full-resolution column.

The observation that underpins this work is that most images contain large continuous regions belonging to the same category that can be segmented accurately at low resolutions. Consider the two-column architecture in Fig. 1. The fact that the computational costs of the half-resolution column are only a quarter of those of the full-resolution column thus allows a significant improvement in efficiency.

The key to the model is a sparse weight map generated by the low-resolution column, each entry of which corresponds to a square region in the original image. Zero-valued entries in the low-resolution weight map indicate regions that do not need to be processed in high-resolution because the low-resolution classification will suffice. Besides, the computational efficiency gained by not processing the indicated areas of the image at high-resolution are more than enough to compensate for the extra cost of generating the low-resolution weight map.

Although significant improvements in segmentation accuracy have been achieved recently [3, 23], improving the efficiency of FCNs has received far less attention. This is despite the fact that it is one of the primary factors limiting their practical application. Conventionally, datasets for general semantic segmentation have medium-sized images. PASCAL VOC [8] for example, has images of no more than 500500 pixels. The resolutions of typical cameras are far greater, but more importantly, applications including driverless cars, and overhead image analysis demand a spatial acuity that a 500 500 image cannot achieve.

The Cityscapes [6] dataset is intended to provide images such as might be captured by a driverless car. These images are of 10242048 pixels, and are captured at approximately 15 frames per second. The fact that many applications require high-resolution images to be captured and processed constantly drives significant practical demand for high pixel-throughput semantic segmentation.

In this work, our contributions are:

  • We introduce spatial sparsity into a typical two-column fully-convolutional network, and show how to largely improve the inference speed without having a significant adverse impact on accuracy.

  • We show that it is possible to reduce the computational cost of an indicative FCN by a factor of approximately 25, at the cost of a small drop in accuracy, using spatial sparsity, but also in-column and cross-column connections, and by removing residual units.

2 Related work

The proposed approach is closely related to two of the most active topics in computer vision, i.e, residual networks (ResNets) and semantic image segmentation using fully-convolutional networks (FCNs).

He et al. [10, 11]

proposed ResNets to combat the vanishing gradient problem during training very deep convolutional networks. A ResNet is usually composed of multiple stacked residual units, each of which either directly passes through or makes some modifications to its input. ResNets have outperformed previous state-of-the-art models in various tasks, such as object detection 

[7] and semantic image segmentation [3]. They have gradually replaced VGGNets [18] in the computer vision community, as the standard feature extractors. Nevertheless, note that the real mechanism underpinning the effectiveness of ResNets is not yet clear. Veit et al. [20] claimed that they behave like ensembles of relatively shallow networks. On the other hand, Greff et al. [9]

interpreted a ResNet as learning unrolled iterative estimation. They claimed that the first residual unit would learn a coarse estimation, while the following units would learn to refine this estimation iteratively.

Most of the recent state-of-the-art approaches to semantic image segmentation are based on FCNs, which were proposed by Long et al. [15]

. FCNs soon became the mainstream approache to dense prediction tasks, such as depth estimation and image super-resolution, primarily due to their efficiency. On top of FCNs, Chen et al. 

[4] fused the score maps obtained from two versions of an input image with different sizes using scale-aware weights. Empirical results in the literature [3] also show that stronger pre-trained features (using ResNets instead of VGGNets as the backbone networks) can further improve FCN performance.

3 Method

In this section we demonstrate the structure of our (single-column and two-column) baseline fully-convolutional networks (FCNs), introduce spatial sparsity into the two-column version, and finally describe the additional methods that we have adopted to further improve performance.

3.1 Basic FCNs

The low resolution of extracted feature maps is one of the challenges in applying traditional deep convolutional networks to semantic segmentation. This problem originates from the need for a large field-of-view, while maintaining computational tractability, and results in a variety of down-sampling operations, including, for example, spatial pooling with a stride of two.

We show three typical approaches to solving this problem in Fig. 2. A classic FCN [15] predicts multiple groups of score maps from feature maps of different resolutions, and directly fuses (by summing) these score maps to make the final prediction. While this works, it is not the most effective choice. The DeepLab approaches [2, 3] instead remove part of the down-sampling operations. At the same time, they use dilated convolution kernels to ensure the consistency of field-of-view. However, larger feature maps inevitably lead to increased computational costs, which undermines our goal. On the other hand, we in this work use a structure inspired by the SharpMask [17] model, which was originally proposed for instance segmentation. Our empirical results show it offers a good compromise between efficiency and effectiveness.

Figure 2: Three typical approaches to increasing the resolution of predicted score maps, i.e., classic fully-convolutional networks [15], dilated networks [2], and our method derived from SharpMask [17]. Note that the distinction between fusing the score maps directly and combining low-level and high-level features is the key difference between the classic approach and our SharpMask-like approach.

3.2 Two-column FCNs

The size of the content to be recognized can vary significantly in semantic segmentation tasks, which underpins the importance of multi-scale processing. To this end, a typical pipeline includes the following three steps. First, calculate the score maps for an input image; second, down-sample that image and calculate another group of score maps; and finally, combine the previous two groups of score maps. Note that this can readily be generalized for cases with more than two groups of score maps.

Figure 3: Four typical approaches to fusing the predicted score maps from two columns, i.e., sum/max [4], attention-to-scale [4] and our coarse-to-fine. Note that whether the scale-aware weights depend on the full-resolution column is the key difference between the classic attention-to-scale and our coarse-to-fine approaches.

We show four typical approaches to multi-scale fusion in Fig. 3

. The most straightforward two choices are directly applying the element-wise summation or maximization to the score maps obtained from the two columns. Another common approach in the literature is to first generate a group of (spatially varying) scale-aware weights, then apply the Softmax activation function to ensure that the two entries at the same spatial location sum to one, and finally calculate the weighted element-wise summation. Chen et al. 

[4] have evaluated all of the above three methods (represented by the first two diagrams in Fig. 3). They observed that the ‘attention-to-scale’ approach performed the best in their proposed framework. The key drawback of this approach, particularly in the context of our model, is the dependence of the scale-aware weights on the full-resolution column. Given that full-resolution features do not exist for significant areas of the image, they cannot inform the calculation of the scale-aware weights, since much of the information required to achieve the red arrow in Fig. 3 is unavailable. We thus adopt the illustrated ‘coarse-to-fine’ approach instead, whereby the scale-aware weights depend only on the half-resolution column.

3.3 Spatial sparsity

We here introduce sparsity to network activations but not weights. One straightforward approach would be to apply a winner-take-all strategy, which amounts to setting all activations to zero except for the largest value, or perhaps the largest values for some fixed

. Another approach has been proposed in the context of restricted Boltzmann machines 


, which amounts to penalizing the cross entropy between the distribution of each activation (across different data points) and a specified binomial distribution. Ideally, each activation will get activated (being one) with a specified probability

, given different input data. The first approach seems suboptimal but still works reasonably according to our experiments. The second approach performs consistently better, however.

We can also encourage sparsity in the activations by sparse coding [19], e.g., by penalizing their norm. However, with this approach we cannot directly specify a target active probability. The model may then compute zero or all of the local regions of an image in its full-resolution column. This behaviour will lead to wide variations in inference times between different images, which is a critical drawback in a real-time system.

We expect that some of the square regions in an image would be assigned with all-zero weights, so we can skip these regions in the full-resolution column from the very beginning, as illustrated in Fig. 1

. Typically, given a local region in the original image, there is a group of feature vectors extracted at its spatial location in the half-resolution column. Suppose that an image can be evenly divided into

square regions, and that there are vectors in the feature maps corresponding to each region. We apply a single convolution kernel with a stride of to those feature maps, and obtain a weight matrix with entries, each of which corresponds to one square region in the original image. Suppose that there are images per mini-batch, then the obtained sparse weight will have shape . To ensure sparsity, we add a term [12]


to the overall loss function, where

is a hyper-parameter scaling this term, is the specified target probability, and is a moving average probability. This is computed as [12]


where the momentum (used throughout this work), is the moving average probability used in the previous iteration, and is the probability estimated only with the training data used in the current iteration. However, instead of the convolution version derived from [12]


we in this work use


Note that the modification made here is critical, because an image usually has a certain structure, especially those in the Cityscapes [6] dataset. There may be a large continuous region in the upper part (sky), or another continuous region in the bottom part (road). This observation suggests that the active probability of a region should vary as its spatial location changes. Thus, in the context of this work, instead of skiping the regions per location with a given probability, as in Eqn. (3), it is more reasonable to skip the regions per image with a given probability, as in Eqn. (4).

Figure 4: The structure of our model. The configurations of layers are given as texts above the corresponding arrows. For example, ‘Conv.: 3, 128, 3, 8’ indicates a convolution layer having 128 kernels in the shape of 33, which are applied with a dilation rate of three and divided into eight groups [13]. Blue dotted rectangles are feature maps of the cropped inputs; red dash-dot arrows and rectangles denote the routes only enabled during training; and back-propagation gradients never go through green dashed paths. Best viewed in colour.

3.4 Network structure

Our proposed model is an extension to the ‘coarse-to-fine’ two-column structure illustrated in Fig. 3, modified to achieve lower computational costs during inference. Note that we name the pipeline in Fig. 1 ‘fast inference’, to distinguish it from the classic one. The key distinction is that the fast-inference version only computes score maps for a part of an image in the full-resolution column. To this end we, as usual, compute a pair of scale-aware weight maps, i.e.,  for the half and for the full-resolution column. We also compute an additional sparse weight map following the steps described in the previous subsection. We then up-sample to ’s shape, and calculate the element-wise product of the two, which is the sparse ‘coarse-to-fine’ weight map required for the full-resolution column. We also quantize the sparse weight map into a mask, which will be applied to the local regions cropped from the original image in the full-resolution column. More details of our model are shown in Fig. 4. Note the two extra Softmax loss functions, as used by Chen et al. [4], and the in-column connections, as used in SharpMask [17]. All the above components constitute our basic ‘sparse coarse-to-fine’ model.

This basic model works well but loses too much accuracy when switching from classic to fast inference. The cause of this problem is that an image is sliced into too small crops (typically 256256), so a lot of pixels (near the boundary of an image crop) are classified without enough contexts during fast inference. To avoid this problem, we make another two modifications to the basic model, as shown in Fig. 4. First, we also crop each input image during training. This is undesirable for a plain two-column model, due to the above demonstrated boundary problem. However, it makes sense in our case here, since we will crop the image anyway during fast inference. In this way, we can at least extract consistent features in both the training and fast inference phases. We process the obtained image crops separately as different samples, and finally put their feature maps together to approximate those of the original image. We call this operation ‘uncrop’. This modification ensures a model to return exactly the same results either in the classic or fast inference phase, together with the above described masking operation. As illustrated in Fig. 4, we ‘uncrop’ the extracted features and in-column connections in the full-resolution column. Second, we add several cross-column connections. Since the half-resolution column covers a whole image, reusing its features in the full-resolution column can help relieve the boundary problem, We label this model as ‘improved sparse coarse-to-fine’.

We have also observed that the configuration of added layers can be optimized for better efficiency, at the cost of a limited drop in accuracy, as shown in Fig. 4. First, we gradually reduce the number of kernels as the feature maps grow spatially, i.e., 128, 64 and 32. Second, we introduce group sparsity [13], i.e., eight groups for those layers directly on top of the raw features, and respectively eight, four and two groups for those 11 layers within the jump connections. Third, we use a 11 (but not 33) layer on top of the raw features in the full-resolution column.

3.5 Residual unit removal

Removing part of the layers from top to bottom (those close to the output end) is the conventional way to reuse the features of a pre-trained network. This method works well for classic models, e.g., AlexNets [13] and VGGNets [18], as well as ResNets [10]. Usually, we only remove the top-most layer, which is the linear classifier. Furthermore, we can gradually reduce the computational costs by removing more and more layers, from top to bottom. There is a trade-off, however, in that using fewer layers improves efficiency but removes high-level features.

Veit et al. [20] found that removing one arbitrary residual unit (with identity mappings) from a ResNet had little impact on its performance. Besides, Greff et al. [9] claimed that a group of consecutive residual units can learn an unrolled iterative estimation, supposing that all units (except for the first one) have identity mappings. In other words, subsequent units are iteratively refining the coarse estimation learned by the first unit. Based on these observations, we can safely remove at most 12 of the 16 residual units in the ResNet-50 model [10], since there are only four residual units with non-identity mappings. At the same time, the last of the four units outputs a coarse estimation of the high-level features learned by the original ResNet-50 model. Our empirical results show that this technique steadily reduces the computational costs, but sometimes has an adverse impact on the performance. However, we find it possible to control this side effect using proper training strategies.

Increasing dilations Up-sampling with jump connections Pixel acc. Mean acc. Mean IoU Calculations
1 2 3 4 5 1/321/16 1/161/8 1/8 1/4
95.67 82.61 74.83 786g
95.56 82.07 74.21 256g
95.40 81.64 73.78 165g
Table 1: Results (%) of networks with different configurations of kernel dilations and up-sampling layers on the Cityscapes [6] val set. All of the three models are SharpMask-like. And structure of the third one is given in Fig. 2, which is chosen in this work for efficiency.

4 Experiments

We use the ResNet-50 [10] model to extract features throughout all the experiments. Our implementation was carried out using the MXNet [5] tool-kit. The actual inference speed, especially on GPU cards, may vary largely depending on the implementation details. We thus report the number of multiplication-adds per forward pass instead for the sake of fair comparison.

4.1 Dataset

We evaluate our method using the Cityscapes [6] dataset, which consists of street scene photos taken by vehicle-carried cameras. In total, there are 2,975 labelled images for training, another 500 for validation, i.e., the val set. There are also 1,525 testing images for which the ground-truth labels are kept secret to enable fair evaluation, i.e., the test set. There is also an additional set, consisting of 19,998 coarsely labelled images. Pixels in an image may belong to 1 of 19 semantic categories, including road, car, pedestrian, bicycle, etc. They further belong to seven super-categories, i.e., flat, nature, object, sky, construction, human, and vehicle. All images in this dataset are of the same size, which is very large, i.e., 10242048. On the val set, we report, 1) the pixel accuracy, which is the percentage of correctly labelled pixels on a whole test set, 2) the mean pixel accuracy, which is the mean of class-wise pixel accuracies, and 3) the mean IoU score, which is the mean of class-wise intersection-over-union scores. On the test set, we only report the mean IoU scores.

4.2 Basic FCNs

Table 1 shows results for three different basic FCNs. The structure of the third model is illustrated in Fig. 2, labelled the ‘SharpMask-like FCN’. We predict quarter resolution labels for the best accuracy, according to Wu et al. [21]. Namely, for a 10242048 Cityscapes image, we predict 19 (the number of valid categories) 256512 score maps, and up-sample them back to the original resolution. Our backbone network, i.e., ResNet-50 [10], only calculates 1/32 resolution feature maps. In the literature, there are two approaches to restoring the quarter resolution maps. First, we can add up-sampling layers together with jump connections [15] on top of the features. Alternatively, we can remove the down-sampling operations and accordingly increase the kernel dilation rates in the following convolution layers, i.e., using the hole algorithm [2]. Each approach has its advantages. We can thus use both in the same network, as an intermediate choice. We show how the prediction resolution is increased in the first two groups of columns in Table 1. For example, in the first model, we increase the dilation rate by a factor of two both after the fourth and fifth down-sampling operations (both implemented by convolution layers) in ResNet-50; and then we up-sample the obtained 1/8 resolution feature maps by a factor of two. For all the three networks the added hidden feature layers consistently have 128 33 kernels, which are all applied with dilations so that the receptive fields have sizes around 200. For example, the dilation rates for the three hidden feature layers in the third model are respectively 3, 6 and 12. For the top-most linear classifier, the first network has 19 33 kernels, while the latter two only have 11 kernels.

Table 1 shows that to choose among these models is to compromise between effectiveness and efficiency. Since we aim at a real-time model in this work, the best trade-off is achieved by the third approach, i.e., to use three up-sampling layers with jump connections. We thus build our models using this approach for the following experiments.

4.3 Impact of multi-scaling and fusing

Fusion approach Input resolution Pixel acc. Mean acc. Mean IoU Calculations
1/4 1/2 full 2
max 95.64 83.48 75.34 206g
95.62 82.57 74.30 216g
95.68 82.84 75.16 824g
95.65 83.48 75.21 865g
sum 95.59 82.69 75.20 206g
attention-to-scale 95.64 82.62 75.22 206g
coarse-to-fine (CTF) 95.68 82.94 75.14 206g
sparse coarse-to-fine (SCTF) 95.43 82.37 74.72 206g
improved sparse coarse-to-fine (ISCTF) 95.56 83.76 75.40 212g
Table 2: Results (%) of networks with different input columns and fusion approaches on the Cityscapes [6] val set. Refer to Fig. 3 for structures of the first four fusion approaches; and refer to Fig. 4 for the structures of the latter two. This table shows that it is a good choice to only use half and full-resolution inputs, and that all fusion approaches perform similarly. Refer to Section 4.3 for more details.

We first study the impact of different input columns, with the ‘max’ fusion method, as shown in Table 2. Doubling the input resolution almost quadruples the computational cost, from 206g to 824g, but has no positive impact on the mean IoU score, which goes from 75.34% to 75.16%. Adding another column, with a quarter or double resolution input, does not improve the performance either. Thus, in the following experiments, we use the two-column configuration with half and full-resolution inputs. Although this increases the computational costs by about 25%, from 165g to 206g, we in return achieve better mean IoU scores.

We also find that the previously proposed fusion approaches, i.e., ‘sum’, ‘max’ and ‘attention-to-scale’, perform similarly, which is in contrast to the observations of Chen et al. [4]. This difference probably stems from the different characteristics of the datasets, i.e., Cityscapes [6] vs. PASCAL VOC 2012 [8], and backbone networks, i.e., ResNet-50 [10] vs. VGG-16 [18], which is not our focus in this work.

Besides, our ‘coarse-to-fine’ (CTF) model also performs comparably to the above three approaches. This result suggests that there is no need for the attention model to depend on the full-resolution column, which is the key observation that enables us to speed-up the inference phase by introducing spatial sparsity. In other words, we can skip some local regions of an input image in the full-resolution column to reduce the computational costs. Introducing the spatial sparsity while still testing following the classic inference pipeline, the ‘sparse coarse-to-fine’ (SCTF) approach performs slightly worse than CTF by 0.42%. However, the ‘improved sparse coarse-to-fine’ (ISCTF) approach outperforms CTF by 0.26%. This improvement probably originates from the cross-column connections, which can enhance features in the full-resolution column using those features with relatively long-range context information obtained from the half-resolution column.

4.4 Impact of spatially sparse testing

Table 3 shows that the proposed fast inference approach leads to a significant degradation in performance (about 3%) for SCTF, from 74.72% to 71.74%, due to the boundary problem. However, ISCTF returns consistent results using either classic or fast inference. Although we can specify a target active probability during training, it still is a loose constraint which cannot fix the number of actually activated local regions. Ideally, we should skip an arbitrary number of local regions per image in the full-resolution column, depending on the number of zeros in its generated sparse weight map. However, for implementation convenience, we always skip the same number of regions per image, by applying the winner-take-all strategy. Skipping half of the local regions (16/32), we can consistently reduce the computational costs by about 35% for SCTF, from 206g to 133g, and about 34% for ISCTF, from 212g to 139g.

The remaining notable points about the results in Table 3 are as follows. First, the proposed method consistently outperforms the trivial ‘winner-take-all’ strategy. Second, seems the best setting here. Third, although we can achieve better accuracy with , i.e., 75.40% and 139g. it also seems a good choice to let for efficiency, i.e., 74.74% and 103g, which is the very setting we use in our following experiments. Fourth, using too small local regions (128128) is harmful, since it becomes harder to overcome the boundary problem.

Approach to sparsity Input size Region size Computed Pixel acc. Mean acc. Mean IoU Calc.
sparse coarse-to-fine (SCTF)
sparse activations 10242048 256 16/32 95.08 79.54 71.74 133g
improved sparse coarse-to-fine (ISCTF)
winner-take-all (WTA) 10242048 256 8/32 95.29 80.88 72.59 103g
10242048 256 12/32 95.33 81.89 73.57 121g
10242048 256 16/32 95.33 82.30 74.37 139g
sparse activations 10242048 256 4/32 95.06 80.49 72.26 84.5g
10242048 256 6/32 95.30 81.54 73.04 93.7g
10242048 256 8/32 95.35 83.04 74.74 103g
10242048 256 12/32 95.42 83.49 75.16 121g
10242048 256 16/32 95.53 83.33 74.97 139g
10242048 128 64/128 95.60 83.37 75.02 139g
10242048 256 16/32 95.56 83.76 75.40 139g
10242048 256 16/32 95.54 83.55 75.19 139g
Table 3: Fast inference results (%) of networks with different configurations of spatial sparsity on the Cityscapes [6] val set. Note the drastic drop in accuracy of SCTF compared to the one in Table 2, due to the boundary problem. Besides, the trivial WTA method performs reasonably but is consistently inferior to our method with sparsity constraints to activations. For efficiency, instead of the best performing configuration, i.e., , we next always use the setting. Refer to Section 4.4 for more details.

4.5 Impact of removing residual units

We show the results of networks with different residual units removed in Table 4. For efficiency, we choose relatively aggressive configurations here. Notably, we can remove all units on the top-most level in the full-resolution column. In this case, we also remove the following 11 layer, since there are no feature maps as its input any more. However, this does not cause a fatal problem, probably due to the first cross-column connection. According to the results in Table 4, unit removal has an adverse impact on performance, since it changes the inputs of many units. However, the resulting gaps can be removed by online bootstrapping [21] and adding in the Cityscapes [6] coarse set during training. For those bad performing models with removed units, we find that the generated attention weights for the half-resolution column sometimes dominate. In this case, there is no contribution to the final prediction from the full-resolution column. Probably, we remove units so aggressively in the full resolution column that this column can hardly converge to a reasonable point. In this way, the attention model learns to discard this column and the whole model converges into a bad local minima. However, fortunately our adopted strategies can help the model step out of this local minima. Besides, as listed in the bottom-most row in Table 4, the model trained from scratch performs much worse than its pre-trained counterpart (63.54% vs. 66.12%), which further justifies our method of unit removal.

1 column 1/2 column ISCTF (, ) + online bs. + coarse set Calc.
Removed 1 2 3 4 5 Removed 1 2 3 4 5 Pixel acc. Mean acc. Mean IoU Mean IoU Mean IoU
0 3 4 6 3 0 3 4 6 3 95.38 82.71 73.66 74.40 74.61 77.0g
13 1 1 1 0 6 2 3 4 1 94.89 78.21 69.93 71.30 74.09 33.8g
13 1 1 1 0 6 1 2 5 2 94.72 79.06 70.35 72.52 73.71 33.8g
12 1 1 2 0 8 1 2 4 1 94.70 77.90 69.73 70.65 74.31 31.5g
12 1 1 1 1 8 1 2 4 1 94.68 77.72 69.35 31.3g
13 1 1 1 0 8 1 2 4 1 94.73 77.82 69.63 71.34 29.3g
13 1 1 1 0 10 1 1 3 1 94.34 74.59 66.12 68.53 73.20 24.7g
1 1 1 0 1 1 3 1 93.87 72.63 63.54 65.33 70.73 24.7g
Table 4: Results (%) of networks with different configurations of removed residual units on the Cityscapes [6] val set. All models have the optimized structure shown in Fig. 4. The bottom-most model is trained from scratch. Note the marginal gains of the top-most model (with no unit removed) achieved by online bootstrapping [21] and enlarging training data, compared to those for the remaining ones. This shows that the two adopted strategies can effectively remove the side effect of the unit removal. Refer to Section 4.5 for more details.

4.6 Ablation study

We show the respective costs and contributions of the components in Table 5. On top of the ISCTF model, spatial sparsity together with fast inference reduces 51.4% of the computations costs, but only with a 0.6% loss of accuracy. And network structure optimization further reduces the costs by 25.2%. On top of the ISCTF model trained with online bootstrapping [21] and enlarged training data, our Model A reduces the computational costs by 59.0%, with a 1.03% loss of accuracy. This cost is approximately 25 times less than that of the baseline model, i.e., 31.5g v.s. 786g.

Approach Pixel acc. Mean acc. Mean IoU Overall Calc. Overall
single-column model 95.67 82.61 74.83 786g
two-column models
max 95.64 83.48 75.34 206g
SCTF () 95.43 82.37 74.72 206g
ISCTF () 95.35 83.04 74.74 212g
+ fast inference 103g
+ structure optimizing 95.38 82.71 73.66 77.0g
+ online bootstrapping 95.51 81.93 74.40
+ Cityscapes coarse set 95.53 83.50 74.61
Model A: 1-1-2-0-1-2-4-1 95.46 82.91 74.31 31.5g
Table 5: Results (%) of ablation study and comparison with our implemented baseline single-column model (doubling the dilation factor twice and up-sampling with jump connections only once as listed in Table 1) on the Cityscapes [6] val set.

4.7 Comparison with previous methods

We compare with previous methods in the literature, especially those with inference speed reported, as listed in Table 6. Here, our reported speed is obtained using the built-in profiler of MXNet [5], evaluated using a PC having one i7-4790 CPU and one Geforce GTX 980 video card installed with CUDA 8.0 and cuDNN 5.1. Among the (almost) real-time approaches, our method outperforms the previous best one with a clear margin, i.e., 14.6%. There is a concurrent work to ours released via arXiv (labelled ICNet by Zhao et al. [22]), which is similar to our model in the sense that it also follows a multi-column structure. However, we here rely on spatial sparsity and the new style of removing units, which were not present in their work. Besides, they also applied model compression, which may be a complementary technique to our method.

Method mean IoU Time Speed (fps)
FCN-8s [15] 65.3% 500ms 2.0
DeepLab-v2 [3] 71.4% 625ms 1.6
RefineNet [14] 73.6% 0.9
PSPNet [23] 80.2% 0.5
SegNet [1] 57.0% 60ms 16.7
ENet [16] 58.3% 13ms 76.9
Ours 72.9% 68ms 14.7
Table 6: Comparison with previous best performers on the Cityscapes [6] test set, especially those with inference speeds reported. Note that the speeds are only for reference, since the implementation details vary significantly between different works.

4.8 Qualitative results

We show qualitative results in Fig. 5. An example of the boundary problem discussed in Section 3.4 is shown in the second row. Due to lack of context information, the SCTF model failed to identify some pixels inside the yellow car, while the ISCTF model is able to figure it out. We also show two examples of the activated local regions in the full-resolution column in the third row. These are reasonably activated regions, since there usually are small pedestrians or vehicles around them, which require being processed in high resolutions. To skip as many regions as possible (for efficiency), the left case may be preferable. Since the regions have smaller sizes, we can more accurately locate the hard regions. However, on the other hand, using smaller regions may aggravate the boundary problem.

Figure 5: Qualitative results. Second row: Comparison between SCTF and ISCTF, showing the boundary problem due to insufficient contexts. Third row: Actually computed local regions in the full-resolution column. Better viewed in colour.

5 Conclusion

We in this work have proposed a real-time and accurate approach to semantic image segmentation. To this end, we have introduced spatial sparsity into a carefully-tailored two-column network, and studied the impact of removing residual units to the performance of our method. Finally, we have achieved a 25 times reduction of computational costs, only for a 2.0% loss of accuracy on the Cityscapes val set.