Panoptic Feature Pyramid Networks

01/08/2019 ∙ by Alexander Kirillov, et al. ∙ 10

The recently introduced panoptic segmentation task has renewed our community's interest in unifying the tasks of instance segmentation (for thing classes) and semantic segmentation (for stuff classes). However, current state-of-the-art methods for this joint task use separate and dissimilar networks for instance and semantic segmentation, without performing any shared computation. In this work, we aim to unify these methods at the architectural level, designing a single network for both tasks. Our approach is to endow Mask R-CNN, a popular instance segmentation method, with a semantic segmentation branch using a shared Feature Pyramid Network (FPN) backbone. Surprisingly, this simple baseline not only remains effective for instance segmentation, but also yields a lightweight, top-performing method for semantic segmentation. In this work, we perform a detailed study of this minimally extended version of Mask R-CNN with FPN, which we refer to as Panoptic FPN, and show it is a robust and accurate baseline for both tasks. Given its effectiveness and conceptual simplicity, we hope our method can serve as a strong baseline and aid future research in panoptic segmentation.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 2

page 8

Code Repositories

panoptic-fpn-gluon

Panoptic Feature Pyramid Networks


view repo

FPN-Semantic-segmentation

use FPN to FPN-Semantic-segmentation。pytorch version


view repo

amenity-detection

aminity-detection


view repo
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

Our community has witnessed rapid progress in semantic segmentation, where the task is to assign each pixel a class label (e.g. for stuff classes), and more recently in instance segmentation, where the task is to detect and segment each object instance (e.g. for thing classes). These advances have been aided by simple yet powerful baseline methods, including Fully Convolutional Networks (FCN) [39] and Mask R-CNN [23] for semantic and instance segmentation, respectively. These methods are conceptually simple, fast, and flexible, serving as a foundation for much of the subsequent progress in these areas. In this work our goal is to propose a similarly simple, single-network baseline for the joint task of panoptic segmentation [29], a task which encompasses both semantic and instance segmentation.

Figure 1: Panoptic FPN: (a) We start with an FPN backbone [34], widely used in object detection, for extracting rich multi-scale features. (b) As in Mask R-CNN [23], we use a region-based branch on top of FPN for instance segmentation. (c) In parallel, we add a lightweight dense-prediction branch on top of the same FPN features for semantic segmentation. This simple extension of Mask R-CNN with FPN is a fast and accurate baseline for both tasks.

While conceptually straightforward, designing a single network that achieves high accuracy for both tasks is challenging as top-performing methods for the two tasks have many differences. For semantic segmentation, FCNs with specialized backbones enhanced by dilated convolutions [55, 10] dominate popular leaderboards [17, 14]. For instance segmentation, the region-based Mask R-CNN [23] with a Feature Pyramid Network (FPN) [34] backbone has been used as a foundation for all top entries in recent recognition challenges [35, 58, 41]. While there have been attempts to unify semantic and instance segmentation [44, 1, 9], the specialization currently necessary to achieve top performance in each was perhaps inevitable given their parallel development and separate benchmarks.

Figure 2: Panoptic FPN results on COCO (top) and Cityscapes (bottom) using a single ResNet-101-FPN network.

Given the architectural differences in these top methods, one might expect compromising accuracy on either instance or semantic segmentation is necessary when designing a single network for both tasks. Instead, we show a simple, flexible, and effective architecture that can match accuracy for both tasks using a single network that simultaneously generates region-based outputs (for instance segmentation) and dense-pixel outputs (for semantic segmentation).

Our approach starts with the FPN [34] backbone popular for instance-level recognition [23] and adds a branch for performing semantic segmentation in parallel with the existing region-based branch for instance segmentation, see Figure 1. We make no changes to the FPN backbone when adding the dense-prediction branch, making it compatible with existing instance segmentation methods. Our method, which we call Panoptic FPN for its ability to generate both instance and semantic segmentations via FPN, is easy to implement given the Mask R-CNN framework [22].

While Panoptic FPN is an intuitive extension of Mask R-CNN with FPN, properly training the two branches for simultaneous region-based and dense-pixel prediction is important for good results. We perform careful studies in the joint setting for how to balance the losses for the two branches, construct minibatches effectively, adjust learning rate schedules, and perform data augmentation. We also explore various designs for the semantic segmentation branch (all other network components follow Mask R-CNN). Overall, while our approach is robust to exact design choices, properly addressing these issues is key for good results.

When trained for each task independently, our method achieves excellent results for both instance and semantic segmentation on both COCO [35] and Cityscapes [14]. For instance segmentation, this is expected as our method in this case is equivalent to Mask R-CNN. For semantic segmentation, our simple dense-prediction branch attached to FPN yields accuracy on par with the latest dilation-based methods, such as the heavily-engineered DeepLabV3+ [12].

For panoptic segmentation [29], we demonstrate that with proper training, using a single FPN for solving both tasks simultaneously yields accuracy equivalent to training two separate FPNs, with essentially half the compute. With the same compute, a joint network for the two tasks outperforms two independent networks by a healthy margin. Example panoptic segmentation results are shown in Fig. 2.

Panoptic FPN is memory and computationally efficient, incurring only a slight overhead over Mask R-CNN. By avoiding the use of dilation, which has high overhead, our method can use any standard top-performing backbone (e.g. a large ResNeXt [53]). We believe this flexibility, together with the fast training and inference speeds of our method, will benefit future research on panoptic segmentation.

We used a preliminary version of our model (semantic segmentation branch only) as the foundation of the first-place winning entry in the COCO Stuff Segmentation [6] track in 2017. This single-branch model has since been adopted and generalized by several entries in the 2018 COCO and Mapillary Challenges, showing its flexibility and effectiveness. We hope our proposed joint panoptic segmentation baseline is similarly impactful.

2 Related Work

Panoptic segmentation:

The joint task of thing and stuff segmentation has a rich history, including early work on scene parsing [49], image parsing [50]

, and holistic scene understanding 

[54]. With the recent introduction of the joint panoptic segmentation task [29], which includes a simple task specification and carefully designed task metrics, there has been a renewed interest in the joint task.

This year’s COCO and Mapillary Recognition Challenge [35, 41] featured panoptic segmentation tracks that proved popular. However, every competitive entry in the panoptic challenges used separate networks for instance and semantic segmentation, with no shared computation.111For details of not yet published winning entries in the 2018 COCO and Mapillary Recognition Challenge please see: http://cocodataset.org/workshop/coco-mapillary-eccv-2018.html. TRI-ML used separate networks for the challenge but a joint network in their recent updated tech report [32] (which cites a preliminary version of our work). Our goal is to design a single network effective for both tasks that can serve as a baseline for future work.

Instance segmentation:

Region-based approaches to object detection, including the Slow/Fast/Faster/Mask R-CNN family [21, 20, 46, 23], which apply deep networks on candidate object regions, have proven highly successful. All recent winners of the COCO detection challenges have built on Mask R-CNN [23] with FPN [34], including in 2017 [37, 43] and 2018. Recent innovations include Cascade R-CNN [7], deformable convolution [15], and sync batch norm [43]. In this work, the original Mask R-CNN with FPN serves as the starting point for our baseline, giving us excellent instance segmentation performance, and making our method fully compatible with these recent advances.

An alternative to region-based instance segmentation is to start with a pixel-wise semantic segmentation and then perform grouping to extract instances [30, 36, 1]. This direction is innovative and promising. However, these methods tend to use separate networks to predict the instance-level information (e.g., [30, 1, 36] use a separate network to predict instance edges, bounding boxes, and object breakpoints, respectively). Our goal is to design a single network for the joint task. Another interesting direction is to use position-sensitive pixel labeling [33] to encode instance information fully convolutionally; [44, 9] build on this.

Nevertheless, region-based approaches remain dominant on detection leaderboards [35, 58, 41]. While this motivates us to start with a region-based approach to instance segmentation, our approach would be fully compatible with a dense-prediction branch for instance segmentation.

Semantic segmentation:

FCNs [39] serve as the foundation of modern semantic segmentation methods. To increase feature resolution, which is necessary for generating high-quality results, recent top methods [12, 56, 5, 57] rely heavily on the use of dilated convolution [55] (also known as atrous convolution [10]). While effective, such an approach can substantially increase compute and memory, limiting the type of backbone network that can be used. To keep this flexibility, and more importantly to maintain compatibility with Mask R-CNN, we opt for a different approach.

As an alternative to dilation, an encoder-decoder [2] or ‘U-Net’ [47] architecture can be used to increase feature resolution [25, 42, 19, 45]. Encoder-decoders progressively upsample and combine high-level features from a feedforward network with features from lower-levels, ultimately generating semantically meaningful, high-resolution features (see Figure 5). While dilated networks are currently more popular and dominate leaderboards, encoder-decoders have also been used for semantic segmentation [47, 2, 19].

In our work we adopt an encoder-decoder framework, namely FPN [34]. In contrast to ‘symmetric’ decoders [47], FPN uses a lightweight decoder (see Fig. 5). FPN was designed for instance segmentation, and it serves as the default backbone for Mask R-CNN. We show that without changes, FPN can also be highly effective for semantic segmentation.

Multi-task learning:

Our approach is related to multi-task learning. In general, using a single network to solve multiple diverse tasks degrades performance [31], but various strategies can mitigate this [28, 40]. For related tasks, there can be gains from multi-task learning, e.g. the box branch in Mask R-CNN benefits from the mask branch [23], and joint detection and semantic segmentation of thing classes also shows gains [3, 8, 16, 44]. Our work studies the benefits of multi-task training for stuff and thing segmentation.

3 Panoptic Feature Pyramid Network

Our approach, Panoptic FPN, is a simple, single-network baseline whose goal is to achieve top performance on both instance and semantic segmentation, and their joint task: panoptic segmentation [29]. Our design principle is to start from Mask R-CNN with FPN, a strong instance segmentation baseline, and make minimal changes to also generate a semantic segmentation dense-pixel output (see Figure 1).

3.1 Model Architecture

Feature Pyramid Network:

We begin by briefly reviewing FPN [34]. FPN takes a standard network with features at multiple spatial resolutions (e.g., ResNet [24]), and adds a light top-down pathway with lateral connections, see Figure 1a. The top-down pathway starts from the deepest layer of the network and progressively upsamples it while adding in transformed versions of higher-resolution features from the bottom-up pathway. FPN generates a pyramid, typically with scales from 1/32 to 1/4 resolution, where each pyramid level has the same channel dimension (256 by default).

Instance segmentation branch:

The design of FPN, and in particular the use of the same channel dimension for all pyramid levels, makes it easy to attach a region-based object detector like Faster R-CNN [46]. Faster R-CNN performs region of interest (RoI) pooling on different pyramid levels and applies a shared network branch to predict a refined box and class label for each region. To output instance segmentations, we use Mask R-CNN [23], which extends Faster R-CNN by adding an FCN branch to predict a binary segmentation mask for each candidate region, see Figure 1b.

Panoptic FPN:

As discussed, our approach is to modify Mask R-CNN with FPN to enable pixel-wise semantic segmentation prediction. However, to achieve accurate predictions, the features used for this task should: (1) be of suitably high resolution to capture fine structures, (2) encode sufficiently rich semantics to accurately predict class labels, and (3) capture multi-scale information to predict stuff regions at multiple resolutions. Although FPN was designed for object detection, these requirements – high-resolution, rich, multi-scale features – identify exactly the characteristics of FPN. We thus propose to attach to FPN a simple and fast semantic segmentation branch, described next.

Figure 3: Semantic segmentation branch. Each FPN level (left) is upsampled by convolutions and bilinear upsampling until it reaches 1/4 scale (right), theses outputs are then summed and finally transformed into a pixel-wise output.

Semantic segmentation branch:

To generate the semantic segmentation output from the FPN features, we propose a simple design to merge the information from all levels of the FPN pyramid into a single output. It is illustrated in detail in Figure 3. Starting from the deepest FPN level (at 1/32 scale), we perform three upsampling stages to yield a feature map at 1/4 scale, where each upsampling stage consists of 33 convolution, group norm [52]

, ReLU, and 2

 bilinear upsampling. This strategy is repeated for FPN scales 1/16, 1/8, and 1/4 (with progressively fewer upsampling stages). The result is a set of feature maps at the same 1/4 scale, which are then element-wise summed. A final 11 convolution, 4 bilinear upsampling, and softmax are used to generate the per-pixel class labels at the original image resolution. In addition to stuff classes, this branch also outputs a special ‘other’ class for all pixels belonging to objects (to avoid predicting stuff classes for such pixels).

Implementation details:

We use a standard FPN configuration with 256 output channels per scale, and our semantic segmentation branch reduces this to 128 channels. For the (pre-FPN) backbone, we use ResNet/ResNeXt [24, 53]

models pre-trained on ImageNet 

[48] using batch norm (BN) [27]. When used in fine-tuning, we replace BN with a fixed channel-wise affine transformation, as is typical [24].

3.2 Inference and Training

Panoptic inference:

The panoptic output format [29] requires each output pixel to be assigned a single class label (or void) and instance id (the instance id is ignored for stuff classes). As the instance and semantic segmentation outputs from Panoptic FPN may overlap; we apply the simple post-processing proposed in [29] to resolve all overlaps. This post-processing is similar in spirit to non-maximum suppression and operates by: (1) resolving overlaps between different instances based on their confidence scores, (2) resolving overlaps between instance and semantic segmentation outputs in favor of instances, and (3) removing any stuff regions labeled ‘other’ or under a given area threshold.

Figure 4: Backbone architecture efficiency. We compare methods for increasing feature resolution for semantic segmentation, including dilated networks, symmetric decoders, and FPN, see Figure 5. We count multiply-adds and memory used when applying ResNet-101 to a 2 megapixel image. FPN at output scale 1/4 is similar computationally to dilation-16 (1/16 resolution output), but produces a 4 higher resolution output. Increasing resolution to 1/8 via dilation uses a further 3 more compute and memory.
Figure 5: Backbone architectures for increasing feature resolution. (a) A standard convolutional network (dimensions are denoted as #blocks#channels

resolution). (b) A common approach is to reduce the stride of select convolutions and use dilated convolutions after to compensate. (c) A U-Net 

[47] style network uses a symmetric decoder that mirrors the bottom-up pathway, but in reverse. (d) FPN can be seen as an asymmetric, lightweight decoder whose top-down pathway has only one block per stage and uses a shared channel dimension. For a comparison of the efficiency of these models, please see Figure 4.

Joint training:

During training the instance segmentation branch has three losses [23]: (classification loss), (bounding-box loss), and (mask loss). The total instance segmentation loss is the sum of these losses, where and are normalized by the number of sampled RoIs and is normalized by the number of foreground RoIs. The semantic segmentation loss, , is computed as a per-pixel cross entropy loss between the predicted and the ground-truth labels, normalized by the number of labeled image pixels.

We have observed that the losses from these two branches have different scales and normalization policies. Simply adding them degrades the final performance for one of the tasks. This can be corrected by a simple loss re-weighting between the total instance segmentation loss and the semantic segmentation loss. Our final loss is thus: . By tuning and it is possible to train a single model that is comparable to two separate task-specific models, but at about half the compute.

3.3 Analysis

Our motivation for predicting semantic segmentation using FPN is to create a simple, single-network baseline that can perform both instance and semantic segmentation. However, it is also interesting to consider the memory and computational footprint of our approach relative to model architectures popular for semantic segmentation. The most common designs that produce high-resolution outputs are dilated convolution (Figure 5b) and symmetric encoder-decoder models that have a mirror image decoder with lateral connections (Figure 5c). While our primary motivation is compatibility with Mask R-CNN, we note that FPN is much lighter than a typically used dilation-8 network, 2 more efficient than the symmetric encoder-decoder, and roughly equivalent to a dilation-16 network (while producing a 4 higher resolution output). See Figure 4.

4 Experiments

Our goal is to demonstrate that our approach, Panoptic FPN, can serve as a simple and effective single-network baseline for instance segmentation, semantic segmentation, and their joint task of panoptic segmentation [29]. For instance segmentation, this is expected, since our approach extends Mask R-CNN with FPN. For semantic segmentation, as we simply attach a lightweight dense-pixel prediction branch (Figure 3) to FPN, we need to demonstrate it can be competitive with recent methods. Finally, we must show that Panoptic FPN can be trained in a multi-task setting without loss in accuracy on the individual tasks.

We therefore begin our analysis by testing our approach for semantic segmentation (we refer to this single-task variant as Semantic FPN). Surprisingly, this simple model achieves competitive semantic segmentation results on the COCO [35] and Cityscapes [14] datasets. Next, we analyze the integration of the semantic segmentation branch with Mask R-CNN, and the effects of joint training. Lastly, we show results for panoptic segmentation, again on COCO and Cityscapes. Qualitative results are shown in Figures 2 and 6. We describe the experimental setup next.

4.1 Experimental Setup

Coco:

The COCO dataset [35] was developed with a focus on instance segmentation, but more recently stuff annotations were added [6]. For instance segmentation, we use the 2017 data splits with 118k/5k/20k train/val/test images and 80 thing classes. For semantic segmentation, we use the 2017 stuff data with 40k/5k/5k splits and 92 stuff classes. Finally, panoptic segmentation [29] uses all 2017 COCO images with 80 thing and 53 stuff classes annotated.

Cityscapes:

Cityscapes [14] is an ego-centric street-scene dataset. It has 5k high-resolution images (10242048 pixels) with fine pixel-accurate annotations: 2975 train, 500 val, and 1525 test. An additional 20k images with coarse annotations are available, we do not use these in our experiments. There are 19 classes, 8 with instance-level masks.

Single-task metrics:

We report standard semantic and instance segmentation metrics for the individual tasks using evaluation code provided by each dataset. For semantic segmentation, the mIoU (mean Intersection-over-Union) [17] is the primary metric on both COCO and Cityscapes. We also report fIoU (frequency weighted IoU) on COCO [6] and iIoU (instance-level IoU) on Cityscapes [14]. For instance segmentation, AP (average precision averaged over categories and IoU thresholds) [35] is the primary metric and AP and AP are selected supplementary metrics.

Panoptic segmentation metrics:

We use PQ (panoptic quality) as the default metric to measure Panoptic FPN performance, for details see [29]. PQ captures both recognition and segmentation quality, and treats both stuff and thing categories in a unified manner. This single, unified metric allows us to directly compare methods. Additionally, we use PQSt and PQTh to report stuff and thing performance separately. Note that PQ is used to evaluate Panoptic FPN predictions after the post-processing merging procedure is applied to the outputs of the semantic and instance branches.

COCO training:

We use the default Mask R-CNN 1 training setting [22] with scale jitter (shorter image side in [640, 800]). For semantic segmentation, we predict 53 stuff classes plus a single ‘other’ class for all 80 thing classes.

Cityscapes training:

We construct each minibatch from 32 random 5121024 image crops (4 crops per GPU) after randomly scaling each image by 0.5 to 2.0. We train for 65k iterations starting with a learning rate of 0.01 and dropping it by a factor of 10 at 40k and 55k iterations. This differs from the original Mask R-CNN setup [23] but is effective for both instance and semantic segmentation. For the largest backbones for semantic segmentation, we perform color augmentation [38] and crop bootstrapping [5]

. For semantic segmentation, predicting all thing classes, rather than a single ‘other’ label, performs better (for panoptic inference we discard these predictions). Due to the high variance of the mIoU (up to 0.4), we report the median performance of 5 trials of each experiment on Cityscapes.

backbone mIoU FLOPs memory
DeeplabV3 [11] ResNet-101-D8 77.8 1.9 1.9
PSANet101 [57] ResNet-101-D8 77.9 2.0 2.0
Mapillary [5] WideResNet-38-D8 79.4 4.3 1.7
DeeplabV3+ [12] X-71-D16 79.6 0.5 1.9
Semantic FPN ResNet-101-FPN 77.7 0.5 0.8
Semantic FPN ResNeXt-101-FPN 79.1 0.8 1.4
(a) Cityscapes Semantic FPN. Performance is reported on the val set and all methods use only fine Cityscapes annotations for training. The backbone notation includes the dilated resolution ‘D’ (note that [12] uses both dilation and an encoder-decoder backbone). All top-performing methods other than ours use dilation. FLOPs (multiply-adds ) and memory (# activations ) are approximate but informative. For these larger FPN models we use color and crop augmentation at train time. Our baseline is comparable to state-of-the-art methods in accuracy and efficiency.
backbone mIoU fIoU
Vllab [13] Stacked Hourglass 12.4 38.8
DeepLab VGG16 [10] VGG-16 20.2 47.5
Oxford [4] ResNeXt-101 24.1 50.6
G-RMI [18] Inception ResNet v2 26.6 51.9
Semantic FPN ResNeXt-152-FPN 28.8 55.7
(b) COCO-Stuff 2017 Challenge results. We submitted an early version of Semantic FPN to the 2017 COCO Stuff Segmentation Challenge held at ECCV (http://cocodataset.org/#stuff-2017). Our entry won first place without ensembling, and we outperformed competing methods by at least a 2 point margin on all reported metrics.
Width Cityscapes COCO
64 74.1 39.6
128 74.5 40.2
256 74.6 40.1
(c) Ablation (mIoU): Channel width of 128 for the features in the semantic branch strikes a good balance between accuracy and efficiency.
Aggr. Cityscapes COCO
Sum 74.5 40.2
Concat 74.4 39.9
(d) Ablation (mIoU): Sum aggregation of the feature maps in the semantic branch is marginally better and is more efficient.
Table 1: Semantic Segmentation using FPN.
mIoU AP AP AP PQTh
0.0 - 33.9 55.6 35.9 46.6
0.1 37.2 34.0 55.6 36.0 46.8
0.25 39.6 33.7 55.3 35.5 46.1
0.5 41.0 33.3 54.9 35.2 45.9
0.75 41.1 32.6 53.9 34.6 45.0
1.0 41.5 32.1 53.2 33.6 44.6
+0.1 +0.0 +0.1 +0.2
(a) Panoptic FPN on COCO for instance segmentation ().
mIoU AP AP PQTh
0.0 - 32.2 58.7 51.3
0.1 68.3 32.5 59.2 52.9
0.25 71.8 32.8 59.6 52.7
0.5 72.0 32.7 59.5 52.9
0.75 73.4 32.8 58.8 52.3
1.0 74.2 33.2 59.7 52.4
+1.0 +1.0 +1.1
(b) Panoptic FPN on Cityscapes for instance segmentation ().
AP mIoU fIoU PQSt
0.0 - 40.2 67.2 27.9
0.1 20.1 40.6 67.5 28.4
0.25 25.5 41.0 67.8 28.6
0.5 29.2 41.3 68.0 28.9
0.75 30.8 41.1 68.2 28.9
1.0 32.1 41.5 68.2 29.0
+1.2 +1.0 +1.1
(c) Panoptic FPN on COCO for semantic segmentation ().
AP mIoU iIoU PQSt
0.0 - 74.5 55.8 62.4
0.1 27.4 75.3 57.6 62.5
0.25 30.5 75.5 58.3 62.5
0.5 32.0 75.0 58.2 62.2
0.75 32.6 74.3 58.2 61.7
1.0 33.2 74.2 57.4 61.4
+1.0 +2.5 +0.1
(d) Panoptic FPN on Cityscapes for semantic segmentation ().
Table 2: Multi-Task Training: (a,b) Adding a semantic segmentation branch can slightly improve instance segmentation results over a single-task baseline with properly tuned (results bolded). Note that indicates the weight assigned to the semantic segmentation loss and serves as the single-task baseline. (c,d) Adding an instance segmentation branch can provide even stronger benefits for semantic segmentation over a single-task baseline with properly tuned (results bolded). As before, indicates the weight assigned to the instance segmentation loss and serves as the single-task baseline. While promising, we are more interested in the joint task, for which results are shown in Table 3.
backbone AP PQTh mIoU PQSt PQ
COCO R50-FPN2 33.9 46.6 40.2 27.9 39.2
R50-FPN 33.3 45.9 41.0 28.7 39.0
-0.6 -0.7 +0.8 +0.8 -0.2
Cityscapes R50-FPN2 32.2 51.3 74.5 62.4 57.7
R50-FPN 32.0 51.6 75.0 62.2 57.7
-0.2 +0.3 +0.5 -0.2 +0.0
(a) Panoptic Segmentation: Panoptic R50-FPN vs. R50-FPN2. Using a single FPN network for solving both tasks simultaneously yields comparable accuracy to two independent FPN networks for instance and semantic segmentation, respectively, but with half the compute.
backbone AP PQTh mIoU PQSt PQ
COCO R50-FPN2 33.9 46.6 40.2 27.9 39.2
R101-FPN 35.2 47.5 42.1 29.5 40.3
+1.3 +0.9 +1.9 +1.6 +1.1
Cityscapes R50-FPN2 32.2 51.3 74.5 62.4 57.7
R101-FPN 33.0 52.0 75.7 62.5 58.1
+0.8 +0.7 +1.3 +0.1 +0.4
(b) Panoptic Segmentation: Panoptic R101-FPN vs. R50-FPN2. Given a roughly equal computational budget, a single FPN network for the panoptic task outperforms two independent FPN networks for instance and semantic segmentation by a healthy margin.
loss AP PQTh mIoU PQSt PQ
COCO alternate 31.7 43.9 40.2 28.0 37.5
combine 33.3 45.9 41.0 28.7 39.0
+1.6 +2.0 +0.8 +0.7 +1.5
Cityscapes alternate 32.0 51.4 74.3 61.3 57.4
combine 32.0 51.6 75.0 62.2 57.7
+0.0 +0.2 +0.7 +0.9 +0.3
(c) Training Panoptic FPN. During training, for each minibatch we can either combine the semantic and instances loss or we can alternate which loss we compute (in the latter case we train for twice as long). We find that combining the losses in each minibatch performs much better.
FPN AP PQTh mIoU PQSt PQ
COCO original 33.3 45.9 41.0 28.7 39.0
grouped 33.1 45.7 41.2 28.4 38.8
-0.2 -0.2 +0.2 -0.3 -0.2
Cityscapes original 32.0 51.6 75.0 62.2 57.7
grouped 32.0 51.8 75.3 61.7 57.5
+0.0 +0.2 +0.3 -0.5 -0.2
(d) Grouped FPN. We test a variant of Panoptic FPN where we group the 256 FPN channels into two sets and apply the instance and semantic branch to its own dedicated group of 128. While this gives mixed gains, we expect better multi-task strategies can improve results.
Table 3: Panoptic FPN Results.

4.2 FPN for Semantic Segmentation

Cityscapes:

We start by comparing our baseline Semantic FPN to existing methods on the Cityscapes val split in Table (a)a. We compare to recent top-performing methods, but not to competition entires which typically use ensembling, COCO pre-training, test-time augmentation, and so on. Our approach, which is a minimal extension to FPN, is able to achieve strong results compared to heavily engineered systems like DeepLabV3+ [12], which have undergone many design iterations. In our baseline we deliberately avoid orthogonal architecture improvements like Non-local [51] or SE [26] which would likely yield further gains. In terms of compute and memory, Semantic FPN is lighter than typical dilation models, while yielding higher resolution features (see also Figure 4). Overall, these results demonstrate that our approach is a strong baseline for semantic segmentation.

Coco:

An earlier version of our approach won the 2017 COCO-Stuff challenge. Results are reported in Table (b)b. As this was an early design, the the semantic branch differed slightly (each upsampling module had two 33 conv layers and ReLU before bilinear upscaling to the final resolution, and features were concatenated instead of summed, please compare with Figure 3). As we will show in the ablations shortly, results are fairly robust to the exact branch design. Our competition entry was trained with color augmentation [38] and at test time balanced the class distribution and used multi-scale inference. Finally, we note that at the time we used a training schedule specific to semantic segmentation similar to our Cityscapes schedule (but with double learning rate and halved batch size).

Ablations:

We perform a few ablations to analyze our proposed semantic segmentation branch (shown in Figure 3). For consistency with further experiments in our paper, we use stuff annotations from the COCO Panoptic dataset (which as discussed differ from those used for the COCO Stuff competition). Table (c)c shows ResNet-50 Semantic FPN with varying number of channels in the semantic branch. We found that 128 strikes a good balance between accuracy and efficiency. In Table (d)d we compare element-wise sum and concatenation for aggregating feature maps from different FPN levels. While accuracy for both is comparable, summation is more efficient. Overall we observe that the simple architecture of the new dense-pixel labelling branch is robust to exact design choices.

4.3 Multi-Task Training

Single-task performance of our approach is quite effective; for semantic segmentation the results in the previous section demonstrate this, for instance segmentation this is known as we start from Mask R-CNN. However, can we jointly train for both tasks in a multi-task setting?

To combine our semantic segmentation branch with the instance segmentation branch in Mask R-CNN, we need to determine how to train a single, unified network. Previous work demonstrates that multi-task training is often challenging and can lead to degraded results [31, 28]. We likewise observe that for semantic or instance segmentation, adding the secondary task can degrade the accuracy in comparison with the single-task baseline.

In Table 2 we show that with ResNet-50-FPN, using a simple loss scaling weight on the semantic segmentation loss, , or instance segmentation loss, , we can obtain a re-weighting that improves results over single-task baselines. Specifically, adding a semantic segmentation branch with the proper improves instance segmentation, and vice-versa. This can be exploited to improve single-task results. However, our main goal is to solve both tasks simultaneously, which we explore in the next section.

Figure 6: More Panoptic FPN results on COCO (top) and Cityscapes (bottom) using a single ResNet-101-FPN network.
PQ PQTh PQSt
Artemis 16.9 16.8 17.0
LeChen 26.2 31.0 18.9
MPS-TU Eindhoven 27.2 29.6 23.4
MMAP-seg 32.1 38.9 22.0
Panoptic FPN 40.9 48.3 29.7
(a) Panoptic Segmentation on COCO test-dev. We submit Panoptic FPN to the COCO test-dev leaderboard (for details on competing entries, please see http://cocodataset.org/#panoptic-leaderboard). We only compare to entires that use a single network for the joint task. We do not compare to competition-level entires that utilize ensembling (including methods that ensemble separate networks for semantic and instance segmentation). For methods that use one network for panoptic segmentation, our approach improves PQ by an 9 point margin.
PQ PQTh PQSt mIoU AP
DIN [1] 53.8 42.5 62.1 - 28.6
Panoptic FPN 58.1 52.0 62.5 75.7 33.0
(b) Panoptic Segmentation on Cityscapes. For Cityscapes, there is no public leaderboard for panoptic segmentation at this time. Instead, we compare on val to the recent work of Arnab and Torr [1] who develop a novel approach for panoptic segmentation, named DIN. DIN is representative of alternatives to region-based instance segmentation that start with a pixel-wise semantic segmentation and then perform grouping to extract instances (see the related work for a discussion). Panoptic FPN, without any bells and whistles, outperforms DIN by a 4.3 point PQ margin.
Table 4: Comparisons of ResNet-101 Panoptic FPN to the state of the art.

4.4 Panoptic FPN

We now turn to our main result: testing Panoptic FPN for the joint task of panoptic segmentation [29], where the network must jointly and accurately output stuff and thing segmentations. For the following experiments, for each setting we select the optimal and from

, ensuring that results are not skewed by fixed choice of

’s.

Main results:

In Table (a)a we compare two networks trained separately with Panoptic FPN using the same backbone. Panoptic FPN yields comparable performance but with half the compute. We also balance computational budgets by comparing two separate networks with ResNet-50 backbones each and Panoptic FPN with ResNet-101, see Table (b)b. Using roughly equal computational budget, Panoptic FPN significantly outperforms two separate networks. Taken together, these results demonstrate that the joint approach is strictly beneficial, and that our Panoptic FPN can serve as a solid baseline for the joint task.

Ablations:

We perform additional ablations on Panoptic FPN with ResNet-50. First, by default, we combine the instance and semantic losses together during each gradient update. A different strategy is to alternate the losses on each iteration (this may be useful as different augmentation strategies can be used for the two tasks). We compare these two options in Table (c)c; the combined loss demonstrates better performance. Next, in Table (d)d we compare with an architecture where FPN channels are grouped into two sets, and each task uses one of the two features sets as its input. While the results are mixed, we expect more sophisticated multi-task approaches could give stronger gains.

Comparisons:

We conclude by comparing Panoptic FPN with existing methods. For these experiments, we use Panoptic FPN with a ResNet-101 backbone and without bells-and-whistles. In Table (a)a we show that Panoptic FPN substantially outperforms all single-model entries in the recent COCO Panoptic Segmentation Challenge. This establishes a new baseline for the panoptic segmentation task. On Cityscapes, we compare Panoptic FPN with an approach for panoptic segmentation recently proposed in [1] in Table (b)b. Panoptic FPN outperforms [1] by a 4.3 point PQ margin.

5 Conclusion

We introduce a conceptually simple yet effective baseline for panoptic segmentation. The method starts with Mask R-CNN with FPN and adds to it a lightweight semantic segmentation branch for dense-pixel prediction. We hope it can serve as a strong foundation for future research.

References

  • [1] A. Arnab and P. H. Torr. Pixelwise instance segmentation with a dynamically instantiated network. In CVPR, 2017.
  • [2] V. Badrinarayanan, A. Kendall, and R. Cipolla. Segnet: A deep convolutional encoder-decoder architecture for image segmentation. arXiv:1511.00561, 2015.
  • [3] S. Bell, C. Lawrence Zitnick, K. Bala, and R. Girshick.

    Inside-outside net: Detecting objects in context with skip pooling and recurrent neural networks.

    In CVPR, 2016.
  • [4] P. Bilinski and V. Prisacariu. COCO-Stuff 2017 Challenge: Oxford Active Vision Lab team. 2017.
  • [5] S. R. Bulò, L. Porzi, and P. Kontschieder. In-place activated batchnorm for memory-optimized training of DNNs. In CVPR, 2018.
  • [6] H. Caesar, J. Uijlings, and V. Ferrari. COCO-Stuff: Thing and stuff classes in context. In CVPR, 2018.
  • [7] Z. Cai and N. Vasconcelos. Cascade R-CNN: Delving into high quality object detection. In CVPR, 2018.
  • [8] J. Cao, Y. Pang, and X. Li. Triply supervised decoder networks for joint detection and segmentation. arXiv preprint arXiv:1809.09299, 2018.
  • [9] L.-C. Chen, A. Hermans, G. Papandreou, F. Schroff, P. Wang, and H. Adam. MaskLab: Instance segmentation by refining object detection with semantic and direction features. In CVPR, 2018.
  • [10] L.-C. Chen, G. Papandreou, I. Kokkinos, K. Murphy, and A. L. Yuille. DeepLab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. arXiv:1606.00915, 2016.
  • [11] L.-C. Chen, G. Papandreou, F. Schroff, and H. Adam. Rethinking atrous convolution for semantic image segmentation. arXiv:1706.05587, 2017.
  • [12] L.-C. Chen, Y. Zhu, G. Papandreou, F. Schroff, and H. Adam. Encoder-decoder with atrous separable convolution for semantic image segmentation. In ECCV, 2018.
  • [13] J.-T. Chien and H.-T. Chen. COCO-Stuff 2017 Challenge: Vllab team. 2017.
  • [14] 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 CVPR, 2016.
  • [15] J. Dai, H. Qi, Y. Xiong, Y. Li, G. Zhang, H. Hu, and Y. Wei. Deformable convolutional networks. In ICCV, 2017.
  • [16] N. Dvornik, K. Shmelkov, J. Mairal, and C. Schmid. BlitzNet: A real-time deep network for scene understanding. In ICCV, 2017.
  • [17] M. Everingham, S. A. Eslami, L. Van Gool, C. K. Williams, J. Winn, and A. Zisserman. The PASCAL visual object classes challenge: A retrospective. IJCV, 2015.
  • [18] A. Fathi and K. Murphy. COCO-Stuff 2017 Challenge: G-RMI team. 2017.
  • [19] G. Ghiasi and C. C. Fowlkes. Laplacian pyramid reconstruction and refinement for semantic segmentation. In ECCV, 2016.
  • [20] R. Girshick. Fast R-CNN. In ICCV, 2015.
  • [21] R. Girshick, J. Donahue, T. Darrell, and J. Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In CVPR, 2014.
  • [22] R. Girshick, I. Radosavovic, G. Gkioxari, P. Dollár, and K. He. Detectron. https://github.com/facebookresearch/detectron, 2018.
  • [23] K. He, G. Gkioxari, P. Dollár, and R. Girshick. Mask R-CNN. In ICCV, 2017.
  • [24] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In CVPR, 2016.
  • [25] S. Honari, J. Yosinski, P. Vincent, and C. Pal. Recombinator networks: Learning coarse-to-fine feature aggregation. In CVPR, 2016.
  • [26] J. Hu, L. Shen, and G. Sun. Squeeze-and-excitation networks. In CVPR, 2018.
  • [27] S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
  • [28] A. Kendall, Y. Gal, and R. Cipolla. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In CVPR, 2018.
  • [29] A. Kirillov, K. He, R. Girshick, C. Rother, and P. Dollár. Panoptic segmentation. arXiv:1801.00868, 2017.
  • [30] A. Kirillov, E. Levinkov, B. Andres, B. Savchynskyy, and C. Rother. InstanceCut: from edges to instances with multicut. In CVPR, 2017.
  • [31] I. Kokkinos.

    UberNet: Training a universal convolutional neural network for low-, mid-, and high-level vision using diverse datasets and limited memory.

    In CVPR, 2017.
  • [32] J. Li, A. Raventos, A. Bhargava, T. Tagawa, and A. Gaidon. Learning to fuse things and stuff. arXiv:1812.01192, 2018.
  • [33] Y. Li, H. Qi, J. Dai, X. Ji, and Y. Wei. Fully convolutional instance-aware semantic segmentation. In CVPR, 2017.
  • [34] T.-Y. Lin, P. Dollár, R. Girshick, K. He, B. Hariharan, and S. Belongie. Feature pyramid networks for object detection. In CVPR, 2017.
  • [35] T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick. Microsoft COCO: Common objects in context. In ECCV, 2014.
  • [36] S. Liu, J. Jia, S. Fidler, and R. Urtasun. SGN: Sequential grouping networks for instance segmentation. In CVPR, 2017.
  • [37] S. Liu, L. Qi, H. Qin, J. Shi, and J. Jia. Path aggregation network for instance segmentation. In CVPR, 2018.
  • [38] W. Liu, D. Anguelov, D. Erhan, C. Szegedy, S. Reed, C.-Y. Fu, and A. C. Berg. SSD: Single shot multibox detector. In ECCV, 2016.
  • [39] J. Long, E. Shelhamer, and T. Darrell. Fully convolutional networks for semantic segmentation. In CVPR, 2015.
  • [40] I. Misra, A. Shrivastava, A. Gupta, and M. Hebert. Cross-stitch networks for multi-task learning. In CVPR, 2016.
  • [41] G. Neuhold, T. Ollmann, S. Rota Bulò, and P. Kontschieder. The mapillary vistas dataset for semantic understanding of street scenes. In CVPR, 2017.
  • [42] A. Newell, K. Yang, and J. Deng.

    Stacked hourglass networks for human pose estimation.

    In ECCV, 2016.
  • [43] C. Peng, T. Xiao, Z. Li, Y. Jiang, X. Zhang, K. Jia, G. Yu, and J. Sun. Megdet: A large mini-batch object detector. In CVPR, 2018.
  • [44] V.-Q. Pham, S. Ito, and T. Kozakaya. BiSeg: Simultaneous instance segmentation and semantic segmentation with fully convolutional networks. In BMVC, 2017.
  • [45] P. O. Pinheiro, T.-Y. Lin, R. Collobert, and P. Dollár. Learning to refine object segments. In ECCV, 2016.
  • [46] S. Ren, K. He, R. Girshick, and J. Sun. Faster R-CNN: Towards real-time object detection with region proposal networks. In NIPS, 2015.
  • [47] O. Ronneberger, P. Fischer, and T. Brox. U-Net: Convolutional networks for biomedical image segmentation. In MICCAI, 2015.
  • [48] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, A. C. Berg, and L. Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. IJCV, 2015.
  • [49] J. Tighe, M. Niethammer, and S. Lazebnik. Scene parsing with object instances and occlusion ordering. In CVPR, 2014.
  • [50] Z. Tu, X. Chen, A. L. Yuille, and S.-C. Zhu. Image parsing: Unifying segmentation, detection, and recognition. IJCV, 2005.
  • [51] X. Wang, R. Girshick, A. Gupta, and K. He. Non-local neural networks. In CVPR, 2018.
  • [52] Y. Wu and K. He. Group normalization. In ECCV, 2018.
  • [53] S. Xie, R. Girshick, P. Dollár, Z. Tu, and K. He. Aggregated residual transformations for deep neural networks. In CVPR, 2017.
  • [54] J. Yao, S. Fidler, and R. Urtasun. Describing the scene as a whole: Joint object detection, scene classification and semantic segmentation. In CVPR, 2012.
  • [55] F. Yu and V. Koltun. Multi-scale context aggregation by dilated convolutions. In ICLR, 2016.
  • [56] H. Zhao, J. Shi, X. Qi, X. Wang, and J. Jia. Pyramid scene parsing network. In CVPR, 2017.
  • [57] H. Zhao, Y. Zhang, S. Liu, J. Shi, C. C. Loy, D. Lin, and J. Jia. PSANet: Point-wise spatial attention network for scene parsing. In ECCV, 2018.
  • [58] B. Zhou, H. Zhao, X. Puig, S. Fidler, A. Barriuso, and A. Torralba. Scene parsing through ADE20K dataset. In CVPR, 2017.