Introduction
Convolutional Neural Networks (CNNs) have achieved huge success in computer vision tasks such as image recognition [He et al.2016, Yang et al.2018], semantic segmentation [Long, Shelhamer, and
Darrell2015, Chen et al.2018], object detection [Girshick2015, Ren et al.2015], and instance segmentation [He et al.2017]. The semantic segmentation task answers which background scene a pixel belongs to, while the instance segmentation task predicts foreground object masks. Recently, the panoptic segmentation task introduced in [Kirillov et al.2019b] aims to unify the results of semantic and instance segmentation into a single pipeline. The system performs semantic segmentation for pixels that belong to amorphous background scenes, named stuff. For countable foreground objects, named things, the goal is to assign each object region with the right thing class, as well as an instance id
, identifying which object it belongs to. As a result, panoptic segmentation cannot have overlapping segments. However, most cuttingedge highperformance instance segmentation methods [He et al.2017] adopt the regionbased strategy [Girshick et al.2014], and output overlapping segments. As shown in Figure 1, the object pairs, such as cupdinning table, bottledinning table, and bowldinning table, share overlapping regions from instance segmentation output. Therefore, resolving overlaps and producing coherent segmentation results are the main challenge for the panoptic segmentation task [Kirillov et al.2019b].
In [Kirillov et al.2019b]
, the semantic and instance segmentation are trained separately, and their panoptic results are merged by heuristic postprocessing steps. Later studies aim to unify the semantic and instance segmentation into an endtoend training framework
[Kirillov et al.2019a, Li et al.2019b, Liu et al.2019, Xiong et al.2019, Porzi et al.2019, Yang et al.2019, Li et al.2018]. The panoptic results are usually produced by fusion strategies [Kirillov et al.2019a, Li et al.2019b], or predicted by a panoptic head [Liu et al.2019, Xiong et al.2019]. These studies do not explicitly model overlap relations among objects, which is especially important for datasets with rich categories and complex scenes. However, modeling overlap is challenging without the supervision of object relations or depth information.In this study, we introduce the scene overlap graph network (SOGNet) for panoptic segmentation. The SOGNet consists of four components: the joint segmentation, the relational embedding module, the overlap resolving module, and the panoptic head. The SOGNet trains semantic and instance segmentation in an endtoend fashion, explicitly encodes overlap relations, resolves the overlap between any pair of objects in a differentiable way, and outputs a unified panoptic result in the panoptic head.
Similar to [Kirillov et al.2019a, Li et al.2019b, Liu et al.2019, Xiong et al.2019, Porzi et al.2019, Li et al.2018], we also use ResNets [He et al.2016] with feature pyramid network (FPN) [Lin et al.2017] as the shared backbone for our semantic and instance segmentation branches. Inspired by the relation classification in scene graph parsing tasks [Zellers et al.2018, Woo et al.2018], we formulate the overlapping problem in panoptic segmentation as a simplified scene graph with directed edges, in which there are only three relation types for instance with respect to : no overlap, covering as a subject, and being covered as an object. We name this representation as scene overlap graph in this study. We leverage the category, geometry, and appearance information of objects to perform edge feature embedding for the scene overlap graph, and output a matrix that explicitly encodes overlap relations. However, different from scene graph parsing tasks with the commonly used Visual Genome dataset [Krishna et al.2017] that has relation annotations, the panoptic segmentation task does not offer annotations of object relations or depth information, so the overlap relations cannot be modeled with direct supervision.
In order to overcome this problem, we develop the overlap resolving module, which resolves the overlaps between any pair of instances in a differentiable way. The mask logits after removing overlaps are then used for perpixel instance id
classification in the panoptic head with the panoptic annotation. In doing so, the supervision from pixellevel classification helps the instancelevel modeling of overlap relations.
We list the contributions in this study as follows:

We formulate the overlapping problem in panoptic segmentation as a structured representation, named scene overlap graph. Using category, geometry and appearance features, we perform relational embedding and output a matrix that explicitly encode overlap relations.

In order to deal with the lack of supervision on overlap relations, we develop an overlap resolving module that resolves overlaps between any pair of instances in a differentiable way. The supervision from perpixel instance
id
classification in the panoptic head helps to encode overlap relations. We also generate an approximate ground truth as weak supervision to quantify the accuracy of overlap relations predicted by our network. 
Experiments on the COCO and Cityscapes datasets show that, our proposed method is able to accurately predict overlap relations, and outperform the stateoftheart performance for panoptic segmentation.
Related Work
Image Segmentation
The semantic segmentation task focuses on background scenes and is based on fully convolutional networks (FCNs) [Long, Shelhamer, and Darrell2015]. Because detail information is important for dense prediction problems, later studies learn finer representation by deconvolution [Noh, Hong, and Han2015], encoderdecoder structures [Badrinarayanan, Kendall, and Cipolla2017], or introducing skip connections between downsampling and upsampling paths [Ronneberger, Fischer, and Brox2015]. Other methods aim to aggregate multiscale context [Farabet et al.2013, Chen et al.2018, Zhao et al.2017], and better capture longrange dependencies [Zheng et al.2015, Li et al.2019a]. The instance segmentation task deals with foreground objects. Similar to object detection [Girshick2015, Ren et al.2015], many instance segmentation studies [Li et al.2017, He et al.2017] also adopt the regionbased strategy [Girshick et al.2014], and are able to achieve strong performance due to accurate localization for instances. As another stream, segmentationbased methods [Liang et al.2018, Arnab and Torr2017] perform pixelwise classification and then construct object instances by grouping.
The recently proposed task, panoptic segmentation [Kirillov et al.2019b], requires a unified result for background scenes and foreground objects. A naive implementation is to train the two subtasks separately, and then fuse the results by heuristic rules [Kirillov et al.2019b]. Followup studies train semantic and instance segmentation in an endtoend network by sharing backbone [de Geus, Meletis, and
Dubbelman2018, Kirillov et al.2019a, Li et al.2019b, Liu et al.2019, Xiong et al.2019, Porzi et al.2019, Yang et al.2019, Li et al.2018]. Most of them use fusion heuristics to produce the final output. In [Liu et al.2019, Xiong et al.2019], a panoptic head is constructed to predict instance id
. Li et al. [Li et al.2018] introduce a binary mask to differentiate between thing or stuff for each pixel. A semi and weaklysupervised method is proposed in [Li, Arnab, and Torr2018] to relieve the cost of pixellevel annotation.
An important aspect ignored by current panoptic segmentation studies is modeling and resolving overlaps. The study [Lazarow, Lee, and Tu2019] tries to learn instance occlusions but cannot resolve them in the endtoend training. As a comparison, our study is able to explicitly model overlap relations, telling us whether an instance lies upon or beneath another, and resolve their overlaps in a differentiable way to generate the panoptic output.
Relational Modeling
Parsing relationships of objects has been one of the core components of visual understanding. In [Hu et al.2018], appearance and geometry features are used to build interactions for object detection. The visual relationship datasets, such as Visual Genome, inspire a series of studies on scene graph generation. In [Zellers et al.2018, Woo et al.2018], the lowrank outer product [Kim et al.2017] is adopted to perform relational embedding from object features. Other relation reasoning methods are proposed by graphbased propagation [Xu et al.2017], associative embedding [Newell and Deng2017], and introducing an efficient module [Santoro et al.2017].
In our study, we formulate the overlapping problem as a simplified scene graph, and also perform relational embedding to encode overlap relations. Our method differs from these studies in that our problem does not offer relation annotation to supervise. We use the supervision from panoptic head to help the modeling of overlap relations.
Scene Overlap Graph Network
In the scene graph generation task [Zellers et al.2018, Woo et al.2018, Xu et al.2017], objects in an image are constructed as a graph and their relations are directed edges. We formulate the overlapping problem in panoptic segmentation as a similar structure, named scene overlap graph (SOG). There are three relation types for instance with respect to : no overlap, covering as a subject, and being covered as an object. Our proposed SOGNet consists of four components. The joint segmentation connects semantic and instance segmentation in a unified network. The relational embedding module explicitly encodes overlap relations of objects. After the overlap resolving module, overlaps among instances are removed in a differentiable way. Finally, the panoptic head performs perpixel instance id
classification. An illustration of our SOGNet architecture is shown in Figure 2.
Joint Segmentation
Following current popular methods, we use ResNet with FPN as the shared backbone of semantic and instance segmentation branches. The Mask RCNN structure is adopted for our instance segmentation head, which outputs the box regression, class prediction, and mask segmentation for foreground objects. As for semantic head, the FPN feature maps first go through three deformable convolution layers [Dai et al.2017], and then are upsampled to the scale. Finally, they are concatenated to generate the perpixel category prediction. This branch is supervised with both stuff and thing classes, and then the semantic logits of stuff classes are extracted into the panoptic head. We train our model using instance and panoptic annotation. The panoptic annotation that gives perpixel category and instance id
supervises the semantic and panoptic head, respectively. The instance annotation contains overlaps and is used for instance segmentation.
Relational Embedding Module
For any training image, we are given the ground truth , where , , and refer to the bounding box, onehot category, and corresponding mask for instance , respectively, and is the number of instances in this image. As illustrated in Figure 2, we perform relational embedding using the ground truth in the training phase. During inference, we replace them with the prediction from Mask RCNN branch. The and (there are 80 thing classes for COCO) encode geometry and category information, respectively. In order to include appearance feature, we resize the values inside box from as
, which is consistent with the size of Mask RCNN’s output. The resized mask is flattened to be a vector, denoted as
.The bilinear pooling method learns joint representation for pair of features and is widely applied to visual question answering [Kim et al.2017, Kim, Jun, and Zhang2018], and image recognition [Yu et al.2018] tasks. We construct our category and appearance relation features using the lowrank outer product in [Kim et al.2017]. For a pair of instances and , their category relation feature is calculated as:
(1) 
where denotes the Hadamard product (elementwise multiplication), is the ReLU nonlinear activation, and are two linear embeddings that project the input into subject and object features, respectively, and maps the relation feature into output dimension . We then have the category relation features as:
(2) 
where “[ ]” is the concatenation operation. In a similar way, using as the input of Eq. (1), we can also construct the appearance relation features .
The relative geometry provides strong information to infer whether two objects have overlap or not. Following [Hu et al.2018, Woo et al.2018], we have the translation and scaleinvariant relative geometry feature encoded as:
(3) 
where are coordinates and scales extracted from , and is a linear matrix that maps the 4dimensional relative geometry feature into highdimensional . We can further have the geometry relation features . We concatenate these edge representations about appearance, category, and geometry as:
(4) 
where . The relational embedding is further used to encode overlap relations.
Overlap Resolving Module
Based on relational embedding, we introduce the overlap resolving module to explicitly model overlap relations and resolve overlaps among instances in a differentiable way.
As illustrated in Figure 2, the relation features, , go through a layer to have a singlechannel output with the sigmoid activation to restrict the values within . We reshape the output as a square matrix, denoted as . The element has a physical meaning to represent the potential of instance being covered by instance . Because there can be only one overlap relation between instances and , we then introduce the overlap relation matrix defined as:
(5) 
where denotes the ReLU activation that is used to filter out the negative differences between potentials on symmetric positions. In doing so, if , it encodes that instance is being covered by instance , while on its symmetric position, . When , the instances and do not have overlaps. Besides, all diagonal elements equals to 0. As explained later, the positive elements in will be optimized towards in implementations. We now show how to leverage the overlap relation matrix to resolve overlaps.
For each bounding box, , of the ground truth instances, we have its mask logits (the activations before sigmoid) of
from the Mask RCNN output. We then interpolate these logits back to the image scale
by bilinear interpolation and padding outside the box. These logits, denoted as
, may have overlaps because Mask RCNN is regionbased and operates on each region independently. Using the matrix , we can deal with the overlaps between instances and as:(6) 
where is the output logit of instance , and represents the sigmoid activation that turns the logit into a binarylike mask . The elementwise multiplication, , calculates the intersecting region between instances and . The value decides whether the elements in intersecting region should be removed from the logit . When approaches , equals to , thus the logit will not be affected, and vice versa.
Considering the overlap relations of all the other instances on , we have:
(7) 
and then the computational steps of the overlap resolving module can be formulated as:
(8) 
where , and denotes the Tucker product along the 3rd dimension (reshape as for inner product with , and then return to
). We see that our module is friendly to tensor operations in current deep learning frameworks, and is differentiable for resolving overlaps, so that the SOGNet can be trained in an endtoend fashion.
Panoptic Head
The overlap relation matrix, , explicitly encodes whether there is intersection between any pair of instances, and if there is, the overlapping region should be removed from which instance. However, we are not provided with the supervision of overlap relations by the panoptic segmentation task. Because accurately resolving overlaps has a strong correlation with the quality of final panoptic output, we can exploit the pixellevel panoptic annotation to assist in the process of modeling overlap relations encoded by . As illustrated in Figure 2, the instance logits after the SOG module are then fed into the panoptic head.
Following UPSNet [Xiong et al.2019], we incorporate the logits from semantic head into the mask logits . We get the logits of th object from semantic output by taking the values inside its ground truth box from the channel corresponding to its ground truth category , and padding zeros outside the box. In UPSNet, they are combined by addition, which is denoted as “Panoptic Head 1”. Here we develop an improved combination denoted as “Panoptic Head 2”. They are compared as:
(9)  
(10) 
where is the combined logit,
denotes the sigmoid function and
is a factor to balance the numerical difference between semantic output values and mask logits. We set to be 2 in our experiments. Finally, we concatenate the combined instance logits and the stuff logits from the semantic head to perform perpixel instanceid
classification with the standard cross entropy loss function,
.Despite we do not have the supervision to know which instance lies on the other one, we can leverage the ground truth binary masks, , to infer whether two instances have overlaps or not. We produce a symmetric relation matrix defined as:
(11) 
where calculates the area of a binary mask through sum operation, calculates the intersection mask through elementwise multiplication, and denotes the indicator function that equals to 1 when the condition holds. All diagonal elements are filled with . When , it indicates that the overlapped intersection over the smaller object is larger than , which means there is a significant overlap between instances and . With the symmetric relation matrix , we can introduce the relation loss function as:
(12) 
which calculates the mean squared error between and . In doing so, when there is overlap between instances and , i.e., , the overlap relation or is forced to approach , so that it will not contribute trivially when removing overlaps by Eq. (6).
In total, our SOGNet has the loss functions for semantic and instance segmentation, the panoptic loss for instance id
classification, and the relation loss to help optimizing the overlap relation matrix .
Evaluation Metrics
Panoptic Quality
We adopt the evaluation metric introduced in
[Kirillov et al.2019b], called Panoptic Quality (PQ). It can be viewed as the multiplication of a segmentation term (SQ) and a recognition term (RQ):(13) 
where and are predicted and ground truth segments, and , and denote the true positive, false positive and false negative sets, respectively.
Overlap Accuracy
For dataset, such as COCO, the instance annotation permits overlapping instances, while the panoptic annotation contains no overlaps. We can leverage the difference between the two annotations to generate an approximate ground truth of overlap relations, in order to test the quality of overlap relations predicted by our model. The method is also used in [Lazarow, Lee, and Tu2019] to generate their occlusion ground truth.
Concretely, we are provided with the instance annotation , and the panoptic annotation . For any pair of instances and , we calculate the intersecting region by , and inspect which one of and mainly covers the intersecting region, to know if lies upon or the other way round. Note that the instance and panoptic annotation are not seamlessly matched. Thus this method can only produce approximately true overlap relations
Using the synthetic ground truth as weak supervision, we construct a new asymmetric relation matrix . When , we have , and it means instance is covered by . We can have a new relation loss function in this weaklysupervised setting to replace Eq. (12) with:
(14) 
which directly supervises the overlap relation matrix . In experiments, the weaklysupervised manner by Eq. (14) and our method by Eq. (12) have similar performances. Note that the supervision is only valid for datasets such as COCO that has difference between instance and panoptic annotations. It will be ineffective for datasets such as Cityscapes. But our method by Eq.(12) works in both cases.
Thus the weaklysupervised manner by Eq. (14) is served to test the efficacy of our method. Using the weak supervision , we develop a metric, named overlap accuracy (OA), to quantify the quality of overlap predictions encoded by . The OA of image is calculated as:
(15) 
where , and . Our reported OA is an average over all images in the validation set.
Experiments
We conduct experiments on the COCO and Cityscapes datasets for panoptic segmentation, and show that our proposed SOGNet is able to accurately predict overlap relations and outperform stateoftheart performances.
Implementation Details
Training
We set the weights of loss functions following [Xiong et al.2019]. The weight of panoptic head is 0.1 for COCO and 0.5 for Cityscapes. The weight of relation loss is set to 1.0. We train the models with a batchsize of
images distributed on 8 GPUs. The region proposal network (RPN) is also trained endtoend. The SGD optimizer with 0.9 Nesterov momentum and a weight decay of
is used. We use an equivalent setting to UPSNet for fair comparison. Images are resized with the shorter edge as 800, and the longer edge less than 1333. We freeze all batch normalization (BN)
[Ioffe and Szegedy2015] layers within the ResNet backbone. For COCO, we train the SOGNet for 180K iterations. The initial learning rate is set to and is divided by at the 120Kth and 160Kth iterations. For Cityscapes, we train for 24K iterations and drop the learning rate at the 18Kth iteration. Besides, in order to test the quality of our overlap predictions, we perform an ablation study on COCO using a shorter training schedule because our relation loss converges soon. We only train for 45K iterations and drop the learning rate at iteration 30K and 40K. We do not adopt the void channel prediction proposed in UPSNet. In implementations, we filter out the instances that have no overlap with any other instance to reduce negative samples and computation overhead.Inference
During inference phase, the ground truths
as the input of our relational embedding are replaced with the predictions from Mask RCNN branch. In order to remove invalid instances, we filter out instances whose probability is lower than a threshold, and perform an NMSlike procedure, following
[Kirillov et al.2019b, Xiong et al.2019]. For highly overlapped predictions of the same class, we keep the mask with the higher confidence score and discard the other one if the intersection is larger than a threshold. Otherwise, we keep the noninteracting part and deal with the next instance. The final output is predicted by our panoptic head. For stuff segment whose area is lower than 4096, we set the corresponding region as void.Ablation Study
Box  Cat  Mask  PQ  SQ  RQ  OA 

✓      37.5  76.3  47.0  69.62 
  ✓    37.9  76.6  47.3  75.48 
✓  ✓    38.3  76.8  47.7  88.19 
✓  ✓  ✓  38.4  76.9  47.8  89.22 
Weakly supervised  38.4  77.0  47.7  89.31 
Methods  PQ  SQ  RQ 

PlainNet + heuristics  39.6  78.7  48.4 
PlainNet + heuristics + label prior  40.9  78.8  49.7 
PlainNet + PH1  42.3  78.6  52.1 
SOGNet (PH1)  43.0  78.1  53.1 
SOGNet (PH2)  43.7  78.7  53.5 
We use ResNet50 as backbone with a short training schedule, and conduct experiments to analyze feature combinations for our relational embedding, and test the quality of overlap relations predicted by our method. As shown in Table 1, we use different features as the input of our relational embedding. When only category or geometry feature is adopted, the performance improvement on PQ is not so significant, and the overlap prediction does not show high accuracy. When category and geometry features are used together, the embedding becomes much more powerful. Mask feature also slightly improves the overlap accuracy. We expect that a more sophisticated feature design will further boost the performance. It is observed that the weaklysupervised method by Eq. (14) achieves a similar result to our method by Eq. (12). As shown in Figure 3, we visualize the overlap relations predicted by , as well as the approximate ground truth, , on images from the validation set. More examples can be found in the supplementary material. It is shown that the matrix accurately predicts some overlap relations, including baseball gloveperson, tiepersonbus, and spooncupdinning table. The results demonstrate that the overlap relations are modeled well with the help of supervision from perpixel instance id
classification in the panoptic head. Our method is able to encode overlap relations without direct supervision on them.
Using the standard training schedule and ResNet50 as the backbone, we also perform comparisons between SOGNet and heuristic inference. The heuristics in [Kirillov et al.2019b] sort instances according to their objectness scores to deal with overlaps. In [Li et al.2019b], some handcrafted label priors are made to rule overlap orders. For example, tie should always cover person. As a comparison, SOGNet explicitly predict overlap relations and resolve overlaps in a differentiable way. We train the joint segmentation component of SOGNet as a PlainNet, and perform inference with different methods. As shown in Table 2, label prior helps to improve the performance. When PlainNet adds the panoptic head for inference to produce the panoptic results, the performance becomes better. The SOGNet with relational embedding and overlap resolving has a further improvement. And our proposed Panoptic Head 2 (PH2) performs better than PH1. In Figure 4, we visualize the panoptic segmentation results of heuristic inference and SOGNet. It is shown that SOGNet better deals with the overlapping problem.
Models  backbone  PQ  SQ  RQ 

Megvii  ensemble  53.2  83.2  62.9 
Caribbean  ensemble  46.8  80.5  57.1 
PKU360  ResNeXt152FPN  46.3  79.6  56.1 
Panoptic FPN  ResNet101FPN  40.9     
OANet  ResNet101FPN  41.3     
AUNet  ResNeXt152FPN  46.5  81.0  56.1 
UPSNet  ResNet101FPN  46.6  80.5  56.9 
SOGNet  ResNet101FPN  47.8  80.7  57.6 
Comparison with Other Methods
We run SOGNet on the COCO and Cityscapes datasets, and compare the results with stateoftheart methods including the method in [Li, Arnab, and Torr2018], JSIS [de Geus, Meletis, and Dubbelman2018], TASCNet [Li et al.2018], Panoptic FPN [Kirillov et al.2019a], OANet [Liu et al.2019], AUNet [Li et al.2019b], UPSNet [Xiong et al.2019], and OCFusion [Lazarow, Lee, and Tu2019].
As shown in Table 3, with ResNet101FPN as the backbone, our proposed SOGNet achieves the highest singlemodel performance on the COCO testdev set. It has a 1.3% PQ improvement than AUNet that uses a larger backbone. SOGNet also performs better than UPSNet using the same backbone and training schedule.
The results of SOGNet on the COCO and Cityscapes validation set are shown in Table 4. It is observed that SOGNet generalizes well to Cityscapes. It has a 0.7% improvement than TASCNet and UPSNet. On the COCO validation set, SOGNet has a 1.2% improvement than UPSNet using the same backbone. The mIoU and AP of SOGNet are 54.56 and 34.2 on COCO, which are similar to the results of UPSNet (54.3 and 34.3 as reported). It indicates that our better panoptic performance is not derived from a stronger semantic or instance segmentation model. More importantly, SOGNet is the only method that can explicitly encode overlap relations and tell us which instance lies upon or beneath another.
Models  backbone  PQ  PQ  PQ 

Cityscapes  
Q.Li et al.  ResNet101  53.8  42.5  62.1 
Panoptic FPN  ResNet101  58.1  52.0  62.5 
TASCNet  ResNet50  59.3  56.3  61.5 
UPSNet  ResNet50  59.3  54.6  62.7 
SOGNet  ResNet50  60.0  56.7  62.5 
COCO  
JSIS  ResNet50  26.9  29.3  23.3 
Panoptic FPN  ResNet101  40.3  47.5  29.5 
OCFusion  ResNet50  41.2  49.0  29.0 
UPSNet  ResNet50  42.5  48.5  33.4 
SOGNet  ResNet50  43.7  50.6  33.2 
Conclusion
In this study, we aim to model overlap relations and resolve overlaps in a differentiable way for panoptic segmentation. We develop the SOGNet composed of the joint segmentation, the relational embedding module, the overlap resolving module, and the panoptic head. It is able to explicitly encode overlap relations without direct supervision on them. Ablation studies detach SOGNet and analyze the efficacy of each component. Experiments demonstrate that SOGNet accurately predicts overlap relations, and outperforms the stateoftheart methods on both COCO and Cityscapes.
Acknowledgements
Z. Lin is supported by NSF China under grant no.s 61625301 and 61731018 and Zhejiang Lab.
Supplementary Material
We offer more visualization examples of the overlap relations predicted by our method, as shown in Figure 5.
References
 [Arnab and Torr2017] Arnab, A., and Torr, P. H. 2017. Pixelwise instance segmentation with a dynamically instantiated network. In CVPR, 441–450.
 [Badrinarayanan, Kendall, and Cipolla2017] Badrinarayanan, V.; Kendall, A.; and Cipolla, R. 2017. Segnet: A deep convolutional encoderdecoder architecture for image segmentation. TPAMI 39(12):2481–2495.
 [Chen et al.2018] Chen, L.C.; Papandreou, G.; Kokkinos, I.; Murphy, K.; and Yuille, A. L. 2018. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. TPAMI 40(4):834–848.
 [Dai et al.2017] Dai, J.; Qi, H.; Xiong, Y.; Li, Y.; Zhang, G.; Hu, H.; and Wei, Y. 2017. Deformable convolutional networks. In ICCV, 764–773.
 [de Geus, Meletis, and Dubbelman2018] de Geus, D.; Meletis, P.; and Dubbelman, G. 2018. Panoptic segmentation with a joint semantic and instance segmentation network. arXiv preprint arXiv:1809.02110.
 [Farabet et al.2013] Farabet, C.; Couprie, C.; Najman, L.; and LeCun, Y. 2013. Learning hierarchical features for scene labeling. TPAMI 35(8):1915–1929.
 [Girshick et al.2014] Girshick, R.; Donahue, J.; Darrell, T.; and Malik, J. 2014. Rich feature hierarchies for accurate object detection and semantic segmentation. In CVPR, 580–587.
 [Girshick2015] Girshick, R. 2015. Fast rcnn. In ICCV, 1440–1448.
 [He et al.2016] He, K.; Zhang, X.; Ren, S.; and Sun, J. 2016. Deep residual learning for image recognition. In CVPR, 770–778.
 [He et al.2017] He, K.; Gkioxari, G.; Dollár, P.; and Girshick, R. 2017. Mask rcnn. In ICCV, 2961–2969.
 [Hu et al.2018] Hu, H.; Gu, J.; Zhang, Z.; Dai, J.; and Wei, Y. 2018. Relation networks for object detection. In CVPR, 3588–3597.
 [Ioffe and Szegedy2015] Ioffe, S., and Szegedy, C. 2015. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 448–456.
 [Kim et al.2017] Kim, J.H.; On, K.W.; Lim, W.; Kim, J.; Ha, J.W.; and Zhang, B.T. 2017. Hadamard product for lowrank bilinear pooling. In ICLR.
 [Kim, Jun, and Zhang2018] Kim, J.H.; Jun, J.; and Zhang, B.T. 2018. Bilinear attention networks. In NeurIPS, 1564–1574.
 [Kirillov et al.2019a] Kirillov, A.; Girshick, R.; He, K.; and Dollár, P. 2019a. Panoptic feature pyramid networks. In CVPR.
 [Kirillov et al.2019b] Kirillov, A.; He, K.; Girshick, R.; Rother, C.; and Dollár, P. 2019b. Panoptic segmentation. In CVPR.
 [Krishna et al.2017] Krishna, R.; Zhu, Y.; Groth, O.; Johnson, J.; Hata, K.; Kravitz, J.; Chen, S.; Kalantidis, Y.; Li, L.J.; Shamma, D. A.; et al. 2017. Visual genome: Connecting language and vision using crowdsourced dense image annotations. IJCV 123(1):32–73.
 [Lazarow, Lee, and Tu2019] Lazarow, J.; Lee, K.; and Tu, Z. 2019. Learning instance occlusion for panoptic segmentation. arXiv preprint arXiv:1906.05896.
 [Li, Arnab, and Torr2018] Li, Q.; Arnab, A.; and Torr, P. H. 2018. Weaklyand semisupervised panoptic segmentation. In ECCV, 102–118.
 [Li et al.2017] Li, Y.; Qi, H.; Dai, J.; Ji, X.; and Wei, Y. 2017. Fully convolutional instanceaware semantic segmentation. In CVPR, 2359–2367.
 [Li et al.2018] Li, J.; Raventos, A.; Bhargava, A.; Tagawa, T.; and Gaidon, A. 2018. Learning to fuse things and stuff. arXiv preprint arXiv:1812.01192.
 [Li et al.2019a] Li, X.; Zhong, Z.; Wu, J.; Yang, Y.; Lin, Z.; and Liu, H. 2019a. Expectationmaximization attention networks for semantic segmentation. In ICCV, 9167–9176.
 [Li et al.2019b] Li, Y.; Chen, X.; Zhu, Z.; Xie, L.; Huang, G.; Du, D.; and Wang, X. 2019b. Attentionguided unified network for panoptic segmentation. In CVPR.
 [Liang et al.2018] Liang, X.; Lin, L.; Wei, Y.; Shen, X.; Yang, J.; and Yan, S. 2018. Proposalfree network for instancelevel object segmentation. TPAMI 40(12):2978–2991.
 [Lin et al.2017] Lin, T.Y.; Dollár, P.; Girshick, R.; He, K.; Hariharan, B.; and Belongie, S. 2017. Feature pyramid networks for object detection. In CVPR, 2117–2125.
 [Liu et al.2019] Liu, H.; Peng, C.; Yu, C.; Wang, J.; Liu, X.; Yu, G.; and Jiang, W. 2019. An endtoend network for panoptic segmentation. In CVPR.
 [Long, Shelhamer, and Darrell2015] Long, J.; Shelhamer, E.; and Darrell, T. 2015. Fully convolutional networks for semantic segmentation. In CVPR, 3431–3440.
 [Newell and Deng2017] Newell, A., and Deng, J. 2017. Pixels to graphs by associative embedding. In NeurIPS, 2171–2180.
 [Noh, Hong, and Han2015] Noh, H.; Hong, S.; and Han, B. 2015. Learning deconvolution network for semantic segmentation. In ICCV, 1520–1528.
 [Porzi et al.2019] Porzi, L.; Bulò, S. R.; Colovic, A.; and Kontschieder, P. 2019. Seamless scene segmentation. arXiv preprint arXiv:1905.01220.
 [Ren et al.2015] Ren, S.; He, K.; Girshick, R.; and Sun, J. 2015. Faster rcnn: Towards realtime object detection with region proposal networks. In NeurIPS, 91–99.
 [Ronneberger, Fischer, and Brox2015] Ronneberger, O.; Fischer, P.; and Brox, T. 2015. Unet: Convolutional networks for biomedical image segmentation. In MICCAI, 234–241. Springer.
 [Santoro et al.2017] Santoro, A.; Raposo, D.; Barrett, D. G.; Malinowski, M.; Pascanu, R.; Battaglia, P.; and Lillicrap, T. 2017. A simple neural network module for relational reasoning. In NeurIPS, 4967–4976.
 [Woo et al.2018] Woo, S.; Kim, D.; Cho, D.; and Kweon, I. S. 2018. Linknet: Relational embedding for scene graph. In NeurIPS, 560–570.
 [Xiong et al.2019] Xiong, Y.; Liao, R.; Zhao, H.; Hu, R.; Bai, M.; Yumer, E.; and Urtasun, R. 2019. Upsnet: A unified panoptic segmentation network. In CVPR.
 [Xu et al.2017] Xu, D.; Zhu, Y.; Choy, C. B.; and FeiFei, L. 2017. Scene graph generation by iterative message passing. In CVPR, 5410–5419.
 [Yang et al.2018] Yang, Y.; Zhong, Z.; Shen, T.; and Lin, Z. 2018. Convolutional neural networks with alternately updated clique. In CVPR, 2413–2422.
 [Yang et al.2019] Yang, T.J.; Collins, M. D.; Zhu, Y.; Hwang, J.J.; Liu, T.; Zhang, X.; Sze, V.; Papandreou, G.; and Chen, L.C. 2019. Deeperlab: Singleshot image parser. arXiv preprint arXiv:1902.05093.
 [Yu et al.2018] Yu, C.; Zhao, X.; Zheng, Q.; Zhang, P.; and You, X. 2018. Hierarchical bilinear pooling for finegrained visual recognition. In ECCV, 574–589.
 [Zellers et al.2018] Zellers, R.; Yatskar, M.; Thomson, S.; and Choi, Y. 2018. Neural motifs: Scene graph parsing with global context. In CVPR, 5831–5840.
 [Zhao et al.2017] Zhao, H.; Shi, J.; Qi, X.; Wang, X.; and Jia, J. 2017. Pyramid scene parsing network. In CVPR, 2881–2890.

[Zheng et al.2015]
Zheng, S.; Jayasumana, S.; RomeraParedes, B.; Vineet, V.; Su, Z.; Du, D.;
Huang, C.; and Torr, P. H.
2015.
Conditional random fields as recurrent neural networks.
In ICCV, 1529–1537.
Comments
There are no comments yet.