# kernelized Locality-Sensitive Hashing

Locality Sensitive Hashing (LSH) is a form of dimension reduction that finds embedding of high dimensional data into a low dimensional hamming space while providing probabilistic collision guarantees. That is, similar data points will have the same low dimensional mapping with high probability. One immediate application of LSH is large scale nearest neighbour search/classification. A large database of objects (e.g. images) can be partitioned into disjoint buckets so that objects of a single bucket share the same low dimensional representation which is used as a key to that bucket. At query time, the low dimensional representation of the query object determines a single bucket of “the most probably similar objects” which can then be searched in the traditional way.

For each similarity measure, a locality sensitive hashing method has to be designed carefully to ensure practically acceptable probabilistic collision guarantees. It was also noticed that most of the previous work done on LSH assumes that data points come from multidimensional vector space and the underlying embedding is explicitly known. However, that is not always the case. For example the RBF kernel maps the data to an infinite dimensional space which is intractable to explicitly work with. This paper generalizes locality sensitive hashing by proposing a fully kernelized method that provides the desirable collision guarantees.

## Preliminaries

### Central Limit Theorem

Suppose $\mathcal{D}$ is a multivariate distribution with mean $\mu$ and covariance $\Sigma$. Let $x_1, x_2, ..., x_t$ be $t$ random vectors sampled i.i.d from $\mathcal{D}$. The central limit theorem tells us that for sufficiently large $t$, the random vector

$z_t = \sqrt{t}(\bar{x}_t - \mu)$

approximately follows a multivariate Gaussian distribution $\mathcal{N}(0,\Sigma)$, where $\bar{x}_t = \frac{1}{t} \sum_i x_i$

### Whitening Transform

If $x$ is a random vector sampled from some multivariate distribution $\mathcal{D}$ of a zero mean and covariance $\Sigma$ then, the random vector $\Sigma^{-1/2}x$ is of an identity covariance matrix.

$\Sigma$ is defined as $\Sigma = E[xx^T]$.

If $\Sigma$ is positive definite, It will have an eigen decomposition in the form $\Sigma = V \Lambda V^T$ with all eigenvalues $\gt 0$ (note that $\Sigma$ is always symmetric positive semidefinite). Consequently, $\Sigma^{-1/2} = V \Lambda ^{-1/2} V^T$. The covariance of the random vector $\Sigma^{-1/2}x$ is then,

$\tilde{\Sigma} = E[V \Lambda ^{-1/2} V^T x x^T V \Lambda ^{-1/2} V^T] = V \Lambda ^{-1/2} V^T E[xx^T] V \Lambda ^{-1/2} V^T = V \Lambda ^{-1/2} V^T \Sigma V \Lambda ^{-1/2} V^T = I$

Note that the positive definiteness assumption of $\Sigma$ does not always hold making it impossible to do such a transformation in that case.

### Kernel Centering

Given $n$ data points that are accessible only through a kernel function and we are interested in the kernel matrix of a centered version of data points (with the mean subtracted from all points). Let the explicit data representation in the kernel space be $\Phi \in \mathbb{R}^{d \times n}$. An explicit centering of $\Phi$ is given by $\Phi-\frac{1}{n}\Phi\textbf{e}\textbf{e}^T$, where $\textbf{e}$ is a vector of all ones of size $n$.

Computing the kernel of the centered data:

$K_{cnt} = (\Phi-\frac{1}{n}\Phi\textbf{e}\textbf{e}^T)^T(\Phi-\frac{1}{n}\Phi\textbf{e}\textbf{e}^T) = \Phi^T\Phi - \frac{1}{n}\Phi^T\Phi \textbf{e}\textbf{e}^T-\frac{1}{n}\textbf{e}\textbf{e}^T\Phi^T\Phi + \frac{1}{n^2}\textbf{e}\textbf{e}^T\Phi^T\Phi\textbf{e}\textbf{e}^T = K - \frac{1}{n}K\textbf{e}\textbf{e}^T-\frac{1}{n}\textbf{e}\textbf{e}^TK + \frac{\textbf{e}^TK\textbf{e}}{n^2}\textbf{e}\textbf{e}^T$

where $K$ is the kernel matrix of the original data points.

## Locality Sensitive Hashing

The basic idea of Locality Sensitive Hashing  is to map each data point to a b-bit vector (called the hashkey) constructed by applying b independent binary-valued hash functions $h_1,h_2,...,h_b$ to the data points. The hash functions are designed carefully so that similar data points (in terms of some similarity measure) are mapped to the same hashkey with high probability allowing sublinear retrieval of approximate nearest neighbors to any given data point (query).

A valid hash function $h$ must satisfy the property

$Pr[h(x_i)= h(x_j)] = sim(x_i, x_j)$

where $sim(x_i, x_j) \in [0,1]$ is the similarity between two the data points $x_i$ and $x_j$ in terms of the similarity measure for which the hashing scheme is being designed.

For example consider the cosine similarity: $sim(x_i, x_j) = \frac{x_i^Tx_j}{\|x_i\|_2 \|x_j\|_2}$.

It was shown in  that for a vector $r$ of the same dimension as the original data points and $r \sim \mathcal{N}(0,\textit{I})$, that

$Pr[sign(x_i^Tr) = sign(x_j^Tr)] = 1 - \frac{1}{\pi} cos^{-1} (\frac{x_i^Tx_j}{\|x_i\|_2 \|x_j\|_2})$

Based on the result above, the author in  proposed the following hashing function for the cosine similarity:

$h_r(x) = \begin{cases} 1 & r^Tx \ge 0 \\ 0 & \text{otherwise} \end{cases}$      (1)

We can obtain a b-bits vector for each data point $x$ by applying (1) with b independently sampled vectors $r_1,r_2, ..., r_b$ from $\mathcal{N}(0,\textit{I})$ .

Similarly, different hash functions have been developed in previous work to support other similarity measures (e.g. $\ell_p$ norm, inner product, Mahalanobis metric, Jaccard similarity, cosine similarity, edit similarity and Hamming similarity).

Note that similarity measure is closely related to distance measure. We can convert those similarity measures to distance measures.

A distance measure should satisfy the following conditions:

(1) $d(x,x) \ge 0$

(2) d(x,y) == 0 if and only if x==y

(3) d(x,y) == d(y,x)

(4) $d(x,y) \le d(x,z)+d(z,y)$ (the triangle inequality)

We can show that the corresponding distance measures (Jaccard distance, cosine distance, edit distance and Hamming distance) satisfy the conditions.

This paper aims at developing a hashing function that can support arbitrary kernels.

## Kernelized Locality Sensitive Hashing

Building on the results that led to the hashing function in (1), the authors defined a normalized similarity function in terms of an arbitrary kernel $k(.,.)$ in the form:

\begin{align} sim(x_i,x_j) & = k(x_i,x_j)/(\sqrt{k(x_i,x_i)k(x_j,x_j)}) \\ & = \phi(x_i)^T\phi(x_j)/(||\phi(x_i)||_2 ||\phi(x_j)||_2) &&& (2) \end{align}

for some (possibly unknown) embedding function $\phi(.)$. The random projection based hashing method in (1) requires that both the random vector $r$ and the explicit embedding of the data point $\phi(x)$ to be known. That requirement will not be fulfilled when a fully kernelized approach is to be developed.

The main trick used by the authors is to construct $r$ as a weighted sum of a subset of the data points embedded into the kernel space. That does not only make is possible to compute $h_r(\phi(x))$ in (1) in terms of kernels. But also, it ensures that $r$ approximately follows a gaussian distribution as required in (1).

Let the embedding of the data points in the kernel space ($\phi(x_i) \forall i = 1,2,..,n$) follows some distribution $\mathcal{D}$ with mean $\mu$ and covariance $\Sigma$. From the central limit theorem, the random vector $z_t = \sqrt{t}(\frac{1}{t}\sum_{i \in S} \phi(x_i) - \mu)$ follows a gaussian distribution $\mathcal{N}(0,\Sigma)$ where $S$ is a set of sufficiently large number of data points ($t$) sampled i.i.d from $\mathcal{D}$. Further, $\Sigma^{-1/2}z_t \sim \mathcal{N}(0,I)$ by applying a whitening transform to $z_t$. Now, using $r = \Sigma^{-1/2}z_t$,we can defined a hashing function for the similarity measure defined in (2) as

$h_r(x) = \begin{cases} 1 & \phi(x)^T\Sigma^{-1/2}z_t \ge 0 \\ 0 & \text{otherwise} \end{cases}$

The next goal is to estimate $\mu$ and $\Sigma$ using a sample of $p$ data points {$\phi(x_1), \phi(x_2), ..,\phi(x_p)$} and computing $h(\phi(x)) = sign(\phi(x)^T\Sigma^{-1/2}z_t)$ in a fully kernelized way.

Let K be a centered kernel over the $p$ data points (see section 1.3 above). Also let the eigen decomposition of K be $K=U \Theta U^T$ and the eigen decomposition of $\Sigma$ be $\Sigma= V \Lambda V^T$, so $\Sigma^{-1/2}=V \Lambda^{-1/2} V^T$. Let $\theta_k$ and $\Lambda_k$ denote the $k^{th}$ eigenvalues of $K$ and $\Sigma$ respectively. And Let $u_k$ and $v_k$ denote the $k^{th}$ eigenvectors of $K$ and $\Sigma$ respectively. Note that $\theta_k = \Lambda_k$

It is easy to verify that:

$\phi(x)^T\Sigma^{-1/2}z_t = \sum_{k=1}^{p} \frac{1}{\sqrt{\theta_k}}v_k^T\phi(x)v_k^Tz_t \qquad (3)$

It can be noticed that both $v_k^T\phi(x)$ and $v_k^Tz_t$ are projections of $\phi(x)$ and $z_t$ to the $k^{th}$ eigenvector of the covariance matrix of {$\phi(x_1), \phi(x_2), ..,\phi(x_p)$}. That is exactly what Kernel PCA does to find a low dimensional embedding of data points in a kernelized way. Borrowing the projection formula from Kernel PCA:

$v_k^T\phi(x) = \sum_{i=1}^{p} \frac{1}{\sqrt{\theta_k}} u_k(i) \phi(x_i)^T \phi(x) \qquad (4)$

where $\phi(x_i)$ is the embedding of the $i^{th}$ (out of the $p$) sample and $u_k(i)$ is the $i^{th}$ entry of the eigenvector $u_k$.

Similarly,

$v_k^Tz_t = \sum_{i=1}^{p} \frac{1}{\sqrt{\theta_k}} u_k(i) \phi(x_i)^T z_t \qquad (5)$

Substituting (4) and (5) into (3) and simplifying we get:

$\phi(x)^T\Sigma^{-1/2}z_t = \sum_{i=1}^{p} w(i) (\phi(x_i)^T \phi(x))$

where $w(i) = \sum_{j=1}^{p}K_{ij}^{-3/2}\phi(x_j)^Tz_t$.

Assume that the $t$ samples used to compute $z_t$ are a subset of the $p$ samples used to estimate $\Sigma$. Expanding $z_t$ which can be approximated as $z_t=\frac{1}{\sqrt{t}}\sum_{i \in S}\phi(x_i)$ as a result of centering the $p$ samples. $w(i)$ is then defined as:

$w(i) = \frac{1}{\sqrt{t}}\sum_{j=1}^{p}\sum_{\ell \in S} K_{ij}^{-3/2} K_{j\ell}$

Now, It should be clear that $h(\phi(x))$ can be computed in a fully kernelized way, i.e.

$h(\phi(x))=sign(\sum_{i=1}^p w(i)(\phi(x_i)^T\phi(x)-\frac{1}{p}\sum_{j=1}^p\phi(x_i)^T\phi(x)))$

When computing a b-bits hash vector, a single subset of $p$ points is needed to estimate $\Sigma$ for all the $b$ bits. For each individual bit, a different subset of $t$ points needs to be sampled from the $p$ points.

## Discussion

Here is a list of discussion points:

1. Can we use Locality-Sensitive Hashing or the Kernelized version as a fast clustering method? What about the case where clustering is used as a preprocessing step? For example in , the authors proposed to use the centers of k-means clustering as landmarks for the Nystrom method. Can we rely on LSH-based clustering for such task?

2. Can we use LSH or KLSH to build the K-nearest neighbor affinity matrix used in LLE? what about the affinity matrix of Spectral clustering?

3. The presented method uses a sample of $p$ data points to estimate the covariance matrix of the entire $n$ data points. Clearly, $p$ needs to be increased as $n$ increases which can be a serious scalability bottleneck especially, when constructing and decomposing a kernel matrix over the $p$ data points. The authors provided nothing but for an empirical evidence using a single data set to show that a relatively small value of $p$ is enough. That data set was the 80 millions tiny images data set which consists of 80 millions images each of size 32 x 32. Further, the authors represented each image using Gist features which is a vector of dimension 384. Acceptable nearest neighbor retrieval results were claimed using an RBF kernel and a value of $p = 300$ . Do you think that evidence is enough to rely on that method for very large scale datasets? Does the value of $p$ have something to do with the type, the nature, or the original dimension of the dataset? Does it have something to do with the kernel?

4. Quoting from the paper: “Beyond LSH, there are several other dimensionality reduction techniques based on the Johnson-Lindenstrauss lemma that involve computing random projections, and our results may additionally be of interest to those applications.” What are examples of such techniques? and How can LSH or KLSH be useful in such techniques?

## Related Methods

Following is a list of interesting related topics. If time permitted, I would talk about them.

• Johnson-Lindenstrauss Lemma
• Random Projections
• Random Fourier Features

## Experimental Result

The authors empirically validate the effectiveness of the proposed hashing scheme, the paper provides results on three data sets. The primary goal is to verify that the proposed KLSH method can take kernels with unknown feature embeddings, and use them to perform searches that are fast but still reliable relative to a linear scan. The paper presents results showing the percentage of database items searched with hashing as opposed to timing results, which are dependent on the particular optimizations of the code. The experiments show good results, for example in "tiny image" dataset the proposed method often retrieves neighbors very similar to those of the linear scan, but does so by searching only 0.98% of the 80 Million database images.

1. Example-Based Object Recognition

It uses Caltech 101 data set. The correspondence-based local feature kernel(CORR) is used in this experiment. The metric is trained with 15 images per class. A simple k-nearest neighbor classifier(K=1), which utilizes both a linear scan baseline and KLSH, is used to compute accuracy. There is a trade-off between accuracy and speed, under the adjustment of $\epsilon$. When $\epsilon = 0.2$, the best result of 59 percent hashing accuracy is obtained. As for baseline, its search time was quite poor. KLSH has better performance over this data set.

2.Example-Based Scene Recognition

The paper considers hashing with $X^2$-kernel in this experiment. $X^2$-kernel is defined by

$K_{X^w}(h_i,h_j)=exp(- {\frac 1 \gamma} {\sum_{k=1}^H} {\frac {(h_i(k)-h_j(k))^2} {h_i(k)+h_j(k)}} )$

where $H$ is the number of histogram and $\gamma$ is a scaling parameter. A nearest neighbor classification task is taken again to compare linear scan and KLSH. And again, the results of KLSH matches better than the results of linear scan.

3.Large-Scale Image Search with Tiny Images

This paper provides results using very large-scale data of million images. Each image is of 32*32 pixels and very tiny. KLSH is applied to Gaussian RBF kernel this time. Hashing is much faster than linear scan when it comes to large scale data.