PQTable: Non-exhaustive Fast Search for Product-quantized Codes using Hash Tables

TL;DR

The paper introduces PQTable, a fast, hash-table-based search method for product-quantized codes that outperforms linear scans and previous methods in speed and practicality, especially for large-scale, highly compressed data.

Contribution

Proposes PQTable, a non-exhaustive, hash-based search method for product-quantized codes that avoids manual parameter tuning and training, enabling efficient large-scale retrieval.

Findings

Achieves 10^2 to 10^5 times faster search than linear PQ scan.

Handles highly compressed vectors with fast performance on a single CPU.

Uses minimal memory (0.059 ms per query over 10^9 data points with 5.5 GB).

Abstract

In this paper, we propose a product quantization table (PQTable); a fast search method for product-quantized codes via hash-tables. An identifier of each database vector is associated with the slot of a hash table by using its PQ-code as a key. For querying, an input vector is PQ-encoded and hashed, and the items associated with that code are then retrieved. The proposed PQTable produces the same results as a linear PQ scan, and is 10^2 to 10^5 times faster. Although state-of-the-art performance can be achieved by previous inverted-indexing-based approaches, such methods require manually-designed parameter setting and significant training; our PQTable is free of these limitations, and therefore offers a practical and effective solution for real-world problems. Specifically, when the vectors are highly compressed, our PQTable achieves one of the fastest search performances on a single CPU to date with significantly efficient memory usage (0.059 ms per query over 10^9 data points with just 5.5 GB memory consumption). Finally, we show that our proposed PQTable can naturally handle the codes of an optimized product quantization (OPQTable).

Tables

Table 1. TABLE I: Relation among Hamming-based and PQ-based ANN methods.

	Search algorithm
	Exhaustive	Non-exhaustive
Hamming-based	Linear Hamming scan	Multi-table [32, 33, 34]
PQ-based	Linear ADC scan	PQTable (proposed)

Table 2. TABLE II: Estimated and the actually observed best T 𝑇 T for SIFT1B data.

		N
$B$	How	${10}^2$	${10}^3$	${10}^4$	${10}^5$	${10}^6$	${10}^7$	${10}^8$	${10}^9$
32	Observed	4	4	2	2	1	1	1	1
	$T^{\ast }$	4	4	2	2	2	1	1	1
64	Observed	8	8	8	4	4	4	2	2
	$T^{\ast }$	8	8	4	4	4	2	2	2

Table 3. TABLE III: The runtime performance of PQTable with N = 10 9 𝑁 superscript 10 9 N=10^{9} . The accuracy, runtime, and speed-up factors against ADC are presented.

		Recall			Runtime / Speed-up factors vs. ADC
Data	$B$	@1	@10	@100	ADC	1-NN	10-NN	100-NN	Memory [GB]
SIFT1B	32	0.002	0.016	0.080	6.0 s / $1.0$	0.059 ms / $1.0\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟓}}$	0.13 ms / $4.6\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟒}}$	0.15 ms / $4.0\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟒}}$	5.5
	64	0.059	0.237	0.571	8.4 s / $1.0$	6.9 ms / $1.2\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟑}}$	16.6 ms / $5.1\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟐}}$	46.8 ms / $1.8\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟐}}$	19.8
Deep1B	32	0.004	0.022	0.065	6.5 s / $1.0$	0.081 ms / $8.0\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟒}}$	0.15 ms / $4.3\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟒}}$	0.16 ms / $4.1\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟒}}$	5.4
	64	0.079	0.186	0.338	9.3 s / $1.0$	8.7 ms / $1.1\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟑}}$	19.1 ms / $4.9\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟐}}$	54.3 ms / $1.7\times {\mathrm{𝟏𝟎}}^{\mathrm{𝟐}}$	20.9

Table 4. TABLE IV: A performance comparison for different methods using the SIFT1B data with 64-bit codes. The bracketed values are from [ 17 ] . Note that the runtime of PQTable and IVFADC is for 1-NN case.

	Params		Recall					Requirement
System	$\#cell$	List-len	@1	@10	@100	Runtime [ms]	Memory [GB]	Params	Additional training steps
OPQTable	-	-	0.063	0.247	0.579	8.7	19.9	None	None
IVFADC [1]	$2^{13}$	$8\times {10}^6$	0.115 (0.112)	0.395 (0.343)	0.763 (0.728)	209 (155)	(12)	$\#cell$, list-len	Coarse quantizer
OMulti-D-OADC-Local [17]	$2^{14}\times 2^{14}$	${10}^4$	(0.268)	(0.644)	(0.776)	(6)	(15)	$\#cell$, list-len	Coarse quantizer, local codebook

Equations

$$\mathbf{x}\mapsto \bar{\mathbf{x}}=[\bar{x}[1],\dots ,\bar{x}[M]{]}^{\top }.$$

$${\mathbf{x}}^m\mapsto \bar{x}[m]=\underset{k\in \{1,\dots ,K\}}{\mathrm{argmin}}\Vert {\mathbf{x}}^m-{\mathbf{c}}_k^m{\Vert }_2^2.$$

$$d(\mathbf{q},\mathbf{x}{)}^2\sim d_{AD}(\mathbf{q},\mathbf{x}{)}^2=\sum _{m=1}^{M}d{\left({\mathbf{q}}^m,{\mathbf{c}}_{\bar{x}[m]}^m\right)}^2$$

$$p=\frac{\#filled\_slots}{\#slots}=\frac{\#slots-\#empty\_slots}{\#slots},$$

$$p=\frac{2^B-2^B(1-\frac{1}{2^B}{)}^N}{2^B}=1-{\left(1-\frac{1}{2^B}\right)}^N.$$

$$r=\sum _{r^{\prime }=1}^{\infty }(1-p{)}^{r^{\prime }-1}p{r}^{\prime }=\frac{1}{p}=\frac{1}{1-{\left(1-\frac{1}{2^B}\right)}^N}.$$

$$N_{nnslot}=\frac{N}{\#filled\_slots}=\frac{N}{2^B(1-(1-\frac{1}{2^B}{)}^N)}.$$

$$T^{\ast }=2^{Q\left({\log }_2(B/{\log }_{2}N)\right)},$$

$$\{\begin{array}{ll}4N+4DK& \mathrm{if}{T}^{\ast }=1.\\ (4T^{\ast }+\frac{B}{8})N+4DK& \mathrm{else}.\end{array}$$

$$\sum _{t=1}^T{d}_{AD}^t(\mathbf{q},\mathbf{x}{)}^2=d_{AD}(\mathbf{q},\mathbf{x}{)}^2.$$

Full text

I Introduction

With the explosive growth of multimedia data, compressing high-dimensional vectors and performing approximate nearest neighbor (ANN) searches in the compressed domain is becoming a fundamental problem when handling large databases. Product quantization (PQ) [1], and its extensions [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], are popular and successful methods for quantizing a vector into a short code. PQ has three attractive properties: (1) PQ can compress an input vector into an extremely short code (e.g., 32 bit); (2) the approximate distance between a raw vector and a compressed PQ code can be computed efficiently (the so-called asymmetric distance computation (ADC) [1]), which is a good estimate of the original Euclidean distance; and (3) the data structure and coding algorithms are surprisingly simple. Typically, database vectors are quantized into short codes in advance. When given a query vector, similar vectors can be found from the database codes via a linear comparison using ADC (see Fig. 1a).

Although linear ADC scanning is simple and easy to execute, it is efficient only for small datasets as the search is exhaustive (the computational cost is at least $O(N)$ for $N$ PQ codes). To handle large (e.g., $N\sim 10^{9}$) databases, short-code-based inverted indexing systems [13, 14, 3, 15, 16, 17, 18] have been proposed, which are currently the state-of-the-art ANN methods (see Fig. 1b). These systems operate in two stages: (1) coarse quantization and (2) reranking via short codes. In the data indexing phase, each database vector is first assigned to a cell using a coarse quantizer (e.g., k-means [1], multiple k-means [14], or Cartesian products [13, 19]). Next, the residual difference between the database vector and the coarse centroid is compressed to a short code using PQ [1] or its extensions [2, 3]. Finally, the code is stored as a posting list in the cell. In the retrieval phase, a query vector is assigned to the nearest cells by the coarse quantizer, and associated items in corresponding posting lists are traversed, with the nearest one being reranked via ADC. These systems are fast, accurate, and memory efficient, as they can hold $10^{9}$ data points in memory and can conduct a retrieval in milliseconds.

However, such inverted indexing systems are built by a process of carefully designed manual parameter tuning, which imply that runtime and accuracy strongly depend on the selection of parameters. We show the two examples of the effect of such parameter selection in Fig. 2, using an inverted file with Asymmetric Distance Computation (IVFADC) [1].

• •

The left figure shows the runtime over the number of database vectors $N$ with various number of cells ($\#cell$). The result with smaller $\#cell$ is faster for $N=10^{6}$, but that with larger $\#cell$ is faster for $N=10^{9}$. Moreover, the relationship is unclear for $10^{6}<N<10^{9}$. These unpredictable phenomena do not become clear until the searches with several $\#cell$ are examined; however, testing the system is computationally expensive. For example, to plot a single dot of Fig. 2 for $N=10^{9}$, training and building the index structure took around four days in total. This is particularly critical for recent per-cell training methods [16, 15], which require even more computation to build the system.

• •

Another parameter-dependency is given in Fig. 2, right, where the runtime and the accuracy in the search range $w$ are presented. It has been noted in the existing literature that, with larger $w$, slower but more accurate searches are achieved. However, this relation is not simple. When compared the result with $w=1$ and $w=8$, the relationship is preserved. However, the accuracy with $w=64$ is almost identical to that of $w=8$ even though the search is eight times slower. This result implies that users might perform the search with the same accuracy but several times slower if they fail to tune the parameter.

These results confirm that achieving state-of-the-art performances depends largely on special tuning for the testbed dataset such as SIFT1B [20]. In such datasets, recall rates can be easily examined as the ground truth results are given; this is not always true for real-world data. There is no guarantee of achieving the best performance with such systems. In real-world applications, cumbersome trial-and-error-based parameter tuning is often required.

To achieve an ANN system that would be suitable for practical applications, we propose a PQTable; an exact, non-exhaustive, NN search method for PQ codes (see Fig. 1c). We do not employ an inverted index data structure, but find similar PQ codes directly from a database. This achieves the same accuracy as a linear ADC scan, but requires significantly less time. (6.9 ms, instead of 8.4 s, for the SIFT1B data using 64-bit codes). In other words, this paper proposes an efficient ANN search scheme to replace a linear ADC scan when $N$ is sufficiently large. As discussed in Section V, the parameter values required to build the PQTable can be calculated automatically.

The main characteristic of the PQTable is the use of a hash table (see Fig. 1c). An item identifier is associated with the hash table by using its PQ code as a key. In the querying phase, a query vector is first PQ encoded, and identifiers associated with the key are then retrieved.

A preliminary version of this work appeared in our recent conference paper [21]. This paper contains the following significant differences: (1) we improved the table-merging step; (2) the analysis of collision was provided; (3) Optimized Product Quantization [3] was incorporated; and (4) we added massive experimental evaluation using Deep1B dataset [22].

The rest of the paper is organized as follows: Section II introduces related work. Section III briefly reviews the product quantization. Section IV presents our proposed PQTable, and Section V shows an analysis for parameter selection. Experimental results and extensions to Optimized Product Quantization are given in Section VI and Section VII, respectively. Section VIII presents our conclusions.

II Related work

II-A Extensions to PQ

Since PQ was originally proposed, several extensions have been studied. Optimized product quantization (OPQ) [2, 3] rotates an input space to minimize the encoding error. Because OPQ always improves the accuracy of encoding with just an additional matrix multiplication, OPQ has been widely used for several tasks. Our proposed PQTable can naturally handle OPQ codes. We present the results with OPQ in Section VII-A.

Additive quantization [4, 23] and composite quantization [5, 9] generalize the representation of PQ from the concatenation of sub-codewords to the sum of full-dimensional codewords. These generalized PQs are more accurate than OPQ; however, they require a more complex query algorithm.

In addition, recent advances of PQ-based methods include novel problem settings such as supervised [24] and multi-modal [25]. Hardware-based acceleration is discussed as well, including GPU [26, 27] and cache-efficiency [28].

II-B Hamming-based ANN methods

As an alternative to PQ-based methods, another major approach to ANN are Hamming-based methods [29, 30], in which two vectors are converted to bit strings whose Hamming distance approximates their Euclidean distance. Comparing bit strings is faster than comparing PQ codes, but is usually less accurate for a given code length [31].

In Hamming-based approaches, bit strings can be linearly scanned by comparing their Hamming distance, which is similar to linear ADC scanning in PQ. In addition, to facilitate a fast, non-exhaustive ANN search, a multi-table algorithm has been proposed [32]. Such a multi-table algorithm makes use of hash-tables, where a bit-string itself is used as a key for the tables. The results of the multi-table algorithm are the same as those of a linear Hamming scan, but the computation is much faster. For short codes, a more efficient multi-table algorithm was proposed [33], and these methods were then extended to the approximated Hamming distance [34].

Contrarily, a similar querying algorithm and data structure for the PQ-based method has not been proposed to date. Our work therefore extends the idea of these multi-table algorithms to the domain of PQ codes, where a Hamming-based formulation cannot be directly applied. Table I summarizes the relations between these methods.

The connection between PQ-based and Hamming-based methods is also discussed, including polysemous codes [35], k-means hashing [31], and distance-table analysis. [36]

III Background: Product Quantization

In this section, we briefly review the encoding algorithm and search process of product quantization [1].

III-A Product quantizer

Let us denote any $D$-dimensional vector $\mathbf{x}\in\mathbb{R}^{D}$ as a concatenation of $M$ subvectors: $\mathbf{x}=[(\mathbf{x}^{1})^{\top},\dots,(\mathbf{x}^{M})^{\top}]^{\top}$, where each $\mathbf{x}^{m}\in\mathbb{R}^{D/M}$. We assume $D$ can be divided by $M$ for simplicity. A product quantizer, $\mathbb{R}^{D}\to\{1,\dots,K\}^{M}$ is defined as follows111 In this paper, we use a bold font to represent vectors. A square bracket with a non-bold font indicates an element of a vector. For example, given $\mathbf{a}\in\mathbb{R}^{D}$, $d$th element of $\mathbf{a}$ is $a[d]$, i.e., $\mathbf{a}=[a[1],\dots,a[D]]^{\top}$. :

[TABLE]

Each $\bar{x}[m]$ is a result of a subquantizer: $\mathbb{R}^{D/M}\to\{1,\dots,K\}$ defined as follow:

[TABLE]

Note that $K$ $D/M$-dim codewords $C^{m}=\{\mathbf{c}_{k}^{m}\}_{k=1}^{K},\mathbf{c}_{k}^{m}\in\mathbb{R}^{D/M}$ are trained for each $m$ in advance by k-means [37]. In summary, the product quantizer divides an input vector into $M$ subvectors, quantizes each subvector to an integer ($1,\dots,K$), and concatenates resultant $M$ integers. In this paper, this product-quantization is also called “encoding”, and a bar-notation ($\mathbf{\bar{x}}$) is used to represent a PQ code of $\mathbf{x}$.

A PQ code is represented by $B=M\log_{2}K$ bits. Typically, $K$ is set as a power of 2, making $\log_{2}K$ an integer. In this paper, we set $K$ as 256 so that $B=8M$.

III-B Asymmetric distance computation

Distances between a raw vector and a PQ code can be approximated efficiently. Suppose that there are $N$ data points, $\mathcal{X}=\{\mathbf{x}_{n}\}_{n=1}^{N}$, and they are PQ-encoded as a set of PQ codes $\mathcal{\bar{X}}=\{\mathbf{\bar{x}}_{n}\}_{n=1}^{N}$. Given a new query vector $\mathbf{q}\in\mathbb{R}^{D}$, the squared Euclidean distance from $\mathbf{q}$ to $\mathbf{x}\in\mathcal{X}$ is approximated using the PQ code $\mathbf{\bar{x}}$. This is called an asymmetric distance (AD) [1]:

[TABLE]

This is computed as follows: First, $\mathbf{q}^{m}$ is compared to each $\mathbf{c}_{k}^{m}\in\mathcal{C}^{m}$, thereby generating a distance matrix online, where its $(m,k)$ entry denotes the squared Euclidean distance between $\mathbf{x}^{m}$ and $\mathbf{c}^{m}_{k}$. For the PQ code $\mathbf{\bar{x}}$, the decoded vector for each $m$ is fetched as $\mathbf{c}^{m}_{\bar{x}[m]}$. The $d_{AD}$ approximates the distance between the query and the original vector $\mathbf{x}$ using the distance between the query and this decoded vector. Furthermore, the computation can be achieved by simply looking up the distance matrix ($M$ times checking and summing). The computational cost for all $N$ PQ-codes is $O(DK+MN)$, which is fast for small $N$ but still linear in $N$.

IV PQTable

IV-A Overview

In this section, we introduce the proposed PQTable. As shown in Fig. 1c, the basic idea of the PQTable is to use a hash table. Each slot of the hash table is a concatenation of $M$ integers. For each slot, a list of identifiers is associated. In the offline phase, given a $n$th database item (a PQ code $\mathbf{\bar{x}}_{n}$ and an identifier $n$), the PQ code $\mathbf{\bar{x}}_{n}$ itself is used as a key. The identifier $n$ is inserted in the slot. In the retrieval phase, a query vector is PQ-encoded to create a key. Identifiers associated with the key are retrieved. Accessing the slot (i.e., hashing) is an $O(1)$ operation. This process seems very straightforward, but there are two problems to be solved.

IV-A1 The empty-entries problem

Suppose a new query has been PQ encoded and hashed. If the identifiers associated with the slot are not present in the table, the hashing fails. To continue the retrieval, we would need to find new candidates by some other means. To handle this empty-entries problem, we present a key generator, which is mathematically equivalent to a multi-sequence algorithm [13]. This generator creates next nearest candidates one by one, as shown in Fig. 3a. For a given query vector, the generator produces the first nearest code $\mathbf{\bar{x}}=[13,192,3,43]^{\top}$, which is then hashed; however, the table does not contain identifiers associated with that code. The key generator then creates and hashes a next nearest code $\mathbf{\bar{x}}=[13,192,3,22]^{\top}$. In this case, we can find the nearest identifier (“87”) at the eighth-time hashing.

IV-A2 The long-code problem

Even if we can find candidates and continue querying, the retrieval is not efficient if the length of the codes is long compared to the number of slots, e.g., $B=64$ codes for $N=10^{9}$ vectors. Let us recall the example of Fig. 3a. The number of slots (the size of the hash table) is $K^{M}=256^{M}=2^{B}$, whereas the sum of the number of the identifiers is $N$. If $N$ is much smaller than $2^{B}$, the hash table becomes sparse (almost all slots will be empty), and this results in an inefficient querying as we cannot find any identifiers, even if a large number of candidates are created. To solve the long-code problem, we propose table division and merging, as shown in Fig. 3b. The hash table is divided into $T$ small hash tables. Querying is performed for each table, and the results are merged.

We first show the data structure and the querying algorithm for a single table, which uses the key generator to solve the empty entries problem (Section IV-B). Next, we extend the system to multiple hash tables using table division and merging to overcome the long-code problem (Section IV-C).

IV-B Single Hash Table

First, we show a single-table version of the PQTable (Fig. 3a). The single PQTable is effective when the difference between $N$ and $2^{B}$ is not significant. A pseudo-code222 If we speak in a c++ manner, Alg. 1 shows a definition of the PQTable class. The elements in Member are member variables. Functions are regarded as member functions. is presented in Alg. 1. A PQTable is instantiated with a hash-table $tbl$ and a key generator $keygen$ (L2-L3 in Alg. 1). We give the pseudocode of our implementation of the key generator in Appendix A as a reference.

IV-B1 Offline

The offline step is described in Insert function (L4-L6). In the offline step, database vectors $\{\mathbf{x}_{n}\}_{n=1}^{N}$ are PQ-encoded first. The resultant PQ codes $\{\mathbf{\bar{x}}_{n}\}_{n=1}^{N}$ are inserted into a hash table (L6). The function Push$(\mathbf{\bar{x}},n)$ of $tbl$ means inserting an identifier $n$ to $tbl$ using $\mathbf{\bar{x}}$ as a key. If identifiers already exist in the slot, the new $n$ is simply added to the end (e.g., “413” and “352” are associated with the same slot $[0,0,0,1]^{\top}$ in Fig. 3a)

IV-B2 Online

The online step is presented in Query function (L7-L15). In the online step, the function takes a query vector $\mathbf{q}$ and the length of the returned item $L$ as inputs. The function then retrieves $L$ nearest items ($L$ pairs of an identifier and a distance). We denote these nearest items as $\mathcal{S}=\{\mathbf{s}_{l}\}_{l=1}^{L}$, where each $\mathbf{s}_{l}$ is a pair of two scholar values.

First, the key generator is initialized using $\mathbf{q}$ (L9), and the search continues until the $L$ items are retrieved (L10). For each loop, the next nearest PQ code $\mathbf{\bar{x}}$ (and AD $d$) is created (L11). This iterative creation is visualized in the “Key generator” box in Fig. 3a. When the NextKey function of $keygen$ is called, the next nearest PQ code $\mathbf{\bar{x}}$ (in terms of AD from the query) is returned. Using $\mathbf{\bar{x}}$ as a key, the associated identifiers are found from $tbl$ (L12). The Hash function returns all identifiers ($n_{1},n_{2},\dots,$) associated with the slot. For example, $n_{1}=413$ and $n_{2}=352$ are returned if the key $[0,0,0,1]^{\top}$ is hashed in Fig. 3a. For each $n\in\{n_{1},n_{2},\dots\}$, the code and the distance is pushed into $\mathcal{S}$. Owing to NextKey, we can continue querying even if identifiers with the focusing slot are empty, thereby solving the empty-entries problem.

Note again that $keygen$ is mathematically equivalent to the higher-order multi-sequence algorithm [13], which was originally used to divide the space into Cartesian products for coarse quantization. We found that it can be used to enumerate PQ code combinations in the ascending order of AD.

If sufficient numbers of items are collected, items $\mathcal{S}$ are returned (L15). Note that, if $L$ is small enough, the table immediately returns $\mathcal{S}$; i.e., the first $n_{1}$ is returned without fetching $\{n_{2},n_{3},\dots\}$ if $L$ is one. This accelerates the performance.

IV-C Multiple Hash Table

The single-table version of the PQTable may not work when the code-length is long, e.g., $64\leq B$. This is the long code problem described above, where the number of possible slots ($2^{B}$) is too large for efficient processing. For example, in our experiment, the maximum number of database vectors ($N$) is one billion. Therefore, most slots will be empty if $64\leq B$ (i.e., $2^{64}\sim 1.8\times 10^{19}\gg 10^{9}$).

To solve this problem, we propose a table division and merging method. The table is divided as shown in Fig. 3b. If an $B$-bit code table is divided into $T$ $B/T$-bit code tables, the number of the slots decreases, from $2^{B}$ for one table to $2^{B/T}$ for $T$ tables. By properly merging the results from each of the small tables, we can obtain the correct result.

A pseudocode is presented in Alg. 2. The multi-PQTable is instantiated with $T$ hash tables and $T$ key generators.

IV-C1 Offline

The offline step is described in Insert function (L5-L9). Each input PQ code $\mathbf{\bar{x}}$ is divided into $T$ parts. $t$th part is used as a key for $t$th $tbl$ to associate an identifier (L8). For example, if $\mathbf{\bar{x}}_{93}=[13,35,7,9]$ and $T=2$, the first part $[13,35]$ is used as a key for the first table ${tbl}_{1}$, and $n=93$ is inserted. The second part $[7,9]$ is used for the second table, then $n=93$ is inserted. Unlike the single PQTable, the PQ codes themselves are also stored (L9).

IV-C2 Online

The online querying step is presented in Query function (L10-L28). The inputs and outputs are as the same as those for the single PQTable. In addition to the final scores $\mathcal{S}$, we prepare a temporal buffer $\mathcal{S}_{M}$ which is also a set of scores called “marked scores” (L12). As a supplemental structure, we prepare a counter $\mathbf{c}\in\{0,\dots,T\}^{N}$ (L13). The counter counts the frequency of the number $n$. For example, $c[13]=5$ means that $n=13$ appears five times333 We cannot use an array to represent $\mathbf{c}$ for a large $N$, as $\mathbf{c}$ could require more memory space than the hash table itself. We do not need to prepare a full memory space for all $N$ because only a fraction of $n$s are accessed. In our implementation, a standard associative array (std::unordered_map) is leveraged to represent $\mathbf{c}$. .

An input query $\mathbf{q}$ is divided into $T$ small vectors, and $t$th key generator is initialized by the $t$th small vector (L15). The search is performed in the Repeat loop (L16). For each $t$, a small PQ-code ($\{1,\dots,K\}^{M/T}$) is created, hashed, and the associate identifiers are obtained in the same manner as the single PQ-table (L17-L20). This step means finding similar codes by just seeing the $t$th part. Fig. 3b(i, ii) visualizes these operations, where the associated identifiers are retrieved for each hash table. In this case, the 589th PQ code is the nearest to the query if we see only a first half of the vector, but this is not necessarily the case regarding the last half.

Let us describe the proposed result-merging step. Given $n\in\{n_{1},n_{2},\dots\}$, the next step is counting the frequency of $n$; this can be done by simply updating $c[n]\leftarrow c[n]+1$ (L21). These identifiers are possible answers of the problem because at least $t$th part of the PQ code is similar to the query. When $n$ appears for the first time ($c[n]=1$), we compute the actual asymmetric distance between the query and $n$th item ($d_{AD}(\mathbf{q},\mathbf{x}_{n})$). This can be achieved by picking up the PQ-code $\mathbf{\bar{x}}_{n}$ from $\mathcal{\bar{X}}$ (L23). At the same time, we store a pair of $n$ and the computed $d_{AD}$ in $\mathcal{S}_{M}$. We call this step “marking”, as visualized by a gray color in Fig. 3b. The key generation, hashing, and marking are repeated until we find $n$ such that $n$ appears $T$ times, i.e., $c[n]=T$ (L24). Let us denote the $d_{AD}$ of this $n$ as $d_{min}$ (L25). It is guaranteed that any items whose $d_{AD}$ is less than $d_{min}$ are already marked (see Appendix B for the proof). Therefore, the final set of scores $\mathcal{S}$ can be constructed by picking up items whose $d_{AD}$ is less than $d_{min}$ from the marked items (L26). If the number of the scores $|\mathcal{S}|$ is more than the required number $L$, the scores are sorted partially and the top $L$ scores are returned (L27-L28). Fig. 3b(iii, iv) visualizes these processes. Here, we find that $n=456$ appears $T=2$ times (iii), so we evaluate the items in $\mathcal{S}_{M}$. The $d_{min}$ is 0.35, so the items that have $d\leq 0.35$ are selected to construct $\mathcal{S}$. In this case, a sufficient number ($L=2$) of items are in $\mathcal{S}$. Thus, the items in $\mathcal{S}_{M}$ are partially sorted, and the top-$L$ results are returned. If there are not enough items in $\mathcal{S}$, entire loop continues until a sufficient number of items is found.

The intuition of the proposed merging step is simple; marked items have a high possibility of being the nearest items, but much closer PQ code might exist which may be unmarked. If we can find a “bound” of the distance where any items that are closer than the bound must be marked, we simply need to evaluate the marked items. The item which appears $T$ times acts as this bound.

IV-C3 Implementation details

Although we use two sets $\mathcal{S}$ and $\mathcal{S}_{M}$ in Alg. 2 for the ease of explanation, they can be implemented by maintaining an array. In the case $L=1$, we simplify L25-L28 as we do not need to sort results.

V Analysis for Parameter Selection

In this section, we discuss how to determine the value of the parameter required to construct the PQTable. Suppose that we have $N$ $B$-bit PQ-codes ($\{\mathbf{\bar{x}}_{n}\}_{n=1}^{N},\mathbf{\bar{x}}_{n}\in\{1,\dots,K\}^{M},B=M\log K=8M$). To construct the PQTable, we must select one parameter value $T$ (the number of dividing tables). If $B=32$, for example, we need to select the data structure as being either a single 32-bit table, two 16-bit tables, or four 8-bit tables, corresponding to $T=1,2,$ and $4$, respectively. To analyze the performance of the proposed PQTable, we first consider the case in which PQ codes are uniformly distributed. Next, we show that the behavior of hash tables is strongly influenced by the distribution of the database vectors. Taking this into account, we present an indicative value, $T^{*}=B/\log_{2}N$, as proposed by previous work on multi-table hashing [38, 32]. We found that this indicative value estimates the optimal $T$ well.

V-A Observation

Considering a hash table, there is a strong relationship between $N$, the number of slots $2^{B}$, and the computational cost. If $N$ is too small, almost all slots will not be associated with identifiers, and generating candidates will take time. If $N$ is the appropriate size and the slots are well filled, search speed is high. If $N$ is too large compared with the size of the slots, all slots are filled and the number of identifiers associated with each slot is large, which can cause slow fetching.

Fig. 4a shows the relationship between $N$ and the computational time for 32-bit codes with $T=1,2,$ and $4$. Fig. 4b shows that for 64-bit codes and $T=2,4,$ and $8$. We can find that each table has a “hot spot.” In Fig. 4a, for $10^{2}\leq N\leq 10^{3}$, $10^{4}\leq N\leq 10^{5}$, and $10^{6}\leq N\leq 10^{9}$, $T=4,2,$ and $1$ are the fastest, respectively. Given $N$ and $B$, our objective here is to decide the optimal $T$ without constructing tables.

V-B Comparison to uniform distribution

Let us first analyze the case when all items are uniformly distributed in a hash table. Next, we show that the observed behavior of the items is extremely different.

We will consider a single hash table for simplicity. Suppose that each item has an equal probability of hashing to each slot. First, we focus a fill-rate as follows:

[TABLE]

where $0<p\leq 1$. Because we consider a $B$-bit hash table, $\mathrm{\#slots}=2^{B}$. The number of the expected value of empty slots is computed as follows: Because items are equally distributed, the probability that an entry is empty after we insert an item into the table is $1-\frac{1}{2^{B}}$. Because each hashing can be considered as an independent trial, the probability of nothing being hashed to a slot in $N$ trials is $(1-\frac{1}{2^{B}})^{N}$. This indicates that the expected value for an entry being empty (0 for being empty, and 1 for being non-empty) after $N$ insertions is $(1-\frac{1}{2^{B}})^{N}$. Because of the linearity of the expected value, the expected number of empty slots is $2^{B}(1-\frac{1}{2^{B}})^{N}$ (Theorem 5.14 in [39]). From this, the fill-rate is denoted as:

[TABLE]

Note that, for a given query, the probability of the slot being filled is also the same as $p$, as we assume that all queries are also uniformly distributed. We call this probability the hit rate.

Next, we compute $r$, which is the expected number of hashings to find the nearest item. This value corresponds to the number of iterations of loop L10 in Alg. 1 Because the probability of finding the nearest item for the first time in $r^{\prime}$th step is $(1-p)^{r^{\prime}-1}p$, the expected value of $r^{\prime}$ is:

[TABLE]

Finally, we compute $N_{nnslot}$, which indicates the number of items assigned to the slot when hashing is successful. This value corresponds to the number of returned items $|\{n_{1},n_{2},\dots\}|$ in L12 in Alg. 1. Under uniform distribution, we can count $N_{nnslot}$ by simply dividing the total number $N$ by $\mathrm{\#filled\_slots}$:

[TABLE]

Fig. 5a and Fig. 5d show hit rates for $B=16$ and $B=32$, respectively. In addition, we show the observed values of hit-rate over the SIFT1B dataset. Because the actual data follow some distribution in both the query the database sides, the hit-rate is higher than $p$; i.e., $p$ it acts as a bound. Similarly, the number of candidates to find the nearest neighbor is shown in Fig. 5b and Fig. 5e, and the number of items assigned to the slot for the first hit is presented in Fig. 5c and Fig. 5f. Note that $r$ and $N_{nnslot}$ also act as bounds.

Remarkably, the observed SIFT1B data behaves in a completely different way compared to that of the equally-distributed bound, especially for a large $N$. For example, the observed hit rate for $N=10^{9}$ is 0.94 in Fig. 5d, whereas the hit rate for $p$ is just 0.21. Therefore, the first hashing almost always succeeds. This is supported in Fig. 5e, where the required number for finding the searched item is just 1.3 for $N=10^{9}$. At the same time, the number of items assigned to the slot is surprisingly larger than the bound ($1.6\times 10^{4}$ times, as shown in Fig. 5f). This heavily biased behavior is attributed to the distribution of the input SIFT vectors.

Taking this heavily biased observation into account, we present an empirical estimation procedure based on the existing literature, which is both simple and practical.

V-C Indicative value

The literature on multi-table hashing [32, 38] suggests that an indicative number, $B/\log_{2}N$, can be used to divide the table. PQTable differs from previous studies as we are using PQ codes; however this indicative number can provide a good empirical estimate of the optimal $T$. Because $T$ is a power of two in the proposed table, we quantize the indicative number into a power of two, and the final optimal $T^{*}$ is given as:

[TABLE]

where $Q(\cdot)$ is the rounding operation. A comparison with the observed optimal number is shown in Table II. In many cases, the estimated $T^{*}$ is a good estimation of the actual number, and the error margin was small even if the estimation failed, as in the case of $B=32$ and $N=10^{6}$ (see Fig. 4a). Selected $T^{*}$ values are plotted as gray dots in Fig. 4a and 4b.

VI Experimental Results

In this section, we present our experimental results. After the settings of the experiments are presented (Section VI-A), we evaluate several aspects of our proposed PQTable, including the analysis of runtime (Section VI-B), accuracy (Section VI-C), and memory (Section VI-D). Finally, the relationship between the proposed PQTable and dimensionality reduction is discussed (Section VI-E).

VI-A Settings

We evaluated our approach using three datasets, SIFT1M, SIFT1B, and Deep1B. All reported scores are values averaged over a query set.

SIFT1M dataset consists of 10K query, 100K training, and 1M base features. Each feature is a 128D SIFT vector, where each element has a value ranging between 0 and 255. The codewords $C$ are learned using the training data. The base data are PQ-encoded and stored as a PQTable in advance. SIFT1B is also a dataset of SIFT vectors, including 10K query, 100M training, and 1B base vectors. Note that the top 10M vectors from the training features are used for learning $C$. SIFT1M and SIFT1B datasets are from BIGANN datasets [20].

The Deep1B dataset [22] contains 10K query, 350M training, and 1B base features. Each feature was extracted from the last fully connected layer of GoogLeNet [40] for one billion images. The features were compressed by PCA to 96 dimensions and $l_{2}$ normalized. Each element in a feature can be a negative value. For training, we used the top 10M vectors.

In all experiments, $T$ is automatically determined by Eq. (8). All experiments were performed on a server with 3.6 GHz Intel Xeon CPU (6 cores, 12 threads) and 128 GB of RAM. For training $C$, we use a multi-thread implementation. To run the search, all methods are implemented with a single-thread for a fair comparison. All source codes are available on https://github.com/matsui528.

VI-B Runtime analysis

Fig. 6 shows the runtimes per query for the proposed PQTable and a linear ADC scan. The results for SIFT1B with $B=32$ codes are presented in Fig. 6a (linear plot) and Fig. 6c (log-log plot). The runtime of ADC depends linearly on $N$ and was fast for a small $N$, but required 6.0 s to scan $N=10^{9}$ vectors. Alternatively, the PQTable ran for less than 1ms in all cases. Specifically, the result of $N=10^{9}$ with 1-NN was $10^{5}$ times faster than that of the ADC. The runtime and the speed-up factors against ADC are summarized in Table III.

The results with $B=64$ codes are presented in Fig. 6b and Fig. 6d. The speed-up over ADC was less dramatic than that of $B=32$, but was still $10^{2}$ to $10^{3}$ times faster when $10^{8}<N$, which is highlighted in the linear plot (Fig. 6b).

Fig. 6e and Fig. 6f illustrate the results for Deep1B dataset with $B=32$ and $B=64$, respectively. Notably, the runtimes for Deep1B show a similar tendency as those for SIFT1B, even though the distribution of SIFT features and GoogLeNet features are completely different.

VI-C Accuracy

Table III illustrates the accuracy (Recall@1) of PQTable and ADC for $N=10^{9}$. In all cases, the accuracy of PQTable is as the same as that of ADC.

As expected, the recall@1 of $B=32$ is low (0.002 for SIFT1B, $B=32$) because a vector is highly compressed into a 32 bit PQ-code. However, the search of over one billion data points was finished within just 0.059 ms. These remarkably efficient results suggest that PQTable is one of the fastest search schemes to date for billion-scale datasets on a single CPU. Furthermore, because the data points are highly compressed, the required memory usage is just 5.5 GB. Such fast searches with highly compressed data would be useful in cases where the runtime and the memory consumption take precedence over accuracy.

Note that the results with $B=64$ are comparable to the state-of-the-art inverted-indexing-based methods; e.g., 0.571 for PQTable v.s. 0.776 for OMulti-D-OADC-Local [17] (recall@100), even though the PQTable does not require any parameter tunings.

VI-D Memory consumption

We show the estimated and actual memory usage of the PQTable in Fig. 7. Concrete values for $N=10^{9}$ are presented in Table III. For the case of a single table ($T=1$), the theoretical memory usage involves the identifiers (4 bytes for each) in the table and the centroids of the PQ codes. For multi-table cases, each table needs to hold the identifiers, and the PQ codes themselves. Using Eq. (8), this theoretical lower-bound memory consumption (bytes) is summarized as:

[TABLE]

As a reference, we also show the cases where codes are linearly stored for a linear ADC scan ($BN/8+4KD$ bytes) in Fig. 7.

For the $N=10^{9}$ with $B=64$ case, the theoretical memory usage is 16 GB, and the actual cost is 19.8 GB. This difference comes from an overhead for the data structure of hash tables. For example, 32-bit codes in a single table directly holding $2^{32}$ entries in an array require 32 GB of memory, even if all elements are empty. This is due to a NULL pointer requiring 8 bytes with a 64-bit machine. To achieve more efficient data representation, we employed a sparse direct-address table [32] as the data structure, which enabled the storage of $10^{9}$ data points with a small overhead and provided a worst-case runtime of $O(1)$.

When PQ codes are linearly stored, only 8 GB for $N=10^{9}$ with $B=64$ are required. Therefore, we can say there is a trade-off among the proposed PQTable and the linear ADC scan in terms of runtime and memory footprint (8.4 s with 8 GB v.s. 6.9 ms with 19.8 GB).

VI-E Distribution of each component of the vectors

Finally, we investigated how the distribution of vector components affects search performance, particularly for the multi-table case. We prepared the SIFT1M data for the evaluation. Principal-component analysis (PCA) is applied the data to ensure the same number of dimensionality (128). Fig. 8a shows the average and standard deviation for each dimension of the original SIFT data, and Fig. 8b presents that of the PCA-aligned SIFT data. In both cases, a PQTable with $T=4$ and $B=64$ was constructed. The dimensions associated with each table were plotted using the same color, and the sum of the standard deviations for each table is shown in the legends.

As shown in Fig. 8a, the values for each dimension are distributed almost equally, which is the best case scenario for our PQTable. Alternatively, Fig. 8b shows a heavily biased distribution, which is not desirable as the elements in Tables 2, 3, and 4 have almost no meaning. In such a situation, however, the search is only two times slower than for the original SIFT data (2.9 ms for the original SIFT v.s. 6.1 ms for the PCA-aligned SIFT). From this, we can say the PQTable remains robust for heavily biased element distributions. Note that the recall value is lower for the PCA-aligned case because PQ is less effective for biased data [1].

VII Extension to OPQTable

In this section, we incorporate Optimized Product Quantization (OPQ) [3] into PQTable (Section VII-A). We then show a comparison to existing methods (Section VII-B).

VII-A Optimized Product Quantization Table

OPQ [2, 3] is a simple yet effective extension of PQ. In the offline encoding phase, database vectors are pre-processed by applying a rotation(orthogonal) matrix, and the rotated vectors are then simply PQ encoded. In the online search phase, the rotation matrix is applied to a query vector, and the search is then performed in the same manner as PQ.

Our PQTable framework can naturally handle OPQ codes (we call this an OPQTable). Fig. 9 illustrates the runtime performance of the OPQTable. Compared to the PQTable, the OPQTable requires an additional $D\times D$ matrix multiplication for each query ($O(D^{2})$). In the SIFT1B and Deep1B datasets, this additional cost is not significant. The runtimes are similar to that of the PQTable. In addition, we found that accuracy is slightly but steadily better than that of the PQTable. For SIFT1B, 0.002 (PQTable) v.s. 0.003 (OPQTable) with $B=32$, and 0.059 v.s. 0.063 with $B=64$. For Deep1B, 0.004 v.s. 0.006 with $B=32$, and 0.079 v.s. 0.082 with $B=64$. In terms of memory usage, OPQTable requires storing an additional $D\times D$ matrix, $4D^{2}$ bytes. This additional cost is also negligible for SIFT1B and Deep1B.

VII-B Comparison with existing methods

Table IV shows a comparison with existing systems for the SIFT1B dataset with 64-bit codes. We compared our OPQTable with two short-code-based inverted indexing systems: IVFADC [1] and OMulti-D-OADC-Local [17, 16, 15]. IVFADC is the simplest system, and can be regarded as the baseline. The simple k-means is used as the coarse quantizer. OMulti-D-OADC-Local is a current state-of-the-art system. The coarse quantizer involves PQ [13], the space for both the coarse quantizer and the short code is optimized [3], and the quantizers are per-cell-learned [16, 15].

The table shows that IVFADC performs with better accuracy; however, it is usually slower than the OPQTable (8.7 ms v.s. 209 ms). IVFADC requires two parameters to be tuned; the number of space partitions ($\#cell$) and the length of the list for re-ranking (or, equivalently, the search range $w$). This value must be decided regardless of $L$ (the number of items to be returned). As we first discussed in Fig. 2, the decision of these parameters is not trivial, though the proposed OPQ does not require any parameter tunings.

The best-performing system was OMulti-D-OADC-Local; it achieved better accuracy and memory usage than the OPQTable, though the computational cost for both was similar (8.7 ms v.s. 6 ms). To fully make use of OMulti-D-OADC-Local, one must tune two parameters manually (the $\#cell$ and the list-length); $\#cell$ is a critical parameter. The reported value $2^{14}\times 2^{14}$ is the optimal for $N=10^{9}$ data. However, it is not clear that this parameter works well for other $N$. In addition, several training steps are required for learning the coarse quantizer, and for constructing local codebooks, both of which are time-consuming.

From the comparative study, we can say there are advantages and disadvantages for both the inverted indexing systems and our proposed PQTable:

• •

Static vs. dynamic database: For a large static database where users have enough time and computational resources for tuning parameters and training quantizers, the previous inverted indexing systems should be used. Alternatively, if the database changes dynamically, the distribution of vectors may vary over time and parameters may need to be updated often. In such cases, the proposed PQTable would be the best choice.

• •

Ease of use: The inverted indexing systems produce good results but are difficult for a novice user to handle because they require several tuning and training steps. The proposed PQTable is deterministic, stable, conceptually simple, and much easier to use, as users do not need to decide on any parameters. This would be useful if users would like to use an ANN method simply as a tool for solving problems in another domain, such as fast SIFT matching for a large-scale 3D reconstruction [41].

VIII Conclusion

In this study, we proposed the PQTable, a non-exhaustive search method for finding the nearest PQ codes without parameter tuning. The PQTable is based on a multi-index hash table, and includes candidate code generation and the merging of multiple tables. From our analysis, we showed that the required parameter value $T$ can be estimated in advance. An experimental evaluation showed that the proposed PQTable could compute results $10^{2}$ to $10^{5}$ times faster than the ADC-scan method.

Limitations: PQTable is no longer efficient for $\geq$ 128-bit codes. For example, SIFT1B with $T=4$ took approximately 3 s per query; this is still faster than ADC, but slower than the state-of-the-art [17]. This lag was caused by the inefficiency of the merging process for longer bit codes, and handling these longer codes should be an area of focus for future work. It is important to note that $\leq$ 128-bit codes are practical for many applications, such as the use of 80-bit codes for image-retrieval systems [42]. Another limitation is the heavy memory usage of hash tabls, and constructing a memory efficient data structure should also be an area of focus for future work.

Appendix A Key generator

Alg. 3 introduces a data structure and an algorithm of the key generator. This scheme is mathematically equivalent to the multi-sequence algorithm [13]. The data structure of the generator includes a non-duplicate priority-queued ($candidates$) and a 2D-array ($dmat$) (L2-L3). For a given query vector, the querying algorithm operates in two stages: initialization (Init, L5-L14) and key generation (NextKey, L15-L22). Visual examples are shown in Fig. 10 and 11.

When the generator is instantiated, $candidates$, $dmat$, and $C$ are created (L1-L3). $candidates$ is a priority-queue containing no duplicate items. $dmat$ is an $M\times K$ 2D-array consisting of tuples, and each tuple consists of three scalars:$k\in\{1,\dots,K\}$, $dist\in\mathbb{R}$, and $pos\in\{1,\dots,K\}$; $C$ are codewords for PQ. Note that $candidates$ and $dmat$ are created with empty elements. $C$ is pre-trained and loaded.

A-A Initialization

The initialization step takes a query vector $\mathbf{q}\in\mathbb{R}^{D}$ as an input. First, the $m$-th part of $\mathbf{q}$ and $m$-th codewords $C^{m}$ are compared. The resultant squared distances are recorded with $k$ in $dmat$ (L8), and each row in $dmat$ is sorted by distance (L9). After being sorted, the indices are recorded in $pos$ (L11). Next, the first tuple from each row is picked to construct $\mathbf{e}$ (L13). Finally, $\mathbf{e}$ is inserted into $candidates$ (L14). It is clear that the $k$s in $\mathbf{e}$ can create a PQ-code. The entire computational cost of the initialization is $O(K(D+M\log K))$, which is negligible for a large database444If $D$ is sufficiently large, this cost is not negligible. Handling such case is a hot topic [9], but out of the scope of this paper. Fig. 10 illustrates this process.

Note that $candidate$ is a priority queue without duplicate items. We show a data structure and functions over the structure in Alg. 4. This data structure holds a usual priority queue $pqueue$ and a set of integers $Z$. We assume an item has two properties: $v\in\mathbb{R}$ and $z\in\mathbb{N}$. As with a normal priority queue, $v$ shows the priority of an item, whereas $z$ is used as an identifier to distinguish one item from another. When the Push function is called, $z$ of a new item is checked to determine whether it is $Z$ or not. If $z$ already exists, the item is not inserted. If $z$ is not present in $Z$, the item is inserted to $pqueue$, and $z$ is also inserted in $Z$. The Pop function is as the same as a normal priority queue; the item with the minimum $v$ is popped and returned. If we denote $Q$ as the number of items in $pqueue$, the Push takes $O(\log Q)$ on average and $O(\log Q+|Z|)$ in the worst case, using a hash table to represent $Z$. The Pop takes $O(\log Q)$.

In Alg. 3, we inserted not only $v$ and $z$, but also a vector of tuples ($\mathbf{e}$ in L13.) The sum of square distances, $d=\sum_{m=1}^{M}e[m].dist$, is used as a priority $v$. As an identifier $z$ of an item, the combination of $k$s from each tuples ($e[1].k,\dots,e[M].k$) is leveraged. This “duplicate checking” step is a different implementation to the original multi-sequence algorithm [13]; in the original algorithm, an $M$-dimensional array is required to check the duplicates, consuming much more memory for a large $M$ value. The results of the two algorithms were identical.

A-B Key generation:

As previously mentioned, our purpose is to enumerate candidates of hashing one by one. The first candidate is an original PQ-code of $\mathbf{q}$ itself. The second candidate should be a possible code (in $\{1,\dots,K\}^{M}$) whose distance to the query is the second nearest, and the third candidate’s distance should be the third nearest, etc.

Enumeration is achieved by maintaining $candidates$. Whenever NextKey is called, the item with the minimum $d$ is popped from $candidates$, which we denote as $\mathbf{e}$ (L16). If we recall $\mathbf{e}$ consists of $M$ tuples, it is obvious that we have $M$ possibilities for next-nearest codes. Given a current $\mathbf{e}$, we can slightly update $m$-th tuple for each $m\in\{1,\dots,M\}$, making $M$ $\mathbf{e}_{next}$. This update is achieved by fetching the next tuple in $dtable$ because each row in $dtable$ are sorted in the ascending order of $d$ (L18-L20). $M$ $\mathbf{e}_{next}$ are then pushed into $candidates$ (L21). Finally, a PQ-code $\mathbf{\bar{x}}$ is created by picking each $e[m].k$ for each $m$. The PQ-code and $d$ is then returned (L22). This NextKey process is illustrated in Fig. 11.

Appendix B Proof that required identifiers are already marked

We proved that all items whose asymmetric distance ($d_{AD}$) is less that $d_{min}$ must be marked in the querying process of a multi-PQTable. Hereinafter, we denote the $d_{AD}$ from the $t$th part as $d_{AD}^{t}(\mathbf{q},\mathbf{x})$, which leads to:

[TABLE]

Let us assume that the identifier $n^{*}$ such that $c[n^{*}]=T$ is found (L24 in Alg. 2). We define $d_{min}=d_{AD}(\mathbf{q},\mathbf{x}_{n^{*}})$ (L25). In addition, we denote $\mathcal{N}^{t}=\{n^{t}\}$ as a set of identifiers which are marked when $t$th table is focused. For example, in Fig. 3b, $n^{*}=456$, $\mathcal{N}^{1}=\{585,2,456\}$, and $\mathcal{N}^{2}=\{24,456\}$. It is obvious that $d_{AD}^{t}(\mathbf{q},\mathbf{x}_{n})\leq d_{AD}^{t}(\mathbf{q},\mathbf{x}_{n^{*}})$ for any $n\in\mathcal{N}^{t}$ because of its construction. Similarly, it is also clear that $d_{AD}^{t}(\mathbf{q},\mathbf{x}_{n^{*}})<d_{AD}^{t}(\mathbf{q},\mathbf{x}_{n})$ for any $n\notin\mathcal{N}^{t}$. Next, we introduce a proposition.

Proposition: Any items $n$ which satisfied $d_{AD}(\mathbf{q},\mathbf{x}_{n})<d_{min}$ must be already marked.

Proof: This proposition is proved by contradiction. Suppose there is an identifier $\hat{n}$, where $d_{AD}(\mathbf{q},\mathbf{x}_{\hat{n}})<d_{min}$, and $\hat{n}$ has not been marked ($\hat{n}\notin\mathcal{N}^{t}$ for all $t$). Because $\hat{n}$ is not marked, $d_{AD}^{t}(\mathbf{q},\mathbf{x}_{n^{*}})<d_{AD}^{t}(\mathbf{q},\mathbf{x}_{\hat{n}})$ for all $t$, as stated above. Summing up all $t$ leads to $d_{AD}(\mathbf{q},\mathbf{x}_{n^{*}})=d_{min}<d_{AD}(\mathbf{q},\mathbf{x}_{\hat{n}})$. This contradicts the premise.