Abstract

We address the problem of determining correspondences between two images in agreement with a geometric model such as an affine or thin-plate spline transformation, and estimating its parameters. The contributions of this work are three-fold. First, we propose a convolutional neural network architecture for geometric matching. The architecture is based on three main components that mimic the standard steps of feature extraction, matching and simultaneous inlier detection and model parameter estimation, while being trainable end-to-end. Second, we demonstrate that the network parameters can be trained from /media/arxiv_projects/37807/synthetically generated imagery without the need for manual annotation and that our matching layer significantly increases generalization capabilities to never seen before images. Finally, we show that the same model can perform both instance-level and category-level matching giving state-of-the-art results on the challenging Proposal Flow dataset.

Estimating correspondences between images is one of the fundamental problems in computer vision [20] with applications ranging from large-scale 3D reconstruction [2] to image manipulation [22] and semantic segmentation [44]. Traditionally, correspondences consistent with a geometric model such as epipolar geometry or planar affine transformation, are computed by detecting and matching local features (such as SIFT [40] or HOG [12]), followed by pruning incorrect matches using local geometric constraints [45] and robust estimation of a global geometric transformation using algorithms such as RANSAC [19] or Hough transform [34]. This approach works well in many cases but fails in situations that exhibit (i) large changes of depicted appearance due to intra-class variation [23], or (ii) large changes of scene layout or non-rigid deformations that require complex geometric models with many parameters which are hard to estimate in a manner robust to outliers.

In this work we build on the traditional approach and develop a convolutional neural network (CNN) architecture that mimics the standard matching process. First, we replace the standard local features with powerful trainable convolutional neural network features [33], which allows us to handle large changes of appearance between the matched images. Second, we develop trainable matching and transformation estimation layers that can cope with noisy and incorrect matches in a robust way, mimicking the good practices in feature matching such as the second nearest neighbor test [40], neighborhood consensus [45] and Hough transform-like estimation [34].

The outcome is a convolutional neural network architecture trainable for the end task of geometric matching, which can handle large appearance changes, and is therefore suitable for both instance-level and category-level matching problems.

Figure 1: Our trained geometry estimation network automatically aligns two images with substantial appearance differences. It is able to estimate large deformable transformations robustly in the presence of clutter.

The classical approach for finding correspondences involves identifying interest points and computing local descriptors around these points [25]. While this approach performs relatively well for instance-level matching, the feature detectors and descriptors lack the generalization ability for category-level matching.

Recently, convolutional neural networks have been used to learn powerful feature descriptors which are more robust to appearance changes than the classical descriptors [29]. However, these works still divide the image into a set of local patches and extract a descriptor individually from each patch. Extracted descriptors are then compared with an appropriate distance measure [29], by directly outputting a similarity score [24], or even by directly outputting a binary matching/non-matching decision [3].

In this work, we take a different approach, treating the image as a whole, instead of a set of patches. Our approach has the advantage of capturing the interaction of the different parts of the image in a greater extent, which is not possible when the image is divided into a set of local regions.

Related are also network architectures for estimating inter-frame motion in video [52] or instance-level homography estimation [14], however their goal is very different from ours, targeting high-precision correspondence with very limited appearance variation and background clutter. Closer to us is the network architecture of [30] which, however, tackles a different problem of fine-grained category-level matching (different species of birds) with limited background clutter and small translations and scale changes, as their objects are largely centered in the image. In addition, their architecture is based on a different matching layer, which we show not to perform as well as the matching layer used in our work.

Some works, such as [10], have addressed the hard problem of category-level matching, but rely on traditional non-trainable optimization for matching [10], or guide the matching using object proposals [23]. On the contrary, our approach is fully trainable in an end-to-end manner and does not require any optimization procedure at evaluation time, or guidance by object proposals.

Others [35] have addressed the problems of instance and category-level correspondence by performing joint image alignment. However, these methods differ from ours as they: (i) require class labels; (ii) don’t use CNN features; (iii) jointly align a large set of images, while we align image pairs; and (iv) don’t use a trainable CNN architecture for alignment as we do.

In this section, we introduce a new convolutional neural network architecture for estimating parameters of a geometric transformation between two input images. The architecture is designed to mimic the classical computer vision pipeline ( [42]), while using differentiable modules so that it is trainable end-to-end for the geometry estimation task. The classical approach consists of the following stages: (i) local descriptors ( SIFT) are extracted from both input images, (ii) the descriptors are matched across images to form a set of tentative correspondences, which are then used to (iii) robustly estimate the parameters of the geometric model using RANSAC or Hough voting.

Figure 2: Diagram of the proposed architecture. Images IA and IB are passed through feature extraction networks which have tied parameters W, followed by a matching network which matches the descriptors. The output of the matching network is passed through a regression network which outputs the parameters of the geometric transformation.

Our architecture, illustrated in Figure 2, mimics this process by: (i) passing input images IA and IB through a siamese architecture consisting of convolutional layers, thus extracting feature maps fA and fB which are analogous to dense local descriptors, (ii) matching the feature maps (“descriptors”) across images into a tentative correspondence map fAB, followed by a (iii) regression network which directly outputs the parameters of the geometric model, ^θ, in a robust manner. The inputs to the network are the two images, and the outputs are the parameters of the chosen geometric model, a 6-D vector for an affine transformation.

The first stage of the pipeline is feature extraction, for which we use a standard CNN architecture. A CNN without fully connected layers takes an input image and produces a feature map f∈Rh×w×d, which can be interpreted as a h×w dense spatial grid of d-dimensional local descriptors. A similar interpretation has been used previously in instance retrieval [6] demonstrating high discriminative power of CNN-based descriptors. Thus, for feature extraction we use the VGG-16 network [48], cropped at the pool4 layer (before the ReLU unit), followed by per-feature L2-normalization. We use a pre-trained model, originally trained on ImageNet [13] for the task of image classification. As shown in Figure 2, the feature extraction network is duplicated and arranged in a siamese configuration such that the two input images are passed through two identical networks which share parameters.

The image features produced by the feature extraction networks should be combined into a single tensor as input to the regressor network to estimate the geometric transformation. We first describe the classical approach for generating tentative correspondences, and then present our matching layer which mimics this process.

Classical methods start by computing similarities between all pairs of descriptors across the two images. From this point on, the original descriptors are discarded as all the necessary information for geometry estimation is contained in the pairwise descriptor similarities and their spatial locations. Secondly, the pairs are pruned by either thresholding the similarity values, or, more commonly, only keeping the matches which involve the nearest (most similar) neighbors. Furthermore, the second nearest neighbor test [40] prunes the matches further by requiring that the match strength is significantly stronger than the second best match involving the same descriptor, which is very effective at discarding ambiguous matches.

Our matching layer applies a similar procedure. Analogously to the classical approach, only descriptor similarities and their spatial locations should be considered for geometry estimation, and not the original descriptors themselves.

To achieve this, we propose to use a correlation layer followed by normalization. Firstly, all pairs of similarities between descriptors are computed in the correlation layer. Secondly, similarity scores are processed and normalized such that ambiguous matches are strongly down-weighted.

Figure 3: Correlation map computation with CNN features. The correlation map cAB contains all pairwise similarities between individual features fA∈fA and fB∈fB. At a particular spatial location (i,j) the correlation map output cAB contains all the similarities between fB(i,j) and all fA∈fA.

In more detail, given L2-normalized dense feature maps fA,fB∈Rh×w×d, the correlation map cAB∈Rh×w×(h×w) outputted by the correlation layer contains at each position the scalar product of a pair of individual descriptors fA∈fA and fB∈fB, as detailed in Eq. .

cAB(i,j,k)=fB(i,j)TfA(ik,jk)(1)

where (i,j) and (ik,jk) indicate the individual feature positions in the h×w dense feature maps, and k=h(jk−1)+ik is an auxiliary indexing variable for (ik,jk).

A diagram of the correlation layer is presented in Figure 3. Note that at a particular position (i,j), the correlation map cAB contains the similarities between fB at that position and all the features of fA.

As is done in the classical methods for tentative correspondence estimation, it is important to postprocess the pairwise similarity scores to remove ambiguous matches. To this end, we apply a channel-wise normalization of the correlation map at each spatial location to produce the final tentative correspondence map fAB. The normalization is performed by ReLU, to zero out negative correlations, followed by L2-normalization, which has two desirable effects. First, let us consider the case when descriptor fB correlates well with only a single feature in fA. In this case, the normalization will amplify the score of the match, akin to the nearest neighbor matching in classical geometry estimation. Second, in the case of the descriptor fB matching multiple features in fA due to the existence of clutter or repetitive patterns, matching scores will be down-weighted similarly to the second nearest neighbor test [40]. However, note that both the correlation and the normalization operations are differentiable with respect to the input descriptors, which facilitates backpropagation thus enabling end-to-end learning.

The first step of our matching layer, namely the correlation layer, is somewhat similar to layers used in DeepMatching [52] and FlowNet [18]. However, DeepMatching [52] only uses deep RGB patches and no part of their architecture is trainable. FlowNet [18] uses a spatially constrained correlation layer such that similarities are are only computed in a restricted spatial neighborhood thus limiting the range of geometric transformations that can be captured. This is acceptable for their task of learning to estimate optical flow, but is inappropriate for larger transformations that we consider in this work. Furthermore, neither of these methods performs score normalization, which we find to be crucial in dealing with cluttered scenes.

Previous works have used other matching layers to combine descriptors across images, namely simple concatenation of descriptors along the channel dimension [14] or subtraction [30]. However, these approaches suffer from two problems. First, as following layers are typically convolutional, these methods also struggle to handle large transformations as they are unable to detect long-range matches. Second, when concatenating or subtracting descriptors, instead of computing pairwise descriptor similarities as is commonly done in classical geometry estimation and mimicked by the correlation layer, image content information is directly outputted. To further illustrate why this can be problematic, consider two pairs of images that are related with the same geometric transformation – the concatenation and subtraction strategies will produce different outputs for the two cases, making it hard for the regressor to deduce the geometric transformation. In contrast, the correlation layer output is likely to produce similar correlation maps for the two cases, regardless of the image content, thus simplifying the problem for the regressor. In line with this intuition, in Sec. ? we show that the concatenation and subtraction methods indeed have difficulties generalizing beyond the training set, while our correlation layer achieves generalization yielding superior results.

The normalized correlation map is passed through a regression network which directly estimates parameters of the geometric transformation relating the two input images. In classical geometry estimation, this step consists of robustly estimating the transformation from the list of tentative correspondences. Local geometric constraints are often used to further prune the list of tentative matches [45] by only retaining matches which are consistent with other matches in their spatial neighborhood. Final geometry estimation is done by RANSAC [19] or Hough voting [34].

We again mimic the classical approach using a neural network, where we stack two blocks of convolutional layers, followed by batch normalization [27] and the ReLU non-linearity, and add a final fully connected layer which regresses to the parameters of the transformation, as shown in Figure 4. The intuition behind this architecture is that the estimation is performed in a bottom-up manner somewhat like Hough voting, where early convolutional layers vote for candidate transformations, and these are then processed by the later layers to aggregate the votes. The first convolutional layers can also enforce local neighborhood consensus [45] by learning filters which only fire if nearby descriptors in image A are matched to nearby descriptors in image B, and we show qualitative evidence in Sec. ? that this indeed does happen.

Figure 4: Architecture of the regression network. It is composed of two convolutional layers without padding and stride equal to 1, followed by batch normalization and ReLU, and a final fully connected layer which regresses to the P transformation parameters.

A potential alternative to a convolutional regression network is to use fully connected layers. However, as the input correlation map size is quadratic in the number of image features, such a network would be hard to train due to a large number of parameters that would need to be learned, and it would not be scalable due to occupying too much memory and being too slow to use. It should be noted that even though the layers in our architecture are convolutional, the regressor can learn to estimate large transformations. This is because one spatial location in the correlation map contains similarity scores between the corresponding feature in image B and all the features in image A (c.f. equation ), and not just the local neighborhood as in [18].

Another commonly used approach when estimating image to image transformations is to start by estimating a simple transformation and then progressively increase the model complexity, refining the estimates along the way [39]. The motivation behind this method is that estimating a very complex transformation could be hard and computationally inefficient in the presence of clutter, so a robust and fast rough estimate of a simpler transformation can be used as a starting point, also regularizing the subsequent estimation of the more complex transformation.

We follow the same good practice and start by estimating an affine transformation, which is a 6 degree of freedom linear transformation capable of modeling translation, rotation, non-isotropic scaling and shear. The estimated affine transformation is then used to align image B to image A using an image resampling layer [28]. The aligned images are then passed through a second geometry estimation network which estimates 18 parameters of a thin-plate spline transformation. The final estimate of the geometric transformation is then obtained by composing the two transformations, which is also a thin-plate spline. The process is illustrated in Figure 5.

Figure 5: Estimating progressively more complex geometric transformations. Images A and B are passed through a network which estimates an affine transformation with parameters ^θAff (see Fig. ). Image A is then warped using this transformation to roughly align with B, and passed along with B through a second network which estimates a thin-plate spline (TPS) transformation that refines the alignment.

We assume a fully supervised setting, where the training data consists of pairs of images and the desired outputs in the form of the parameters θGT of the ground-truth geometric transformation. The loss function L is designed to compare the estimated transformation ^θ with the ground-truth transformation θGT and, more importantly, compute the gradient of the loss function with respect to the estimates ∂L∂^θ. This gradient is then used in a standard manner to learn the network parameters which minimize the loss function by using backpropagation and Stochastic Gradient Descent.

It is desired for the loss to be general and not specific to a particular type of geometric model, so that it can be used for estimating affine, homography, thin-plate spline or any other geometric transformation. Furthermore, the loss should be independent of the parametrization of the transformation and thus should not directly operate on the parameter values themselves. We address all these design constraints by measuring loss on an imaginary grid of points which is being deformed by the transformation. Namely, we construct a grid of points in image A, transform it using the ground truth and neural network estimated transformations TθGT and T^θ with parameters θGT and ^θ, respectively, and measure the discrepancy between the two transformed grids by summing the squared distances between the corresponding grid points:

L(^θ,θGT)=1NN∑i=1d(T^θ(gi),TθGT(gi))2

where G={gi}={(xi,yi)} is the uniform grid used, and N=|G|. We define the grid as having xi,yi∈{s:s=−1+0.1×n,n∈{0,1,…,20}}, that is to say, each coordinate belongs to a partition of [−1,1] in equally spaced subintervals of steps 0.1. Note that we construct the coordinate system such that the center of the image is at (0,0) and that the width and height of the image are equal to 2, the bottom left and top right corners have coordinates (−1,−1) and (1,1), respectively.

The gradient of the loss function with respect to the transformation parameters, needed to perform backpropagation in order to learn network weights, can be computed easily if the location of the transformed grid points T^θ(gi) is differentiable with respect to ^θ. This is commonly the case, for example, when T is an affine transformation, T^θ(gi) is linear in parameters ^θ and therefore the loss can be differentiated in a straightforward manner.

Our training procedure requires fully supervised training data consisting of image pairs and a known geometric relation. Training CNNs usually requires a lot of data, and no public datasets exist that contain many image pairs annotated with their geometric transformation. Therefore, we opt for training from /media/arxiv_projects/37807/synthetically generated data, which gives us the flexibility to gather as many training examples as needed, for any 2-D geometric transformation of interest. We generate each training pair (IA,IB), by sampling IA from a public image dataset, and generating IB by applying a random transformation TθGT to IA. More precisely, IA is created from the central crop of the original image, while IB is created by transforming the original image with added symmetrical padding in order to avoid border artifacts; the procedure is shown in Figure 6.

Figure 6: Synthetic image generation. Symmetric padding is added to the original image to enlarge the sampling region, its central crop is used as image A, and image B is created by performing a randomly sampled transformation TθGT.

In this section we describe our datasets, give implementation details, and compare our method to baselines and the state-of-the-art. We also provide further insights into the components of our architecture.

Quantitative evaluation of our method is performed on the Proposal Flow dataset of Ham [23]. The dataset contains 900 image pairs depicting different instances of the same class, such as ducks and cars, but with large intra-class variations, the cars are often of different make, or the ducks can be of different subspecies. Furthermore, the images contain significant background clutter, as can be seen in Fig. ?. The task is to predict the locations of predefined keypoints from image A in image B. We do so by estimating a geometric transformation that warps image A into image B, and applying the same transformation to the keypoint locations. We follow the standard evaluation metric used for this benchmark, the average probability of correct keypoint (PCK) [53], being the proportion of keypoints that are correctly matched. A keypoint is considered to be matched correctly if its predicted location is within a distance of α⋅max(h,w) of the target keypoint position, where α=0.1 and h and w are the height and width of the object bounding box, respectively.

Two different training datasets for the affine and thin-plate spline stages, dubbed StreetView-/media/arxiv_projects/37807/synth-aff and StreetView-/media/arxiv_projects/37807/synth-tps respectively, were generated by applying /media/arxiv_projects/37807/synthetic transformations to images from the Tokyo Time Machine dataset [4] which contains Google Street View images of Tokyo.

Each /media/arxiv_projects/37807/synthetically generated dataset contains 40k images, divided into 20k for training and 20k for validation. The ground truth transformation parameters were sampled independently from reasonable ranges, for the affine transformation we sample the relative scale change of up to 2×, while for thin-plate spline we randomly jitter a 3×3 grid of control points by independently translating each point by up to one quarter of the image size in all directions.

In addition, a second training dataset for the affine stage was generated, created from the training set of Pascal VOC 2011 [16] which we dubbed Pascal-/media/arxiv_projects/37807/synth-aff. In Sec. ?, we compare the performance of networks trained with StreetView-/media/arxiv_projects/37807/synth-aff and Pascal-/media/arxiv_projects/37807/synth-aff and demonstrate the generalization capabilities of our approach.

We use the MatConvNet library [51] and train the networks with stochastic gradient descent, with learning rate 10−3, momentum 0.9, no weight decay and batch size of 16. There is no need for jittering as instead of data augmentation we can simply generate more /media/arxiv_projects/37807/synthetic training data. Input images are resized to 227×227 producing 15×15 feature maps that are passed into the matching layer. The affine and thin-plate spline stages are trained independently with the StreetView-/media/arxiv_projects/37807/synth-aff and StreetView-/media/arxiv_projects/37807/synth-tps datasets, respectively. Both stages are trained until convergence which typically occurs after 10 epochs, and takes 12 hours on a single GPU. Our final method for estimating affine transformations uses an ensemble of two networks that independently regress the parameters, which are then averaged to produce the final affine estimate. The two networks were trained on different ranges of affine transformations. As in Figure 5, the estimated affine transformation is used to warp image A and pass it together with image B to a second network which estimates the thin-plate spline transformation. All training and evaluation code, as well as our trained networks, are online at [1].

We compare our method against SIFT Flow [37], Graph-matching kernels (GMK) [15], Deformable spatial pyramid matching (DSP) [31], DeepFlow [43], and all three variants of Proposal Flow (NAM, PHM, LOM) [23]. As shown in Table 1, our method outperforms all others and sets the new state-of-the-art on this data. The best competing methods are based on Proposal Flow and make use of object proposals, which enables them to guide the matching towards regions of images that contain objects. Their performance varies significantly with the choice of the object proposal method, illustrating the importance of this guided matching. On the contrary, our method does not use any guiding, but it still manages to outperform even the best Proposal Flow and object proposal combination.

Furthermore, we also compare to affine transformations estimated with RANSAC using the same descriptors as our method (VGG-16 pool4). The parameters of this baseline have been tuned extensively to obtain the best result by adjusting the thresholds for the second nearest neighbor test and by pruning proposal transformations which are outside of the range of likely transformations. Our affine estimator outperforms the RANSAC baseline on this task with 49% (ours) compared to 47% (RANSAC).

Table 1: Comparison to state-of-the-art and baselines. Matching quality on the Proposal Flow dataset measured in terms of PCK. The Proposal Flow methods have four different PCK values, one for each of the four employed region proposal methods. All the numbers apart from ours and RANSAC are taken from .

In this section we examine the importance of various components of our architecture. Apart from training on the StreetView-/media/arxiv_projects/37807/synth-aff dataset, we also train on Pascal-/media/arxiv_projects/37807/synth-aff which contains images that are more similar in nature to the images in the Proposal Flow benchmark. The results of these ablation studies are summarized in Table 2.

Table 2: Ablation studies. Matching quality on the Proposal Flow dataset measured in terms of PCK. All methods use the same features (VGG-16 cropped at pool4). The networks were trained on the StreetView-/media/arxiv_projects/37807/synth-aff and Pascal-/media/arxiv_projects/37807/synth-aff datasets. For these experiments, only the affine transformation is estimated.

Methods

StreetView-/media/arxiv_projects/37807/synth-aff

Pascal-/media/arxiv_projects/37807/synth-aff

Concatenation

26

29

Subtraction

18

21

Ours without normalization

44

–

Ours

49

45

Figure 7: Filter visualization. Some convolutional filters from the first layer of the regressor, acting on the tentative correspondence map, show preferences to spatially co-located features that transform consistently to the other image, thus learning to perform the local neighborhood consensus criterion often used in classical feature matching. Refer to the text for more details on the visualization.

Image A

Aligned A (affine)

Aligned A (affine+TPS)

Image B

(a) Image A

(b) Image B

(c) Aligned image A

(d) Overlay of (b) and (c)

(e) Difference map

Replacing our correlation-based matching layer with feature concatenation or subtraction, as proposed in [14] and [30], respectively, incurs a large performance drop. The behavior is expected as we designed the matching layer to only keep information on pairwise descriptor similarities rather than the descriptors themselves, as is good practice in classical geometry estimation methods, while concatenation and subtraction do not follow this principle.

As seen in Table 2, our method is relatively unaffected by the choice of training data as its performance is similar regardless whether it was trained with StreetView or Pascal images. We also attribute this to the design choice of operating on pairwise descriptor similarities rather than the raw descriptors.

Table 2 also shows the importance of the correlation map normalization step, where the normalization improves results from 44% to 49%. The step mimics the second nearest neighbor test used in classical feature matching [40], as discussed in Section 3.2. Note that [18] also uses a correlation layer, but they do not normalize the map in any way, which is clearly suboptimal.

We examine filters from the first convolutional layer of the regressor, which operate directly on the output of the matching layer, the tentative correspondence map. Recall that each spatial location in the correspondence map (see Figure 3, in green) contains all similarity scores between that feature in image B and all features in image A. Thus, each single 1-D slice through the weights of one convolutional filter at a particular spatial location can be visualized as an image, showing filter’s preferences to features in image B that match to specific locations in image A. For example, if the central slice of a filter contains all zeros apart from a peak at the top-left corner, this filter responds positively to features in image B that match to the top-left of image A. Similarly, if many spatial locations of the filter produce similar visualizations, then this filter is highly sensitive to spatially co-located features in image B that all match to the top-left of image A. For visualization, we pick the peaks from all slices of filter weights and average them together to produce a single image. Several filters shown in Figure 7 confirm our hypothesis that this layer has learned to mimic local neighborhood consensus as some filters respond strongly to spatially co-located features in image B that match to spatially consistent locations in image A. Furthermore, it can be observed that the size of the preferred spatial neighborhood varies across filters, thus showing that the filters are discriminative of the scale change.

Fig. ? illustrates the effectiveness of our method in category-level matching, where challenging pairs of images from the Proposal Flow dataset [23], containing large intra-class variations, are aligned correctly. The method is able to robustly, in the presence of clutter, estimate large translations, rotations, scale changes, as well as non-rigid transformations and some perspective changes. Further examples are shown in appendix ?.

Fig. ? shows the quality of instance-level matching, where different images of the same scene are aligned correctly. The images are taken from the Tokyo Time Machine dataset [4] and are captured at different points in time which are months or years apart. Note that, by automatically highlighting the differences (in the feature space) between the aligned images, it is possible to detect changes in the scene, such as occlusions, changes in vegetation, or structural differences new buildings being built.

We have described a network architecture for geometric matching fully trainable from /media/arxiv_projects/37807/synthetic imagery without the need for manual annotations. Thanks to our matching layer, the network generalizes well to never seen before imagery, reaching state-of-the-art results on the challenging Proposal Flow dataset for category-level matching. This opens-up the possibility of applying our architecture to other difficult correspondence problems such as matching across large changes in illumination (day/night) [4] or depiction style [5].