Multi-Scale Convolutions for Learning Context Aware Feature Representations

TL;DR

This paper introduces a weakly supervised metric learning approach with a novel multi-scale convolutional layer to generate context-aware features, improving semantic correspondence and matching accuracy.

Contribution

It proposes a new convolutional layer combining differently strided convolutions and a geometrically informed data mining method for better semantic matching.

Findings

Outperforms state-of-the-art on semantic matching benchmarks.

Produces features with high accuracy in nearest neighbor matching.

Enables joint semantic flow prediction and foreground segmentation.

Abstract

Finding semantic correspondences is a challenging problem. With the breakthrough of CNNs stronger features are available for tasks like classification but not specifically for the requirements of semantic matching. In the following we present a weakly supervised metric learning approach which generates stronger features by encoding far more context than previous methods. First, we generate more suitable training data using a geometrically informed correspondence mining method which is less prone to spurious matches and requires only image category labels as supervision. Second, we introduce a new convolutional layer which is a learned mixture of differently strided convolutions and allows the network to encode implicitly more context while preserving matching accuracy at the same time. The strong geometric encoding on the feature side enables us to learn a semantic flow network, which generates more natural deformations than parametric transformation based models and is able to jointly predict foreground regions at the same time. Our semantic flow network outperforms current state-of-the-art on several semantic matching benchmarks and the learned features show astonishing performance regarding simple nearest neighbor matching.

Figures

Tables

Table 1. Table 1 : Influence of different dilation values on PF-PASCAL [ 12 ] using NN matching. We compare our learned mixture (MSConv Learn) with a simple averaging (MSConv Avg.) and Deformable Convolutions (DeformConv) [ 5 ] .

Methods	PCK
	@$0.05$	@$0.1$	@$0.15$
Dilation 1	49.0	68.4	75.6
Dilation 3	48.4	73.5	82.7
Dilation 5	45.9	73.9	84.8
DeformConv [5]	48.7	65.8	71.8
MSConv - Avg.	48.7	74.5	83.7
MSConv - Learn	53.1	77.2	86.0

Table 2. Table 3 : Comparison of our correspondence mining (Ours) against ground truth data (GT) for NN matching on PF-PASCAL [ 12 ] . In addition we split classes and trained on one half and tested on the other half (class split).

Methods	PCK
	@$0.05$	@$0.1$	@$0.15$
GT	53.1	78.1	87.4
Ours	53.1	77.2	86.0
GT (class split)	28.7	54.9	69.5
Ours (class split)	39.0	61.8	73.5

Table 3. Table 5 : Evaluation results on the PF-PASCAL [ 12 ] , Taniai [ 34 ] and PASCAL Parts [ 12 ] dataset. The amount of supervision ranges from none (-), image class labels (classL), image pairs (imgPairs), bounding boxes (bbx) up to full keypoints annotations (keyPts).

Methods	Feat. Extr.	Superv.	PF-PASCAL	Taniai	PASCAL Parts
			PCK@$0.1$	Avg.	IoU	@$0.05$	@$0.1$
DSP [18]	SIFT	–	37	44.5	0.39	17	–
\hdashlinePF [12]	HOG	–	62.5	65.7	0.41	17	36
\hdashlineDCTM [22]	VGG-16	–	69.6	74.0	0.48	32	50
\hdashlineUCN-ST [4]	Inception-v1	keyPts	55.6	67.9	–	26	44
\hdashlineFCSS-LOM [20]	VGG-16	bbox	68.9	66.8	0.44	28	47
\hdashlineSCNet-AG+ [13]	VGG-16	keyPts	72.2	61.9	0.48	18	–
\hdashlineCNNGeo [32]	VGG-16	synth	62.6	67.3	0.51	22.1	46.6
\hdashlineCNNGeo [32]	ResNet-101	synth	69.5	73.5	0.54	25.8	49.5
\hdashlineWAlign [31]	ResNet-101	synth & imgPairs	74.8	73.7	0.55	28.4	53.2
\hdashlineRTNs [19]	VGG-16	imgPairs	74.3	73.2	–	–	–
\hdashlineRTNs [19]	ResNet-101	imgPairs	75.9	77.2	–	–	–
Ours w/NN	VGG-16	classL	77.2	75.7	–	37.2	54.3
\hdashlineOurs	VGG-16	classL	78.5	79.7	0.57	34.7	54.5

Table 4. Table 6: Evaluation of our segmentation network for co-segmentation on the Tania benchmark [ 34 ] .

tt Methods tt	Joulin et al. [16]	Faktor et al. [9]	Tania et al. [34]	test Ours test
IoU	0.39	0.58	0.64	0.72

Table 5. Table 7 : Influence of different dilation values on PF-PASCAL [ 12 ] using NN matching. We compare our learned mixture (MSConv Learn) with a simple averaging (MSConv Avg.).

Methods	PCK, AlexNet [25]
	@$0.05$	@$0.1$	@$0.15$
Dilation 1	43.2	64.1	72.3
Dilation 3	42.9	70.1	81.7
Dilation 5	34.8	66.9	81.1
MSConv - Avg.	44.4	68.1	79.0
MSConv - Learn	49.1	74.2	84.0

Table 6. Table 9 : Matching accuracy on the PF-PASCAL benchmark [ 12 ] , where we compare our performance for training on different datasets.

Method	Training Dataset	PCK
		@$0.05$	@$0.1$	@$0.15$
FCSS-CAT [21]	Caltech-101 [10]	33.6	68.9	79.2
Ours	Caltech-101 [10]	40.0	71.1	84.6
Ours	PF-PASCAL [12]	52.7	78.5	88.1

Table 7. Table 10 : Matching accuracy on the PF-PASCAL dataset [ 13 ] , where we use the definition of PCK from Joen et al. [ 15 ] . The amount of required supervision (Superv.) ranges from no supervision (-), image class labels (classL), segmentation masks (segm) up to full keypoint annotations (keyPts).

Methods	Superv.	PCK
		@$0.05$	@$0.1$	@$0.15$
PF [12]	–	19.2	33.4	49.2
SCNet [13]	keyPts	26.0	48.2	65.8
PARN [15]	segm	26.8	49.1	66.2
Ours w/NN	classL	42.9	66.5	78.8
Ours	classL	42.8	67.8	80.2

Equations

$$L_{\text{affine}}=\frac{1}{h_s{w}_s}\sum _{y=1}^{h_s}\sum _{x=1}^{w_s}\Vert F_s(x,y)-F_t^{\prime }(x,y){\Vert }_2,$$

$$L_{\text{flow}}=\frac{1}{h_s{w}_s}\sum _{y=1}^{h_s}\sum _{x=1}^{w_s}\Vert F_s(x,y)-F_t^{\prime \prime }(x,y){\Vert }_2.$$

$$L_{\text{corr}}=\frac{1}{\sqrt{h_s^2+w_s^2}}\frac{1}{|\Omega |}\sum _{i\in \Omega }\Vert x_{s,i}-x_{t,i}^{\prime \prime }{\Vert }_2,$$

$$\begin{split}L_{\text{mask}}=\frac{1}{h_{s}w_{s}}\sum^{h_{s}}_{y=1}\sum^{w_{s}}_{x=1}&\big{(}M_{s}^{\text{corr}}(x,y)\log(M(x,y))\\ &+(1-M^{\text{corr}}_{s}(x,y))\log(1-M(x,y))\big{)}\end{split}$$

$$\begin{array}{r}{L}_{\text{total}}=L_{\text{aff}}+\gamma L_{\text{flow}}+\mu L_{\text{corr}}+\nu L_{\text{mask}}\end{array}$$

Full text

1 Introduction

††* Both authors contributed equally.

Estimating correspondences between images is one of the main problems in computer vision with application in optical flow, stereo matching, structure from-motion, SLAM and segmentation. Early approaches have focused on finding correspondence between images depicting identical objects or scenes from different viewpoints. With increasingly better feature representations, recent work focuses on estimating correspondences between different instances of the same semantic category [26, 18], which is much more challenging due to the severe visual intra-class variations. In the literature this problem is also denoted as semantic matching or semantic flow estimation for the task of finding dense correspondences.

In general, matching approaches consist of two main parts: First, a feature extraction method, usually a convolutional network, and second, a geometric model, which estimates a global transformation based on local feature similarities. Current state-of-the-art methods try to learn both parts jointly but suffer from three limitations:

1. The feature representation is often based on standard image classification networks, which are not well suited for finding local correspondences. One important reason is that these networks have only a small effective receptive field [29] and cannot resolve matching ambiguities using larger context.
2. The majority of approaches [32, 31, 13] utilize rigid alignment models, like a TPS [1], which aggregate local feature similarities and provide a strong spatial regularization. However, these models are not able to cope with complex non-linear deformations and provide only rough alignments. In contrast non-parametric transformation models try to estimate pixel-wise accurate flow fields [41, 19]. But learning these models requires a large amount of data due to their many degrees of freedom.

A lot of progress has been made in the area of image co-segmentation where the foreground objects in two or more images are predicted. Recent semantic matching algorithms neglect this aspect: they find pixel-wise correspondences but do not predict which pixels in the two images belongs to the foreground object.

In order to address these limitations we introduce the following innovations. First, we introduce a geometrically informed correspondence mining procedure, which generates correspondences on a patch level which can often be resolved only on a higher contextual scale.

Second, we introduce a new network layer which consists of a learnable mixture of convolutions with different dilation strides. This new layer allows the network to propagate information from different spatial resolutions through the network in order to increase the size of the effective receptive field and preserve the spatial localization at the same time. Due to the context enriched features we are able to obtain a strong baseline for dense semantic matching without any transformation model, see Fig. 1. Based on these features the loose geometric regularization of local transformation models can be resolved and we are able to train a semantic flow network in a weakly supervised way which provides more natural warps compared to previous parametric models. Furthermore, we utilize our mined correspondences to learn a segmentation module in our semantic flow network which is capable to provide pixel-wise foreground predictions.

2 Related work

Dense semantic matching. The pioneering work in semantic matching was done by Liu et al. with the development of SIFT Flow [26] and its extension from Kim et al. [18]. They densely sampled SIFT descriptors and formulated a discrete optimization problem for finding an optimal flow field. Due to the success of CNNs more recent approaches replaced hand engineered descriptors [26, 6] with learned features. First there was a strong focus on finding geometric sensitive feature representations for semantic matching [4, 20]. Choey et al. [4] introduced a fully convolutional Siamese architecture with a contrastive loss. And Kim et al. [20] proposed a convolutional descriptor based on the principle of local self-similarity, where the geometric alignment was based on hand-engineered models. More recent approaches combined learning descriptors and geometric alignment models [12, 31]. Han et al. [12] follow Proposal Flow [20] and formulate a convolutional neural network architecture based on region proposals. Using the feature correlation map generated by a Siamese architecture, Roccoco et al. [32, 31] perform regression on the parameters of a thin plate spline [1]. However, these methods are based on parametric transformation models, which provide a strong geometric regularization and poor spatial alignment. There are only a few exceptions where trainable networks for semantic flow fields are examined [41]. Zhou at al. [41] propose an encoder-decoder network for dense semantic flow, which is inspired by architectures from optical flow, but it requires 3D CAD models to synthesize a large set of pixel-wise accurate ground truth flow. Just recently Kim et al. [19] introduced a recurrent network for learning a semantic flow field trained on a set of matching images pairs. But they are not capable to perform pixel-wise foreground prediction.

Weakly supervised training. The majority of semantic matching frameworks are trained on strong supervision in the form of key point annotations [4, 13], 3D models [41], bounding box annotations [20] or image segmentation [15]. There are only few exceptions, like Novotny et al. [30], which use image-level labels to learn discriminative part filters matching across different object instances. But the accuracy of these features are rather limited and restricted to specific object categories. Another popular approach is to utilize synthetically generated image pairs [32, 31, 17]. For conducting alignment of fine-grained categories WarpNet [17] estimates the parameters of a thin plate spline using a point transformer and synthetically warped images. A similar approach is done by Roccoco et al. [32], which regresses the geometric model parameters based on a feature correlation map and train on a large synthetically generated set of image pairs. In the extension [31] they improve their results by fine tuning with an unsupervised soft-inlier count using provided image pairs. Another approach for generating training data is to estimate correspondences using a simple one-cycle-constraint [20, 15]. But this is prone to background clutter and therefore also requires strong supervision in terms of bounding boxes or segmentation masks. In contrast our method does not required labeled image pairs [32, 15, 19], synthetic training data [32, 31], segmentation masks [15] or bounding boxes [20], but only relies on image category labels as source of supervision. Therefore, it makes it possible to learn powerful feature representations for semantic matching from large-scale datasets like ImageNet.

Context aware feature representation. To incorporate more contextual information various approaches have been proposed to enlarge the receptive field size. For semantic segmentation Long et al. [27] proposed a skip architecture to aggregate multiple scales of deep feature hierarchies. Yu et al. [38] introduced dilated convolutions, also known as atrous convolution, which increases the internal filter’s stride. Dai et al. [5] proposed an extension, where the grid like sampling pattern was resolved and augmented with an additional offset module which learns the offset from the target task. For estimating visual correspondences Wang et al. [37] propose a multi-scale pyramid approach, where multi-scale features maps are combined in an optimal way using an attention module. In contrast we learn a mixture of dilated convolutions for each layer which enables the network to propagate information from different scales through the network preserving the overall spatial accuracy.

Contributions. There are four main contributions. (1) We propose a correspondence mining procedure which provides image representations that are better suited for semantic matching compared to training on sparse keypoint annotations. (2) We propose a new convolutional layer, called multi-scale convolution, which produces highly context aware feature representations for the task of semantic matching. (3) Our semantic flow network is not only capable to predict accurate semantic flow but also to provide foreground segmentations. (4) We outperform state-of-the-art methods on challenging benchmark datasets. And simple nearest neighbor matching with our features show competitive performance compared to state-of-the-art matching methods which utilize sophisticated learned transformations models.

3 Approach

In the following we present our new multi-scale convolutional network for learning highly context aware feature representations. To alleviate tedious manual labeling and to obtain enough training data we introduce a weakly supervised mining procedure which requires only class labels. On top of this feature representation we train a semantic flow network, which provides pixel-wise accurate semantic flow and foreground segmentations at the same time.

3.1 Weakly supervised correspondence mining

Given a set of images $\mathcal{I}$ from the same category, our weakly supervised mining approach consists of two main steps. First, using a similarity graph, we identify images depicting semantically similar objects from the same viewpoint and second we utilize a sparse graph matching approach, which finds corresponding regions between a given image pair.

Choosing image pairs to match. Mining correspondences between all image pairs is not feasible and not desirable since objects from different viewpoints or semantically different types would lead to spurious matches. Therefore, we use a simple, yet effective heuristic and construct a k-nearest neighbor graph $\mathcal{G}(\mathcal{I},\mathcal{N})$, where an edge $(i,j)\in\mathcal{N}$ exists if image $I_{j}$ is among the k nearest neighbors of image $I_{i}$. We assume that neighboring images are semantically close and depict objects from similar viewpoints. By selecting all edges we obtain a large set of image pairs on which we apply our graph matching approach for finding corresponding regions.

Finding corresponding regions. For finding matching regions we utilize the spatial feature pyramid representation of Girshick et al. [11] and the sparse graph matching approach of Ufer et al. [36]. Given an image pair $(I_{i},I_{j})$ we extract CNN features from the fourth layer of the network for 6 different image resolutions forming a feature pyramid for both images. Then we extract features in a sliding window manner with a fixed window size, which corresponds to a coverage of both images with patches of different sizes. For these patches, which are covering a range from $20\text{x}20$ up to $80\text{x}80$ pixels in a $224\text{x}224$ image, we are searching for corresponding regions. To reduce the overall number of patches we select a subset in both images using non-maximum suppression on the overall feature activation and a one-cycle consistency constraint. Based on these selected patches in $I_{i}$ we search for their $k$ nearest neighbors in the image $I_{j}$ and obtain matching candidates. Now, analogously to [36, 35], selecting geometric consistent matching candidates in both directions can be formulated as a one-to-one matching problem which leads to a second order Integer Quadratic Program (IQP) which can easily be solved due to the sparsity of the graph with an approximate inference method like TRWS [23]. An additional outlier class makes it possible to discard specific matching candidates which are not in agreement with the dominant geometry. This results in our final set of patch correspondences which are generated on different scales and contains a large amount of correspondences which can not be resolved by their local appearance.

3.2 Feature learning using multi-scale convolutions

For learning our feature representation we follow the standard metric learning approach with a Siamese network [3]. Given two images we extract features from intermediate convolutional layers at the centers of corresponding patches and penalize their Euclidean distance using contrastive loss [4, 20]. The set of matching pairs is given by our mined correspondences and non-matching pairs are generated by hard negative mining. We adopt the hard negative mining approach of UCN [4] by searching for nearest neighbors outside a certain radius of corresponding points in the target image.

Multi-scale convolutions. For learning context aware feature representations we replace all convolutional layers in the network with a combination of dilated convolutions with different strides, which we refer to as multi-scale convolutions. These dilated convolutions are combined in a weighted sum, where the weights are also learned during back propagation, as illustrated in Fig. 3. To obtain the same dimensions of the output feature maps we adjust the zero padding on the input feature map for each scale separately. Each dilated convolution implies a specific receptive field and by optimizing the weighted sum the network learns how to adjust its effective receptive field in each layer for the task of matching. This is important since the network can use the wider context to resolve ambiguities in semantic matching while a smaller receptive field is still available to maintain localization accuracy. In the following experiments we will show that adjusting the weights for each layer is crucial since each layer requires a different amount of contextual information. Our experiments have also shown that applying the non-linear activation before the fusion step provides better results since it prevents the signal of a single scale from suppressing all others.

3.3 Semantic flow network

Based on the previously described encoder we train a semantic flow network which provides dense correspondences and object foreground predictions at the same time. It consists of three main parts, see Fig. 3, which are an affine spatial transformer (A-ST), a flow network and an auxiliary segmentation network.

Affine transformer. After extracting the feature maps we fist try to get a rough alignment of the images. Inspired by the spatial transformer [14] we concatenate the features $F_{s}$ and $F_{t}$ and regress the parameters of an affine transformation from source image $I_{s}$ to the target image $I_{t}$ using a localization network. It is trained by minimizing the $L2$ loss between features $F_{s}$ and the transformed target feature $F^{\prime}_{t}$,

[TABLE]

where $h_{s}$ and $w_{s}$ are the height and width of the source image.

Flow network. To get pixel-wise accurate correspondences we utilize a flow network on top. We follow a similar network architecture as the popular FlowNetSimple model [8]. The input of the network are the concatenated features $F_{s}$ and $F^{\prime}_{t}$, and the output is the flow from source to the affine transformed target image. The warped target feature $F^{\prime\prime}_{t}$ is constructed from $F^{\prime}_{t}$ via grid sampling and the final loss between features $F_{s}$ and $F^{\prime\prime}_{t}$ is computed by the $L2$ distance

[TABLE]

Correspondence loss. Despite the previously introduced unsupervised feature losses which try to find transformations by mapping similar feature on top of each other, we utilize the mined correspondences as proxy ground truth and minimize their $L2$ loss,

[TABLE]

where $(x_{s,i},x_{t,i})$ are the mined correspondences between the source and target image and the $x_{t,i}^{\prime\prime}$ transformed target point $x_{t,i}$ w.r.t. to the predicted affine transformation and the flow field.

Auxiliary segmentation network. The majority of correspondences are localized on the foreground. By aggregating this information over a large set of image pairs we should be able to identify foreground objects. Therefore, we create an auxiliary network for pixel-wise foreground classification. The network shares the architecture and weights of the flow network except the last layer and a sigmoid function which produces the segmentation mask. As our model is trained in an weakly supervised manner, we approximate the ground truth segmentation mask using neighboring pixels of the mined correspondences $M_{s}^{\text{corr}}$. Similar to classification, we minimize the pixel-wise cross-entropy loss

[TABLE]

of the predicted segmentation mask $M$ and the segmentation mask extracted from our correspondences $M^{\text{corr}}_{s}$. Given two images our network produces two probability maps which predict how likely each pixel belongs to the foreground. As postprocessing step we normalize the output of the softmax function to the unit interval and apply the fully-connected CRF of Krähenbühl et. al [24], which results in a binary segmentation mask.

Final loss. We train the semantic flow network by taking a weighted average of the individual losses:

[TABLE]

where $\gamma$, $\mu$ and $\nu$ are hyperparameters.

4 Experiments

In this section we present comparative evaluations with state-of-the-art semantic matching methods and ablation studies of our method.

4.1 Experimental details

In our experiments we train on the PF-PASCAL data set [12], where we neglect the subdivision into image pairs and apply the correspondence mining algorithm on each object class separately. We exclude test image pairs from training.

Unsupervised correspondence mining. For the nearest neighbor graph we set $k=10$ and generate deep pyramid features [11] using conv4 features from AlexNet [25] pre-trained on ILSVRC 2012 [7]. For each image we select 80 patches and generate two matching candidates per patch. Overall our mining procedure generates around 7k image pairs with roughly 80 correspondences per pair.

Feature encoder. As backbone architectures we use VGG-16 [33] pre-trained on ILSVRC 2012 [7] and truncated after the fourth layer. To reduce the feature dimension to 128 we append a $1\text{x}1$ convolutional layer. Our feature encoder is trained on the mined correspondences as proxy ground truth. For training we rescaled images to $224\text{x}224$ pixels and augment the image pairs by mirroring, randomly padding, cropping and rotating each image. For each correspondence we extracted 60 hard negatives and set the radius of positive correspondences to 32 pixels. The margin of contrastive loss is 1 and we trained 12 epochs in total.

Semantic flow network. We followed the same training protocol as for the feature encoder, where we set the hyperparameters $\gamma=4$, $\mu=1$ and $\nu=1$. We computed the loss in forward and backward directions and determined the gradients based on their sum. The radius for generating segmentation masks from correspondences is 5 pixels. We trained the network for 40 epochs.

4.2 Evaluation benchmarks

PF-PASCAL benchmark [12]. We follow the evaluation protocol of [13] and use keypoint annotations of the same test pairs, where the matching accuracy is measured using the percentage of correct keypoints (PCK) [27]. A keypoint is counted as transferred correctly, if its Euclidean distance to the ground truth annotation is smaller than $\alpha$, where the coordinates are normalized in the range $[0,1]$. Please see [13] for more details about this dataset.

PASCAL-Part benchmark [40]. We follow the evaluation protocol of [40] and evaluate on two different tasks, which are part segment matching and keypoint matching. For part segment matching, the flow field accuracy is measured based on the transformation of part segmentation masks. We use the weighted intersection over union (IoU) as quantitative measure, where the weights are determined by the area of each part. Please see [40] for more details.

Taniai benchmark [34]. We follow the evaluation protocol of [34, 31] and measure the flow accuracy by computing PCK densely over the whole flow field of the source object. The misalignment threshold is set to 5 pixels after resizing images so that their larger dimension is 100 pixels. For the NN matching we randomly sample 1000 points on the object. To account for different orientations in this dataset we flip the second image based on the feature loss of the flipped and unflipped version. Please see [34] for more details of this dataset.

4.3 Ablation study: Multi-scale convolution

We investigate the influence of dilation levels and fusion methods. From Tab. 8 we see that by increasing the dilation stride the matching accuracy increases, although the theoretical receptive field already covers the whole image. This is in accordance with Luo et al. [29], who found that the effective receptive field size is much smaller than the theoretical predictions. In Tab. 8 we provide the learned weights for each layer after training on our mined correspondences. It shows that in the first few layers the network prefers convolutions with small dilation levels, but with higher layers this preference is reversed. This is reasonable, since in early layers the network learns low-level concepts which require a high spatial resolution while later layers tend to learn more semantic and contextual relations where a large receptive field is beneficial. Therefore, by adjusting the dilation weight for each multi-scale convolution during the training process we obtain a clear improvement compared to a simple averaging approach.

4.4 Ablation study: Correspondence mining

We evaluate our correspondence mining approach by comparing NN matching accuracies using features trained on our mined correspondences against features trained on ground truth annotations, see Tab. 4. First, we trained each method on the whole training set and evaluated on the test set using all classes, see the upper part of Tab. 4. It shows that by training on our mined correspondences we obtain almost identical matching accuracies without any keypoint or image pair labels. This is remarkable since our mining generates a lot of inconsistent image pairs with many false correspondences. To compare the generalization capabilities of the learned features we select random splits of the dataset classes (class split) and train on one half and test on the other half. From the bottom part of Tab. 4 we observe that our mining procedure generates feature encodings which generalize better to unseen objects.

4.5 Ablation study: Semantic flow network

In Tab. 4 we provide an ablation study of our proposed semantic flow network. It can clearly be seen that all design choices of our basic model improved the performance. This includes the consecutive execution of an affine transformation with a flow field. This is conceptually similar to [19] but circumvents the expensive training of a recurrent network. Furthermore, our experiments have shown that the feature losses $L_{\text{aff}}$ and $L_{\text{flow}}$ are beneficial since they provide an additional training signal in regions where no correspondences are available.

4.6 Results on benchmarks

Qualitative results. Fig. 4 shows qualitative results on the PF-PASCAL dataset [12] with our features using nearest neighbor matching. It can clearly be seen that our matching provides more natural warps and is able to capture difficult non-linear deformations. Please notice the difficulty of this task as demonstrated in Fig. 1. Examples on the Taniai dataset [34] can be seen in Fig. 5. In contrast to previous deep learning based approaches our network is also capable to predict foreground segmentation masks. In Fig. 6 we provide an example of part matchings on the PASCAL Parts dataset [2].

Quantitative results. In Tab. 5 we present quantitative comparisons. We observe that nearest neighbor matching with our features outperform all existing semantic matching methods on the PF-PASCAL dataset [12], including supervised methods [12]. Furthermore our semantic flow network outperforms current benchmarks on PF-PASCAL [12], Taniai [34] and PASCAL Parts [2]. We evaluate our auxiliary segmentation network also for the task of co-segmentation and obtain superior results compared to state-of-the-art on the Taniai dataset [34], see Tab. 6.

5 Conclusion

We have presented a new convolutional layer for semantic matching which learns highly context aware feature representations with a high localization accuracy. It clearly outperforms other methods like dilated and deformable convolutions. To alleviate tedious manual labeling, we have introduced a correspondence mining procedure which requires only class labels and is more effective than training on ground truth keypoints. Therefore, we require less supervision than the current best methods. Our semantic flow network produces more natural warps compared to parametric transformation based models and is also capable to provide reliable foreground segmentation masks at the same time. The presented approach demonstrated significant improvements on several challenging benchmark datasets for semantic matching and joint co-segmentation. In future work we want to learn more powerful features by applying our approach on a large-scale dataset such as ImageNet.

A. Supplementary Material

A.1 Multi-scale convolution

As described in Sect. 3.2 of the main paper, we replace all convolutional layers of the feature extractor with the proposed multi-scale convolutions. In the following we provide an additional ablation study and visualization the effect on the receptive field.

A.1.1 Evaluation using AlexNet [25]

To demonstrate that the proposed multi-scale convolution generalizes to other network architectures, we provide an ablation study analogously to Sect. 4.3 of the main paper for AlexNet [25], see Tab. 8, and provide the learned dilations weights in Tab. 8. Overall, we observe a similar behaviour as we already described in the main paper. The multi-scale convolutions clearly improves the matching accuracies compared to a simple averaging approach.

A.1.2 Visualization of the effective receptive field

In the following we visualize the increased effective receptive field of our multi-scale convolution based feature extractor as we argued in the main paper. Inspired by Zeiler et al. [39], we make the following coverage visualization. Given a target and source image we fix two points and measure their feature similarity depending on the position of a grey square, which slides over the target image and visualize the change of the similarity score as heatmap in the target image. see Fig. 7. This allows us to visualize the regions in the image which are important for the feature similarity. For the standard network configuration with dilation 1, we observe that the region which influences the similarity occupies only a small fraction of the theoretical receptive field (second column) and significantly increases by our multi-scale convolutions (third column).

A.2 Correspondence mining

A.2.1 Examples of mined correspondences

We visualize results of the corresponding mining approach, see Fig. 8. In most cases it delivers consistent image pairs with accurate correspondences. In situations where image pairs are inconsistent or the discovered main geometry is not in agreement with the object depicted in both images the introduced outlier class supresses a lot of wrong correspondences. The resulting proxy segmentation masks are very sparse and inaccurate. However, over a large set of examples the segmentation network learns to generate accurate foreground predictions.

A.2.2 Generalization to other datasets

Despite the trend of state-of-the-art methods [32, 19] to train on PF-PASCAL [12] some previous methods [20, 21] utilized the Caltech-101 dataset [10]. To provide a fair comparison and to show that our feature learning approach generalizes to other datasets, we also train our method on the Caltech-101 dataset [10] and report matching accuracies on the PF-PASCAL benchmark [12], see Tab. 9.

Since we train on another dataset than PF-PASCAL [12] the performance drops significantly, nevertheless, we outperform the current best method, which is trained on Caltech-101 [10].

A.3 Evaluation on benchmarks

A.3.1 Comparison with PARN [15]

The recent publication of Jeaon et al. [15] follows another evaluation protocol for the PF-PASCAL benchmark [13] than we use in the main paper. In order to compare with their method we provide our matching accuracies with this modified definition of percentage of correct keypoints (PCK). They define a keypoint to be correctly transformed if the distance between warped and ground-truth keypoint is smaller than $\alpha\cdot\max(h,w)$ where $\alpha\in[0,1]$ and $h$, $w$ are the height and width of the bounding box in the target image. This leads to a smaller reference length and overall smaller PCK values. From Tab. 10 we can see that we clearly outperform Jeon et al. [15], although they use more supervision in terms of segmentation masks.

A.3.2 Further qualitative results

In this section, we provide additional qualitative results of nearest neighbor matching with our features and joint registration and segmentation using our semantic flow network on the PF-PASCAL [12] and the Taniai [34] dataset, see Figures 9 and 10, respectively. The results support the statement that our algorithm is capable to warp images pixel-wise accurately across objects despite heavy intra-class variation, view-point changes and background clutter. In addition the segmentation network is capable to predict accurately the foreground in both images.