Supervised Discrete Hashing with Relaxation

TL;DR

This paper introduces SDHR, a novel supervised hashing method that optimizes the regression target for improved classification accuracy and retrieval efficiency in high-dimensional data, outperforming previous SDH.

Contribution

The paper proposes a new supervised discrete hashing method called SDHR that optimizes the regression target, enhancing flexibility and accuracy over traditional SDH.

Findings

SDHR outperforms SDH on CIFAR-10, MNIST, and FRGC datasets.

SDHR demonstrates improved retrieval accuracy and efficiency.

Experimental results confirm SDHR's effectiveness in large-scale datasets.

Abstract

Data-dependent hashing has recently attracted attention due to being able to support efficient retrieval and storage of high-dimensional data such as documents, images, and videos. In this paper, we propose a novel learning-based hashing method called "Supervised Discrete Hashing with Relaxation" (SDHR) based on "Supervised Discrete Hashing" (SDH). SDH uses ordinary least squares regression and traditional zero-one matrix encoding of class label information as the regression target (code words), thus fixing the regression target. In SDHR, the regression target is instead optimized. The optimized regression target matrix satisfies a large margin constraint for correct classification of each example. Compared with SDH, which uses the traditional zero-one matrix, SDHR utilizes the learned regression target matrix and, therefore, more accurately measures the classification error of the regression model and is more flexible. As expected, SDHR generally outperforms SDH. Experimental results on two large-scale image datasets (CIFAR-10 and MNIST) and a large-scale and challenging face dataset (FRGC) demonstrate the effectiveness and efficiency of SDHR.

Tables

Table 1. TABLE I: Notations

Notation	Description
$X$	the data matrix
$x_i$	the $i$-th data point
$n$	the training sample size: the number of the total training data points
$B$	the hash codes
$b_i$	the $i$-th row of $B$ (the hash code for $x_i$)
$l$	the length of hash code
$Y$	the label matrix
$c$	the number of classes
$y_i$	the $i$-th row of the matrix $Y$
$y_{ik}$	the $k$-th element of $y_i$
$W$	the projection matrix for the hash code
$F(\cdot )$	a nonlinear embedding to approximate the hash code
$m$	the number of anchor points
$\varphi (\cdot )$	an $m$-dimensional row vector obtained by the RBF kernel
$P$	the projection matrix for the nonlinear embedding
$t$	the translation (offset) vector used in SDHR
$R$	the regression target matrix (code words) used in SDHR
$R_i$	the $i$-th row of the matrix $R$
$L_i$	the label of $x_i$
$e_n$	an $n$-dimensional column vector with all elements equal to one
$r$	the Hamming radius

Table 2. TABLE II: Precision, recall, F-measure of Hamming distance within radius 2, MAP, accuracy, and time on CIFAR-10. Results are reported when the number of hashing bits is 16. For SSH, 5,000 labeled examples are used for similarity matrix construction. The training and test times are in seconds.

Method	precision@$r$=2	recall@$r$=2	F-measure@$r$=2	MAP	accuracy	training time	test time
SDHR	0.4612	0.2835	0.3511	0.4091	0.638	42.4	2.7e-6
SDH	0.4588	0.2805	0.3481	0.4123	0.622	43.9	2.2e-6
BRE	0.1745	0.2118	0.1913	0.1431	0.305	66.0	6.3e-6
KSH	0.4763	0.1167	0.1875	0.4030	0.549	1.3e3	7.8e-5
SSH	0.1674	0.3908	0.2344	0.1687	0.295	17.2	3.0e-6
CCA-ITQ	0.3819	0.1382	0.2030	0.3137	0.539	4.6	1.5e-7
FastHash	0.5560	0.2310	0.3264	0.5253	0.588	1.2e3	4.3e-4
PCA-ITQ	0.2389	0.0221	0.0404	0.1616	0.371	3.3	1.5e-7
AGH	0.2223	0.0553	0.0886	0.1562	0.34	6.9	8.5e-5
IMH	0.1926	0.1454	0.1657	0.1696	0.321	42.5	6.3e-5

Table 3. TABLE III: Precision, recall, F-measure of Hamming distance within radius 2, MAP, accuracy, training time, and test time on MNIST. Results are reported when the number of hashing bits is 64.

Method	precision@$r$=2	recall@$r$=2	F-measure@$r$=2	MAP	accuracy	training time	test time
SDHR	0.9330	0.7943	0.8581	0.9417	0.967	186.2	4.9e-6
SDH	0.9269	0.7711	0.8419	0.9397	0.963	128	5.1e-6
BRE	0.3850	0.0011	0.0021	0.4211	0.839	24060.6	9.3e-5
KSH	0.6454	0.2539	0.3644	0.9103	0.927	1324.7	7.6e-5
SSH	0.6883	0.0738	0.1332	0.4787	0.734	260.2	5.7e-6
CCA-ITQ	0.7575	0.2196	0.3405	0.7978	0.894	16.6	4.1e-7
FastHash	0.8680	0.6735	0.7585	0.9813	0.972	4661.1	0.0012
PCA-ITQ	0.1680	9.3e-4	0.0018	0.4581	0.886	10.1	4.5e-7
AGH	0.8568	0.0131	0.0258	0.5984	0.899	6.9	6.4e-5
IMH	0.8258	0.0889	0.1606	0.6916	0.897	32.2	6.4e-5

Table 4. TABLE IV: Precision, recall, F-measure of Hamming distance within radius 2, MAP, accuracy and time on FRGC. Results are reported when the number of hashing bits is 16.

Method	precision@$r$=2	recall@$r$=2	F-measure@$r$=2	MAP	accuracy	training time	test time
SDHR	0.4893	0.5893	0.5346	0.6161	0.563	5.9	1.4e-6
SDH	0.4851	0.5833	0.5297	0.6138	0.565	1.6	1.7e-6
BRE	0.0352	0.3798	0.0645	0.0851	0.145	117.7	1.3e-5
KSH	0.2697	0.2400	0.2540	0.2654	0.377	333.1	1.1e-4
SSH	0.1286	0.2402	0.1675	0.1593	0.263	5.8	5.7e-6
CCA-ITQ	0.4426	0.4776	0.4594	0.4874	0.59	1.3	1.1e-7
FastHash	0.1646	0.0895	0.1160	0.1199	0.283	62.0	6.2e-4
PCA-ITQ	0.1359	0.2307	0.1710	0.1566	0.275	0.2	9.7e-8
AGH	0.0688	0.4107	0.1179	0.2009	0.237	2.3	1.2e-4
IMH	0.0492	0.4460	0.0886	0.1489	0.198	35.0	8.9e-5

Equations

$$\displaystyle\begin{array}[]{l}\mathop{\min}\limits_{B,F,W}\sum\limits_{i=1}^{n}{\left\|{{y_{i}}-{b_{i}}W}\right\|_{2}^{2}}+\lambda\left\|W\right\|_{F}^{2}\\ \quad\quad\quad\quad+v\sum\limits_{i=1}^{n}{\left\|{{b_{i}}-F\left({{x_{i}}}\right)}\right\|_{2}^{2}}\\ s.t.\;\forall i\quad{b_{i}}\in{\left\{{-1,1}\right\}^{l}}.\\ \end{array}$$

$$\displaystyle\begin{array}[]{l}\mathop{\min}\limits_{B,F,W}\left\|{Y-BW}\right\|_{F}^{2}+\lambda\left\|W\right\|_{F}^{2}+v\left\|{B-F\left(X\right)}\right\|_{F}^{2}\\ s.t.\;B\in{\left\{{-1,1}\right\}^{n\times l}},\\ \end{array}$$

$$F\left(x\right)=\varphi \left(x\right)P,$$

$$P={\left(\varphi {\left(X\right)}^T\varphi \left(X\right)\right)}^{-1}\varphi {\left(X\right)}^{T}B.$$

$$W={\left(B^{T}B+\lambda I\right)}^{-1}{B}^{T}Y.$$

$$\displaystyle\begin{array}[]{l}\mathop{\min}\limits_{{R_{i}}}\left\|{{R_{i}}-{b_{i}}W-{t^{T}}}\right\|_{F}^{2}\\ s.t.\;{R_{i,{L_{i}}}}-\mathop{\max}\limits_{k\neq{L_{i}}}{R_{ik}}\geq 1,\\ \end{array}$$

$$\displaystyle\begin{array}[]{l}\mathop{\min}\limits_{B,R,t,F,W}\sum\limits_{i=1}^{n}{\left\|{{R_{i}}-{b_{i}}W-{t^{T}}}\right\|_{2}^{2}}+\lambda\left\|W\right\|_{F}^{2}\\ \quad\quad\quad\quad\quad+v\sum\limits_{i=1}^{n}{\left\|{{b_{i}}-F\left({{x_{i}}}\right)}\right\|_{2}^{2}}\\ s.t.\;\forall i\quad{b_{i}}\in{\left\{{-1,1}\right\}^{l}}\\ \quad\forall i\quad{R_{i,{L_{i}}}}-\mathop{\max}\limits_{k\neq{L_{i}}}{R_{ik}}\geq 1.\\ \end{array}$$

$$\displaystyle\begin{array}[]{l}\mathop{\min}\limits_{B,R,t,F,W}\left\|{R-BW-{e_{n}}{t^{T}}}\right\|_{F}^{2}+\lambda\left\|W\right\|_{F}^{2}\\ \quad\quad\quad\quad\quad+v\left\|{B-F\left(X\right)}\right\|_{F}^{2}\\ s.t.\;B\in{\left\{{-1,1}\right\}^{n\times l}}\\ \quad\forall i\quad{R_{i,{L_{i}}}}-\mathop{\max}\limits_{k\neq{L_{i}}}{R_{ik}}\geq 1,\\ \end{array}$$

$$\displaystyle\begin{array}[]{l}\mathop{\min}\limits_{t}\;\left\|{{e_{n}}{t^{T}}-\left({R-BW}\right)}\right\|_{2}^{2}\\ =\mathop{\min}\limits_{t}\;tr\left(\begin{array}[]{l}\left({te_{n}^{T}-{{\left({R-BW}\right)}^{T}}}\right)\\ \times\left({{e_{n}}{t^{T}}-\left({R-BW}\right)}\right)\\ \end{array}\right).\\ \end{array}$$

$$t=\frac{{\left(R-BW\right)}^T{e}_n}{n}.$$

$$\begin{array}[]{l}\mathop{\min}\limits_{B}\left\|{R-BW-{e_{n}}{t^{T}}}\right\|_{F}^{2}+v\left\|{B-F\left(X\right)}\right\|_{F}^{2}\\ =\mathop{\min}\limits_{B}\left\|{BW-\left({R-{e_{n}}{t^{T}}}\right)}\right\|_{F}^{2}+v\left\|{B-F\left(X\right)}\right\|_{F}^{2}\\ =\mathop{\min}\limits_{B}\left\|{BW}\right\|_{F}^{2}\\ \quad\quad\quad\quad-2tr\left({B\left({W{{\left({R-{e_{n}}{t^{T}}}\right)}^{T}}+vF{{\left(X\right)}^{T}}}\right)}\right)\\ \quad\quad\quad\quad+vtr\left({{B^{T}}B}\right).\\ \end{array}$$

$$\underset{B}{\min }{\Vert BW\Vert }_F^2-2tr\left(BQ\right)s.t.B\in {\left\{-1,1\right\}}^{n\times l},$$

$$P={\left(\varphi {\left(X\right)}^T\varphi \left(X\right)\right)}^{-1}\varphi {\left(X\right)}^{T}B.$$

$$\displaystyle\begin{array}[]{l}\mathop{\min}\limits_{W}\left\|{R-BW-\frac{{{e_{n}}e_{n}^{T}\left({R-BW}\right)}}{n}}\right\|_{F}^{2}+\lambda\left\|W\right\|_{F}^{2}\\ =\mathop{\min}\limits_{W}\left\|{\left({I-\frac{{{e_{n}}e_{n}^{T}}}{n}}\right)\left({R-BW}\right)}\right\|_{F}^{2}+\lambda\left\|W\right\|_{F}^{2}.\\ \end{array}$$

$$W={\left(B^T\left(I-\frac{e_n{e}_n^T}{n}\right)B+\lambda I\right)}^{-1}{B}^T\left(I-\frac{e_n{e}_n^T}{n}\right)R.$$

$$\displaystyle\begin{array}[]{l}\mathop{\min}\limits_{R}\left\|{R-\left({BW+{e_{n}}{t^{T}}}\right)}\right\|_{F}^{2}\\ s.t.\;\forall i\quad{R_{i,{L_{i}}}}-\mathop{\max}\limits_{k\neq{L_{i}}}{R_{ik}}\geq 1.\\ \end{array}$$

$$\displaystyle\begin{array}[]{l}\mathop{\min}\limits_{r}\sum\nolimits_{q=1}^{c}{{{\left({{r_{q}}-{a_{q}}}\right)}^{2}}}\\ s.t.\;{r_{j}}-\mathop{\max}\limits_{k\neq j}{r_{k}}\geq 1,\\ \end{array}$$

$$\displaystyle\begin{array}[]{l}L\left({{r_{q}},{\lambda_{k}}}\right)=\sum\nolimits_{q=1}^{c}{{{\left({{r_{q}}-{a_{q}}}\right)}^{2}}}\\ \quad\quad\quad\quad\quad\quad+\sum\nolimits_{k=1,k\neq j}^{c}{{\lambda_{k}}\left({1+{r_{k}}-{r_{j}}}\right)},\\ \end{array}$$

$$2\left(r_j-a_j\right)-{\sum }_{k=1,k\ne j}^c{\lambda }_k=0,$$

$$2\left(r_k-a_k\right)+{\lambda }_k=0,k\ne j.$$

$${\lambda }_k\left(1+r_k-r_j\right)=0,k\ne j.$$

Full text

I Introduction

In large-scale visual searching, data must be indexed and organized accurately and efficiently. Hashing has attracted the interest of researchers in machine learning, information retrieval, computer vision, and related communities and has shown promise for large-scale visual searching. This paper focuses on hashing algorithms that encode images, videos, documents, or other data types as a set of short binary codes while preserving the original example structure (e.g., similarities between data points). One advantage of these hashing methods is that pairwise distance calculations can be performed extremely efficiently in Hamming space and, as a result, methods based on pairwise comparisons can be performed more efficiently and applied to large datasets. Due to the flexibility of binary representations, hashing algorithms can be applied in many ways, for example, searching efficiently by exploring only examples falling into buckets close to the query according the Hamming distance or using the hash codes for other tasks such as image classification, face recognition, and indexing.

Hashing methods can be broadly classified into two categories: data-independent and data-dependent methods. Data-independent algorithms do not require training data and randomly construct a set of hash functions without any training. Representative methods include locality-sensitive hashing (LSH) [1] and its variants [2] and the Min-Hash algorithms [3]. A disadvantage of the LSH family is that they usually need a long bit length ($\geq$1000) for satisfactory performance. This results in large storage costs, thus limiting their applications.

Recently, data-dependent or learning-based hashing methods have become popular because learned compact hash codes can effectively and efficiently index and organize massive amounts of data. Instead of randomly generating hash functions as in LSH, data-dependent hashing methods aim to generate short hash codes (typically $\leq$200) using training data. There is abundant literature on different data-dependent hashing methods that can be classified into four main categories.

The first is unsupervised hashing, which does not utilize the label information of training examples. Representative algorithms include spectral hashing (SH) [4], principal component hashing (PCH) [5], principal component analysis [6] iterative quantization (PCA-ITQ) [7, 8], anchor graph-based hashing (AGH) [9], scalable graph hashing with feature transformation (SGH) [10], and inductive manifold hashing (IMH) [11] with t-distributed stochastic neighbor embedding (t-SNE) [12]. However, since unsupervised hashing does not consider the label information of input data, useful information critical for pattern classification may be lost. Thus, various supervised hashing and semi-supervised hashing techniques have been proposed since it is generally believed that label information produces a more discriminative recognition algorithm.

The second category is supervised and semi-supervised hashing, which take full consideration of the class labels. Representative methods in this group include semi-supervised hashing (SSH) [13], kernel-based supervised hashing (KSH) [14], fast supervised hashing using graph cuts and decision trees (FastHash) [15, 16], supervised discrete hashing (SDH) [17], and linear discriminant analysis (LDA) [18] based hashing (LDAHash) [19]. In our view, ranking-based methods [20, 21, 22, 23] (in which ranking labels such as triplets constitute the supervised information) also belong to the supervised hashing group.

The third category is multimodal hashing, which includes multi-source hashing and cross-modal hashing. Multi-source hashing [24, 25] assumes that all the views are provided for a query and aims to learn better codes than unimodal hashing by using all these views. In cross-modal hashing [26], the query represents one modality while the output represents another modality. For example, given a text query, images are returned corresponding to the text. Therefore, both multi-source hashing and cross-modal hashing use multi-modal information [27]. However, they are used in different applications and cross-modal hashing may have wider application than multi-source hashing in practice.

The fourth category is deep learning [28, 29, 30] based hashing. To the best of our knowledge, semantic hashing [31] represents the first use of deep learning for hashing. This seminal work utilized the stacked-restricted Boltzmann machine (RBM) to learn compact hash codes for visual searching. However, the model was complex and required pre-training, which is inefficient in practice. Both deep regularized similarity comparison hashing (DRSCH) [32] and [33] use the deep convolutional neural network (CNN) for hashing. Some other related methods can be found in [34, 35, 36].

In general, the discrete constraints imposed on the hash codes generated by the hash objective functions lead to NP-hard mixed-integer optimization problems. To simplify the optimization in the hash code learning process, most algorithms first solve a relaxed problem by discarding the discrete constraints and then perform a quantization step that turns real values into the approximate hash code by thresholding (or quantization). This relaxation strategy greatly simplifies the original discrete optimization. However, such an approximate solution is suboptimal, typically of low quality, and often produces a less effective hash code due to the accumulated quantization error, especially when learning long-length codes. Most existing hashing methods do not take discrete optimization into account. Shen et al. [17] proposed a novel Supervised Discrete Hashing (SDH) method that aimed to directly learn the binary hash codes without relaxations. To make full use of label information, this method was formulated as a least squares classification to regress each hash code to its corresponding label.

However, the ordinary least squares problem may not be optimal for classification. To further improve the performance, here we propose a novel method called “Supervised Discrete Hashing with Relaxation” (SDHR) to directly learn the regression targets from data. SDHR is essentially a single and compact learning method for multiclass classification. The regression targets learned by SDHR can guarantee that each example (data point) is correctly classified with a large margin. During learning, SDHR does not consider the absolute values in regression targets and only forces relative values to satisfy a large margin for correct classification. Therefore, SDHR is much more accurate and flexible than SDH. The optimization problem of solving the regression target for SDHR is convex, and we employ an efficient alternating procedure to find the regression target. Our experimental results show that SDHR generally performs better than SDH.

The remainder of this paper is organized as follows. Section II outlines SDH. In Section III, we describe our proposed method in detail. The experimental results are presented in Section IV, followed by conclusions in Section V.

II Brief review of supervised discrete hashing

In this section, we introduce the related works SDH [17] by way of introduction. Suppose that we have $n$ examples $X=\{{x_{i}}\}_{i=1}^{n}$ (Table I for a list of notations used in this paper). We aim to learn a set of hash codes $B=\{{b_{i}}\}_{i=1}^{n}\in{\{-1,1\}^{n\times l}}$ to preserve their similarities in the original space, where the $i$th vector ${b_{i}}$ is the $l$-bits hash codes for ${x_{i}}$. The corresponding class labels of all training examples are denoted as $Y=\{{y_{i}}\}_{i=1}^{n}\in{R^{n\times c}}$, where $c$ is the number of classes and ${y_{ik}}=1$ if ${x_{i}}$ belongs to class $k$ and 0 otherwise. The term ${y_{ik}}$ is the $k$th element of ${y_{i}}$.

The objective function of SDH is defined as:

[TABLE]

That is,

[TABLE]

where ${\left\|\cdot\right\|_{F}}$ is the Frobenius norm of a matrix. The first term of (4) is the ordinary least squares regression, which is used to regress each hash code to its corresponding class label. The term $W$ is the projection matrix. The second term of (4) is for regularization. $F\left(\cdot\right)$ in the last term of (4) is a simple yet powerful nonlinear embedding to approximate the hash code

[TABLE]

where $\phi\left(x\right)$ is an $m$-dimensional row vector obtained by the RBF kernel: $\phi\left(x\right)=[\exp\left({{{{{\left\|{x-{a_{1}}}\right\|}^{2}}}\mathord{\left/{\vphantom{{{{\left\|{x-{a_{1}}}\right\|}^{2}}}\sigma}}\right.\kern-1.2pt}\sigma}}\right),\cdots,\exp\left({{{{{\left\|{x-{a_{m}}}\right\|}^{2}}}\mathord{\left/{\vphantom{{{{\left\|{x-{a_{m}}}\right\|}^{2}}}\sigma}}\right.\kern-1.2pt}\sigma}}\right)]$, $\{{a_{j}}\}_{i=1}^{m}$ are randomly selected $m$ anchor points from the training examples, and $\sigma$ is the Gaussian kernel parameter. The matrix $P\in{R^{m\times l}}$ projects $\phi\left(x\right)$ onto the low-dimensional space. Similar formulations as equation (8) are widely used in other methods such as kernel-based supervised hashing (KSH) [14] and binary reconstructive embedding (BRE) [37].

The need of a Gaussian kernel function is shown as follows: existing methods such as locality-sensitive hashing (LSH) do not apply for high-dimensional kernelized data when the underlying feature embedding for the kernel is unknown. Moreover, the using of kernel generalizes such methods as locality-sensitive hashing to accommodate arbitrary kernel functions, making it possible to preserve the algorithm’s sublinear time similarity search guarantees for a wide class of useful similarity functions.

The optimization of (7) involves three steps: the F-step solving $P$, the G-step solving $W$, and the B-step solving $B$:

F-step By fixing $B$, the projection matrix $P$ is easily computed:

[TABLE]

G-step If $B$ is fixed, it is easy to solve $W$, which has a closed-form solution:

[TABLE]

B-step By fixing other variables, $B$ also has a closed-form solution. Please refer to [17] for details.

III Our proposed method: Supervised Discrete Hashing with Relaxation

In this section, we introduce our proposed SDHR method in detail. The first term of SDH’s objective function is to regress ${y_{i}}$ on ${b_{i}}$. That is $\min\left\|{{y_{i}}-{b_{i}}W}\right\|_{2}^{2}$, and the optimal solution ${W^{*}}$ is ${y_{i}}={b_{i}}{W^{*}}$, which is a linear function that will go through the origin of the coordinate. It is more appropriate and flexible to have a translation (offset) vector $t$ and employing the hypothesis ${y_{i}}={b_{i}}W+{t^{T}}$, where ${t^{T}}$ is the transpose of the column vector $t$. In SDH, ${y_{i}}$ is fixed and ${y_{ij}}=1$ if ${x_{i}}$ belongs to the class $j$ and 0 otherwise. To make SDH more discriminative and flexible, we use ${R_{i}}$ instead of ${y_{i}}$ as the regression target (code words) for the $i$th hash code ${b_{i}}$, which satisfies

[TABLE]

where ${L_{i}}$ is the label of ${x_{i}}$. The term ${R_{i}}$ is optimized instead of being given. Our aim is to produce a large margin between the code words of the true label and all the other wrong labels that is larger than one to satisfy the large margin criterion ${R_{i,{L_{i}}}}-\mathop{\max}\limits_{k\neq{L_{i}}}{R_{ik}}\geq 1$. The objective function of SDHR is therefore defined as

[TABLE]

That is,

[TABLE]

where ${e_{n}}$ is an $n$-dimensional column vector with all elements equal to one. Hashing is not specifically designed for classification. Nevertheless, the supervised information is still very helpful. We want the hash codes to be similar for examples from the same class and we want them to be different for examples from different classes. Therefore, we relax the fixed label values to relative ones to satisfy the large margin criterion, which is more flexible than using the fixed label values.

The problem in (23) is a mixed binary optimization problem. By fixing the other variables, solving a single variable is relatively easy. Based on this decomposition, an alternating optimization technique can be adopted to iteratively and efficiently solve this optimization problem. Each iteration alternatively solves $B,\;R,\;W,\;t,\;P$. Therefore, SDHR’s optimization has five steps:

$t$-step When all variables except $t$ are fixed, (23) can be equivalently rewritten as:

[TABLE]

By setting the derivative of (28) with respect to $t$ to zero, $t$ can be solved with closed-form solution

[TABLE]

B-step For solving $B$, (23) can be rewritten as:

[TABLE]

Since $tr\left({{B^{T}}B}\right)$ is a constant, we have

[TABLE]

where $Q={\left({(R-{e_{n}}{t^{T}}){W^{T}}+vF\left(X\right)}\right)^{T}}$.

Thus, $B$ can be solved using the discrete cyclic coordinate descent method, which is similar to solving $B$ in SDH.

F-step The F-step of SDHR is the same as that of SDH:

[TABLE]

G-step If all variables except $W$ are fixed, we put (29) into (23) and get

[TABLE]

By setting the derivative of (34) with respect to $W$ to zero, it is easy to solve $W$, which has a closed-form solution:

[TABLE]

R-step When we fix $B,\;t,\;P$ and $W$, how to solve $R$ in (23) can be transformed to

[TABLE]

It is natural to solve the matrix $R$ row by row, which has a general form of:

[TABLE]

where $r$ and $a$ are the $i$th row of $R$ and $\left({BW+{e_{n}}{t^{T}}}\right)$, respectively; and ${r_{q}}$ and ${a_{q}}$ are the $q$th element of $r$ and $a$, respectively. We can use the Lagrangian multiplier method to solve (41). The Lagrangian function is defined as:

[TABLE]

where ${\lambda_{k}}$ is the Lagrangian multiplier and ${\lambda_{k}}\geq 0$. By setting the derivative of $L\left({{r_{q}},{\lambda_{k}}}\right)$ with respect to ${r_{j}}$ and ${r_{k}}\left({k\neq j}\right)$ to zero, we have

[TABLE]

[TABLE]

Furthermore, using the Kuhn-Tucker condition, we have:

[TABLE]

With (45), (46), and (47), we have $\left({2c-1}\right)$ equations and $\left({2c-1}\right)$ variables. Thus, (41) can be solved in this way. Please note that (41) can be solved using other optimization methods. For example, a method called retargeting proposed in [38] can also used to solve this optimization problem. In summary, our algorithm for solving SDHR is presented in Algorithm 1.

IV Experimental results

In this section, we investigate SDHR’s performance by conducting experiments on a server with an Intel Xeon processor (2.80 GHz), 128GB RAM, and configured with Microsoft Windows Server 2008 and MATLAB 2014b.

We conduct experiments on two large-scale image datasets, CIFAR-10111https://www.cs.toronto.edu/~kriz/cifar.html and MNIST222http://yann.lecun.com/exdb/mnist/, and a large-scale and challenging face dataset FRGC. The proposed method is compared with popular hashing methods including BRE [37], SSH [13], KSH [14], FastHash [15, 16], AGH [9], and IMH [11] with t-SNE [12]. For iterative quantization (ITQ) [7, 8], we use both its supervised version CCA-ITQ and unsupervised version PCA-ITQ. Canonical correlation analysis (CCA) is used as the preprocessing step for CCA-ITQ. We use the public MATLAB codes and the parameters suggested by the corresponding authors. Specifically, for SDH and SDHR, $\lambda$ and $v$ are empirically set to 1 and 1e-5, respectively; we set the maximum iteration number $t$ to 5. For AGH, IMH, SDH, and SDHR, 1,000 randomly selected anchor points are used.

The experimental results are reported in terms of Hamming ranking (mean average precision, MAP), hash lookup (precision, recall, F-measure of Hamming radius 2), accuracy, training time, and test time. The Hamming radius $r$ is set to be 2 as in [39, 17]. The F-measure is defined as 2$\times$precision$\times$recall/(precision + recall). The following evaluation metric is also utilized to measure the performance of the different algorithms: precision at $N$ samples (precision@sample = $N$), which is the percentage of true neighbors among the top $N$ retrieved instances. $N$ is set to be 500 as in [39]. Note that a query is considered to be a false case if no example is returned when calculating precisions. Ground truths are defined by the label information of the datasets.

As a subset of the famous 80M tiny image collection [40], CIFAR-10 contains 60,000 images from 10 classes with 6,000 examples per class. Example images from this dataset are presented in Fig. 1. Each image in this dataset is represented as a 512-dimensional GIST feature vector [41]. MNIST contains 70,000 784-dimensional handwritten digit images from ‘0’ to ‘9’, each image being 28$\times$28 pixels; some example images are shown in Fig. 2. Both MNIST and CIFAR-10 are split into a test set with 1,000 examples and a training set containing all remaining examples. FRGC is described below.

IV-A Experiments on CIFAR-10

The experimental results on CIFAR-10 are shown in Table II. SDHR performs better than SDH in terms of precision, recall, F-measure, and accuracy. For example, the accuracy of SDHR is 1.03-times higher than that of SDH. Moreover, from the last two columns in Table II, we can see that the training time cost of SDHR is lower than that of SDH, which allows the method to be applied to the whole training data. In contrast, KSH and FastHash take about 20 minutes to train. More specifically, the training of SDHR is about 28-times and 31-times faster than FastHash and KSH, respectively, in this case. SSH, CCA-ITQ, PCA-ITQ, AGH, and IMH are also very efficient; however, their performance is generally worse than SDHR. The precision at 500 examples (precision@sample = 500), precision of Hamming radius 2, and accuracy versus the number of hashing bits are presented in Figs. 3-5, respectively. Due to space limitations, we only show some algorithms in the corresponding figure. With respect to precision of Hamming radius 2, SDHR outperforms the other methods when the number of hashing bits is larger than 32, and KSH performs the best when the number of hashing bits is 16. SDHR outperforms all other methods in terms of precision at 500 examples (precision@sample = 500) and accuracy, highlighting the effectiveness of SDHR.

IV-B Experiments on MNIST

The experimental results on MNIST are presented in Table III. SDHR performs best in terms of precision, recall, and F-measure, while FastHash performs best in terms of MAP and accuracy. However, SDHR is much faster than FastHash: SDHR and FastHash take 186.2 and 4661.1 seconds, respectively. Thus, SDHR is about 25-times faster than FastHash in this case. Furthermore, the precision@sample=500, precision of Hamming radius 2, recall of Hamming radius 2, F-measure of Hamming radius 2, MAP, and accuracy curves are shown in Figs. 6-11, respectively. Only some methods are shown due to space limitations. SDHR outperforms the other methods and, furthermore, SDHR particularly outperforms the other methods in terms of recall of Hamming radius 2 and F-measure of Hamming radius 2.

IV-C Experiments on FRGC

The FRGC version two face dataset [42] is a large-scale and challenging benchmark face dataset. FRGC experiment 4 contains 8014 face images from 466 persons in the query set. These uncontrolled images demonstrate variations in blur, expression, illumination, and time. In our experiment, we only select persons with over 10 images in the dataset, resulting in 3160 images from 316 persons. Each image is cropped and resized to 32$\times$32 pixels (256 gray levels per pixel) by fixing the positions of the eyes. For each individual, three images are randomly selected for testing and the remaining seven used for training. Fig. 12 shows example images from FRGC.

The experimental results on FRGC are presented in Table IV. SDHR outperforms the other methods in terms of precision, recall, F-measure, and MAP, while CCA-ITQ outperforms the other methods in terms of accuracy. Fig. 13 shows MAP versus the number of hashing bits on this dataset. Due to space limitations, Fig. 13 only shows representative methods. This figure illustrates two main points: first, SDHR outperforms other methods when the number of hashing bits is less than or equals 64, while KSH performs best when the number of hashing bits is larger than or equal to 128; second, the MAP of all methods increases as the number of hashing bits increases. This might be because, as the number of hashing bits increases, more information can be encoded in the hash code. Therefore, the hash code represents the face image in a more informative and discriminative way. Furthermore, Fig. 14 shows some example query images and the retrieved neighbors on FRGC when 16 bits are used to learn the hash codes. We can see that SDHR shows better searching performance because higher semantic relevance is obtained in the top retrieved examples.

V Conclusions

In this paper, we propose a novel learning-based hashing method called “Supervised Discrete Hashing with Relaxation” (SDHR) based on “Supervised Discrete Hashing” (SDH). SDHR uses learned code words rather than the traditional fixed code words used in SDH to encode class label information. As expected, the SDHR’s performance is better than that of SDH. Real-world image classification and face recognition experiments highlight the advantages of the proposed method.

Although hashing methods can reduce computational costs, the costs remain very large for large-scale image retrieval. Selecting or learning representative examples to represent each class must be further studied.

We used the pixel feature on the MNIST and FRGC datasets. It is possible that advanced visual features rather than the original pixel intensity values will further improve performance. Designing the most appropriate feature for specific hashing algorithms is also a thought-provoking direction for future studies.