Deep Attention-guided Hashing

TL;DR

This paper introduces Deep Attention-guided Hashing (DAgH), a novel two-stream deep learning approach that enhances hash code quality for multimedia retrieval by focusing on salient image regions using attention mechanisms.

Contribution

The paper proposes a new two-stream framework with attention-guided hash codes, improving hash code quality and outperforming state-of-the-art methods on benchmark datasets.

Findings

DAgH outperforms existing methods on CIFAR-10, NUS-WIDE, and ImageNet.

The attention mechanism effectively captures salient image regions.

The end-to-end training improves hash code efficiency.

Abstract

With the rapid growth of multimedia data (e.g., image, audio and video etc.) on the web, learning-based hashing techniques such as Deep Supervised Hashing (DSH) have proven to be very efficient for large-scale multimedia search. The recent successes seen in Learning-based hashing methods are largely due to the success of deep learning-based hashing methods. However, there are some limitations to previous learning-based hashing methods (e.g., the learned hash codes containing repetitive and highly correlated information). In this paper, we propose a novel learning-based hashing method, named Deep Attention-guided Hashing (DAgH). DAgH is implemented using two stream frameworks. The core idea is to use guided hash codes which are generated by the hashing network of the first stream framework (called first hashing network) to guide the training of the hashing network of the second stream framework (called second hashing network). Specifically, in the first network, it leverages an attention network and hashing network to generate the attention-guided hash codes from the original images. The loss function we propose contains two components: the semantic loss and the attention loss. The attention loss is used to punish the attention network to obtain the salient region from pairs of images; in the second network, these attention-guided hash codes are used to guide the training of the second hashing network (i.e., these codes are treated as supervised labels to train the second network). By doing this, DAgH can make full use of the most critical information contained in images to guide the second hashing network in order to learn efficient hash codes in a true end-to-end fashion. Results from our experiments demonstrate that DAgH can generate high quality hash codes and it outperforms current state-of-the-art methods on three benchmark datasets, CIFAR-10, NUS-WIDE, and ImageNet.

Tables

Algorithm 1 Deep Attention-guided Hashing (DAgH).
Input Training Image pair with their similarity label $([x_i,x_j],s_{ij})$ in the first stream framework, a sequence . Training Image $x_i$ and the attention-guided hash codes $B^{att}$ in the second stream framework. Training epoches $T_1$ and $T_2$ of the first and second stream framework optimizations, respectively.
Output First stream framework: $sign\left(Hash\left(Attention\left(x_i|{\Theta }_a\right)|{\Theta }_1\right)\right)$; Second stream framework: $sign\left(Hash\left(x_i|{\Theta }_2\right)\right)$.
Begin Construct the pairwise information matrix $S$ according to (1).
1. for $t=1:T_1$ epoch do
2.   Compute $[b_i^{att},b_j^{att}]$ according to (5)
3.   Train the first hashing network (8) with (11) as activation
4.   Compute ${\Theta }_a,{\Theta }_1$ according to (10)
5.   Set converged the first stream framework as next epoch initialization
6. end for
7. return $sign\left(Hash\left(Attention\left(x_i|{\Theta }_a\right)|{\Theta }_1\right)\right)$, ${\beta }_m\to \infty$.
1. for $t=1:T_2$ epoch do
2.   Compute ${\tilde{y}}_i^2$ according to ${\tilde{y}}_i^2=Hash\left(x_i|{\Theta }_2\right)$
3.   Compute ${\Theta }_2$ according to (14)
4.   Set converged the second stream framework as next epoch initialization
5. end for
6. return $sign\left(Hash\left(x_i|{\Theta }_2\right)\right)$.

Table 2. Table 1: mean Average Precision (mAP) of Hamming Ranking for Different Number of Bits on the Three Image Datasets.

Method	CIFAR-10				NUS-WIDE				ImageNet
	12 bits	24 bits	32 bits	48 bits	12 bits	24 bits	32 bits	48 bits	12 bits	24 bits	32 bits	48 bits
SH [7]	0.127	0.128	0.126	0.129	0.454	0.406	0.405	0.400	0.185	0.273	0.328	0.395
ITQ [8]	0.162	0.169	0.172	0.175	0.452	0.468	0.472	0.477	0.305	0.363	0.462	0.517
SDH [15]	0.285	0.329	0.341	0.356	0.568	0.600	0.608	0.637	0.253	0.371	0.455	0.525
KSH [9]	0.303	0.337	0.346	0.356	0.556	0.572	0.581	0.588	0.136	0.233	0.298	0.342
DHN [16]	0.555	0.594	0.603	0.621	0.708	0.735	0.748	0.758	0.269	0.363	0.461	0.530
CNNH [17]	0.429	0.511	0.509	0.522	0.611	0.618	0.625	0.608	0.237	0.364	0.450	0.525
DNNH [33]	0.552	0.566	0.558	0.581	0.674	0.697	0.713	0.715	0.219	0.372	0.461	0.530
DPSH [52]	0.713	0.727	0.744	0.757	0.752	0.790	0.794	0.812	0.143	0.268	0.304	0.407
DSDH [34]	0.726	0.762	0.785	0.803	0.743	0.782	0.799	0.816	0.312	0.353	0.481	0.533
DAgH	0.731	0.777	0.809	0.821	0.753	0.791	0.811	0.825	0.322	0.377	0.503	0.551

Table 3. Table 2: Performance comparison of DAgH with different first hashing networks, i.e, AlexNet and ResNet18.

Method	12 bits	24 bits	32 bits	48 bits
DAgH-AlexNet	0.753	0.791	0.811	0.825
DAgH-ResNet18	0.769	0.796	0.814	0.823

Equations

$$s_{ij}=\{\begin{array}{ll}1,& \text{mbox}if\text{images}{x}_i\text{and}{x}_j\text{share same class label}\\ 0.& \text{mbox}otherwise\end{array}$$

$$sign(x)=\{\begin{array}{ll}1,& \text{mbox}ifx\ge 0\\ -1.& \text{mbox}otherwise\end{array}$$

$$nor{m}_i(p,q)=\frac{x_i(p,q)-\text{min}(x_i)}{\text{max}(x_i)-\text{min}(x_i)},$$

$$[{\tilde{x}}_i,{\tilde{x}}_j]=[x_i,x_j]\otimes nor{m}_{[{\hat{x}}_i,{\hat{x}}_j]}(p,q).$$

$$b_i^{att}=sign(Hash({\tilde{x}}_i|{\Theta }_1)),$$

$$\text{log}P(S|B)=\prod _{s_{ij}\in \mathcal{S}}\text{log}P(s_{ij}|B),$$

$$P(s_{ij}|b_i,b_j)=\{\begin{array}{ll}\sigma (⟨b_i,b_j⟩),& s_{ij}=1\\ 1-\sigma (⟨b_i,b_j⟩),& s_{ij}=0\end{array}$$

$${\mathcal{L}}_{sem}$$

$$=-\sum _{s_{ij}\in S}(s_{ij}⟨b_i,b_j⟩-\log (1+\text{exp}(⟨b_i,b_j⟩))),$$

$${\mathcal{L}}_{att}$$

$$+\sum _{i,j}\max (0,\lambda -||S_{ij}-\frac{\cos ({\omega }_i,{\omega }_j)+1}{2}|{|}_2),$$

$$\underset{{\Theta }_a,{\Theta }_1}{\min }{\mathcal{L}}_{sem}+\nu {\mathcal{L}}_{att},$$

$$b_i=\tanh (\beta {\omega }_i)+ϵ||\frac{1}{\beta }|{|}_2^2,$$

$$b_i^f=sign(Hash(x_i|{\Theta }_2)),$$

$$P(b_{ik}^{att}|{\tilde{y}}_{ik}^2)=\{\begin{array}{ll}\sigma ({\tilde{y}}_{ik}^2),& b_{ik}^{att}=1\\ 1-\sigma ({\tilde{y}}_{ik}^2),& b_{ik}^{att}=0\end{array}$$

$${\mathcal{L}}_g=-\frac{1}{KN}\sum _{k=1}^K\sum _{i=1}^N\log P\left(b_{ik}^{att}|{\tilde{y}}_{ik}^2\right)$$

$$=-\frac{1}{KN}\sum _{k=1}^K\sum _{i=1}^N[{\log P_{ik}}^{b_{ik}^{att}}\cdot {\log (1-P_{ik})}^{(1-b_{ik}^{att})}]$$

$$=-\frac{1}{KN}\sum _{k=1}^K\sum _{i=1}^N\left[b_{ik}^{att}\log P_{ik}+\left(1-b_{ik}^{att}\right)\log \left(1-P_{ik}\right)\right],$$

$$\frac{\partial {\mathcal{L}}_g}{\partial {\tilde{y}}_{ik}^2}=\frac{\partial {\mathcal{L}}_g}{\partial P_{ik}}\frac{\partial P_{ik}}{\partial {\tilde{y}}_{ik}^2}$$

$$=-\frac{1}{KN}(b_{ik}^{att}\frac{1}{P_{ik}}-\frac{1-b_{ik}^{att}}{1-P_{ik}})(P_{ik}(1-P_{ik}))$$

$$=-\frac{1}{KN}(P_{ik}-b_{ik}^{att}).$$

$$b_q=sign(Hash(x_q|{\Theta }_2)).$$

Full text

Deep Attention-guided Hashing

Zhan Yang1, Osolo Ian Raymond1, WuQing Sun1, Jun Long1,2

1School of Information Science and Engineering, Central South University, Changsha 410083, China

2Network Resources Management and Trust Evaluation Key Laboratory of Hunan Province

junlong@csu.edu.cn Corresponding author. This work was supported in part by the National Natural Science Foundation of China (61472450), the Key Technology R&D Program of Hunan Province (2018GK2052) and the Science and Technology Plan of Hunan (2016TP1003).©2018 IEEE. Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, including reprinting/republishing this material for advertising or promotional purposes, creating new collective works, for resale or redistribution to servers or lists, or reuse of any copyrighted component of this work in other works. See http://www.ieee.org/publications_standards/publications/rights/index.html for more informationIEEE ACCESS DOI: 10.1109/ACCESS.2019.2891894

I.   Introduction

In recent years, the amount of multimedia data (text, image, audio and video data) has been growing exponentially. In order to solve the problems of huge storage requirements and learning capacity in dealing with big data, hashing has been the most popular technique for effective binary representation in many tasks due to its fast retrieval and storage efficiency. Generally speaking, the hashing technique, a widely-studied solution to approximate nearest neighbor search, aims to map the original high-dimensional features to a low-dimensional representation, or a short code, called hash code. Then, re-ranking these short codes (hash codes) in response to each query task, requires only a few computations of the Hamming distance operation for efficient multimedia retrieval (i.e., the hashing technique can use a few Bytes to encode one image of several MBytes or one video of several GBytes). Due to the advantages above, hashing has been applied to many large-scale image retrieval [1, 2, 3, 4], text-image cross-model retrieval [5], and person re-identification tasks [6]. There are two categories of hashing: data-independent and data-dependent hashing. In this paper, we will build data-dependent hashing methods for generating high quality hash codes, which can capture the potential image representations to achieve better performance than data-independent hashing methods, e.g., Spectral Hashing (SH) [7].

Data dependent methods can be further categorized into supervised and unsupervised methods. Unsupervised methods retrieve the neighbors under some kinds of distance metrics, e.g., Iterative Quantization (ITQ) [8]. Compared to the unsupervised methods, supervised methods utilize the semantic labels to improve performance. Many researchers have demonstrated that labels of datasets can improve the quality of hash codes and achieve some success along this direction, e.g., Supervised Hashing with Kernels (KSH) [9], Distortion Minimization Hashing (DMS) [4], Minimal Loss Hashing (MLS) [11], Order Preserving Hashing (OPH) [12], Hamming Distance Metric Learning [13], Semantic Hashing [14], Supervised Discrete Hashing (SDH) [15]. However, the quality of hash codes generated is highly dependent on the way feature selection is done, and these methods use hand-crafted features for representation. The need to perform manual feature selection has been a big limitation to the success of these methods.

In the last few years, deep learning networks (e.g., convolutional neural networks) have been shown to have powerful feature extraction capabilities in image processing. They are able to extract high-level features, which leads to attaining much higher performance levels than using hand-crafted features in many image tasks. To solve the limitations of traditional data-dependent hashing methods, this paper focuses on a learning-based hashing method that adopts deep neural networks as the nonlinear functions to enable end-to-end learning of learnable representations and hash codes. These learning-based methods [10, 16, 17, 18], which use pairwise labels to jointly learn similarity-preserving representations and optimize the pair-wise loss and quantization loss, have exhibited high performance on many benchmark tests.

Although recent learning-based hashing methods have achieved significant progress in multimedia retrieval, there are some limitations of previous learning-based hashing methods in generating long hash codes (say, more than 24 bits), e.g., the learned long hash codes contain repetitive and highly correlated information. Any natural image will contain some useless information, or some interference information that is not relevant for a particular task. Images of the same category may contain completely different backgrounds, different categories of images may have similar backgrounds, directly generating the hash codes by a standard learning-based method (as shown in Figure 1) will in practice result in a higher possibility of having correlated bits as the length of the hash codes increases. Then, highly correlated bits have a large impact on retrieval performance (i.e., the cost-performance ratio decreases with increase in the length of the hash code). As an extreme example, if 256-bit hash codes are positively and negatively completely correlated, the performance will be similar to that of the 1-bit hash codes. To solve these limitations, in this paper, we deal with the salient regions and backgrounds of the images separately. Specifically, the main idea of the paper is to firstly adopt an attention network to generate the attention images from the original images, (i.e, use visual attention models to localize regions in an image to capture features of the regions) and then use pairwise information to generate the attention-guided hash codes from the attention images. Secondly, we use these attention-guided hash codes to guide the training of the second hashing network (i.e., these codes are treated as supervised labels to train the second network).

The contributions of this work are summarized as follows:

The proposed DAgH model combines two stream frameworks. The first stream framework consists of an attention network and a hashing network (the first hashing network). The role of the first stream framework is to generate the attention-guided hash codes. A novel method of using the semantic loss and attention loss to train the first stream framework is proposed. The second stream framework contains another hashing network i.e. the second hashing network. This hashing network is guided by the attention-guided hash codes which were generated from the first stream framework. The second stream framework is trained by the proposed guide loss. To the best of our knowledge, this is the first learning-based hashing method that uses its own attention-guided hash codes to guide the training of the original image hashing network. 2. 2.

In order to guarantee the quality of the final hash codes and eliminate the quantization error, the DAgH model uses a continuous activation function to ensure that the first stream framework is a true end-to-end network and a threshold activation function to ensure that the second stream framework directly generates the final hash codes. In the first stream framework, we chose to use a continuous ATanh activation function for training because it’s easier to optimize than using a $sign$ function with no extra quantization loss. As a result, it shows stronger capacity in learning high quality attention-guided hash codes. When the second stream framework is trained by the attention-guided hash codes, we can use a $sign$ activation function to constrain the output of the second stream framework for generating the binary codes directly. These operations trade off efficacy for efficiency.

The remainder of this paper is structured as follows. In Section II, we briefly introduce the related works. In Section III, we highlight the motivation of our method and provide some theoretical analysis for its implementation. In Section IV, we introduce our experimental results and corresponding analysis and finally in Section V conclude the paper.

II.   Related Work

i.   Hashing

By representing multimedia data as binary codes and taking advantage of fast query retrieval, hashing is a novel technique that can resolve the information retrieval problems in this multimedia era. Wang et al. [21] have provided a comprehensive literature survey that covers the most important methods and latest advances in image retrieval.

We can divide the hashing methods into two categories: data-independent and data-dependent methods. In the early researches, Locality Sensitive Hashing (LSH) was one of the data-independent methods used. LSH hashes input items so that items that are similar have a high probability of being mapped to the same “buckets” (the number of buckets being much smaller than the universe of possible input items) [22]. LSH and several variants (e.g., kernel LSH [23] and $p$-norm LSH [24]) are widely used for large-scale image retrieval. However, there are many limitations of data-independent methods, e.g., the efficiency is low and it requires longer hash codes to attain high performance. Due to the limitations of the data independent methods, current researchers focus on using a variety of machine learning techniques to learn more efficient hash functions based on a given dataset.

Data dependent methods can be further categorized into supervised, semi-supervised and unsupervised methods. Unsupervised hashing methods learn hash functions that encode data points to binary codes by training from unlabeled data. Typical learning criteria include minimize reconstruction error [25, 26, 27, 28] and graph structure learning [29, 30]. Iterative Quantization (ITQ) is one of the unsupervised methods in which the projection matrix is optimized by iterative projection and thresholds according to the given datasets [8]. Compared to the semi-supervised and unsupervised methods, supervised methods utilize the semantic labels to improve performance. Many researchers have proposed along this direction and have achieved some success (They have demonstrated that labels of datasets can improve the quality of hash codes), e.g., Supervised Hashing with Kernels (KSH) [9], Distortion Minimization Hashing (DMS) [4], Minimal Loss Hashing (MLS) [11], Order Preserving Hashing (OPH) [12], Hamming Distance Metric Learning [13], Semantic Hashing [14], Supervised Discrete Hashing (SDH) [15]. The hash codes are generated by minimizing the Hamming distance between similar pairs and maximizing the Hamming distance between dissimilar pairs.

Recently, deep convolutional neural networks have yielded amazing results on many computer vision tasks, this success has attracted the attention of researches of learning-based hashing methods. Convolutional Neural Network Hashing (CNNH) is one of the early works to use a learning-based hashing method, which utilize two stages to learn the image features and hash codes. Following this work, many learning-based hashing techniques have been proposed, e.g., Deep Semantic Ranking Hashing (DSRH) [31] which learns the hash functions by preserving semantic similarity between multi-label images. Deep Visual-Semantic Quantization (DVSQ) [1] generates the compact hash codes by optimizing an adaptive margin loss and a visual-semantic quantization loss over multi-networks. Deep Supervised Hashing (DSH) [32] designs a loss function to pull the outputs of similar pairs of images together and pushes the dissimilar ones far away. Its outputs are relaxed to real values to avoid optimizing the non-differentiable loss function in Hamming distance. Network In Network Hashing (NINH) [33] adopts a triplet ranking loss to capture the relative similarities of images. Deep Supervised Discrete Hashing (DSDH) [34] uses both pairwise label and classification information to learn the hash codes under a single steam framework. Guo et al., [35] show that existing DSH can achieve good results with short hash codes (e.g., 8 to 24 bits) but only lead to marginal performance gain with long hash codes (e.g., 128 bits). They try to divide a single network into many sub-networks to generate hash codes respectively. Extensive researches have taken advantage of deep learning techniques to achieve great improvements compared to traditional data-dependent hashing methods.

However, existing learning-based methods do not consider the high correlation problem of long hash codes. Although convolutional neural networks have powerful capabilities in image feature extraction, they do not deal with the irrelevant features in the image. When long hash codes need to be generated, the correlation problem of the hash codes cannot be ignored. In this paper, we introduce a high-quality hash code generation method, where an attention network is embedded to mine salient regions for guiding the standard supervised learning-based hashing framework.

ii.   Salient Regions Learning

The key challenge of learning high quality hash codes is to locate the salient regions in images. Many methods for locating salient regions have been proposed in recent years. Previous methods of locating the salient regions can be categorized into traditional methods and deep learning based methods.

Traditional methods include techniques such as [36, 37, 38] locating the salient regions by unsupervised methods. Following these works, some hashing methods locate salient regions to improve performance in the unsupervised manner. Shen et al. [39] proposed a cross-modal hashing method which uses RPN [40] to detect salient regions. Then, the two cross-modal networks are used to encode the region information, the semantic dependencies and cues between the words. DPH [41] uses GBVS [42] to count the scores for each pixel. Then, a collection of salient regions are generated based on increasing threshold scores. However, traditional methods use ready-made models to locate salient regions and therefore, when encountering a new dataset, there is no guarantee that the learned salient regions are accurate.

Due to the success of deep learning, most of the methods depend on powerful deep features, which have shown a higher performance gain than hand-crafted features on image classification [43, 44, 45, 47]. Zhao et al. [48] adopted similarity labels to train part model for person re-identification. Lin et al. [49] proposed a bilinear structure, which computes the pairwise feature interactions by two-stream convolutional neural networks to capture the different salient regions between input images and achieved high performance in bird classification. RA-CNN [50] is a recurrent-attention convolutional neural network, which can discover salient regions and learn region-based features recursively. Motivated by [50, 51], we adopt a novel attention network to generate the attention image and use a hashing network to learn the attention-guided hash codes. Then use the generated attention-guided hash codes to guide the second hashing network to learn the final hash codes.

III.   Deep Attention-guided Hashing

In this section, we first give the problem formulation, then show the details of our proposed method, including the framework, loss function and training strategy, and finally show its extensions to out-of-sample data.

i.   Problem Formulation

In similarity retrieval systems, we are given a training set $\mathcal{X}=\{x_{i}\}_{i=1}^{N}$, each image represented by a $d$-dimensional feature vector $x_{i}\in\mathbb{R}^{d}$, where $\mathcal{X}\in\mathbb{R}^{d\times N}$. In supervised learning-based hashing, the pairwise information $S=\{s_{ij}\}$111Note that one image may belong to multiple categories. is derived as:

[TABLE]

Supervised learning-based hashing method learn a nonlinear function $f:\ \mapsto b\in\{-1,1\}^{K}$ from an input space $\mathbb{R}^{d}$ to Hamming space $\{-1,1\}^{K}$ with deep neural network. This method generally contains three steps: 1) using a network for learning deep features of each image $x_{i}$, 2) using a fully-connected hashing layer ($fch$) for transforming the deep features into $K$-dimensional continuous representation $\omega_{i}\in\mathbb{R}^{K}$, 3) using a $sign$ function to quantize the continuous representation $\omega_{i}$ into $K$-bit binary hash code $b_{i}\in\{-1,+1\}^{K}$. The similarity labels $S=\{s_{ij}\}$ can be constructed from semantic labels of data points or relevance feedback in real retrieval systems. In addition, the threshold function $sign(\cdot)$ is an element-wise $sign$ function defined as follows:

[TABLE]

ii.   Network Architecture

To address the limitations of previous learning-based hashing methods, we propose a novel learning-based method. Figure 2 shows the proposed DAgH model. Our method includes two stream framework. The first stream contains an attention network and a hashing network. The attention map is the most critical part of our network, since it allows the network to know which regions should be focused on. Then the hashing network uses the attention images to generate the attention-guided hash codes. Thereafter, in the second stream, these attention-guided hash codes are treated as supervised labels to train an image hashing network which can generate the final hash codes for the input images. The details of all stream frameworks are described in the following subsections.

iii.   The First Stream Framework

As mentioned previously, this stream framework is a true end-to-end deep model which includes an attention network, i.e., $Attention(\cdot|\Theta_{a})$, and a hashing network, i.e., $Hash(\cdot|\Theta_{1})$. In this subsection, we will introduce the main processes of the two networks and the details of the network training.

The Attention Network The role of the attention network is to find salient regions in the original image that need to get attention. These regions are the most representative of the theme of the image, so they can be used for better salient region restoration, and for the first hashing network to focus the assessment on. This attention processing consists of two stages. In the first stage, the proposed FCN-based attention network [62] is used to map the original input image pair $[x_{i},x_{j}]$ to the preliminary attention image pair $[\hat{x}_{i},\hat{x}_{j}]$. Inspired by [51], to build a learnable attention network and guarantee that it generates accurate attention images, we define a normalization function to restrict the value of each pixel between 0 and 1:

[TABLE]

where $(p,q)$ denotes the location $(p,q)$ in an image $x$, $\text{max}(x)$ denotes the maximum pixel value in an image $x$, $\text{min}(x)$ denotes the minimum pixel value in an image $x$.

In the second stage, the attention image pair $[\tilde{x}_{i},\tilde{x}_{j}]$ is computed through a Hadamard product $\otimes$ of the original image pair $[x_{i},x_{j}]$ and the normalization function of the preliminary attention image pair $[\hat{x}_{i},\hat{x}_{j}]$:

[TABLE]

Then we can encode the attention image pair $[\tilde{x}_{i},\tilde{x}_{j}]$ by the first hashing network. The attention network can be gradually fine-tuned their parameters through (10) to mine salient regions automatically.

The First Hashing Network The generated attention image pair $[\tilde{x}_{i},\tilde{x}_{j}]$ as the input of the first hashing network and the semantic information as the pairwise label to train the first hashing network. After the first hashing network is trained, the attention-guided hash code $B^{att}=\{b_{i}^{att}\}^{N}_{i=1}$ is calculated through the trained hashing network:

[TABLE]

where $b_{i}^{att}$ is the attention-guided hash code, $\Theta_{1}$ denotes the parameters of the first hashing network222Note that, the ATanh activation function(the detail about the ATanh activation function can be found in (11)) is used to train the first stream framework (8) and the $sign$ activation function is used as the final output of the first stream framework., and \tilde{x}_{i}$$=$$Attention(x_{i}|\Theta_{a}) is the attention image that is input into the first hashing network and generated by the attention network, $\Theta_{a}$ is the parameters of the attention network.

The no-quantization loss training strategy of the first stream framework is expatiated as follows:

Similarity Measure

For a pair of binary hash codes $b_{i}$ and $b_{j}$, the relationship between their Hamming distance $\text{dist}_{H}$ and inner product $\langle\cdot,\cdot\rangle$ is formulated as follows: $\text{dist}_{H}=\frac{1}{2}(K-\langle b_{i},b_{j}\rangle)$. The larger the inner product of two hash codes, the smaller the Hamming distance, and vice versa. Therefore, the inner product through two hash codes is a reliable criterion for evaluating the similarity between them.

In supervised learning-based hashing method, the Maximum Likelihood (WL) estimation of the hash codes $B=[b_{1},b_{2},...,b_{N}]$ for all $N$ images is:

[TABLE]

where $P(S|B)$ denotes the likelihood function. Given each image pair with their similarity label $([x_{i},x_{j}],s_{ij})$, $P(s_{ij}|b_{i},b_{j})$ is the conditional probability of $s_{ij}$ given the pair of corresponding hash codes $[b_{i},b_{j}]$, which is naturally defined as logistic function:

[TABLE]

where $\sigma(x)=1/(1+e^{-x})$ is the sigmoid activation function, $\langle b_{i},b_{j}\rangle=\frac{1}{2}b_{i}^{T}b_{j}$.

Loss Function

Semantic Loss Considering the similarity measure,the following loss function is used to learn the hash codes:

[TABLE]

where $b_{i}=sign(\omega_{i})$, which converts the $K$-dimensional representation $\omega_{i}$ to exactly binary hash codes333Note that, Equation (8) need to first learn the continuous representation $\omega_{i}$, which are quantized to binary values in a separated operation using $sign$ function, this will result in quantization errors.. Equation (8) is the negative $log$ likelihood loss function, which represents the Hamming distance of two similar images that are as small as possible, and the Hamming distance of two dissimilar images that are as large as possible. Then, we define an attention loss to train the attention network to capture some salient regions of the image.

Attention Loss In training the attention network, we denote the continuous representation pair of $fch$ layer (also called binary-like codes) as $[\omega_{i},\omega_{j}]$. Then we obtain the optimal hash code pair $[b_{i},b_{j}]$ from the continuous representation pair $[\omega_{i},\omega_{j}]$. Given $[b_{i},b_{j}]\in\{-1,1\}^{k}$, the cosine similarity between the continuous representation pair can be defined as $\cos(\omega_{i},\omega_{j})=\frac{\omega_{i}^{T}\omega_{j}}{||\omega_{i}||_{2}||\omega_{j}||_{2}}$, which is in the range of $(-1,1)$. Therefore, we use $\frac{\cos(\omega_{i},\omega_{j})+1}{2}$ to restrict the similarity value to $(0,1)$. The attention loss is written as below:

[TABLE]

where $\lambda>0$ is a margin parameter. The attention loss will punish the attention network to make it better capture the salient regions.

Overall, combining Equation (8) and (9), the loss of the first stream framework can be written as:

[TABLE]

where $\Theta_{a},\Theta_{1}$ are the first stream framework parameters efficiently optimized using standard back-propagation with automatic differentiation techniques.

End-to-End Learning

In many of the recent hashing methods [8, 15, 16, 32, 34, 51, 52, 53, 54], quantization error is an important part of their optimization process, which will directly result in retrieval quality. These hashing methods first need to learn continuous representations (binary-like codes) through $sigmoid$ and $\tanh$ functions, then, the binary-like codes are binarized into hash codes in a separate operation of $sign$ thresholding. Therefore, the gap between the binary-like codes and hash codes is called the quantization error. For examples, in  [51], the quantization error is defined as $\mathcal{L}_{reg}=\sum_{i}||\omega_{i}-b_{i}||_{1}$, in ITQ [8], the quantization error is defined as $\mathcal{L}_{ITQ}=||\omega_{i}-b_{i}||_{2}$, where $b_{i}=sign(\omega_{i})\in\{1,-1\}^{K}$. Although the optimization methods propose to reduce the quantization error, the activations of the $fch$ layer are still not binary. This is because a $sign$ function is non-smooth and non-convex, and therefore has no gradient (i.e., the gradient of $sign$ function is zero for all non-zero inputs, which makes the classical back-propagation infeasible for training deep networks.). Cao et al. [55] proposed a justifiable approach based on the continuation of the $\tanh$ function, which approaches the $sign$ function with the scale parameter $\beta$ in its limit: $\lim_{\beta\rightarrow\infty}\tanh(\beta x)=sign(x)$, they prove the convergence of this optimization when adopting a sequence of increasing values of $\beta$ during training. However, in order to ensure that the continuous $\tanh$ function is differential everywhere that can be optimized via standard back-propagation, a regularization term should be considered [56]. Such activation function is named as Adaptive Tanh (ATanh):

[TABLE]

where $\epsilon$ is the regularization constant. The second term of (11) is a regularization term. The regularization term is a penalty to the standard $\tanh(\beta x_{i})$, when $\beta$ gradually increases, the ATanh function approaches the $sign$ function and has the reliable-ability to generate hash codes. When $\beta\rightarrow\infty$, the optimization problem will converge to the original deep learning to hash problem in (8) with $sign(x)$ activation function. We follow the empirical parameters setting and first set the parameter $\beta_{0}=1$ as the initialization. At each epoch $T$, we increase $\beta$ and fine-tune the first stream framework of DAgH in the next epoch. With the parameter $\beta\rightarrow\infty$ of the (11), the network will converge to the first stream framework of DAgH with $sign$ as activation function, which can generate high-quality attention-guided hash codes as we required. The time consumption of ATanh as the activation function in the whole network is negligible (i.e., both forward and backward computation is negligible) [56]. Different from the previous hashing methods mentioned above, there is no-extra quantization error within such an end-to-end hashing net, hence it shows stronger capacity in learning high-quality attention-guided hash codes.

iv.   The Second Stream Framework

As shown in Figure 2, we directly adopt a pre-trained AlexNet as the base of the second hashing network. After obtaining the attention-guided hash code $B^{att}$, we thereafter utilize it as the supervised labels and the original images $\mathcal{X}=\{x_{i}\}^{N}_{i=1}$ to train the hashing network. When the hashing network is trained, the final hash codes $b_{i}^{f}$ are computed through the trained hashing network:

[TABLE]

where $b_{i}^{f}$ is the final hash code, $\Theta_{2}$ denotes the parameters of the second hashing network, and $\tanh(\cdot)$ as activation of the $fch$ layer of the hashing network.

The details of learning strategy are explained as follows:

Attention-Guided Strategy

As mentioned above, when the first stream framework is trained, the generated attention-guided hash codes are used as the supervised labels to guide the second hashing network. Considering the powerful image feature extraction ability of convolutional neural networks, here we adopt the famous and widely used AlexNet, which is commonly used in baseline models. The AlexNet consists of 5 convolutional layers $(c1-c5)$, and 2 fully-connected layers $(fc1-fc2)$, and is pre-trained on the ImageNet dataset. To obtain the hash codes, we add a $k$-nodes hash layer, called $fch$, each node of $fch$ layer corresponds to 1 bit in the target hash code. With the $fch$ layer, the previous layer representation is transformed to a $k$-dimensional representation. The architecture of the second hashing network is shown in Figure 2.

More specifically, let $\tilde{y}_{i}^{2}=Hash(x_{i}|\Theta_{2})$ be the output of the second hashing network, where $x_{i}$ is the original input image and $\Theta_{2}$ is the parameter of the second hashing network. Since our goal is to use the attention-guided hash code $b_{i}^{att}$ to guide the second hashing network through sigmoid cross-entropy loss function, we need to convert the value of -1 in the attention-guided hash codes to 0 so that the value of the attention-guided hash code is $b_{i}^{att}\in\{0,1\}^{K}$. We define the following likelihood functions:

[TABLE]

where $b_{ik}^{att}$ is the hash code corresponding to the $k$-th bit of the $i$-th element in $b_{i}^{att}$, $\ \tilde{y}_{ik}^{2}$ is the output of the $k$-th node in $fch$ layer of the $i$-th element, and $\sigma(\cdot)$ is a sigmoid function as shown in (7).

Loss Function

Guide Loss In order to use the attention-guided hash codes to guide the second hashing network, we define a guide loss, which is written as follows:

[TABLE]

where $N$ is the number of training images, $K$ is the number of bits in each hash code, and $P_{ik}=\sigma(\tilde{y}_{ik}^{2})$.

In order to minimize (14), we use the Back-Propagation (BP) algorithm to learn the parameter $\Theta_{2}$ of the second hashing network with stochastic gradient descent (SGD). Specifically, we take the derivative of the guide loss:

[TABLE]

Thereafter, we can obtain $\partial\mathcal{L}_{g}/\partial\Theta_{2}$ with $\partial\mathcal{L}_{g}/\partial\tilde{y}_{ik}^{2}$ using the chain rule, i.e., we can use BP to update the parameter $\Theta_{2}$ of the second hashing network. After training, we obtain the trained AlexNet model for the final hashing model and the corresponding image hash codes can be generated by (12).

v.   Out-of-Sample Extension

After our proposed DAgH model is trained, we can easily generate its hash code through the second hashing network. For example, given a new instance $x_{q}\notin\mathcal{X}$, we directly use it as the input of DAgH model, then forward propagate the second hashing network to generate its hash code as follows:

[TABLE]

IV.   Experiments

In order to demonstrate the performance of our proposed DAgH method, we carried out extensive experiments on three widely used benchmark datasets, i.e., CIFAR-10, NUS-WIDE, and ImageNet, to verify the effectiveness of our method.

i.   Datasets and Settings

CIFAR-10 [57] dataset consists of 60,000 images with a resolution of 32$\times$32 in 10 categories (each category has 6,000 images). Each image has only one category. In our experiment, we randomly selected 100 images per category (i.e., 1,000 images in total) as the test set, 500 images per category (i.e., 5,000 images in total) as the training set. The rest of the images are used as gallery in the testing phase.

NUS-WIDE [58] is a dataset contains that nearly 270K (260,648) images collected from the public web. It is a multi-label dataset. There are 81 semantic concepts manually annotated for evaluating retrieval performance. In our experiment, as in [17] and [34], we selected the 21 most frequent concepts. We randomly sample 100 images per class (i.e., 2,100 images in total) as the test set, 500 images per class (i.e., 10,500 images in total) as the training set. The rest of the images are treated as the gallery in the testing phase.

ImageNet [59] dataset is a well-known benchmark dataset for the Large Scale Visual Recognition Challenge (ILSVRC 2015). It contains 1,000 categories with over 1.2M images in the training set and 50,000 images in the validation set, where each image has only one category. As in [3] and [54], we randomly selected 100 categories which led to a database with about 120K images and a query set with about 5,000 images. In this dataset, we randomly selected 100 images per class (i.e., 10,000 in total) as the training set.

ii.   Baselines

We compared our proposed DAgH method against some classic or state-of-the-art hashing methods. We roughly divided these methods into two groups: traditional hashing methods and learning-based hashing methods. The traditional hashing methods include unsupervised hashing methods: SH [7], ITQ [8], and supervised hashing methods: SDH [15], KSH [9]. The learning-based hashing methods include DPSH [52], DHN [16], CNNH [17], DNNH [33], DSDH [34]. These methods are based on either AlexNet [19] or CNN-F [60] network architecture. The AlexNet network and CNN-F network have similar network architectures (i.e., They consist of 5 convolutional layers and 2 fully connected layers). As in the traditional hashing methods, we used $\text{DeCAF}_{7}$ features [61]. For learning-based methods, we used raw images as input. In fact, in the past few years, many more advanced networks have been created such as ResNet [20], WRNs [46]. The aim of our paper is to demonstrate a novel technique based on AlexNet that is able to outperform baseline models. If we adopted the advanced networks, we would be unable to know whether the performance gain was given by our DAgH method or by the advanced networks.

We evaluated the image retrieval quality on four metrics: mean Average Precision (mAP), Precision-Recall curves (PR), Precision curves within Hamming distance 2 (P@H$\mathbf{=}$2), Precision curves with different Number of top returned samples (P@N). For fair comparison, we adopted MAP@1000 for ImageNet and MAP@5000 for other datasets as in [34]

iii.   Implementation Details

The DAgH method was implemented on Pytorch and batch gradient descent was used to train the network. As shown in Figure 2, our model consists of three networks: an attention network and two hashing networks. We use a very famous attention network, i.e., FCN [62] as the base model for the attention network. As discussed in [62], there are three different network models (i.e., FCN-8s, FCN-16s, and FCN-32s). We use the fusing method of FCN-16s to improve performance. Readers can find more details about the attention network in [62]. We used AlexNet for the all hashing networks. We fine-tuned convolutional layers and fully-connected layers copied from AlexNet pre-trained on ImageNet and trained the hashing layer $fch$ by back-propagation (BP). As the $fch$ layer is trained from scratch, we set its learning rate to be 10 times that of the lower layers. In our proposed DAgH method, in batch form are used as the input and every two images in the same batch constitute an image pair. The parameters of our proposed DAgH model are learned by minimizing the proposed loss function. The training procedure, i.e., DAgH, is summarized in Algorithm 1.

Network Parameters In our DAgH, the value of hyper-parameter $\nu$ is 50 and $\lambda$ is 0.3. The parameter $\epsilon$ of ATanh follows the empirical value of 0.001 in [56]. We use mini-batch Stochastic Gradient Descent (SGD) with 0.9 momentum and the learning rate annealing strategy implemented in Pytorch. The mini-batch size chosen was 32 and the weight decay parameter selected was 0.0005.

iv.   Results and Discussions

The mAP results of all methods for different lengths of hash codes on CIFAR-10, NUS-WIDE, and ImageNet are listed in Table 1. Results on CIFAR-10 dataset show that the proposed DAgH method substantially outperforms all other methods against which it was compared. Compared to traditional hashing methods, such as, ITQ, the best shallow hashing method using deep features achieves an absolute boost of 77.83%, 78.25%, 78.74%, and 78.68% corresponding to different lengths of hash codes, respectively. In addition, most of the learning-based hashing methods perform better than the traditional hashing methods. In particular, DSDH, the state-of-the-art learning-based hashing method, achieves the best performance among all the learning-based methods. Compared to DSDH, our DAgH method can achieve absolute boosts of 0.68%, 1.90%, 2.9%, and 2.2% in average mAP corresponding to different lengths of hash codes, respectively. Similar to the other hashing methods, we also conducted experiments for large-scale image retrieval. For NUS-WIDE and ImageNet datasets, if two images share at least one same label, they are considered to belong to the same category. The results of experiments using the NUS-WIDE and ImageNet datasets on Table 1 show that the proposed DAgH method outperforms the best existing traditional hashing image retrieval methods (i.e., ITQ) by 41.20% and 5.17% in average mAP for different lengths of hash codes on these datasets, respectively. Compared to the state-of-the-art learning-based hashing method (i.e., DSDH). We achieve absolute boosts of 1.26% ,3.64% in average mAP for different lengths of hash codes on these datasets, respectively. These results demonstrate that our approach can boost the retrieval performance.

We also observe from the Table 1 that the gap between the learning-based methods and traditional hashing methods is larger on CIFAR-10 dataset than NUS-WIDE and ImageNet datasets. The reasons are that the number of categories in NUS-WIDE and ImageNet datasets are more than those in CIFAR-10 dataset, and each of the image may contain multiple labels. By carefully comparing the performance of different bits, we found that our proposed method showed a higher degree of performance improvement when tested on at long bits (i.e., 32bits and 48 bits) compared to short bits (i.e, 12bits and 24 bits). This means that our approach can make the hash codes more informative.

An important indicator for evaluating image retrieval performance is Precision within Hamming radius 2 (P@H=2) because such Hamming ranking only require $O(1)$ time for query operations. As shown in Figures 3(b), 4(b), and 5(b), DAgH achieves the highest P@H=2 results on all the datasets. In particular, P@H=2 of DAgH with 24 bits achieves the best performance. This shows that DAgH can learn more quality hash codes. Norouzi et al.  [63] show that when generating relatively longer hash codes, the Hamming space will become sparse and few data points will fall within the Hamming ball with a radius of 2. This is why many learning-based hashing methods can achieve good image retrieval performances on short hash codes.

The other important indicators are Precision-Recall curves (PR) and Precision curves with a different Number of top returned samples (P@N). These results are shown in Figures 3(a), 4(a), 5(a) and Figures 3(c), 4(c), 5(c), respectively. We can observe that the performance of our proposed model (DAgH) is better than the models to which it was compared. For example, using the proposed model, more semantic neighbors are retrieved, which is desirable in practical applications. In particular, DAgH achieves stable precision improvement at every recall level test and tests on the number of top images returned, which is very useful for real-world practical systems.

v.   Other Analysis

Impact of the first hashing network selection: As shown in Figure 2, (the architecture of DAgH), we leverage a hashing network in the first stream framework to generate the attention-guided hash codes from the attention images. Intuitively, the performance of the hashing network could affect the quality of the attention-guided hash codes, i.e., the better the attention-guided hash codes is, the better the performance achieved by the second hashing network. To confirm this, we further design a new variant of DAgH, i.e., DAgH-ResNet18, which adopts ResNet-18 as the first hashing network, instead of AlexNet used in previous experiments. ResNet is a well-known convolutional neural network, and its performance in image processing is better than that of AlexNet. We carried out experiments on the NUS-WIDE dataset. The mAP results are shown in Table 2. DAgH-AlexNet implies that AlexNet was used in the first stream framework and ResNet-18 was used in DAgH-ResNet18. From table 2, the following observations were made:

DAgH-ResNet18 outperforms DAgH-AlexNet in most cases except in the case of 48 bits. This proves that DAgH can obtain better results by using a first hashing network with better performance. 2. 2.

The performance gap between DAgH-ResNet18 and DAgH-AlexNet was very small. This indicate that DAgH is not sensitive to attention-guided hash codes, this may be because the information of the attention hash codes is diluted when they guide the generation of new hash codes.

Impact of the hyper-parameters: In this subsection, we analyze the impact of the hyper-parameters, i.e., the value of the attention parameter $\nu$ and the margin parameter $\lambda$. The experiments are conducted on the NUS-WIDE dataset. The value of the attention penalty parameter $\nu$ is selected using values within the range 20 to 80 with a constant step-size of 10 and the margin parameter $\lambda$ is using values within the range 0 to 0.5 with a constant step-size 0.05. Figure 6 shows that DAgH can achieve good performance on NUS-WIDE dataset within the range $40\leq\nu<60$. As shown in Figure 6, the model is sensitive to the value of the margin parameter $\lambda$ and achieved good performance on NUS-WIDE dataset with $0.2\leq\lambda\leq 0.35$. This is because according to (9), if the value of margin is small, the attention loss has a lower impact in punishing the attention network, and as the result, the attention image pair will be similar to the original image pair. If the value of margin is large, the attention loss will affect (10).

Encoding Time: In practical retrieval systems, time efficiency for generating the hash codes for a new instance (image) is an important factor in the evaluation model. In this part, we compare the encoding time of the proposed DAgH method and other baseline hashing methods: ITQ [8], SDH [15], KSH [9], DPSH [52], DHN [16], CNNH [17], DNNH [33], and DSDH [34]. Since the input instances are originally raw images, for fair comparison, we take into consideration both the time cost for feature extraction and hashing encoding. We report both the feature extraction time efficiency for traditional hashing methods and the encoding cost for learning-based hashing methods on GPU and the hashing encoding time of traditional hashing methods on CPU. The encoding times (in microseconds, base 10) of involved hashing methods are presented in Figure 7 using a logarithmic scale on the CIFAR-10 dataset with 48 bits hash codes. From Figure 7, it can be seen that traditional hashing methods such as ITQ, and KSH, actually perform quite decently with encoding times faster than leaning-based hashing methods by an order of magnitude. However, traditional hashing methods require a separate process for feature extraction. When the full process of using a traditional method is put into consideration (feature extraction + traditional hashing method), the encoding time of the traditional methods is much worse than that of leaning-based hashing methods by an order of magnitude. The computing platform is equipped with an Intel 2$\times$ Intel E5-2600 CPU, 128G RAM, and a NVIDIA TITAN Xp 12G GPU. The encoding time basically depends on the adopted neural network model rather than the hashing method. Thus the time varies little with different lengths of hash codes.

Visualization of Hash Codes: Figure 8 shows the t-SNE visualization [64] of the hash codes learned by the proposed DAgH method and the best learning-based hashing baseline DSDH on the ImageNet dataset (we sample 10 categories for the case of visualization). We can observe that the hash codes generated by DAgH exhibit clear discriminative structures where the hash codes in different categories are well separated, while the hash codes generated by DSDH do not show such discriminative structures. The results verify that the hash codes learned through the proposed DAgH are more discriminative than those learned by DSDH, enabling more effective image retrieval.

V.   Conclusion

In this paper, we propose a novel attention-guided hashing method for image retrieval, named DAgH. To improve the quality of the generated hash codes, in other words, to address the high correlation problems of the generated hash codes, our method consists of two stream frameworks, which consist of an attention network and two hashing networks. The attention network can automatically mine the key region of an image and generate the attention images. The hashing networks are used to learn semantic-preserving hash codes. The first hashing network generates the attention-guided hash codes from the attention images using pairwise labels to learn the attention-guided hash codes. The second hashing network is then guided by the attention-guided hash codes to generate the final hash codes. On the choice of the hash activation function, the first stream framework uses a continuous ATanh activation function for training and the second stream framework uses a threshold function $sign(\cdot)$. Comprehensive experiments on the three benchmark image retrieval datasets demonstrate that the DAgH outperforms the state-of-the-art methods.

In the future, we plan to extend the self-hashing network to support image retrieval with relative similarity labels, i.e., condense the two stream framework into a single self-training network.

Acknowledgment

The authors would also like to thank the associate editor and anonymous reviewers for their comments to improve the paper.