DyFT: a dynamic similarity search method on integer sketches

Abstract

Similarity-preserving hashing is a core technique for fast similarity searches, and it randomly maps data points in a metric space to strings of discrete symbols (i.e., sketches) in the Hamming space. While traditional hashing techniques produce binary sketches, recent ones produce integer sketches for preserving various similarity measures. However, most similarity search methods are designed for binary sketches and inefficient for integer sketches. Moreover, most methods are either inapplicable or inefficient for dynamic datasets, although modern real-world datasets are updated over time. We propose dynamic filter trie (DyFT), a dynamic similarity search method for both binary and integer sketches. An extensive experimental analysis using large real-world datasets shows that DyFT performs superiorly with respect to scalability, time performance, and memory efficiency. For example, on a huge dataset of 216 million data points, DyFT performs a similarity search 6000 times faster than a state-of-the-art method while reducing to one-thirteenth in memory.

Implementation details

Although our experimental code is publicly available at https://github.com/kampersanda/dyft, we describe some of the implementation details for the interested reader.

Management of database For all the methods, a database of sketches $X =\{x_1,x_2, \dots ,x_n\}$ has to be stored to quickly compute the Hamming distance $H(x_i,y)$ for final verification to query sketch y. We describe physical representations of binary and integer sketches, which were applied to all the methods in our experiments. Since the length of a sketch m was set to 32 or 64 in our experiments, we consider $m = O(w)$ for a word size w.

A binary sketch was straightforwardly stored in a binary format since the Hamming distance can be computed in O(1) by exploiting bit-parallelism offered by CPUs: $H(x,y) = \textsf {Popcnt}(x \oplus y)$, where $\oplus$ is a bitwise-XOR operation and $\textsf {Popcnt}(\cdot )$ counts the number of 1s. Popcnt is known as a population count operation and is supported in modern CPU instruction sets. We used the built-in GCC function __builtin_popcount for this.

For integer sketches, we employed the generalization of the computation approach for binary sketches, which was proposed by Zhang et al. [42]. This approach encodes x into $\hat{x}$ in a vertical format, i.e., the i-th significant m bits of each character of x are stored to $\hat{x}[i]$ of consecutive m bits. Given sketches $\hat{x}$ and $\hat{y}$ in the vertical format, we can compute H(x, y) as follows. We initialize a bitmap t of m bits in which all the bits are set to zero. For each $i = 0,1,\ldots ,\lceil {\log _2 \sigma }\rceil -1$, we iteratively perform $t \leftarrow t \vee (\hat{x}[i] \oplus \hat{y}[i])$, where $\vee$ is a bitwise-OR operation. $\textsf {Popcnt}(t)$ for the resulting t is the same as H(x, y). The computation time is $O(\log \sigma )$. Thus, we stored integer sketches in the vertical format and employed the computation approach.

Assignment of smaller Hamming radii DyFT$^+$ employs the multi-index approach [17] to leverage a DyFT search for a large Hamming radius. In a traditional manner, it assigns radius $\lfloor {r/q}\rfloor$ to each block not to produce false negatives based on the (basic) pigeonhole principle. Recently, Qin et al. [34] developed the general pigeonhole principle that allows the multi-index approach to assign smaller radii than $\lfloor {r/q}\rfloor$. It ensures that the multi-index search does not produce false negatives when the sum of radii assigned for each block is $r - q + 1$. In DyFT$^+$ and MIH, we assigned radii for each block in a round-robin manner until the total was $r - q + 1$.

Implementation of DyFT pointers Although our method can significantly reduce the number of DyFT nodes, the main memory-consuming part is still the representation of DyFT nodes. Pointers on a 64-bit machine can be very expensive for representing DyFT nodes. Even for the largest dataset CP216M, the number of DyFT nodes was 217 million and less than $2^{27}$ when $\sigma = 16$ and $r=1$. Hence, we reserved a consecutive memory block to store DyFT nodes and implemented a DyFT pointer using a 32-bit integer within the memory block. The memory block was expanded by doubling its size. The modification is fair to the competitors since the implementations of MIH and HWT also assume that the database size n can be represented in a 32-bit integer.