Fast and Exact Nearest Neighbor Search in Hamming Space on Full-Text Search Engines

TL;DR

This paper presents a novel engineering approach to enable full-text search engines to perform fast and exact nearest neighbor search in Hamming space, significantly improving speed over existing methods.

Contribution

It revisits and combines three techniques from information retrieval to adapt full-text search engines for efficient NNS in binary codes, a novel integration.

Findings

Achieves significant speed-ups over state-of-the-art term match approaches

Enables efficient and exact NNS in Hamming space within full-text search engines

Supports multi-model search and reduces memory consumption

Abstract

A growing interest has been witnessed recently from both academia and industry in building nearest neighbor search (NNS) solutions on top of full-text search engines. Compared with other NNS systems, such solutions are capable of effectively reducing main memory consumption, coherently supporting multi-model search and being immediately ready for production deployment. In this paper, we continue the journey to explore specifically how to empower full-text search engines with fast and exact NNS in Hamming space (i.e., the set of binary codes). By revisiting three techniques (bit operation, subs-code filtering and data preprocessing with permutation) in information retrieval literature, we develop a novel engineering solution for full-text search engines to efficiently accomplish this special but important NNS task. In the experiment, we show that our proposed approach enables full-text search engines to achieve significant speed-ups over its state-of-the-art term match approach for NNS within binary codes.

Tables

Table 1. Table 1: Means and standard deviations (in brackets) of search latency (measured in ms) under different scenarios. FENSHSES is dramatically faster than the term match approach, and all of the three techniques involved in FENSHSES contribute substantially to this performance improvement.

$m$	$r$	Term match	Bit operation	FENSHSES w/o prep.	FENSHSES
128	5	641.99 (19.01)	41.38 (6.38)	2.80 (3.50)	1.08 (1.25)
	10	638.20 (16.65)	42.24 (7.39)	7.40 (5.07)	3.62 (1.54)
	15	637.63 (16.14)	43.08 (7.90)	7.19 (5.09)	3.45 (1.55)
	20	638.41 (17.41)	42.65 (7.59)	15.51 (5.88)	9.51 (2.18)
256	5	1259.22 (30.66)	75.35 (11.87)	6.24 (6.48)	2.18 (2.02)
	10	1257.04 (20.68)	75.06 (11.27)	6.28 (6.63)	2.13 (1.97)
	15	1270.38 (25.88)	75.81 (12.22)	6.70 (6.93)	2.09 (1.56)
	20	1278.47 (25.56)	75.50 (11.94)	18.02 (10.71)	7.67 (2.85)

Equations

$$\mathcal{B}=\left\{{\mathbf{b}}_1,{\mathbf{b}}_2,\dots ,{\mathbf{b}}_n\right\}\subset {\left\{0,1\right\}}^m,$$

$$B_H(\mathbf{q},r):=\left\{\mathbf{b}\in \mathcal{B}|d_H(\mathbf{b},\mathbf{q})\le r\right\},$$

$${\mathcal{O}}_b=\left\{i\in [m]|b_i=0\right\}\text{mbox}and{\mathcal{I}}_b=\left\{i\in [m]|b_i=1\right\},$$

$$d_H(\mathbf{b},\mathbf{q})=m-\left(\sum _{i\in {\mathcal{I}}_q}\text{mathbbm}{1}_{\left\{i\in {\mathcal{I}}_b\right\}}+\sum _{j\in {\mathcal{O}}_q}\text{mathbbm}{1}_{\left\{j\in {\mathcal{O}}_b\right\}}\right).$$

$$[\underset{{\mathbf{b}}^1}{\underbrace{b_1,\dots ,b_{\frac{m}{s}}}},\underset{{\mathbf{b}}^2}{\underbrace{b_{\frac{m}{s}+1},\dots ,b_{\frac{2m}{s}}}},\dots \dots ,\underset{{\mathbf{b}}^s}{\underbrace{b_{m-\frac{m}{s}+1},\dots ,b_m}}].$$

$$B_H(\mathbf{q},r)\subseteq \bigcup _{i=1}^s\left\{\mathbf{b}\in \mathcal{B}\left|{\mathbf{b}}^i\in B_H({\mathbf{q}}^i,\lfloor \frac{r}{s}\rfloor \right)\right\}.$$

$$\underset{\pi :[m]\to [m]}{\min }$$

$$\pi \text{mbox}isapermutation.$$

$${\mathbf{P}}_{\pi }={\left[\begin{array}{cccc}{\mathbf{e}}_{\pi (1)}& {\mathbf{e}}_{\pi (2)}& \cdots & {\mathbf{e}}_{\pi (m)}\end{array}\right]}^T$$

$$\left(\pi (i),\pi (j)\right)\leftarrow \left(\pi (j),\pi (i)\right).$$

Full text

1 Introduction

Full-text search engines, based on first-order document-term statistics such as TF-IDF and Okapi BM25, have been deployed ubiquitously in nowadays web applications to help customers find textual documents that match their specified keywords.

Recently, active efforts from both academia and industry [12, 19, 18, 1, 14] have been witnessed to empower full-text search engines with the capability of nearest neighbor search (NNS). Compared with other NNS solutions (e.g., Annoy [3], FLANN [15], FAISS [7] and SPTAG [6]), such full-text search engine based ones have a number of clear advantages.

Implemented in secondary memory.

As demonstrated by Amato et al. (2018), unlike other NNS solutions implemented in main memory , due to the highly optimized disk-based index mechanics behind full-text search engines, NNS systems established on full-text search engines substantially reduce main-memory consumption. This makes such systems more cost-effective and thus more suitable to big-data applications.

Flexible in multi-model search.

As highlighted by Mu et al. (2018), enabling full-text search engines with NNS paves a coherent way for multi-model searches–e.g., allowing users to express their interests in both visual and textual queries (see Fig. 1 for an application of multi-model search in eCommerce)–at which most of other NNS systems fall short.

Ready for production.

Last but not least, as emphasized by Rygl et al. (2017), NNS systems built upon full-text search engines are extremely well-prepared for production deployment. Due to the cutting-edge engineering designs from full-text search engines (e.g., Elasticsearch and Solr), important features like horizontal scaling, I/O and cache optimization, security configuration, index and cluster management, real-time monitoring and RESTful APIs are immediately ready to be consumed by such NNS systems, so that engineers can effectively avoid reinventing the wheel themselves.

Blessed by all the above distinct benefits, we continue this journey to explore specifically effective ways to achieve exact nearest neighbor search in Hamming space (i.e., the set of binary codes) on top of full-text search engines.

Problem statement.

Specifically, with the following dataset of binary codes,

[TABLE]

the goal of our paper is to enable full-text search engines with the capability of efficiently finding all $r$-neighbors of $\bm{q}$ in $\mathcal{B}$, namely

[TABLE]

where $d_{H}(\bm{b},\bm{q}):=\sum_{i=1}^{m}\mathbbm{1}_{\left\{b_{i}\neq q_{i}\right\}}$ denotes the Hamming distance between binary code $\bm{b}$ and $\bm{q}$.111It is worth noting that the $r$-neighbor search problem studied by the paper can also be easily adapted to conduct $k$-NN ($k$-nearest neighbors) search by progressively increasing the Hamming search radius $r$ until $k$ neighbors are found.

Why binary codes?

Finding nearest neighbors in Hamming space is an extremely important subclass of NNS, as learning and representing textual or visual data with compact and semantic binary vectors is a pretty mature technology and common practice in nowadays information retrieval. Using well-trained binary vectors instead of floating ones enables dramatic reductions in storage and communication costs without too much sacrifice in search accuracy. In particular, eBay builds its whole visual search system [20] by finding nearest neighbors within binary codes extracted from catalog and query images through the supervised semantic-preserving deep Hashing (SSDH) model [11].

What is missing?

However, most of the aforementioned full-text search engines based NNS solutions [19, 18, 1, 14] would fail to deal with binary codes, as they find nearest neighbors on full-text search engines by generating and indexing surrogate textual tokens merely based on information collected from several top entries of each floating vector in terms of magnitude. The only exception is the term match approach developed by Lux and Marques (2013) in their Java library called LIRE (Lucene Image Retrieval). The core idea is to calculate Hamming distance between two binary codes by matching their bits at each position. This term match approach on one hand is a natural way to leverage full-text search engines to conduct NNS, but on the other hand heavily overlooks the intrinsic and special properties within binary codes by treating binary digits simply as texts. Motivated by this, we revisit three pervasive techniques from information retrieval literature: bit operation, sub-code filtering and data preprocessing with permutation. By integrating these three techniques seamlessly into full-text search engines, we end up with a solution that outperforms the term match one dramatically in terms of search latency.

Elasticsearch.

Elasticsearch (ES), built upon Apache Lucene, is an open-source, real-time, distributed and multi-tenant full-text search engine. Since its first release in Feb. 2010, it has become the most popular enterprise search engine and widely adopted by a variety of companies (e.g., Ebay, Facebook, GitHub, Lyft and Shopify) for either internal or external uses to discover relevant documents. Similar to previous works [19, 18, 1, 14], without the loss of general applicability to other full-text search engines, we elaborate our core ideas concretely on the platform of Elasticsearch. First-hand experiences in implementing this ES-based solution are extensively addressed, which should be greatly valuable for practitioners to understand and replicate our approach.

Organization.

The rest of the paper is organized as follows. In Section 2, we first review the term match approach widely implemented on full-text search engines to find nearest neighbors among binary codes. In Section 3, we propose a better one for full-text search engines to accomplish this task. Specifically, we implement an Elasticsearch-based solution called FENSHSES (Fast Exact Neighbor Search in Hamming Space on Elasticsearch) to conduct nearest neighbor search in Hamming space. We incorporate three techniques into FENSHSES: bit operation, which enables Elasticsearch to compute Hamming distance with just a few bit operations; sub-code filtering, which instructs Elasticsearch to conduct a simple but effective screening process before any Hamming distance calculation and therefore empower FENSHSES with sub-linear search times; data preprocessing with permutation, which preprocesses binary codes with appropriate permutation to maximize the effect of sub-code filtering. In Sec. 4, we show that FENSHSES outperforms the term match approach dramatically in terms of search latency.

2 Term Match from LIRE

Based on its definition, Hamming distance is nothing but the number of positions at which two binary codes vary. As a result, full-text search engines can naturally compute this through term match. Specifically, for each binary code $\bm{b}$, we can index its positions corresponding to ones and zeros, respectively, i.e.,

[TABLE]

with $[m]:=\left\{1,2,\ldots,m\right\}$. When the query binary code $\bm{q}$ arrives, Elasticsearch can simply calculate its Hamming distance to each binary code $\bm{b}\in\mathcal{B}$ by matching its zero and one positions with $\bm{b}^{\prime}s$:

[TABLE]

The JSON-encoded request body for Elasticsearch to find $B_{H}(\bm{q},r)$ by computing (3) is illustrated in JSON 2,222All ES-related implementations are based on Elasticsearch 6.1.0. where we denote $u:=|\mathcal{I}_{q}|$ and $v:=|\mathcal{O}_{q}|$.

This term match approach, firstly introduced in the Java library LIRE [12] to find visually similar images (based on their binary visual features), is currently the cutting-edge approach for full-text search engines to find nearest neighbors within binary codes. Some of its variants (e.g., using fuzzy query based on Levenshtein edit distance) are also widely used on full-text search engines nowadays.

3 Proposed Approach: FENSHSES

The term match approach treats each binary digit (i.e., bit) in a textual way, which heavily overlooks the intrinsic and special properties of binary codes. By making better uses of these properties, we introduce a novel approach called FENSHSES (Fast Exact Neighbor Search in Hamming Space on Elasticsearch), whose complete JSON-encoded ES request body can be found in JSON 5. In essence, FENSHSES integrates three techniques: bit operation, sub-code filtering and data preprocessing with permutation, which should be generally applicable to other full-text search engines besides Elasticsearch. These three techniques are pervasively used in nearest neighbors search for binary codes; but as fas as we know, this is the first-time such techniques are seamlessly integrated into full-text search engines, and thus leads to a novel NNS solution with minimal main memory consumption, full support in multi-modal search and extreme readiness to be deployed in production (per our discussions in Section 1).

3.1 Bit Operation

Motivated by the well-known fact that hamming distances between binary codes can be computed extremely fast using bit operations, in this part, we will explore how we can replace term match by natively empowering Elasticsearch to calculate hamming distances through bit operations.

For an $m$-bit binary code $\bm{b}$, we will first segment it into $s$ sub-codes:333For simplicity, we assume $s$ divides $m$.

[TABLE]

Since $d_{H}(\bm{q},\bm{b})=\sum_{i\in[s]}d_{H}(\bm{q}^{i},\bm{b}^{i})$, the Hamming distance calculation is reduced into $s$ ones with binary codes of much shorter length. We re-implement the assembly codes found in the notable HAKMEM memo [5] to compute the Hamming distance between two short binary codes of length 64 or less into Painless–a simple and secure scripting language designed specifically for Elasticsearch. When the query binary code $\bm{q}$ is issued, we will invoke hmd64bit $s$ times to calculate $\left\{d_{H}(\bm{q}^{i},\bm{b}^{i})\right\}_{i=1}^{s}$ by specifying $\bm{q}^{i}$ and $\bm{b}^{i}$ as parameters accordingly and then sum them up. The whole process can be efficiently implemented in ES using the function score query, where several functions are combined to calculate the score of each document (see lines 15-31 in JSON 5).

3.2 Sub-Code Filtering

So far, regardless of the term match approach or the bit operation one, we have to exhaustively compute the Hamming distance between $\bm{q}$ and each binary code in $\mathcal{B}$. This expensive linear scan is not desirable for many applications where the number of codes in $\mathcal{B}$ is in the order of millions or even billions [20]. As a remedy, in this part, we will borrow a simple but powerful counting argument from Norouzi et al. (2012) to conduct a screening process before any Hamming distance calculation, which successfully empowers our FENSHSES approach with sub-linear search times.

Suppose binary codes are segmented into $s$ sub-codes as in (4). Then for two codes $\bm{b}$ and $\bm{q}$ within $r$ Hamming distance, among all their $s$ sub-code pairs $\left\{(\bm{b}^{i},\bm{q}^{i})\right\}_{i=1}^{s}$, there must be at least one pair with Hamming distance no larger than $\lfloor\frac{r}{s}\rfloor$, which mathematically implies

[TABLE]

This simple counting argument yields great potentials in reducing the number of Hamming distance calculations needed to find all $r$-neighbors $\bm{q}$ in $\mathcal{B}$. Specifically, according to relationship (5), it is safe to just consider binary codes belonging to the set on the right side of (5), whose size could be substantially smaller than $n$ for $r\ll m$. It is worth noting that similar ideas have been frequently revisited in many different contexts–e.g., multi-index hashing [16] and string similarity joins [10], and a generalized version of (5) is also derived recently [17].

Due to the inverted-indexing nature of full-text search engines, this sub-code filtering step is extremely suitable and straightforward to be implemented on full-text search engines. Specifically, on Elasticsearch, we can simply leverage the filter context (see lines 8-14 in JSON 5), within which each sub-code Hamming ball $B_{H}\left(\bm{q}_{i},\lfloor\frac{r}{s}\rfloor\right)$ is obtained by the terms query (e.g., line 11 in JSON 5), and the union is achieved through a boolean combination of should clauses.

3.3 Data Preprocessing with Permutation

The effectiveness of sub-code filtering will be maximized if the bits within the same sub-code group are statistically independent. Since hamming distance is invariant to permutation transformation, it is tempting to transform binary codes in $\mathcal{B}$ with appropriate permutation towards this desired group independence property.

For two Bernoulli random variables $x$ and $y$, they are independent if and only if their correlation coefficient $\rho(x,y)=0$. Therefore, it is natural to find a permutation $\bar{\pi}$ to minimize correlation effects among each sub-code segment. This immediately leads to the following optimization problem proposed by Wan et al. (2013) to improve the performance of [16]:

[TABLE]

Here $\bm{D}=\mathrm{diag}\left(\bm{I}_{d\times d},\ldots,\bm{I}_{d\times d}\right)\in\mathbb{R}^{m\times m}$ is a block diagonal matrix with $\bm{I}_{d\times d}$ as a matrix of ones and $d=m/s$, $\bm{P}_{\pi}$ is the permutation matrix induced by $\pi$:

[TABLE]

and $\bm{M}$ is a matrix in $\mathbb{R}^{m\times m}$ whose $(i,j)$-entry is obtained from $\mathcal{B}$ as the absolute value of the correlation between the $i$-th and the $j$-th bits.

Problem (6) is essentially an instance of the extensively studied balanced graph partition problem [8, 2, 9, 4]. In FENSHSES, we solve problem (6) by the well-known and scalable Kernighan-Lin algorithm [8], the gist of which is to find appropriate pairs $i,j\in[m]$ and swap their mappings in $\pi$ with

[TABLE]

We leave it as a future work to solve (6) by more recently developed approximation algorithms with better theoretical guarantees–e.g., the one based on semidefinite relaxation [9].

3.4 Elasticsearch index for FENSHSES

For the proposed FENSHSES approach, the data to be indexed into Elasticsearch cluster is pretty minimal. For each binary code $\bm{b}\in\mathcal{B}$, we only need to index its sub-codes $\left\{\bm{b}^{1},\bm{b}^{2},\ldots,\bm{b}^{s}\right\}$.444More accurately speaking, what being indexed are the integers represented by the binary sub-codes. In JSON 4, we demonstrate how to index sub-codes together with other fields into one Elasticsearch index. Here we assume that bit operation and sub-code filtering segment binary codes in the same manner. If their segmentations are different, it might be recommended to index two sets of sub-codes into the same Elasticsearch index by treating each set as a nested datatype.

Suppose sub-codes $\left\{\bm{b}^{1},\bm{b}^{2},\ldots,\bm{b}^{s}\right\}$ are semantic visual embeddings from product images. With other product information (e.g., title, brand and price) indexed together with $\left\{\bm{b}^{1},\bm{b}^{2},\ldots,\bm{b}^{s}\right\}$ into one Elasticsearch index, we can easily achieve multi-model searches depicted in Figure 1 by adding filters (e.g., term filter and range filter) into JSON 5.

4 Experiment

We compare search latencies between the term match approach and FENSHSES with semantic binary codes generated from Jet.com’s catalog images. To better understand the contribution of each technique involved in FENSHSES, we experiment systematically with four methods: the term match baseline, FENSHSES with just bit operation, FENSHSES without data preprocessing and FENSHSES.

Settings.

Our dataset $\mathcal{B}$ is generated using half a million images selected from Jet.com’s furniture catalog through the SSDH model [11], which leverages deep CNN (convolutional neural network) to output semantic binary codes in an end-to-end manner555Note that the purpose of the experiment is not to compare different embedding models, but to evaluate the performance of FENSHESES, which should be generally applicable to NNS in any Hamming space.. We choose the length of binary codes to be $128$ and $256$ respectively. For the setting of FENSHSES, we keep the sub-code length as $64$ for bit operation and $16$ for sub-code filtering throughout the experiment, since we observe such segmentations consistently yield satisfactory performances. Each Elasticsearch index is created with five shards and zero replica on a single-node Elustersearch cluster deployed on a Microsoft Azure virtual machine with 12 cores and 112 GiB of RAM.

Evaluation.

We randomly select 1,000 binary codes from $\mathcal{B}$ to act as query codes $\bm{q}$. For each $\bm{q}$, we compare the search latencies among all four methods with Hamming distance $r\in\left\{5,10,15,20\right\}$.

Results.

As shown in Table 1, FENSHSES is much faster than the term match approach. To better visualize these speed-ups, we plot average search latencies under logarithmic transformation in Fig. 6 and 7. In the following, we address the contribution of each component of FENSHSES respectively.

• •

By computing the Hamming distance using bit operation instead of term match, we consistently observe around sixteen times speedup over different $m$ and $r$.

• •

The amount of speed-up introduced by sub-code filtering varies with the radius $r$. Specifically, as $\lfloor\frac{16r}{s}\rfloor$ heavily influence the number of data points to be considered for Hamming distance computation (see (5)), for $r$’s with the same value of $\lfloor\frac{16r}{s}\rfloor$, the search latencies of FENSHSES w/o prep. are quite similar. As $\lfloor\frac{16r}{s}\rfloor$ becomes larger, the sub-code filtering technique will become less effective. In practice, since we most likely care about nearest neighbors within a small radius, the sub-code filtering technique should be capable of greatly reducing the search latency.

• •

By reshuffling binary codes to reduce their correlations within each sub-code group, the technique of data processing with permutation not only accelerates FENSHSES in terms of the average search latency, but also stabilizes its overall performance with much smaller standard deviation.

• •

A comprehensive comparison between FENSHSES and FAISS [7] in terms of indexing speed, search latency and RAM consumption is also conducted in [13], where FENSHSES demonstrates competitive performance.

5 Conclusion

It has been recently demonstrated that NNS systems built upon full-text search engines are capable of effectively reducing main memory consumption, coherently supporting multi-model search and being well-prepared for production deployment. Motivated by these clear advantages, in this paper, we explore how to empower full-text search engines to efficiently find nearest neighbors in Hamming space. By revisiting bit operation, sub-code filtering and data preprocessing with permutation, we propose a novel approach to accomplish this task, which shown empirically to be substantially faster than the term match approach (the state-of-art one for nowadays full-text search engines to find nearest neighbors within binary codes). By implementing the proposed approach non-trivially on the Elasticsearch platform, we delivered a cutting-edge engineering solution called FENSHSES. In the future, we will also explore how to implement our approach efficiently on other full-text search engines (e.g., Solr and Sphinx).

Acknowledgment

We are grateful to three anonymous reviewers for their helpful suggestions and comments that substantially improve the paper. We would also like to thank Aliasgar Kutiyanawala for helping us fix a bug in an earlier version of JSON 3, and thank Eliot P. Brenner for bringing the work [19] to our attention.