Semantic labelling and instance segmentation are two tasks that require particularly costly annotations. Starting from weak supervision in the form of bounding box detection annotations, we propose a new approach that does not require modification of the segmentation training procedure. We show that when carefully designing the input labels from given bounding boxes, even a single round of training is enough to improve over previously reported weakly supervised results. Overall, our weak supervision approach reaches 95 quality of the fully supervised model, both for semantic labelling and instance segmentation.READ FULL TEXT VIEW PDF
We present a weakly supervised model that jointly performs both semantic...
Weakly supervised semantic segmentation is receiving great attention due...
In order to handle the challenges of autonomous driving, deep learning h...
Grocery stores have thousands of products that are usually identified us...
We introduce DiscoBox, a novel framework that jointly learns instance
Training convolutional networks for semantic segmentation with strong
This work provides a simple approach to discover tight object bounding b...
Convolutional networks (convnets) have become the de facto technique for pattern recognition problems in computer vision. One of their main strengths is the ability to profit from extensive amounts of training data to reach top quality. However, one of their main weaknesses is that they need a large number of training samples for high quality results. This is usually mitigated by using pre-trained models (e.g. with
training samples for ImageNet classification), but still thousands of samples are needed to shift from the pre-training domain to the application domain. Applications such as semantic labelling (associating each image pixel to a given class) or instance segmentation (grouping all pixels belonging to the same object instance) are expensive to annotate, and thus significant cost is involved in creating large enough training sets.
Compared to object bounding box annotations, pixel-wise mask annotations are far more expensive, requiring more time . Cheaper and easier to define, box annotations are more pervasive than pixel-wise annotations. In principle, a large number of box annotations (and images representing the background class) should convey enough information to understand which part of the box content is foreground and which is background. In this paper we explore how much one can close the gap between training a convnet using full supervision for semantic labelling (or instance segmentation) versus using only bounding box annotations.
Our experiments focus on the Pascal classes  and show that using only bounding box annotations over the same training set we can reach of the accuracy achievable with full supervision. We show top results for (bounding box) weakly supervised semantic labelling and, to the best of our knowledge, for the first time report results for weakly supervised instance segmentation.
We view the problem of weak supervision as an issue of input label noise. We explore recursive training as a de-noising strategy, where convnet predictions of the previous training round are used as supervision for the next round. We also show that, when properly used, “classic computer vision” techniques for box-guided instance segmentation are a source of surprisingly effective supervision for convnet training.
In summary, our main contributions are:
We explore recursive training of convnets for weakly supervised semantic labelling, discuss how to reach good quality results, and what are the limitations of the approach (Section 3.1).
We show that state of the art quality can be reached when properly employing GrabCut-like algorithms to generate training labels from given bounding boxes, instead of modifying the segmentation convnet training procedure (Section 3.2).
We report the best known results when training using bounding boxes only, both using Pascal VOC12 and VOC12+COCO training data, reaching comparable quality with the fully supervised regime (Section 4.2).
We are the first to show that similar results can be achieved for the weakly supervised instance segmentation task (Section 6).
Semantic labelling may be tackled via decision forests 
or classifiers over hand-crafted superpixel features. However, convnets have proven particularly effective for semantic labelling. A flurry of variants have been proposed recently [32, 26, 5, 24, 48, 18, 46]. In this work we use DeepLab  as our reference implementation. This network achieves state-of-the-art performance on the Pascal VOC12 semantic segmentation benchmark and the source code is available online.
In order to keep annotation cost low, recent work has explored different
forms of supervision for semantic labelling: image labels [29, 28, 27, 30, 42],
points , scribbles [44, 23],
and bounding boxes [8, 27]. [8, 27, 15]
also consider the case where a fraction of images are fully supervised.
 proposes a framework to handle
all these types of annotations.
In this work we focus on box level annotations for semantic labelling of objects. The closest related work are thus [8, 27]. BoxSup  proposes a recursive training procedure, where the convnet is trained under supervision of segment object proposals and the updated network in turn improves the segments used for training. WSSL 
proposes an expectation-maximisation algorithm with a bias to enable the network to estimate the foreground regions. We compare with these works in the result sections.Since all implementations use slightly different networks and training procedures, care should be taken during comparison. Both  and  propose new ways to train convnets under weak supervision. In contrast, in this work we show that one can reach better results without modifying the training procedure (compared to the fully supervised case) by instead carefully generating input labels for training from the bounding box annotations (Section 3).
In contrast to instance agnostic semantic labelling that groups pixels
by object class, instance segmentation groups pixels by object instance
and ignores classes.
Object proposals [35, 16] that generate segments (such as [34, 21]) can be used for instance segmentation. Similarly, given a bounding box (e.g. selected by a detector), GrabCut  variants can be used to obtain an instance segmentation (e.g. [22, 7, 41, 40, 47]).
To enable end-to-end training of detection and segmentation systems, it has recently been proposed to train convnets for the task of instance segmentation [14, 33]
. In this work we explore weakly supervised training of an instance segmentation convnet. We use DeepMask as a reference implementation for this task. In addition we re-purpose DeepLabv2 network , originally designed for semantic segmentation, for the instance segmentation task.
The goal of this work is to provide high quality semantic labelling starting from object bounding box annotations. We design our approach aiming to exploit the available information at its best. There are two sources of information: the annotated boxes and priors about the objects. We integrate these in the following cues:
Since the bounding boxes are expected to be exhaustive, any pixel not covered by a box is labelled as background.
The box annotations bound the extent of each instance. Assuming a prior on the objects shapes (e.g. oval-shaped objects are more likely than thin bar or full rectangular objects), the box also gives information on the expected object area. We employ this size information during training.
Other than extent and area, there are additional object priors at hand. Two priors typically used are spatial continuity and having a contrasting boundary with the background. In general we can harness priors about object shape by using segment proposal techniques , which are designed to enumerate and rank plausible object shapes in an area of the image.
We first describe a naive baseline that serves as starting point for our exploration. Given an annotated bounding box and its class label, we label all pixels inside the box with such given class. If two boxes overlap, we assume the smaller one is in front. Any pixel not covered by boxes is labelled as background.
Figure 2 left side and Figure (c)c show such example annotations. We use these labels to train a segmentation network with the standard training procedure. We employ the DeepLabv1 approach from  (details in Section 4.1).
We observe that when applying the resulting model over the training set, the network outputs capture the object shape significantly better than just boxes (see Figure 2). This inspires us to follow a recursive training procedure, where these new labels are fed in as ground truth for a second training round. We name this recursive training approach Naive.
The recursive training is enhanced by de-noising the convnet outputs using extra information from the annotated boxes and object priors. Between each round we improve the labels with three post-processing stages:
Any pixel outside the box annotations is reset to background label (cue C1).
If the area of a segment is too small compared to its corresponding bounding box (e.g. IoU), the box area is reset to its initial label (fed in the first round). This enforces a minimal area (cue C2).
As it is common practice among semantic labelling methods, we filter the output of the network to better respect the image boundaries. (We use DenseCRF  with the DeepLabv1 parameters ). In our weakly supervised scenario, boundary-aware filtering is particularly useful to improve objects delineation (cue C3).
The recursion and these three post-processing stages are crucial to reach good performance. We name this recursive training approach Box, and show an example result in Figure 2.
|input rectangles||1 training round||5 rounds||10 rounds||truth|
We also consider a second variant that, instead of using filled rectangles as initial labels, we fill in the 20% inner region, and leave the remaining inner area of the bounding box as ignore regions. See Figure (d)d. Following cues C2 and C3 (shape and spatial continuity priors), the 20% inner box region should have higher chances of overlapping with the corresponding object, reducing the noise in the generated input labels. The intuition is that the convnet training might benefit from trading-off lower recall (more ignore pixels) for higher precision (more pixels are correctly labelled). Starting from this initial input, we use the same recursive training procedure as for Box.
Despite the simplicity of the approach, as we will see in the experimental section 4, / is already competitive with the current state of the art.
However, using rectangular shapes as training labels is clearly suboptimal. Therefore, in the next section, we propose an approach that obtains better results while avoiding multiple recursive training rounds.
The box baselines are purposely simple. A next step in complexity consists in utilising the box annotations to generate an initial guess of the object segments. We think of this as “old school meets new school”: we use the noisy outputs of classic computer vision methods, box-driven figure-ground segmentation  and object proposal  techniques, to feed the training of a convnet. Although the output object segments are noisy, they are more precise than simple rectangles, and thus should provide improved results. A single training round will be enough to reach good quality.
GrabCut  is the established technique
to estimate an object segment from its bounding box. We propose to
use a modified version of GrabCut, which we call ,
where HED boundaries  are used as pairwise term
instead of the typical RGB colour difference. (The HED boundary detector
is trained on the generic boundaries of BSDS500 ).
We considered other GrabCut variants, such as [7, 40];
however, the proposed gives higher quality segments
(see supplementary material).
Similar to , we also consider a variant, which trades off recall for higher precision. For each annotated box we generate multiple () perturbed outputs. If of the segments mark the pixel as foreground, the pixel is set to the box object class. If less than of the segments mark the pixels as foreground, the pixel is set as background, otherwise it is marked as ignore. The perturbed outputs are generated by jittering the box coordinates () as well as the size of the outer background region considered by GrabCut (from to ). An example result of can be seen in Figure (g)g.
With our final approach we attempt to better incorporate the object shape priors by using segment proposals . Segment proposals techniques are designed to generate a soup of likely object segmentations, incorporating as many “objectness” priors as useful (cue C3).
We use the state of the art proposals from MCG . As final stage the MCG algorithm includes a ranking based on a decision forest trained over the Pascal VOC 2012 dataset. We do not use this last ranking stage, but instead use all the (unranked) generated segments. Given a box annotation, we pick the highest overlapping proposal as a corresponding segment.
Building upon the insights from the baselines in Section 3.1 and 3.2, we use the MCG segment proposals to supplement . Inside the annotated boxes, we mark as foreground pixels where both MCG and agree; the remaining ones are marked as ignore. We denote this approach as or for short.
Because MCG and provide complementary information, we can think of as an improved version of
providing a different trade-off between precision and recall on the generated labels (see Figure(i)i).
The BoxSup method  also uses MCG object proposals during training; however, there are important differences. They modify the training procedure so as to denoise intermediate outputs by randomly selecting high overlap proposals. In comparison, our approach keeps the training procedure unmodified and simply generates input labels. Our approach also uses ignore regions, while BoxSup does not explore this dimension. Finally, BoxSup uses a longer training than our approach.
Section 4 shows results for the semantic labelling task, compares different methods and different supervision regimes. In Section 5 we show that the proposed approach is also suitable for the instance segmentation task.
Our approach is equally suitable (and effective) for weakly supervised instance segmentation as well as for semantic labelling. However, only the latter has directly comparable related work. We thus focus our experimental comparison efforts on the semantic labelling task. Results for instance segmentation are presented in Section 6.
Section 4.1 discusses the experimental setup, evaluation, and implementation details for semantic labelling. Section 4.2 presents our main results, contrasting the methods from Section 3 with the current state of the art. Section 4.3 further expands these results with a more detailed analysis, and presents results when using more supervision (semi-supervised case).
We evaluate the proposed methods on the Pascal VOC12 segmentation
benchmark . The dataset consists of foreground
object classes and one background class. The segmentation part of
the VOC12 dataset contains training, validation,
and test images. Following previous work [5, 8],
we extend the training set with the annotations provided by ,
resulting in an augmented set of training images.
In some of our experiments, we use additional training images from the COCO  dataset. We only consider images that contain any of the Pascal classes and (following ) only objects with a bounding box area larger than pixels. After this filtering, images remain (from training and validation sets), which are added to our training set. When using COCO data, we first pre-train on COCO and then fine-tune over the Pascal VOC12 training set.
All of the COCO and Pascal training images come with semantic labelling annotations (for fully supervised case) and bounding box annotations (for weakly supervised case).
We use the “comp6” evaluation protocol. The performance is measured in terms of pixel intersection-over-union averaged across classes (mIoU). Most of our results are shown on the validation set, which we use to guide our design choices. Final results are reported on the test set (via the evaluation server) and compared with other state-of-the-art methods.
For all our experiments we use the DeepLab-LargeFOV network, using the same train and test parameters as . The model is initialized from a VGG16 network pre-trained on ImageNet . We use a mini-batch of images for SGD and initial learning rate of , which is divided by after a / iterations (for Pascal/COCO). At test time, we apply DenseCRF . Our network and post-processing are comparable to the ones used in [8, 27].
Note that multiple strategies have been considered to boost test time results, such as multi-resolution or model ensembles [5, 18]. Here we keep the approach simple and fixed. In all our experiments we use a fixed training and test time procedure. Across experiments we only change the input training data that the networks gets to see.
Figure 4 presents
the results for the recursive training of the box baselines from Section
3.1. We see that the scheme,
a recursive training from rectangles disregarding post-processing
stages, leads to poor quality. However, by using the suggested three
post-processing stages, the baseline obtains a significant
gain, getting tantalisingly close to the best reported results on
the task . Details of the contribution of each
post-processing stage are presented in the supplementary material.
Adding ignore regions inside the rectangles ()
provides a clear gain and leads by itself to state of the art results.
Figure 4 also shows the result of using longer training for fully supervised case. When using ground truth semantic segmentation annotations, one training round is enough to achieve good performance; longer training brings marginal improvement. As discussed in Section 3.1, reaching good quality for requires multiple training rounds instead, and performance becomes stable from round 5 onwards. Instead, / do not benefit from additional training rounds.
Table 1 evaluates results
on the Pascal VOC12 validation set. It indicates the
results after rounds, and ///
results after one round. “Fast-RCNN” is the result using detections
 to generate semantic labels (lower-bound),
“GT Boxes” considers the box annotations as labels, and
indicates our fully supervised segmentation network result obtained
with a training length equivalent to three training rounds (upper-bound
for our results). We see in the results that using ignore regions
systematically helps (trading-off recall for precision), and that
provides better results than
Table 2 indicates the box-driven segment results after training round and shows comparison with other state of the art methods, trained from boxes only using either Pascal VOC12, or VOC12+COCO data. and both feed the network with rectangle segments (comparable to ), while and exploit arbitrary shaped segments (comparable to ). Although our network and post-processing is comparable to the ones in [8, 27], there are differences in the exact training procedure and parameters (details in supplementary material).
Overall, our results indicate that - without modifying the training procedure - is able to improve over previously reported results and reach of the fully-supervised training quality. By training with COCO data  before fine-tuning for Pascal VOC12, we see that with enough additional bounding boxes we can match the full supervision from Pascal VOC 12 ( versus ). This shows that the labelling effort could be significantly reduced by replacing segmentation masks with bounding box annotations.
|Weak||-||V 10k||Bearman et al. ||45.1||-||-|
|Semi||V 1.4k||V 9k||||62.1||-||-|
|Full||V 10k||-||BoxSup ||63.8||-||-|
|VOC12 + COCO (V+C)|
|Semi||V 10k||C 123k||||68.2||71.0||97.0|
|Full||V+C 133k||-||BoxSup ||68.1||-||-|
Table 2 compares results in the semi-supervised modes considered by [8, 27], where some of the images have full supervision, and some have only bounding box supervision. Training with of Pascal VOC12 semantic labelling annotations does not bring much gain to the performance ( versus ), this hints at the high quality of the generated input data.
By using ground-truth annotations on Pascal plus bounding box annotations on COCO, we observe points gain ( , see Table 2). This suggests that the overall performance could be further improved by using extra training data with bounding box annotations.
Our results from , , and all indirectly include information from the BSDS500 dataset  via the HED boundary detector . These results are fully comparable to BoxSup-MCG , to which we see a clear improvement. Nonetheless one would like to know how much using dense boundary annotations from BSDS500 contributes to the results. We use the weakly supervised boundary detection technique from  to learn boundaries directly from the Pascal VOC12 box annotations. Training using weakly supervised HED boundaries results in point loss compared to using the BSDS500 ( versus mIoU on Pascal VOC12 validation set). We see then that although the additional supervision does bring some help, it has a minor effect and our results are still rank at the top even when we use only Pascal VOC12 + ImageNet pre-training.
For comparison purposes with [8, 27]
we used DeepLabv1 with a VGG-16 network in our experiments.
To show that our approach also generalizes across different convnets,
we also trained DeepLabv2 with a ResNet101 network .
Table 3 presents the results.
Similar to the case with VGG-16, our weakly supervised approach reaches of the fully supervised case when training with VOC12/VOC12+COCO, and the weakly supervised results with COCO data reach similar quality to full supervision with VOC12 only.
|VOC12 + COCO|
Complementing the experiments of the previous sections, we also explore a second task: weakly supervised instance segmentation. To the best of our knowledge, these are the first reported experiments on this task.
As object detection moves forward, there is a need to provide richer output than a simple bounding box around objects. Recently [14, 33, 31] explored training convnets to output a foreground versus background segmentation of an instance inside a given bounding box. Such networks are trained using pixel-wise annotations that distinguish between instances. These annotations are more detailed and expensive than semantic labelling, and thus there is interest in weakly supervised training.
The segments used for training, as discussed in Section 3.2, are generated starting from individual object bounding boxes. Each segment represents a different object instance and thus can be used directly to train an instance segmentation convnet. For each annotated bounding box, we generate a foreground versus background segmentation using the method (Section 3.2), and train a convnet to regress from the image and bounding box information to the instance segment.
We choose a purposely simple instance segmentation pipeline, based on the “hyper-columns system 2” architecture . We use Fast-RCNN  detections (post-NMS) with their class score, and for each detection estimate an associated foreground segment. We estimate the foreground using either some baseline method (e.g. GrabCut) or using convnets trained for the task [33, 6].
Inspired by [45, 4], we modify DeepLab to accept four input channels: the input image RGB channels, plus a binary map with a bounding box of the object instance to segment. We train the network to output the segmentation mask of the object corresponding to the input bounding box. The additional input channel guides the network so as to segment only the instance of interest instead of all objects in the scene. The input box rectangle can also be seen as an initial guess of the desired output. We train using ground truth bounding boxes, and at test time Fast-RCNN detection boxes are used.
We train and using
results either over Pascal VOC12 or VOC12+COCO
data (1 training round, no recursion like in Section 3.1),
and test on the VOC12 validation set, the same set of images used
in Section 4. The augmented annotation
from  provides per-instance segments for
VOC12. We do not use CRF post-processing for neither of the networks.
Following instance segmentation literature [13, 14] we report in Table 4 at IoU threshold and . is similar to the traditional VOC12 evaluation, but using IoU between segments instead of between boxes. Since we have a fixed set of windows, we can also report the average best overlap (ABO)  metric to give a different perspective on the results.
|VOC12 + COCO|
We consider five training-free baselines: simply filling in the detection rectangles (boxes) with foreground labels, fitting an ellipse inside the box, using the MCG proposal with best bounding box IoU, and using GrabCut and (see Section 3.2), initialized from the detection box.
The results table 4 follows the same trend as the semantic labelling results in Section 4. provides the best results among the baselines considered and shows comparable performance to , while our proposed outperforms both techniques. We see that our weakly supervised approach reaches of the quality of fully-supervised case (both on and ABO metrics) using two different convnets, and , both when training with VOC12 or VOC12+COCO.
Examples of the instance segmentation results from weakly supervised (VOC12+COCO) are shown in Figure 6. Additional example results are presented in the supplementary material.
The series of experiments presented in this paper provides new insights on how to train pixel-labelling convnets from bounding box annotations only. We showed that when carefully employing the available cues, recursive training using only rectangles as input can be surprisingly effective (). Even more, when using box-driven segmentation techniques and doing a good balance between accuracy and recall in the noisy training segments, we can reach state of the art performance without modifying the segmentation network training procedure (). Our results improve over previously reported ones on the semantic labelling task and reach of the quality of the same network trained on the ground truth segmentation annotations (over the same data). By employing extra training data with bounding box annotations from COCO we are able to match the full supervision results. We also report the first results for weakly supervised instance segmentation, where we also reach of the quality of the fully-supervised training.
Our current approach exploits existing box-driven segmentation techniques, treating each annotated box individually. In future work we would like to explore co-segmentation ideas (treating the set of annotations as a whole), and consider even weaker forms of supervision.
Decoupled deep neural network for semi-supervised semantic segmentation.In NIPS, 2015.
Pushing the boundaries of boundary detection using deep learning.In ICLR, 2016.
Weakly- and semi-supervised learning of a dcnn for semantic image segmentation.In ICCV, 2015.
Constrained convolutional neural networks for weakly supervised segmentation.In ICCV, 2015.
Secrets of grabcut and kernel k-means.In ICCV, 2015.
Conditional random fields as recurrent neural networks.In ICCV, 2015.
This supplementary material provides additional quantitative and qualitative results:
In Section 3 of the main paper we recursively train a convnet directly on the full extend of bounding box annotations as foreground labels, disregarding post-processing stages. We name this recursive training approach Naive. Using this supervision and directly applying recursive training leads to significant degradation of the segmentation output quality, see Figure S1.
To improve the labels between the training rounds three post-processing stages are proposed. Here we discuss them in more detail:
Box enforcing: Any pixel outside the box annotations is reset to background label (cue C1, see Section 3 in the main paper).
Outliers reset: If the area of a segment is too small compared to its corresponding bounding box (e.g. IoU), the box area is reset to its initial label (fed in the first round). This enforces a minimal area (cue C2).
CRF: As it is common practice among semantic labelling methods, we filter the output of the network to better respect the image boundaries. (We use DenseCRF  with the DeepLabv1 parameters ). In our weakly supervised scenario, boundary-aware filtering is particularly useful to improve objects delineation (cue C3).
Figure S1 presents results of the recursive training using boxes as input and shows the contribution of the post-processing stages. We see that the naive recursive training is ineffectual. However as soon as some constraints (box enforcing and outliers reset, cues C1+C2) are enforced, the quality improves dramatically after the first round of recursive training. These results already improve over previous work considering rectangles only input [8, 27] (both using a similar convnet to ours) and achieve points improvement over  (from to mIoU, see Figure S1 “Box enf.+Outliers reset”).
Even more, when also adding CRF filtering (+ cue C3) over the training set, we see a steady grow after each round, stabilizing around . This number is surprisingly close to the best results obtained using more sophisticated techniques , which achieve around (see Figure S1 and Table S2).
Our results indicate that recursive training of a convnet is robust to input noise as soon as appropriate care is taken to de-noise the output between rounds, enabled by given bounding boxes and object priors.
In this work we focus on box level annotations for semantic labelling of objects. The closest related work are thus [8, 27]. Since all implementations use slightly different networks and training procedures, care should be taken during comparison. Both  and  propose new ways to train convnets under weak supervision. Both of the approaches build upon the DeepLab network , however, there are a few differences in the network architecture.
WSSL  employs 2 different variants of the DeepLab architecture with small and large receptive field of view (FOV) size. For each experiment WSSL evaluates with both architectures and reports the best result obtained (using boxes or segments as input). BoxSup  uses their own implementation of the DeepLab with the small FOV. In our approach all the experiments employ the DeepLab architecture with the large FOV.
There are also differences in the training procedure. For SGD WSSL uses a mini-batch of 20-30 images and fine-tunes the network for about 12 hours (number of epochs is not specified) with the standard learning parameters (following). In the SGD training BoxSup uses a mini-batch size of 20 and the learning rate is divided by 10 after every 15 epochs. The training is terminated after 45 epochs. We use a mini-batch of 30 images for SGD and the learning rate is divided by 10 after every 2k iterations, ~6 epochs. Our network is trained for 6k iterations, ~18 epochs.
Similarly to our approach, the BoxSup method  uses MCG object proposals during training. However, there are important differences. They modify the training procedure so as to denoise intermediate outputs by randomly selecting high overlap proposals. In comparison, our approach keeps the training procedure unmodified and simply generates input labels. Our approach also uses ignore regions, while BoxSup does not explore this dimension.
WSSL  proposes an expectation-maximisation algorithm with a bias to enable the network to estimate the foreground regions. In contrast, in our work we show that one can reach better results without modifying the training procedure (compared to the fully supervised case) by instead carefully generating input labels for training from the bounding box annotations (Section 3.2 in the main paper).
As discussed in Section 3.2 in the main paper we propose to employ box-guided instance segmentation to increase quality of the input data. Our goal is to have weak annotations with maximal quality and minimal loss in recall. In Section 3.1 in the main paper we explored how far could we get with just using boxes as foreground labels. However, to obtain results of higher quality several rounds of recursive training are needed. Starting from less noisier object segments we would like to reach better performance with just one training round.
For this purpose we explore different GrabCut-like  techniques, the corresponding quantitative results are in Table S1. For evaluation we use the mean IoU measure. Previous work evaluated using the 50 images from the GrabCut dataset , or images with one salient object . The evaluation of Table S1 compares multiple methods over object windows, where the objects are not salient, have diverse sizes and occlusions level. This is a more challenging scenario than usually considered for GrabCut-like methods.
GrabCut  is the established technique to estimate an object segment from its bounding box. To further improve its quality we propose to use better pairwise terms. We name this variant GrabCut+. Instead of the typical RGB colour difference the pairwise terms in GrabCut+
are replaced by probability of boundary as generated by HED. The HED boundary detector is trained on the generic boundaries of BSDS500 . Moving from GrabCut to GrabCut+ brings a points improvement, see Table S1.
Figure S2 presents examples of the considered weak annotations. This figure extends Figure 3 of the main paper.
In Table S2, we present per class results on the Pascal VOC12 test set for the methods reported in the main paper in Table 2.
On average with our weakly supervised results we achieve quality of full supervision across all classes when training with VOC12 only or VOC12+COCO.
Figure S3 presents qualitative results for semantic labelling on Pascal VOC12. The presented semantic labelling examples show that high quality segmentation can be achieved using only detection bounding box annotations. This figure extends Figure 5 of the main paper.
Figure S4 illustrates additional qualitative results for instance segmentations given by the weakly supervised and models. This figure complements Figure 6 from the main paper.
Figure S5 shows examples of instance segmentation given by different methods. Our proposed weakly supervised model achieves competitive performance with fully supervised results and provides higher quality output in comparison with box-guided segmentation techniques. The model also provides similar results, see Table 4 in the main paper.