Feature Fusion for Robust Patch Matching With Compact Binary Descriptors

TL;DR

This paper introduces a convolutional network framework that fuses pixel domain and transformed domain features to learn compact, discriminative binary patch descriptors, significantly improving matching accuracy across multiple datasets.

Contribution

It proposes a novel feature fusion approach combining pixel and transformed domain features within a deep learning framework for robust patch matching.

Findings

Outperforms state-of-the-art methods in accuracy

Achieves better rate and complexity trade-offs

Effective across multiple datasets

Abstract

This work addresses the problem of learning compact yet discriminative patch descriptors within a deep learning framework. We observe that features extracted by convolutional layers in the pixel domain are largely complementary to features extracted in a transformed domain. We propose a convolutional network framework for learning binary patch descriptors where pixel domain features are fused with features extracted from the transformed domain. In our framework, while convolutional and transformed features are distinctly extracted, they are fused and provided to a single classifier which thus jointly operates on convolutional and transformed features. We experiment at matching patches from three different datasets, showing that our feature fusion approach outperforms multiple state-of-the-art approaches in terms of accuracy, rate, and complexity.

Figures

Tables

Table 1. TABLE III: Fraction of patch pairs misclassified both by convolutional and DCT features: different types of features lead to different errors, thus are complementary ( B = 128 ) 𝐵 128 (B=128) .

	N/L	N/Y
Common False Negatives [%]	29.0	28.5
Common False Positives [%]	16.5	14.7

Equations

$$C(d_1,d_2)\text{ensurestackMath}\text{stackon}[1pt]=\Delta \frac{⟨d_1,d_2⟩}{\Vert d_1\Vert \text{hfill}\cdot \Vert d_2\Vert }=\frac{{\sum }_{j=1}^B{d}_{1,j}{d}_{2,j}}{\sqrt{{\sum }_{j=1}^B{d}_{1,j}^2}\text{hfill}\sqrt{{\sum }_{j=1}^B{d}_{2,j}^2}}.$$

$$L(l_i,y_i)=(l_i-C(d_1^i,d_2^i){)}^2.$$

$$H(b_1,b_2)\text{ensurestackMath}\text{stackon}[1pt]=\Delta \Vert b_1\Vert +\Vert b_2\Vert -2⟨b_1,b_2⟩,$$

$$H_N(b_1,b_2)=\frac{1}{B}H(b_1,b_2),$$

Full text

I Introduction

Comparing image patches is a key task in a number of computer vision applications such as object identification, photo stitching, stereo baseline estimation, etc. Patch comparison usually takes place by comparing local descriptors that are robust to rotations, scale, illumination and, to some extents, perspective, and changes. Descriptors such as SIFT had to be handcrafted according to the specific task or considered signal. Recent advances in deep learning showed that it is possible to train a neural network to automatically learn and compare local descriptors without necessarily resorting to handcrafted descriptors.

Over the past years, a number of descriptors designs based upon Convolutional Neural Networks (CNN) have been proposed [1]. The work of [2] explores different CNN architectures, showing that best results are achieved when pairs of patches are jointly encoded and a decision network is trained to learn an appropriate inter-patch distance metric. The authors of [3] address the problem of generating SIFT-like descriptors within a deep learning framework, showing that deep learning generated descriptors can be used as a drop-in replacement for SIFT descriptors as they retain key properties such as invariance to rotations, illumination and perspective changes. In [4], the specific problem of matching wide baseline stereo images by comparing local patches using a siamese CNN is addressed. The authors show that the network patch matching accuracy can be greatly enhanced augmenting the training set of patches by rotation and illumination changes. In [5], an approach based on fusing two complementary and asymmetric descriptors extracted from the convolutional domain is proposed. The authors of [6] address the related yet different problem of learning global hash codes over whole images. Their approach is limited to small size images due to complexity constraints. In addition, global descriptors are inherently unsuited for geometric verification, showing the advantages of local descriptors based approaches. Finally, in [7] a complete image matching pipeline based on a deep learning framework is presented: whereas such architecture goes beyond the scope of the present work, it clearly shows the potentials of image matching architectures based on deep learning frameworks.

Our goal is to learn patch descriptors that are highly discriminative and, at the same time, rate efficient and computationally lightweight to generate and compare. According to such requirements, many of the above designs fall short in one or more aspect. In [3], descriptors are devised as a drop-in replacement for SIFT descriptors, thus they are encoded as real-valued vectors, whereas binary vectors are desirable in reason of their improved rate efficiency. In [2] best performance is achieved by jointly encoding pairs of patches, an approach that is not suitable for the common case where the reference patch is available only through its descriptor at query time. Such approach also requires replicating the same decision network learned at training time when deployed on the field, impacting significantly in terms of complexity. The approach of [5] shows state-of-the-art results, however at the expense of duplicating the feature extraction pipeline complexity. For such reasons, how to learn and compare patch descriptors that are at the same time discriminative and efficient both in terms of rate and complexity is still an open research issue.

In this work, we introduce the idea of fusing features from the convolutional layers and from the discrete cosine transform to learn binary patch descriptors within a deep learning framework. DCT features have been previously considered for feature dimensionality and redundancy reduction in patch matching and face recognition problems [8, 9]. However, to the best of our knowledge, no previous work has considered the problem of fusing features from the convolutional and the DCT domains within a deep learning framework. We propose a framework that is designed around a Siamese network, which allows to independently generate descriptors from single patches. We learn real-valued compact descriptors by minimizing a loss function of the cosine distance between pairs of descriptors, where the cosine distance happens to be the best-fitting real-valued relaxation for the Hamming distance, enabling straightforward descriptors quantization and subsequent comparison. We experiment with three challenging datasets, showing better performance than state-of-the-art competitors for identical bitrate and comparable performance to more complex approaches despite lower bitrate. The rest of this paper is organized as follows. In Sec. II relevant background literature is surveyed. Sec. III describes the proposed convolutional approach to patch matching via feature fusion in terms of network architecture and training procedures. Sec. IV provides a thorough experimental validation of the framework over three sets of real image patches. Sec. V draws the conclusions and discusses potential directions for further investigations.

II Background

This section provides the relevant background on Siamese neural networks, a class of feed-forward artificial neural networks. Siamese networks find application in a number of problems where it is required to learn a similarity or distance function between pairs of equally dimensioned signals, ranging from face verification [10] to real-time object tracking [11]. Siamese networks are composed by (at least) two topologically identical and independent subnetworks which share an identical set of learnable parameters. In most image and video applications, each subnetwork typically includes one or more convolutional layers for extracting features from the input signal spatial domain. Optionally, a number of fully connected layers projects such features to a typically lower-dimensional space, yielding a vector of features representing the signal provided as input to the subnetwork. The output of each subnetwork can be seen as a (compact) description of the input signal, which is thus often defined as descriptor. Finally, one predefined or learnable distance function measures the similarity between the two descriptors produced by each subnetwork. In this context, the network produces as output a measure of the extent to which two input patches are similar or dissimilar. Concerning the patch matching problem addressed by this work, Siamese architectures enable to independently compute each patch descriptor, allowing for patch matching with precomputed descriptors. Therefore, in the following, we use a Siamese architecture as the cornerstone of our network, whereas we leave the application of our feature fusion approach to other network architectures for future research.

III Proposed Method

In this section, we first describe a Siamese convolutional network architecture suitable for convolutional and DCT feature fusion. Next, we describe a fully-supervised training procedure with the associated loss function. Finally, we briefly describe the descriptor quantization process.

III-A Network Architecture

The architecture in Fig. 1 relies on a Siamese topology where the two subnetworks receive as input a pair of same size image patches $(I_{1},I_{2})$. Each subnetwork is structured as follows: the first part is composed of M convolutional modules, where each k-th module $m_{k}$ ($k\in{1,...,M}$) is composed by one convolutional layer with an hyperbolic tangent nonlinearity and one 2$\times$2 max-pooling layer. All the convolutional layers are composed of 5$\times$5 filters (kernels), and convolutions are of the wide type with border padding and one-pixel stride. The number of filters in the first $(m=1)$ module’s convolutional layer is set to $64$ and doubles at each module, thus the number of featuremaps produced as output by each convolutional layer doubles with index $k$. However, the resolution of each featuremap is reduced by a fourfold factor after each max-pooling layers, so the overall number of features generated by each module shrinks by a factor of two after each m-th module. The number of convolutional features produced as output by the k-th module is referred to as $F_{C}$ in the following. Fig. 1 shows that, for each subnetwork, a parallel branch of the pipeline implements a 2D discrete cosine transform of the input signal. Next, a subset of $F_{D}$ coefficients from the top-left corner of the transformed patch matrix is selected in zig-zag scanning order starting from the DC coefficient. The result is a number of $F_{D}$ additional DCT features that complements the $F_{C}$ convolutional features.

Finally, the $F_{C}$ convolutional features are concatenated with the $F_{D}$ DCT features, yielding a vector of $F_{C}+F_{D}$ fused features that represents a projection of the input signal to a $(F_{C}+F_{D})$-dimensional space. Fused features are processed by a first fully connected layer with $512$ units (neurons) with hyperbolic tangent activation functions. A second fully connected layer with B units, to which we refer as bottleneck layer in the following, generates a B-elements patch descriptor. Accordingly, the two subnetworks receive as input the pair of image patches $(I_{1},I_{2})$ and produce as output the corresponding pair of descriptors $(d_{1},d_{2})$ of B real-valued elements each.

In order to establish the similarity between the two descriptors $(d_{1},d_{2})$, we resort to the cosine distance function, which produces an output in the range [-1,1], and it is defined as

[TABLE]

Such cosine distance represents the ultimate output of the proposed network. Hence, when a pair of patches $x=(I_{1},I_{2})$ is fed into the network, the associated cosine distance $y=C(d_{1},d_{2})$ between its descriptors is produced. The cosine distance enjoys several useful properties: first, it is always continuous and differentiable, thus it allows fully supervised, end-to-end, training of the network as discussed in the following; moreover, cosine distance affinity with the Hamming distance enables straightforward descriptor quantization and binary comparison as described in Sec. III-C.

Finally, let us define as network complexity the number of learnable parameters in the network. Concerning the architecture showed in Fig. 1, the complexity of the first fully connected layer ($512$ units) dominates the overall network complexity. Thus, the network complexity is approximately equal to $(F_{C}+F_{D})\cdot 512$, i.e. its complexity increases linearly with the number of fused features.

III-B Training

Let us define as the i-th training sample the pair of identically sized image patches $x_{i}=(I_{1}^{i},I_{2}^{i})$. $I_{1}^{i}$ and $I_{2}^{i}$ are said to be matching (equivalently, that $x^{i}$ is a matching sample) whenever $I_{1}^{i}$ and $I_{2}^{i}$ represent the same image detail, and non-matching otherwise. Let $y^{i}=C(d_{1}^{i},d_{2}^{i})$ and $l^{i}$ be the network output and the corresponding target label (i.e., the expected network outcome), respectively. Our ultimate goal is to learn network parameters such that the network generates pairs of discriminative descriptors $(d_{1}^{i},d_{2}^{i})$. However, as we aim at training the network end-to-end with a fully supervised approach, we recast the problem on learning parameters such that the network, given as input the i-th sample $x^{i}$, generates an output for which $y^{i}=l^{i}$. To this end, the choice of the training label $l^{i}$ is pivotal. Concerning pairs of matching patches, the network is expected to produce similar descriptors such that $C(d_{1}^{i},d_{2}^{i})\approx 1$, so we impose $l^{i}=1$ for matching samples. Considering the comparison of non-matching pairs of patches, we observe that such process is equivalent to comparing random i.i.d. patches $(I_{1}^{i},I_{2}^{i})$, which in turn is equivalent to measuring the cosine distance between the associated i.i.d. descriptors $(d_{1}^{i},d_{2}^{i})$. Given two zero-mean i.i.d. $(d_{1}^{i},d_{2}^{i})$, we experimentally observed that $C(d_{1}^{i},d_{2}^{i})$ has a zero-mean Normal distribution, i.e. $E[C(d_{1}^{i},d_{2}^{i})]=0$. For all the experiments we run, we verified that the descriptors generated by our network are identically distributed and have zero-mean, therefore we impose $l^{i}=0$ for non-matching samples.

With the training labels defined as indicated, the network can be trained via error gradient backpropagation, finding the parameters minimizing a loss function that, for the i-th training sample, is defined as

[TABLE]

That is, the network is trained to minimize a sample classification error function defined as the square error between the desired and the actual network outcome (i.e., the sample label). Regarding the practical aspects of the training procedure, we verified that normalizing the input patches over their own $l_{2}$ norm increases the robustness and generalization capacity of the network with respect to illumination variations. Also, we follow the common practice of normalizing the input patches with respect to mean pixel intensity and standard deviation as calculated over the entire training set. We also observed that Spatial Batch Normalization as defined in [12] speeds up the training and boosts performance. Similarly, we normalize the DCT features $F_{D}$ with respect to mean and standard deviation values over the entire coefficients set so that their value share the same distribution of the convolutional features $F_{C}$.

III-C Descriptor Quantization

Binary descriptors enable lower bitrates and simple Hamming distance computation. Having verified that the trained network generates zero-mean descriptors, we quantize the B-elements descriptors $(d_{1},d_{2})$ over 1 bit via sign quantization, obtaining single bit, B-long descriptors $(b_{1},b_{2})$. Our choice of the cosine distance as similarity function is instrumental to comparing the binary descriptors $(b_{1},b_{2})$ via a simple Hamming distance. In fact, the cosine distance definition between $d_{1}$, and $d_{2}$ in Eq. 1 can be recasted as the L2-normalized inner product between $d_{1}$ and $d_{2}$. Given the definition of Hamming distance

[TABLE]

where $\langle\cdot,\cdot\rangle$ indicates the inner product, and $\|\cdot\|$ refers to the bit count of the sequence, it follows that the cosine distance is equivalent to the Hamming distance, up to a scaling factor and an additive term. Therefore, pairs of binary descriptors are simply compared via the normalized Hamming distance

[TABLE]

which is close to 0 for pairs of matching patches, and close to 1 otherwise, and performance is computed as explained in the following section.

IV Experimental Evaluation

We evaluate our proposed architecture for patch matching over three datasets [13] of 64$\times$64 patches extracted from 3D reconstructions of the Liberty statue ($L$), the Notredame cathedral ($N$) and the Yosemite mountains ($Y$), centered upon Difference of Gaussians (DoG) key points with canonical scale and orientation, as shown in Fig. 2. Following the approach of [13], we train the network three times, one for each dataset, and we evaluate its performance on the two other datasets for a total of 6 different training/testing setups per experiment (e.g., the $L/N$ setup indicates training on Liberty and testing on Notredame). For each setup, the network is trained with $250000$ pairs of matching pairs and $250000$ pairs of non-matching patches, whereas testing is performed over $25000$ pairs of matching and $25000$ pairs of non-matching patches. We implemented the proposed architecture using the Torch7 framework and trained our network following the procedure described in the Sec. III-B over an NVIDIA K80 GPU. We rely on gradient descent with adaptive gradient optimization as defined in [14], with an initial learning rate set to $10^{-4}$ and over batches of $100$ pairs of samples ($100$ matching samples and $100$ non-matching samples per batch). The training ends when the error on the testing set has not decreased over the past $10$ epochs or after $400$ epochs. Coherently with [13], first we compute ROC curves by thresholding the normalized Hamming distance between pairs of binary B-long descriptors, then, for each setup, we measure the False Positive Rate (FPR) for a True Positive Rate (TPR) set to $95$%. In the following, we refer to the FPR computed for a TPR of $95$% simply as patch classification error for the sake of brevity.

Preliminarily, we experiment to find the convolutional configuration of the network architecture in Fig. 1 that yields the best baseline performance when $B=128$ bits. Namely, we want to find the best tradeoff between the number and resolution of convolutional featuremaps. To this end, we first vary the number of convolutional modules $M\in\{2,3,4\}$ (as M increases, the number of featuremaps doubles while their resolution is halved horizontally and vertically). Furthermore, we experiment dropping the maxpooling layer in M-th convolutional module which additionally allows us to double the featuremaps resolution without affecting their count. As this experiment focuses on convolutional features, we deactivate the DCT branch of each subnetwork (i.e., $F_{D}=0$). Table I shows the performance of six different network configurations (-mp rows account for the cases where the M-th module maxpooling layer is disabled). $FMN$ and $FMR$ columns indicate number and resolution of the featuremaps respectively, where $FMN\times FMR=F_{C}$. We observe that $8\times 8$ featuremaps consistently yield the best results: our hypothesis is that larger featuremaps do not convey enough semantic information, whereas smaller featuremaps lack the spatial resolution to preserve texture details.

Next, we evaluate the entire network performance when DCT features are fused with convolutional features while accounting for network complexity. Input patches resolution is $64\times 64$ pixels, so each input patch DCT can be represented as a vector of $4096$ real-valued coefficients. To keep the complexity low, we consider only the first $F_{D}=561$ lower frequency coefficients selected as described in Sec. III-A. The additional network complexity due to the introduction of the DCT features, defined as $F_{D}/F_{C}$, is negligible as it takes the values of 3.42% and 1.71% for the $M=3$ and $M=4$ cases, respectively. Table II shows the results of the experiment: the second column reports the actual number of convolutional features $F_{C}$ compared to the number of DCT features $F_{D}=561$. As a general trend, we see that fusing DCT and convolutional features always improve the performance. Most importantly, the configuration with $M=3$ convolutional modules ($16945$ fused features) now yields better performance than the $M=4-\textit{mp}$ configuration ($33329$ fused features), despite the overall network complexity is reduced nearly by a twofold factor (about 9M parameters versus 17M parameters). The experiment shows that fusing convolutional features with transformed domain features further improves performance while keeping the network complexity under control.

We attempt now to understand why feature fusion boosts performance. Without loss of generality, we repeat the previous experiment over a smaller training set of $100000$ training pairs extracted from the Notredame dataset ($50$% matching, $50$% non matching), testing over $10000$ pairs of patches from the Liberty (i.e. N/L setup) and $10000$ pairs from the Yosemite (i.e. N/Y setup) datasets. We aim at assessing the effect of convolutional and DCT features separately, on an equal number of features basis (i.e., $F_{C}=F_{D}$). Therefore, we first experiment with a configuration of our architecture in Fig. 1 where all the features generated by the DCT are provided as input to the fully connected layers without zig-zag selection, whereas the convolutional features are dropped altogether (i.e., $F_{D}=4096,F_{C}=0$). Next, we experiment dropping all the DCT features and considering instead a convolutional architecture with $M=5$ modules (i.e., $F_{D}=0,F_{C}=4096$). Table III reports the percentage of misclassified pairs of patches in both scenarios, quantified as the intersection of the sets over their union. We break down such erroneously classified pairs of patches in terms of common false negatives and common false positives for a threshold on the normalized Hamming Distance computed over the quantized descriptors that are equal to $0.325$. The ratio of pairs of patches that are misclassified in both scenarios is significantly lower than $30$%. This experiment suggests that convolutional and DCT features convey complementary information, thus explaining the increased ability to discern between patches of matching and non-matching pairs we observed when fusing convolutional and DCT features. Fig. 3 shows the Top-5 misclassified nonmatching samples (corresponding to a $29$% of common false positives in Table III). Only the second column in the left image (convolutional features only) is also found as third column in the right image (DCT features only), confirming that different types of features yield to complementary classification errors.

Next, we experiment varying the descriptor bitrate beyond the $B=128$ bits considered in our experiments so far. We experiment with the configuration $M=3$ with feature fusion ($F_{C}=16384,F_{D}=561$), which provided the best performance-complexity trade-off in Table II, and its counterpart with convolutional features only ($F_{D}=0$). As expected, Fig. 4 shows that the patch classification error decreases when B increases. Most importantly, Fig. 4 shows that the error decreases faster when fusing features, i.e. feature fusion improves the performance-bitrate trade-off of our framework. Fig. 4 includes a third line that corresponds to the configuration where non-quantized descriptors are considered in place of binary descriptors. For $B=64$, the performance loss due to descriptor quantization is lower than 1% and further decreases rapidly as B increases. Hence, sign quantization precisely matches the descriptors space into the Hamming space conserving the relative distance between vectors and allowing vector similarity preservation.

Finally, Table 4 compares our framework with several state-of-the-art approaches in binary patch matching. Our approach outperforms all the competitors on an equal bitrate basis. Our approach is outperformed on the N/L, Y/L, and N/Y setups only by DeepCD [5], which however relies on an aggregated descriptor rate of $768$ bits that largely exceeds our maximum considered bitrate of $B=256$ bits.

V Conclusions and future works

In this work, we proposed to fuse convolutional features from the convolutional layers with features from the discrete cosine transform in a deep neural network for binary patch matching. Qualitative experiments suggest that different types of features are complementary in discriminating patches. Quantitative experiments over three challenging datasets confirm that our feature fusion approach outperforms several existing state of the art techniques based on convolutional features only. A careful design of the network topology and training procedures allowed us to capture distinctive features within the patches, enabling a very competitive architecture that also deploys feature fusion, allowing for performance improvement. We leave for our future investigations experimenting with different transform functions and evaluating our framework within a complete image matching pipeline.