Instance Segmentation, TensorMask
Sliding-window object detectors that generate bounding-box object predictions over a dense, regular grid have advanced rapidly and proven popular. In contrast, modern instance segmentation approaches are dominated by methods that first detect object bounding boxes, and then crop and segment these regions, as popularized by Mask R-CNN. In this work, we investigate the paradigm of dense sliding-window instance segmentation, which is surprisingly under-explored. Our core observation is that this task is fundamentally different than other dense prediction tasks such as semantic segmentation or bounding-box object detection, as the output at every spatial location is itself a geometric structure with its own spatial dimensions. To formalize this, we treat dense instance segmentation as a prediction task over 4D tensors and present a general framework called TensorMask that explicitly captures this geometry and enables novel operators on 4D tensors. We demonstrate that the tensor view leads to large gains over baselines that ignore this structure, and leads to results comparable to Mask R-CNN. These promising results suggest that TensorMask can serve as a foundation for novel advances in dense mask prediction and a more complete understanding of the task. Code will be made available.READ FULL TEXT VIEW PDF
Instance Segmentation, TensorMask
The sliding-window paradigm—finding objects by looking in each window placed over a dense set of image locations
—is one of the earliest and most successful concepts in computer vision[37, 39, 9, 10] and is naturally connected to convolutional networks . However, while today’s top-performing object detectors rely on sliding window prediction to generate initial candidate regions, a refinement stage is applied to these candidate regions to obtain more accurate predictions, as pioneered by Faster R-CNN  and Mask R-CNN  for bounding-box object detection and instance segmentation, respectively. This class of methods has dominated the COCO detection challenges .
Recently, bounding-box object detectors which eschew the refinement step and focus on direct sliding-window prediction, as exemplified by SSD  and RetinaNet , have witnessed a resurgence and shown promising results. In contrast, the field has not witnessed equivalent progress in dense sliding-window instance segmentation; there are no direct, dense approaches analogous to SSD / RetinaNet for mask prediction. Why is the dense approach thriving for box detection, yet entirely missing for instance segmentation? This is a question of fundamental scientific interest. The goal of this work is to bridge this gap and provide a foundation for exploring dense instance segmentation.
Our main insight is that the core concepts for defining dense mask representations, as well as effective realizations of these concepts in neural networks, are both lacking. Unlike bounding boxes, which have a fixed, low-dimensional representation regardless of scale, segmentation masks can benefit from richer, more structured representations. For example, each mask is itself a 2D spatial map, and masks for larger objects can benefit from the use of larger spatial maps. Developing effective representations for dense masks is a key step toward enabling dense instance segmentation.
To address this, we define a set of core concepts for representing masks with high-dimensional tensors that allows for the exploration of novel network architectures for dense mask prediction. We present and experiment with several such networks in order to demonstrate the merits of the proposed representations. Our framework, called TensorMask, establishes the first dense sliding-window instance segmentation system that achieves results near to Mask R-CNN.
The central idea of the TensorMask representation is to use structured
4D tensors to represent masks over a spatial domain. This perspective stands in contrast to prior work on the related task of segmenting class-agnostic object proposals such as DeepMask and InstanceFCN  that used unstructured
3D tensors, in which the mask is packed into the third ‘channel’ axis. The channel axis, unlike the axes representing object position, does not have a clear geometric meaning and is therefore difficult to manipulate. By using a basic channel representation, one misses an opportunity to benefit from using structural arrays to represent masks as 2D entities—analogous to the difference between MLPs and ConvNets  for representing 2D images.
Unlike these channel-oriented approaches, we propose to leverage 4D tensors of shape , in which both —representing object position—and —representing relative mask position—are geometric sub-tensors, , they have axes with well-defined units and geometric meaning the image. This shift in perspective from encoding masks in an unstructured channel axis to using structured geometric sub-tensors enables the definition of novel operations and network architectures. These networks can operate directly on the sub-tensor in geometrically meaningful ways, including coordinate transformation, up-/downscaling, and use of scale pyramids.
Enabled by the TensorMask framework, we develop a pyramid structure over a scale-indexed list of 4D tensors, which we call a tensor bipyramid. Analogous to a feature pyramid, which is a list of feature maps at multiple scales, a tensor bipyramid contains a list of 4D tensors with shapes , where indexes scale. This structure has a pyramidal shape in both and geometric sub-tensors, but growing in opposite directions. This natural design captures the desirable property that large objects have high-resolution masks with coarse spatial localization (large ) and small objects have low-resolution masks with fine spatial localization (small ).
We combine these components into a network backbone and training procedure closely following RetinaNet  in which our dense mask predictor extends the original dense bounding box predictor. With detailed ablation experiments, we evaluate the effectiveness of the TensorMask framework and show the importance of explicitly capturing the geometric structure of this task. Finally, we show TensorMask yields similar results to its Mask R-CNN counterpart (see Figs. 1 and 2). These promising results suggest the proposed framework can help pave the way for future research on dense sliding-window instance segmentation.
The modern instance segmentation task was introduced by Hariharan  (before being popularized by COCO ). In their work, the method proposed for this task involved first generating object mask proposals [38, 1]
, then classifying these proposals. In earlier work, the classify-mask-proposals methodology was used for other tasks. For example, Selective Search  and the original R-CNN 
classified mask proposals to obtain box detections and semantic segmentation results; these methods could easily be applied to instance segmentation. These early methods relied on bottom-up mask proposals computed by pre-deep-learning era methods[38, 1]; our work is more closely related to dense sliding-window methods for mask object proposals as pioneered by DeepMask . We discuss this connection shortly.
The now dominant paradigm for instance segmentation involves first detecting objects with a box and then segmenting each object using the box as a guide [8, 40, 21, 17]. Perhaps the most successful instantiation of the detect-then-segment methodology is Mask R-CNN , which extended the Faster R-CNN  detector with a simple mask predictor. Approaches that build on Mask R-CNN [26, 30, 4] have dominated leaderboards of recent challenges [24, 29, 6]. Unlike in bounding-box detection, where sliding-window [27, 33, 23] and region-based [11, 34] methods have both thrived, in the area of instance segmentation, research on dense sliding-window methods has been missing. Our work aims to close this gap.
A third class of approaches to instance segmentation (, [3, 19, 2, 25]) builds on models developed for semantic segmentation [28, 5]. These approaches label each image pixel with a category and some auxiliary information that a clustering algorithm can use to group pixels into object instances. These approaches benefit from improvements on semantic segmentation and natively predict higher-resolution masks for larger objects. Compared to detect-then-segment methods, label-pixels-then-cluster methods lag behind in accuracy on popular benchmarks [24, 29, 6]. Instead of employing fully convolutional models for dense pixel labeling, TensorMask explores the framework of building fully convolutional (, dense sliding window) models for dense mask prediction, where the output at each spatial location is itself a 2D spatial map.
To the best of our knowledge, no prior methods exist for dense sliding-window instance segmentation. The proposed TensorMask framework is the first such approach. The closest methods are for the related task of class-agnostic mask proposal generation, specifically models such as DeepMask [31, 32] and InstanceFCN 
which apply convolutional neural networks to generate mask proposals in adense sliding-window manner. Like these approaches, TensorMask is a dense sliding-window model, but it spans a more expressive design space. DeepMask and InstanceFCN can be expressed naturally as class-agnostic TensorMask models, but TensorMask enables novel architectures that perform better. Also, unlike these class-agnostic methods, TensorMask performs multi-class classification in parallel to mask prediction, and thus can be applied to the task of instance segmentation.
The central idea of the TensorMask framework is to use structured high-dimensional tensors to represent image content (, masks) in a set of densely sliding windows.
Consider a window sliding on a feature map of width and height . It is possible to represent all masks in all sliding window locations by a tensor of a shape , where each mask is parameterized by pixels. This is the representation used in DeepMask .
The underlying spirit of this representation, however, is in fact a higher dimensional (4D) tensor with shape . The sub-tensor represents a mask as a 2D spatial entity. Instead of viewing the channel dimension as a black box into which a mask is arranged, the tensor perspective enables several important concepts for representing dense masks, discussed next.
The unit of length (or simply unit) of each spatial axis is a necessary concept for understanding 4D tensors in our framework. Intuitively, the unit of an axis defines the length of one pixel along it. Different axes can have different units.
The unit of the and axes, denoted as , can be set as the stride the input image (, res of ResNet-50  has 16 image pixels). Analogously, the and axes define another 2D spatial domain and have their own unit, denoted as . Shifting one pixel along the or axis corresponds to shifting pixels on the input image. The unit need not be equal to the unit , a property that our models will benefit from.
Defining units is necessary because the interpretation of the tensor shape is ambiguous if units are not specified. For example, represents a window in image pixels if 1 image pixel, but a window in image pixels if 2 image pixels. The units and how they change due to up/down-scaling operations are central to multi-scale representations (more in §3.6).
With the definition of units, we can formally describe the representational meaning of a tensor. In our simplest definition, this tensor represents the windows sliding over . We call this the natural representation. Denoting as the ratio of units, formally we have:
Natural Representation: For a 4D tensor of shape , its value at coordinates represents the mask value at in the window centered at .222Derivation: on the input image pixels, the center of a sliding window is , and a pixel located this window is at . Projecting to the domain (, normalizing by the unit ) gives us and .
Here , where ‘’ denotes cartesian product. Conceptually, the tensor can be thought of as a continuous function in this domain. For implementation, we must instead rasterize the 4D tensor as a discrete function defined on sampled locations. We assume a sampling rate of one sample per unit, with samples located at integer coordinates (, if 3, then ). This assumption allows the same value to represent both the length of the axis in terms of units (, 3) and also the number of discrete samples stored for the axis. This is convenient for working with tensors produced by neural networks that are discrete and have lengths.
Fig. 3 (left) illustrates an example when and is 1. The natural representation is intuitive and easy to parse as the output of a network, but it is not the only possible representation in a deep network, as discussed next.
In the natural representation, a sub-tensor located at represents values at offset pixels instead of directly at . When using convolutions to compute features, preserving pixel-to-pixel alignment between input pixels and predicted output pixels can lead to improvements (this is similar to the motivation for RoIAlign ). Next we describe a pixel-aligned representation for dense masks under the tensor perspective.
Formally, we define the aligned representation as:
Aligned Representation: For a 4D tensor , its value at coordinates represents the mask value at in the window centered at .
is the ratio of units in the aligned representation.
Here, the sub-tensor at pixel always describes the values taken at this pixel, it is aligned. The subspace does not represent a single mask, but instead enumerates mask values in all windows that overlap pixel . Fig. 3 (right) illustrates an example when (nine overlapping windows) and is 1.
Note that we denote tensors in the aligned representation as (and likewise for coordinates/units). This is in the spirit of ‘named tensors’  and proves useful.
) that those score maps behave like our aligned representation but with nearest-neighbor interpolation on, which makes them unaligned. We test this experimentally and show it degrades results severely.
We introduce a coordinate transformation between natural and aligned representations, so they can be used interchangeably in a single network. This gives us additional flexibility in the design of novel network architectures.
For simplicity, we assume units in both representations are the same: , and , and thus (for the more general case see §A.1). Comparing the definitions of natural aligned representations, we have the following two relations for : and . With , solving this equation for and gives: and . A similar results hold for . So the transformation from the aligned representation () to the natural representation () is:
We call this transform align2nat. Likewise, solving this set of two relations for and gives the reverse transform of nat2align: . While all the models presented in this work only use align2nat, we present both cases for completeness.
Without restrictions on , these transformations may involve indexing a tensor at a non-integer coordinate, if is not an integer. Since we only permit integer coordinates in our implementation, we adopt a simple strategy: when the op align2nat is called, we ensure that is a positive integer. We can satisfy this constraint on by changing units with up/down-scaling ops, as described next.
The aligned representation enables the use of a coarse sub-tensors to create finer sub-tensors, which proves quite useful. Fig. 4 illustrates this transformation, which we call up_align2nat and describe next.
The up_align2nat op accepts a tensor as input. The sub-tensor is coarser than the desired output (so its unit is bigger). It performs bilinear upsampling, up_bilinear, in the domain by , reducing the underlying unit by . Next, the align2nat op converts the output into the natural representation. The full up_align2nat op is shown in Fig. 4.
As our experiments demonstrate, the up_align2nat op is effective for generating high-resolution masks without inflating channel counts in preceding feature maps. This in turn enables novel architectures, as described next.
In multi-scale box detection it is common practice to use a lower-resolution feature map to extract larger-scale objects [10, 22]—this is because a sliding window of a fixed size on a lower-resolution map corresponds to a larger region in the input image. This also holds for multi-scale mask detection. However, unlike a box that is always represented by four numbers regardless of its scale, a mask’s pixel size must scale with object size in order to maintain constant resolution density. Thus, instead of always using units to present masks of different scales, we propose to adapt the number of mask pixels based on the scale.
Consider the natural representation on a feature map of the finest level. Here, the domain has the highest resolution (smallest unit). We expect this level to handle the smallest objects, so the domain should have the lowest resolution. With reference to this, we build a pyramid that gradually reduces and increases . Formally, we define a tensor bipyramid as:
Tensor bipyramid: A tensor bipyramid is a list of tensors of shapes: , for , with units and .
Because the units are the same across all levels, a mask has more pixels in the input image. In the domain, because the units increase with , the number of predicted masks decreases for larger masks, as desired. Note that the total size of each level is the same (it is ). A tensor bipyramid can be constructed using the swap_align2nat operation, described next.
This swap_align2nat op is composed of two steps: first, an input tensor with fine and coarse is upscaled to using up_align2nat. Then is subsampled to obtain the final shape. The combination of up_align2nat and subsample, shown in Fig. 5, is called swap_align2nat: the units before and after this op are swapped. For efficiency, it is not necessary to compute the intermediate tensor of shape from up_align2nat, which would be prohibitive. This is because only a small subset of values in this intermediate tensor appear in the final output after subsampling. So although Fig. 5 shows the conceptual computation, in practice we implement swap_align2nat as a single op that only performs the necessary computation and has complexity regardless of .
We now present models enabled by TensorMask representations. These models have a mask prediction head that generates masks in sliding windows and a classification head to predict object categories, analogous to the box regression and classification heads in sliding-window object detectors [27, 23]. Box prediction is not necessary for TensorMask models, but can easily be included.
Our mask prediction branch attaches to a convolutional backbone. We use FPN , which generates a pyramid of feature maps with sizes with a fixed number of channels per level . These maps are used as input for each prediction head: mask, class, and box. Weights for the heads are shared across levels, but not between tasks.
We always use the natural representation (§3.2) as the output format of the network. Any representation (natural, aligned, ) can be used in the intermediate layers, but it will be transformed into the natural representation for the output. This standardization decouples the loss definition from network design, making use of different representations simpler. Also, our mask output is class-agnostic, , the window always predicts a single mask regardless of class; the class of the mask is predicted by the classification head. Class-agnostic mask prediction avoids multiplying the output size by the number of classes.
We consider a set of four baseline heads, illustrated in Fig. 6. Each head accepts an input feature map of shape for any . It then applies a 1
1 convolutional layer (with ReLU) with the appropriate number of output channels such that reshaping it into a 4D tensor produces the desired shape for the next layer, denoted as ‘conv+reshape’. Fig. 6a and 6b are simple heads that use natural and aligned representations, respectively. In both cases, we use output channels for the 11 conv, followed by align2nat in the latter case. Fig. 6c and 6d are upscaling heads that use the natural and aligned representations, respectively. Their 11 conv has fewer output channels than in the simple heads.
In a baseline TensorMask model, one of these four heads is selected and attached to all FPN levels. The output forms a pyramid of , see Fig. 7a. For each head, the output sliding window always has the same unit as the feature map on which it slides: for all levels.
Unlike the baseline heads, the tensor bipyramid head (§3.6) accepts a feature map of fine resolution at all levels. Fig. 8 shows a minor modification of FPN to obtain these maps. For each of the resulting levels, now all , we first use conv+reshape to produce the appropriate 4D tensor, then run a mask prediction head with swap_align2nat, see Fig. 7b. The tensor bipyramid model is the most effective TensorMask variant explored in this work.
We use a version of the DeepMask assignment rule  to label each window. A window satisfying three conditions a ground-truth mask is positive:
(i) Containment: the window fully contains and the longer side of , in image pixels, is at least 1/2 of the longer side of the window, that is, .333A fallback is used to increase small object recall: masks smaller than the minimum assignable size are assigned to windows of the smallest size.
(ii) Centrality: the center of ’s bounding box is within one unit () of the window center in distance.
(iii) Uniqueness: there is no other mask that satisfies the other two conditions.
If satisfies these three conditions, then the window is labeled as a positive example whose ground-truth mask, object category, and box are given by . Otherwise, the window is labeled as a negative example.
In contrast to the IoU-based assignment rules for boxes in sliding-window detectors (, RPN , SSD , RetinaNet ), our rules are mask-driven. Experiments show that our rules work well even when using only 1 or 2 window sizes with a single aspect ratio of 1:1, versus, , RetinaNet’s 9 anchors of multiple scales and aspect ratios.
For the mask prediction head, we adopt a per-pixel binary classification loss. In our setting, the ground-truth mask inside a sliding window often has a wide margin, resulting in an imbalance between foreground background pixels. Therefore instead of using binary cross-entropy, we use focal loss  to address the imbalance, specifically we use FL with and . The mask loss of a window is averaged over the pixels in the window (note that in a tensor bipyramid the window size varies across levels), and the total mask loss is averaged over all positive windows (negative windows do not contribute to the mask loss).
For the classification head, we again adopt FL with and . For box regression, we use a parameter-free loss. The total loss is a weighted sum of all task losses.
Our FPN implementation closely follows ; each FPN level is output by four 33 conv layers of channels with ReLU (instead of one conv in the original FPN ). As with the heads, weights are shared across levels, but not between tasks. In addition, we found that averaging (instead of summing ) the top-down and lateral connections in FPN improved training stability. We use FPN levels 2 through 7 () with 128 channels for the four conv layers in the mask and box branches, and 256 (the same as RetinaNet ) for the classification branch. Unless noted, we use ResNet-50 .
For training, all models are initialized from ImageNet pre-trained weights. We use scale jitter where the shorter image side is randomly sampled from [640, 800] pixels. Following SSD  and YOLO , which train models longer (
65 and 160 epochs) than[23, 17], we adopt the ‘6’ schedule  (72 epochs), which improves results. The minibatch size is 16 images in 8 GPUs. The base learning rate is 0.02, with linear warm-up  of 1k iterations. Other hyper-parameters are kept the same as .
Inference is similar to dense sliding-window object detectors. We use a single scale of 800 pixels for the shorter image side. Our model outputs a mask prediction, a class score, and a predicted box for each sliding window. Non-maximum suppression (NMS) is applied to the top-scoring predictions using box IoU on the regressed boxes, following the settings in . To convert predicted soft masks to binary masks at the original image resolution, we use the same method and hyper-parameters as Mask R-CNN .
We report results on COCO instance segmentation . All models are trained on the 118k train2017 images and tested on the 5k val2017 images. Final results are on test-dev. We use COCO mask average precision (denoted by AP). When reporting box AP, we denote it as AP.
|Mask R-CNN ||R-50-FPN||24||34.9||57.2||36.9||15.4||36.6||50.8|
|Mask R-CNN, ours||R-50-FPN||24||34.9||56.8||36.8||15.1||36.7||50.6|
|Mask R-CNN, ours||R-50-FPN||72||36.8||59.2||39.3||17.1||38.7||52.1|
|Mask R-CNN, ours||R-101-FPN||72||38.3||61.2||40.8||18.2||40.6||54.1|
Tab. 1 compares natural aligned representations with simple heads (Fig. 6a 6b). Both representations perform similarly, with a marginal gap of 0.2 AP. The simple natural head can be thought of as a class-specific variant of DeepMask  with an FPN backbone  and focal loss . As we aim to use lower-resolution intermediate representations, we explore upscaling heads next.
Tab. (a)a compares natural aligned representations with upscaling heads (Fig. 6c 6d). The output size is fixed at 1515. Given an upscaling factor , the conv in Fig. 6 has channels, , 9 channels with (225 channels if no upscaling). The difference in accuracy is big for large : the aligned variant improves AP +15.6 over the natural head (115% relative) when 5.
The tensor view reveals the sub-tensor as a 2D spatial entity that can be manipulated. Tab. (b)b compares the upscale aligned head with bilinear (default) nearest-neighbor interpolation on . We refer to this latter variant as unaligned since quantization breaks pixel-to-pixel alignment. The unaligned variant is related to InstanceFCN  (see §A.2).
Replacing the best feature pyramid model with a tensor bipyramid yields a large 4.1 AP improvement (Tab. (c)c). Here, the mask size is 1515 on level , and is 480480 for ; see Fig. 7b. The higher resolution masks predicted for large objects (, at ) have clear benefit: AP jumps by 7.0 points. This improvement does not come at the cost of denser windows as the output is at resolution.
Again, we note that it is intractable to have, , a 480-channel conv. The upscaling aligned head with bilinear interpolation is key to making tensor bipyramid possible.
Thus far we have used a single window size (per-level) for all models, that is, . Analogous to the concept of anchors in RPN  that are also used in current detectors [33, 27, 23], we extend our method to multiple window sizes. We set , leading to two heads per level. Tab. (d)d shows the benefit of having two window sizes: it increases AP by 1.6 points. More window sizes and aspect ratios are possible, suggesting room for improvement.
Tab. 7 summarizes the best TensorMask model on test-dev and compares it to the current dominant approach for COCO instance segmentation: Mask R-CNN . We use the Detectron  code to reflect improvements since  was published. We modify it to match our implementation details (FPN average fusion, 1k warm-up, and box loss). Tab. 7 row 1 & 2 verify that these subtleties have a negligible effect. Then we use training-time scale augmentation and a longer schedule , which yields an 2 AP increase (Tab. 7 row 3) and establishes a fair and solid baseline for comparison.
The best TensorMask in Tab. (d)d achieves 35.5 mask AP on test-dev (Tab. 7 row 4), close to Mask R-CNN counterpart’s 36.8. With ResNet-101, TensorMask achieves 37.3 mask AP with a 1.0 AP gap behind Mask R-CNN. These results demonstrate that dense sliding-window methods can close the gap to ‘detect-then-segment’ systems (§2). Qualitative results are shown in Figs. 2, 10, and 11.
We report box AP of TensorMask in §A.3. Moreover, compared to Mask R-CNN, one intriguing property of TensorMask is that masks are independent from boxes. In fact, we find joint training of box and mask only gives marginal gain over mask-only training, see §A.4.
Speed-wise, the best R-101-FPN TensorMask runs at 0.38s/im on a V100 GPU (all post-processing included), Mask R-CNN’s 0.09s/im. Predicting masks in dense sliding windows (100k) results in a computation overhead, Mask R-CNN’s sparse prediction on 100 final boxes. Accelerations are possible but outside the scope of this work.
TensorMask is a dense sliding-window instance segmentation framework that, for the first time, achieves results close to the well-developed Mask R-CNN framework—both qualitatively and quantitatively. It establishes a conceptually complementary direction for instance segmentation research. We hope our work will create new opportunities and make both directions thrive.
In Sec. 3.4 we have assumed and . Here we relax this condition and only assume . Again, we still have the following two relations for : and . Solving for and gives: and . Then align2nat is:
More generally, consider arbitrary units , , , and . Then the relations between the natural and aligned representation can be rewritten as:
Note that these relations only hold in the image pixel domain (hence the usage of all units). Solving for , gives:
And the align2nat transform becomes:
This version of the coordinate transformation demonstrates the role of units and may enable more general uses.
We prove that the InstanceFCN  output behaves as an upscaling aligned head with nearest-neighbor interpolation.
In , each output mask has pixels that are divided into bins. A mask pixel is read from the channel corresponding to the pixel’s bin. In our notation,  predicts which is related to the natural representation by:
where is a rounding operation and the integers and index a bin. Now, define a new function by:
and new coordinates: and (likewise for and ). Then can be written as:
Eqn.(8) says that is the nearest-neighbor interpolation of on . Eqn.(7), (6), and the new coordinates show that is computed from by the align2nat transform with . Thus, InstanceFCN masks can be constructed in the TensorMask framework by predicting , performing nearest-neighbor interpolation of on to get , and then using align2nat to compute natural masks .
In Tab. 8 we show the associated bounding-box (bb) object detection results. Overall, TensorMask has a comparable box AP with Mask R-CNN and outperforms RetinaNet.
|Faster R-CNN, ours||72||40.6||61.4||44.2|
|Mask R-CNN, ours||72||41.7||62.5||45.7|
One intriguing property of TensorMask is that masks are not dependent on boxes. This not only opens up new model designs that are mask-specific, but also allows us to investigate whether box predictions improve masks in a multi-task setting. Here, we conduct experiments without the use of a box head. Note that although we predict masks densely, we still need to perform NMS for post-processing. If regressed boxes are absent, we simply use the bounding boxes of the masks as a substitute (and also to report box AP).
Tab. 9 gives the results. We observe a slight degradation switching from the default setting which uses original boxes (row 1) for NMS to using mask bounding boxes (row 2). After accounting for this, TensorMask without a box head (row 3) has nearly equal mask AP to the mask+box variant (row 2). These results indicate that the role of the box head is auxiliary in our system, in contrast to Mask R-CNN.
We show more results in Figs. 10 and 11. For these, and all visualizations in the main text, we display all detections that have a calibrated score 0.6. We use a simple calibration that maps uncalibrated detector scores to precision values: for each model and for each category, we compute its precision-recall (PR) curve on val2017. As a PR curve is parameterized by score, we can map an uncalibrated score for the detector-category pair to its corresponding precision value. Score-to-precision calibration enables a fair visual comparison between methods using a fixed threshold.
The cityscapes dataset for semantic urban scene understanding.In CVPR, 2016.
The perceptron: a probabilistic model for information storage and organization in the brain.Psychological review, 1958.