Metric-Learning based Deep Hashing Network for Content Based Retrieval of Remote Sensing Images

TL;DR

This paper introduces a metric-learning based deep hashing network for remote sensing image retrieval, which effectively learns semantic feature spaces and compact binary codes, significantly improving retrieval accuracy over existing methods.

Contribution

It proposes a novel deep hashing network that jointly learns a semantic metric space and binary codes, enhancing retrieval performance in remote sensing images.

Findings

Significant improvement in retrieval accuracy over state-of-the-art methods.

Effective joint learning of semantic space and binary codes.

Maintains fast search speed with improved performance.

Abstract

Hashing methods have been recently found very effective in retrieval of remote sensing (RS) images due to their computational efficiency and fast search speed. The traditional hashing methods in RS usually exploit hand-crafted features to learn hash functions to obtain binary codes, which can be insufficient to optimally represent the information content of RS images. To overcome this problem, in this paper we introduce a metric-learning based hashing network, which learns: 1) a semantic-based metric space for effective feature representation; and 2) compact binary hash codes for fast archive search. Our network considers an interplay of multiple loss functions that allows to jointly learn a metric based semantic space facilitating similar images to be clustered together in that target space and at the same time producing compact final activations that lose negligible information when binarized. Experiments carried out on two benchmark RS archives point out that the proposed network significantly improves the retrieval performance under the same retrieval time when compared to the state-of-the-art hashing methods in RS.

Figures

Tables

Table 1. TABLE I: mAP@20 and average retrieval time in the UCMD archive.

			# Hash Bits K
Methods	mAP	Time (in ms)	K=16		K=24		K=32
			mAP	Time (in ms)	mAP	Time (in ms)	mAP	Time (in ms)
NN-Inception feat. (Euclidean)	0.724	45.1	-	-	-	-	-	-
NN-Inception feat. (Hamming)	0.359	10.1	-	-	-	-	-	-
KSLSH [3]	-	-	0.557	25.3	0.594	25.5	0.630	25.6
Our MiLaN	-	-	0.875	25.3	0.890	25.5	0.904	25.6
Our MiLaN (Eucledian)	-	-	0.903	35.3	0.894	35.8	0.916	36.0

Table 2. TABLE II: mAP with data augmentation for the UCMD archive.

	DPSH [12]	DHNN [5]	Our MiLaN
K = 32	0.748	0.939	0.977
K = 64	0.817	0.971	0.991

Table 3. TABLE III: mAP@20 and average retrieval time for the AID archive.

			# Hash Bits K
Methods	mAP	Time (in ms)	K=16		K=24		K=32
			mAP	Time (in ms)	mAP	Time (in ms)	mAP	Time (in ms)
NN-Inception feat. (Euclidean)	0.719	145.1	-	-	-	-	-	-
NN-Inception feat. (Hamming)	0.402	60.2	-	-	-	-	-	-
KSLSH [3]	-	-	0.426	115.3	0.467	116.1	0.495	117.5
Our MiLaN	-	-	0.876	117.5	0.891	116	0.926	114.5

Equations

$$\begin{array}[]{cc}\mathcal{L}_{Metric}=&\displaystyle\sum_{i=1}^{M}max\Big{(}0,||f(\mathbf{g}_{i}^{a})-f(\mathbf{g}_{i}^{p})||_{2}^{2}-\\ &||f(\mathbf{g}_{i}^{a})-f(\mathbf{g}_{i}^{n})||_{2}^{2}+\alpha\Big{)},\end{array}$$

$$\begin{array}[]{cc}\mathcal{L}_{Push}=-\frac{1}{K}\displaystyle\sum_{i=1}^{M}||f(\mathbf{g}_{i})-0.5\mathbf{1}||^{2},\end{array}$$

$$\begin{array}[]{cc}\mathcal{L}_{Balancing}=\displaystyle\sum_{i=1}^{M}(mean(f(\mathbf{g}_{i}))-0.5)^{2},\end{array}$$

$$\begin{array}[]{cc}\mathcal{L}=\mathcal{L}_{Metric}+\lambda_{1}\mathcal{L}_{Push}+\lambda_{2}\mathcal{L}_{Balancing},\end{array}$$

$${\mathbf{b}}_n$$

Full text

I Introduction

The advancement of satellite technology has resulted in an explosive growth of Remote Sensing (RS) image archives. Content-Based Image Retrieval (CBIR) methods in RS aim to retrieve those archive images which are the most similar with respect to a given query image. Traditional Nearest Neighbour (NN) search algorithms (which exhaustively compare the query image with all the images in the archive) are time consuming and thus prohibitive for large-scale RS image retrieval problems [1]. To alleviate this issue, hashing-based search techniques have been recently proposed in RS. A hashing-based method involves learning a hash function, $\mathbf{b}=h(\mathbf{d})$, which maps a high-dimensional image descriptor $\mathbf{d}\in{\rm I\!R}^{D}$ into a low-dimensional binary code $\mathbf{b}\in\{0,1\}^{\textit{K}}$, where $D>>\textit{K}$. Besides improving the computational efficiency, hashing methods also reduce the storage costs significantly. For instance, Locality-Sensitive Hashing (LSH) [2] learns $n$ different hash functions $[h_{1},h_{2},...,h_{n}]$ by choosing $n$ random projecting vectors obtained from a multivariate Gaussian distribution. In the context of CBIR in RS, two hashing-based methods have been introduced in [3, 4, 5]. Demir et al. [3] learn two hash functions in the kernel space using hand-crafted features (SIFT) and a bag-of-visual-words representation. [4] extends these hashing methods by describing each image with multi-hash codes and using the spectral histograms of the image regions. However, the effectiveness of the binary codes relies on both the approach used for the hash-function and the adopted image descriptors. Specifically, common hand-crafted features are not optimized for the retrieval task and have a limited capability to accurately represent the high-level semantic content of RS images.

The limitations of hand-crafted features is nowadays addressed by using deep Convolutional Neural Networks (CNNs), which learn a feature space directly optimized for the final task (e.g., classification). For instance, Li et al., [5] introduce a deep Hashing Neural Network (DHNN) to address CBIR in RS. DHNN jointly learns semantically accurate deep features and binary hash codes, by means of a cross-entropy loss function. However, entropy-based losses are particularly effective in classification problems, but less effective in defining a metric space which clusters together similar images, a concept which is crucial in a CBIR framework. Specifically, the absence of a margin threshold between positive and negative samples leads to a poor generalization. As a result, to achieve a high retrieval performance, DHNN requires long hash codes and a large amount of annotated training images, which is difficult to collect in common RS archives.

To address these issues, we propose to use an intermediate representation, obtained with a big CNN (Inception Net [6]) pre-trained on ImageNet and not fine tuned. In our approach Inception Net is not re-trained, thus we avoid overfitting risks when using small labeled datasets, as those commonly available in RS. Inception Net is pre-trained on ImageNet, a dataset of more that one million (labeled), non-RS images. The visual knowledge acquired by Inception Net on this dataset is exploited to extract an intermediate representation of our RS images. Using this representation as input, we train a second network whose final features are jointly optimized (using a combination of different losses) for both the retrieval task and the hash-code production. In summary, the contributions of our Metric-Learning based Deep Hashing Network (MiLaN) are: (1) We use as input an intermediate feature representation to alleviate overfitting problems on small RS annotated datasets. (2) We train a DNN on top of these intermediate features, whose final feature representation is jointly optimized for both a CBIR task and a hash-code production task. This letter extends our work presented in [7] introducing a detailed ablation study of MiLaN, a latent-space visualization and additional experiments, including testing on another RS dataset.

II Metric-Learning based Deep Hashing Network

We assume that a small set of training images is available: $\mathcal{I}=\{x_{1},x_{2},...,x_{P}\}$, where each $x_{i}$ is associated with a corresponding class label $y_{i}\in\mathcal{Y}=\{y_{1},y_{2},...,y_{P}\}$. Our goal is to learn a hash function encoding an image into a binary code: $h:\mathcal{I}\rightarrow\{0,1\}^{K}$, where K is the number of bits in the hash code. Importantly, $h$ should capture the semantics of the images in a similarity space. This is achieved using a specific loss function which clusters together semantically similar samples. Specifically, we use a triplet loss [8], which learns a metric space such that the Euclidean distance between two points in this space faithfully corresponds to the visual similarity between the corresponding pair of images in the pixel space. Moreover, we use two additional losses: 1) A representation penalty loss, which pushes the activations of the last layer of the network to be binary; and 2) A bit-balancing loss, which encourages the network to produce hash codes having (on expectation) an equivalent number of 0s and 1s. The latter is important to guarantee that all the final bit codes are effectively useful for the binary-based retrieval task.

As mentioned in Sec. I, the success of DNNs in vision tasks relies on the use of big CNNs which extract visual information from raw-pixel data. However, these big networks are prone to overfit when trained using small labeled dataset, which is the common case in RS frameworks. In order to solve this problem, we propose to use a big CNN (Inception Net [6]) pre-trained on ImageNet, without re-training. Specifically, Inception Net is used to extract an intermediate representation of our RS images. Then, a smaller network ($f$) is trained using this representation as input in order to learn our final hash function. In more detail, each image in $\mathcal{I}$ is fed to the Inception Net [6] and we use the last layer ($Pool_{3}$) right before the softmax layer as our intermediate feature representation. This layer is composed of 2048 neurons, whose activations represent the result of an average pooling on the convolutional feature maps of the layer before (Fig.1).

Let $\mathcal{G}=\{\mathbf{g}_{1},\mathbf{g}_{2},...,\mathbf{g}_{P}\}$, $\mathbf{g}_{i}\in{\rm I\!R}^{2048}$ be the set of the intermediate features extracted from $\mathcal{I}$. The elements of $\mathcal{G}$ are fed to the network $f$, whose weights are randomly initialized. The goal of $f$ is to learn a mapping from the intermediate features to a metric space which is semantically significant for the specific RS retrieval task: $f:{\rm I\!R}^{2048}\rightarrow{\rm I\!R}^{K}$. The real-valued activations of the last layer of $f$ are finally quantized using a simple thresholding to obtain the binary hash codes.

The main loss used to train $f$ is the triplet loss, which is based on the intuition that images with the same label (hence, sharing the same visual semantics) should lie closer to each other in the learned metric space more than those images having different labels (see Fig. 2). In more detail, a triplet ($\mathcal{T}$) of samples is sampled from $\mathcal{G}$: $\mathcal{T}=\{(\mathbf{g}_{i}^{a},\mathbf{g}_{i}^{p},\mathbf{g}_{i}^{n})\}$, where $\mathbf{g}_{i}^{a}$ (called anchor) is sampled randomly from $\mathcal{G}$ together with its associated class label $y_{i}$; $\mathbf{g}_{i}^{p}$ (called the positive sample) is drawn among the samples having the same class labels ($y_{i}$) of the anchor; and $\mathbf{g}_{i}^{n}$ (called the negative sample) is again chosen randomly from $\mathcal{G}$ such that it belongs to a class $y_{j}$, where $y_{j}\neq y_{i}$. For training the network with Stochastic Gradient Descent (SGD), a mini-batch of M triplets is sampled and the following triplet loss is minimized:

[TABLE]

where $\alpha$ is the minimum margin threshold, which is forced between the positive and negative distances.

The network $f$ is composed of 3 fully-connected layers with 1024, 512 and K neurons each, being K the number of desired hash bits. We use LeakyReLU in the two hidden layers to allow negative gradients to flow during the backward pass and a sigmoid activation in the final layer to restrict the output activations in [0, 1].

In order to push the final real activations towards the extremities of the sigmoid range, and inspired by [9], we use a second loss whose goal is to maximize the sum of the squared errors between the output-layer activations and the value 0.5:

[TABLE]

where $\mathbf{1}$ is a vector of 1s having dimension K.

Also inspired by [9], we adopt a third loss which encourages each output neuron to fire with a 50% chance. This means that the binary code representations of the images will have (on average) a balanced number of 0s and 1s, hence all the bits of the code are equally used. The balancing loss is:

[TABLE]

where $mean(f(\mathbf{g}_{i}))$ is the mean of the output activations.

The final objective function is a weighted combination of the three losses:

[TABLE]

where $\lambda_{1}$ and $\lambda_{2}$ weight the relative loss importance.

When training of $f$ is done, the final hashing function $h$ is obtained by quantizing the values in ${\rm I\!R}^{K}$. For a given archive image $x$, let $\mathbf{g}$ be its intermediate feature obtained using Inception Net and $\mathbf{v}=f(\mathbf{g})$. The final binary code $\mathbf{b}=h(f(\mathbf{g}))$ is given by:

[TABLE]

Finally, in order to retrieve an image $x_{j}$, which is semantically similar to a query image $x_{q}$, we use the Hamming distance between $h(x_{q})$ and $h(x_{j})$. Note that, with a slight abuse of notation, in the rest of the paper we write $h(x)$ to mean $h(f(\mathbf{g}))$, where $\mathbf{g}$ is the intermediate feature corresponding to $x$. During retrieval, the Hamming distance is computed between the query $h(x_{q})$ and each image in the archive and the obtained distances are sorted in ascending order of magnitude. The top-$k$ instances with the lowest distances are retrieved.

III Dataset Description And Design Of The Experiments

In our experiments we use two RS benchmarks. The first archive is the widely used UC Merced [10] (UCMD) archive that contains 2100 aerial images from 21 different land cover categories, where each category includes 100 images. The pixel size of each image in the archive is 256 $\times$ 256 and the spatial resolution is 30 cm. The second benchmark archive is the Aerial Image Data Set [11] (AID) which is much larger with respect to the UCMD archive. The images are extracted from the Google Earth and and each image in the archive is a section of 600 $\times$ 600 pixels. AID contains 10,000 images from 30 different categories and the number of images in each category varies between between 220 to 420. The spatial resolution of the images varies between 50 cm to 8 m.

MiLaN111Our code is available at: https://github.com/MLEnthusiast/MHCLN was trained using a mini-batch of triplets having a cardinality $M$=30. For a much larger archive we suggest to include only those triplets in the mini-batch, which contain semi-hard negatives (i.e., only those negative samples which violate the threshold margin $\alpha$) which allows for a faster convergence of the network. The value of the threshold margin $\alpha$ was set to $0.2$, which is determined by cross-validation, using a validation set composed of 20 images per class. The hyperparameters $\lambda_{1}$=0.001 and $\lambda_{2}$=1 have also been chosen using the same validation set. We used the Adam Optimizer with a small learning-rate $\eta$ = $10^{-4}$. The other two Adam hyper-parameters $\beta_{1}$ and $\beta_{2}$ were set to 0.5 and 0.9, respectively.

We compare MiLaN with the state-of-the-art supervised hashing methods KSLSH [3] and DHNN [5]. However, due to the lack of a publicly available code for DHNN, we can only report its results for the UCMD archive. A Gaussian RBF kernel is used for KSLSH. We also use, as baseline, a Nearest Neighbour (NN) search with our intermediate features. Specifically, ’NN-Inception feat. (Euclidean)’ refers to a NN search using the Inception Net features and the Euclidean distance. The comparison with MiLaN shows the advantage of learning a metric space on top of these features. Moreover, ’NN-Inception feat. (Hamming)’ refers to a NN search using binary hash codes (of length $K=2048$). These hash codes are computed using the same thresholding rule as in Eq. 5. The results of each method are provided in terms of: i) mean Average Precision (mAP); and ii) computational time. Specifically, mAP@k is based on the top-k retrieved images. We consider two different scenarios. In the first, no data augmentation is used and 60% of all the images of each category is used for training and cross-validation, while the rest for testing. In the second scenario, we use data augmentation obtained by means of basic geometric transformations.

IV Experimental Results

IV-A Results: the UCMD Dataset

Table I shows that the MiLaN mAP is significantly higher than ’NN-Inception feat. (Euclidean)’ (for all the values of $K$), which shows the advantage of learning a metric space. Moreover, the retrieval time is also drastically reduced by the fact that our network outputs binary hash codes and an efficient Hamming distance can be computed over the archive elements. On the other hand, ’NN-Inception feat. (Hamming)’ is faster (as expected) but the plain binarization of the CNN features leads to a drastic loss of information, which explains the results inferior to ’NN-Inception feat. (Euclidean)’. This shows the importance of learning how to compute effective binary codes, which in our case is the result of applying Eq.2 and Eq. 3. The last row of Table I reports the results obtained using the final MiLaN features before quantization (Eq. 5). As expected, retrieval in an ${\rm I\!R}^{K}$ space is more effective than in $\{0,1\}^{K}$. However, hash codes (’Our MiLaN’) significantly improve searching time, with a negligible accuracy drop. This shows that MiLaN is able to learn features which can be easily binarized while mostly preserving the metric space.

In order to show the contribution of the hash-code production losses, we report below the results obtained, respectively, with $K=16,24,32$, when: (1) $\lambda_{1}=\lambda_{2}=1$: 0.231, 0.524, 0.408 and when: (2) $\lambda_{1}=\lambda_{2}=0.001$: 0.823, 0.851, 0.907.

MiLaN, with K = 24, also significantly outperforms (+29.6% mAP) KSLSH, with a similar retrieval time. Qualitative results are shown in Fig. 4 where, using as query an image of an “airplane”, MiLaN retrieves semantically more similar images than KSLSH.

We perform experiments on the UCMD archive also under the second scenario, where we consider data augmentation as suggested by [5]. Accordingly, we replicate the experimental set-up of DHNN [5] by augmenting the original data set with images rotated by 90*∘, 180∘* and 270*∘*, yielding 8400 images. Then, out of the 8400 images, 7400 are randomly chosen for training the network and remaining 1000 images are used for evaluation. It is worth noting that the 7400 training images are also used as a search set as suggested by [5]. Table II compares DHNN [5] with our MiLaN using mAP. These results show that MiLaN requires a smaller K to reach a higher mAP. For instance, when K = 32, the mAP for MiLaN is 3.8% higher than that of DHNN. Moreover, the mAP of MiLaN with K = 32 is again 0.6% higher than the mAP obtained by DHNN with twice the number of hash bits, i.e., K = 64. We highlight that the use of such an experimental set-up, as proposed by [5], may lead to the identical but rotated variants of a same image being present in both the training and the test sets and thus leading to over-saturated results. In fact, the network can memorize the test samples (rotated variants) which are present in the training set. However, we adopt this training and evaluation protocol in order to fairly compare with [5].

To visualize the K-dimensional binary codes corresponding to the test images, we perform a t-distributed stochastic neighbour embedding (t-SNE) which projects these representations in a 2D space. Fig. 3a shows the results in case of KSLSH. Note that, although the samples of the “agricultural” category stand out clearly from the rest of the samples belonging to the other categories, the remainder of the samples are mostly cluttered in one big heap having minimal inter-class separation. This shows that KSLSH is not discriminative enough. In contrast, Fig. 3b shows that MiLaN leads to samples exhibiting much more compact clusters. For instance, the categories “freeway” and “overpass”, which exhibit similar visual patterns, lie close to each other and yet far enough to have their own well-separated clusters.

We also analyse the impact of the length of the hash codes on the retrieval performance. Fig. 5a shows that, both for KSLSH and for MiLaN, the mAP@20 increases with an increase in the number of the hash bits. However, the average precision curve for MiLaN with respect to all the K values, stays considerably above the KSLSH results. This indicates that the proposed network efficiently maps semantic information into its discriminative hash codes with varying lengths, significantly outperforming the corresponding KSLSH results. Finally, we train MiLaN with different train:test splits and report mAP@20 at K=32 in Fig. 5b. For instance, Fig. 5b shows that the mAP obtained by MiLAN using only 30% of the training images is much higher than the mAP obtained by KSLSH with 80% of the total training images.

IV-B Results: the AID Dataset

In the experiments on the AID archive, we split the images of each category with a 60:40 train:test split-ratio. The results of this archive demonstrate similar trends as those in UCMD. In summary, MiLaN achieves a higher mAP@20 with respect to all the other methods (Table III). For instance, with K = 16, the mAP@20 of MiLaN is 45% higher than that of KSLSH. A similar trend is kept between these two methods for higher values of K. Moreover, the AID dataset results confirm all the observations pointed out in Sec. IV-A concerning the comparison among MiLaN,’NN-Inception feat. (Euclidean)’ and ’NN-Inception feat. (Hamming)’, again confirming the advantage of simultaneously learning a metric space and the hash codes on top of the adopted CNN features.

Finally, we report an ablation study conducted on the AID archive. Fig. 5c shows that, with increasing values of $K$, the map@50 values of MiLaN increases monotonically and outperforms KSLSH for all values of $K$. Similarly, in Fig. 5d, we observe that, when the number of the top-$k$ retrieved images increases, the map@50 value slightly decreases for MiLaN but quite significantly for the KSLSH.

V Conclusion

In this letter we have introduced a metric-learning based deep hashing method for fast and accurate RS CBIR. The proposed approach is based on an intermediate representation of the RS images obtained using an external, not-retrained CNN (in our case we used Inception Net, pre-trained on ImageNet, but other networks can be used as well). This representation is important to avoid overfitting risks in small-size labeled RS datasets. Using this representation as input instead of raw-pixel data, we train our hashing network using three different losses: a triplet loss which is in charge of learning a metric space and a balancing and a representation loss which effectively learn to produce binary hash codes. In this way we jointly solve two problems: we avoid overfitting risks using the intermediate features and we learn how to produce similarity-based hash codes. Our empirical analysis shows the advantage of this combined strategy, which is more accurate and time-efficient than state-of-the-art methods.

Acknowledgments

This work was supported by the European Research Council (ERC) through the ERC-2017-STG BigEarth Project under Grant 759764.