Distance Quantization in Computing Distance in High Dimensional Space

Abstract

Techniques and systems for quantization based nearest neighbor searches can include quantizing a set of candidate points based on one or more characteristics of a query point; generating metric values based on the quantized candidate points, respectively, the metric values being indicative of respective proximities between the query point and the candidate points; and selecting one or more of the candidate points in response to the query point based on the metric values. In some implementations, techniques and systems can compress search metric computation resolution by implementing non-uniform scalar quantization within a metric computation process.

Description

BACKGROUND

This document relates to nearest neighbor search techniques and their implementations based on computer processors.

Various applications perform nearest neighbor searches to locate one or more points closest to an input point, such as a query point. Nearest neighbor searches can include locating a data point inside a data set S in metric space M that is closest to a given query point q ε M based on a distance metric d:q×S→. In some cases, metric space M is the k-dimensional Euclidean space ^k . The nearest neighbor for a point is given by:

NN(q)={ x ε S|∀x ε S ⊂ M, q ε M:d( x,q)≦d(x,q)}.

A distance metric can measure a proximity of one point to another point. One example of a distance metric is the Minkowski metric. A Minkowski metric of order p, also known as the p-norm distance, measures a distance between two k-dimensional data points q and x. The Minkowski metric is defined as:

$d\left(q,r\right)={q-r}_p={\left(\sum _{j=1}^k{q_j-r_j}^p\right)}^{1/p}.$

Performing a metric computation can include calculating a value based on the Minkowski metric. For example, a metric computation can include performing a distance computation in each dimension to compute respective dimension-distances: dist_j(q,r)=|q_j−r_j|^p performing a summation of all such distances:

$\sum _{j=1}^d{\mathrm{dist}}_j\left(q,r\right),$

and performing a 1/p-th power computation on an output of the summation to produce an output.

SUMMARY

This document describes, among other things, technologies that perform quantization based nearest neighbor searches.

Techniques for quantization based nearest neighbor searches can include quantizing a set of candidate points based on one or more characteristics of a query point; generating metric values based on the quantized candidate points, respectively, the metric values being indicative of respective proximities between the query point and the candidate points; and selecting one or more of the candidate points in response to the query point based on the metric values. Other implementations can include corresponding systems, apparatus, and computer programs, configured to perform the actions of the methods, encoded on computer storage devices.

These and other implementations can include one or more of the following features. Implementations can compress search metric computation resolution based on non-uniform scalar quantization within a metric computation process. Quantizing the candidate points can include accessing non-uniform intervals based on the query point, each non-uniform interval being described by one or more threshold values and associated with a range of inputs and an output, and quantizing the candidate points based on non-uniform intervals. The query point and the candidate points can include elements that correspond to respective dimensions. Quantizing the candidate points can include using different sets of non-uniform intervals, associated with respective different ones of the dimensions, to quantize the dimensional elements of the candidate points, each set of non-uniform intervals selected based on a respective element of the query point. Generating metric values based on quantized candidate points can include summing quantized elements of a quantized candidate point to produce a metric value. Implementations can include performing motion estimation based on information including the selected one or more candidate points.

Implementations can include determining one or more quantizers that preserve distance ranking between the query point and the candidate points. Quantizing the candidate points based on one or more characteristics of the query point can include using the one or more quantizers. Quantizing the candidate points based on one or more characteristics of the query point can include using different quantizers, associated with different dimensions, to quantize elements. Determining one or more quantizers can include determining a number of quantization levels, one or more quantization threshold values, and mapping values for one or more dimensions.

Implementations can include determining one or more statistical characteristics of multiple, related, query points; the query points can include elements that correspond to respective dimensions. Implementations can include determining one or more quantizers based on the one or more statistical characteristics, each quantizer corresponding to at least one of the dimensions and operable to generate a quantized output based on an input. Quantizing the candidate points based on one or more characteristics of the query point can include using the one or more quantizers. Determining one or more quantizers can include determining a quantizer that maps successive bins of input values to respective integer values. Determining one or more quantizers can include determining threshold values that delineate non-uniform quantization intervals based on an iterative process that minimizes a nearest neighbor search measure.

In another aspect, techniques can include accessing a set of candidate points from a memory; and operating processor electronics to perform operations based on the set of candidate points with respect to a query point to produce values being indicative of respective proximities between the query point and the candidate points, and use the values to determine a nearest neighbor point from the set of candidate points. The computations include applying non-uniform quantizations based on one or more characteristics of the query point. Other implementations can include corresponding systems, apparatus, and computer programs, configured to perform the actions of the methods, encoded on computer storage devices.

These and other implementations can include one or more of the following features. Applying non-uniform quantizations can include quantizing the candidate points based on non-uniform intervals. Non-uniform intervals can be described by a set of threshold values that are based on the query point. Each one of the quantized candidate points can include quantized elements corresponding to a plurality of dimensions. Operating processor electronics to perform operations can include operating processor electronics to sum quantized elements of a corresponding one of the quantized candidate points to produce a corresponding one of the values. The query point can include elements corresponding to a plurality of dimensions. Candidate points can include elements corresponding to the plurality of dimensions. Operating processor electronics to perform operations can include operating processor electronics to generate, for two or more of the dimensions, a partial distance term that is indicative of a distance between corresponding elements of the query point and each one of the candidate points. Operating processor electronics to perform operations can include operating processor electronics to quantize the partial distance terms based on the non-uniform intervals. Operating processor electronics to perform operations can include operating processor electronics to determine a metric value based on a summation of the quantized partial distance terms associated with the each one of the candidate points. Partial distance terms can include dimension-distance terms. Quantizing can reduce a bit-depth of each dimension-distance term.

In another aspect, apparatuses and systems can include a memory configured to store data points and processor electronics. Data points can include elements that correspond to respective dimensions. Processor electronics can be configured to access a query point, use one or more of the data points as candidate points, use one or more quantizers to quantize the candidate points based on one or more characteristics of the query point, generate metric values based on the quantized candidate points, respectively, the metric values being indicative of respective proximities between the query point and the candidate points, select one or more of the candidate points, based on the metric values, as an output to the query point.

Particular embodiments of the subject matter described in this document can be implemented so as to realize one or more of the following advantages. Quantization based metric computations based on non-uniform quantization can preserve nearest neighbor search rankings Applying non-uniform quantization to candidate points can maintain distance rankings

Quantization based metric techniques can provide reduced complexity for metric computations. In some implementations, the number of computationally expensive arithmetic processes such as those associated with calculating non-quantized dimension-distances can be reduced. Complexity of one or more additional arithmetic processes associated with a metric computation can be reduced. Quantization based metric techniques can be implemented such that complexity does not increase with the order of the 1_p norm. In some implementations, quantizing the output of each dimension-distance computation into 1-bit outputs can significantly reduce implementation complexity and its performance tends to be nearly unchanged for several applications because some dimension-distances tend to exhibit very compact low-variance statistical characteristics. Implementations can use one or more data sets or dimension reduction techniques to provide additional complexity reduction.

Quantization based metric techniques can be implemented with one or more applications such as video processing, vector quantization, information retrieval, pattern recognition, optimization tasks, and computer graphics. For example, quantization based metric techniques can be implemented to find similar images in a database. Video coding applications can use quantization based metric techniques for various tasks such as motion estimation and compensation for video coding. For example, without using any filtering, transform, or sorting process, one or more embodiments based on the described techniques and systems can provide on average 0.02 dB loss using only 1 bit per dimension instead of 8 bits and 0.0 dB loss when 2 bits are used.

The details of one or more embodiments of the subject matter described in this document are set forth in the accompanying drawings and the description below. Other features, aspects, and advantages of the subject matter will become apparent from the description, the drawings, and the claims.

BRIEF DESCRIPTION OF THE DRAWINGS

FIGS. 1A and 1B show different examples of non-uniform quantization within a metric computation technique.

FIGS. 2A and 2B show examples of various circuitry in some metric computation implementations.

FIGS. 3A and 3B show examples of complexity behaviors for different metric computation techniques based on input bit size.

FIGS. 4A, 4B, and 4C show examples of comparisons of complexity-performance trade-offs for four different scenarios.

FIGS. 5A and 5B show examples of comparisons between different cost functions.

FIG. 6 shows examples of different techniques performances as a function of quantization thresholds.

FIGS. 7A and 7B show examples of different techniques performances as a function of bit rate.

FIGS. 8A, 8B, and 8C show example performance measures using different image sequences.

FIG. 8D shows examples of different computational complexity costs.

FIG. 9 shows an example of a quantization based on a nearest-neighbor-preserving metric approximation technique.

FIGS. 10A and 10B show examples of metric computation architectures that include one or more quantizers.

FIG. 11 shows an example of a system configured to perform non-uniform quantized based metric computations.

FIG. 12 shows an example of a process that includes non-uniform quantized based metric computations.

Like reference symbols and designations in the various drawings indicate like elements.

DETAILED DESCRIPTION

Searching for nearest neighbors in high dimensional spaces is important to a wide range of areas and related applications including statistics, pattern recognition, information retrieval, molecular biology, optimization tasks, artificial intelligence, robotics, computer graphics, and data compression. Various real world applications perform searches in high dimensional search spaces with often highly varying non-deterministic data sets, which can lead to increased exponential complexity in search computations. Thus, finding the nearest neighbor in high dimensional space can pose serious computational challenges due to factors including the size of the data point set such as a database, dimensionality of the search space, and metric complexity. For example, computational complexity associated with some nearest neighbor implementations can be high due to high dimensional space searches.

Some nearest neighbor techniques reduce complexity based on altering the data set while computing a distance metric to full precision. Some techniques are based on using partial information, e.g., a data set S can be altered so that only parts of the database are searched or only part of the query data is used for matching. For example, some techniques search only a subset of candidate vectors. In another example, some techniques reduce search space dimensionality. Some nearest neighbor techniques can alter the data set S by using algorithms such as data-restructuring, filtering, sorting, sampling, transforming, bit-truncating, quantizing and can blindly compute a given metric to full resolution for a dissimilarity comparison based on such alterations data to locate the minimum distance data point.

This document describes, among other things, techniques and systems to perform fast nearest neighbor search computations. The described techniques and systems can provide significant reduction in complexity based on preserving the fidelity of the minimum distance ranking instead of the data set S, and selectively reducing the search metric computation resolution—instead of blindly computing a metric to full resolution. In some implementations, a metric value is computed only in order to compare different candidate points, and thus the metric value itself is not important, as long as the metric value provides relative information that permits a metric technique to identify the candidate closest to the query point. A query point can be represented as a query vector. The described techniques and systems can apply non-uniform quantization based one or more characteristics of a query point to reduce search metric computation resolution in such a way that the minimum distance ranking is most likely to be preserved. The techniques and systems can use one or more quantizers optimized to minimize the impact of quantization on identifying the nearest neighbor.

A nearest neighbor search process can include accessing a query point and a set of candidate points. The process can quantize the candidate points based on one or more characteristics of the query point. The process can calculate metric values based on the quantized candidate points. In some implementations, the metric values are indicative of respective proximities between the query point and the candidate points. The process can output one or more of the candidate points in response to the query point based on the metric values. In some implementations, the output can include the identities of one or more candidate points in a distance rank order.

Various nearest neighbor search processes can use a quantization based metric computation method. For example, metric techniques can apply quantization to one or more aspects of a Minkowski metric. A quantized metric can be based on a quantized form of a Minkowski metric. A quantized metric can include a quantization function such as Q_j and Q′_j For example, a quantized metric d can be represented as:

$\stackrel{\_}{d}\left(q,r\right)={\left(\sum _{j=1}^kQ_j\left({q_j-r_j}^{p}\right)\right)}^{1/p}.$

In yet another aspect, a quantized metric d can be represented as:

$\stackrel{\_}{d}\left(q,r\right)={\left(\sum _{j=1}^k{\stackrel{\_}{Q}}_j^{\prime }\left(r_j\right)\right)}^{1/p}.$

The above two equations including Q_j and Q″_j, respectively, may have similar, if not identical, computational performance. A quantizer can be configured to quantize the output of a dimension-distance |q_j−r_j|^p. Such a quantizer can provide a reduced bit-depth of each dimension-distance output which can lead to a significant complexity reduction in metric processes such as in a tree of k−1 summations and in a 1/p-th power computation. In some implementations, a quantizer can be implemented such that the input dimension-distance computation |q_j−r_j|^p does not have to be computed at all. In some cases, quantizer thresholds can be fixed over multiple queries and a given query point, q, being constant over searching many different candidate points, e.g., different r. In some implementations, a quantizer can be configured to directly quantize candidate points. For example, candidate points can be quantized directly without having to compute |q_j−r_j|^p first and then to apply quantization.

The quantization function Q_j represents quantization on a j-th dimensional input and uses a threshold set such as {θ_ji}₁₌₁^N-1. The quantization function Q″_j uses a threshold set such as {q_j±θ_ji^1/p}_i=1^N-1. Compared to Q_j, Q″_j uses twice as many thresholds even though computation of |q_j−r_j|^p is not required. In some implementations, quantization using Q″_j can be performed using a table-lookup method to increase performance. In some implementations, the inversion operation and the p-th power operation associated with a metric function can be replaced with operations that compare a value with one or more thresholds. In some implementations, a quantization function can use a threshold set such as {sign(q_j−r_j)·θ_ji^1/p}_i−1^{N 1} or {±θ_ji^1/p}_i−1^{N 1}.

Quantization based metric computation can reduce associated computational complexity. In some implementations, this result in reduced complexity in one or more calculations of a metric computation. In some implementations, such a complexity reduction may come with some performance loss due to possible information loss caused by a quantization process. For example, coarser quantizer may increase the complexity reduction ratio while it may lead to an increased information loss.

FIG. 1A shows an example of non-uniform quantization within a metric computation technique. In this example, a metric computation technique, such as one based on a Minkowski metric, can measure the dissimilarity between two k-dimensional data points q and x. The metric computation technique can include computing partial distance terms such as dimension-distance terms, e.g., dist_j(q,x)=|1_j−x_j|^p, for each dimension by performing operations such as subtracting 110, taking the absolute value 115, and rising to the p-th power 120.

The metric computation technique can include applying non-uniform scalar quantization 125 on the partial distance terms to produce quantized partial distance terms. Applying non-uniform scalar quantization 125 can include using a set of integer values that are assigned to respective intervals that cover possible input values. For example, a partial distance term value that falls into a specific interval can be assigned the integer value corresponding to that specific interval. Hence, the quantized partial distance value can be the corresponding integer value. are not required to be uniform. The set of intervals can be non-uniform, e.g., one interval has a larger span than another interval. The metric computation technique can sum over the quantized partial distance terms using a network of one or more summations 130. The metric computation technique can perform a 1/p-th power computation 135 on an output of the summation(s) to produce an output. In some implementations, non-uniform scalar quantization 125 can include using a quantizer that is chosen to preserve a minimum distance ranking

FIG. 1B shows a different example of non-uniform quantization within a metric computation technique. In this example, a metric computation technique, such as one based on a Minkowski metric, can measure the dissimilarity between two k-dimensional data points q and x. The metric computation technique can apply a non-uniform scalar quantization 140 on each of the dimensional values for the point x, which is represented by Q′(x_i). The quantization function can be different for one or more of the dimensions. For example, each dimensional value can be quantized using different sets of intervals and different assigned values to the intervals. In some implementations, the selection of intervals is based on a query point which is represented by q in this example. Applying non-uniform scalar quantization 140 can transform a n-bit value representation into a 1-bit quantized value representation. The quantized outputs can be summed via one or more summations 145. The metric computation technique can perform a 1/p-th power computation 150 on an output of the summation(s) network to produce an output. In some implementations, non-uniform scalar quantization 140 can include using a quantizer that is chosen to preserve a minimum distance ranking.

In one aspect, non-uniform scalar quantization can be applied within a metric computation process. In various implementations, this approach can be used to achchieve significant complexity savings by reducing the number of operations such as a total number of additions and complexity such as an adder bit depth of required arithmetic operations. Moreover, these computational savings can have minimal impact on performance because quantization processes can preserve the minimum distance ranking fidelity. In some implementations, metric computation processes can include non-uniform scalar quantization and one or more techniques that modify a candidate data set S.

Computational complexity, computation-related power consumption and circuit size of most arithmetic elements such as adder or multiplier can depend on an input bit depth. Computational complexity tends to increase linearly or exponentially with the number of input bit lines in various circuitry for executing such computations. A dimension-distance computation that includes performing |q_j−r_j|^p can result in n·p bit depth output, where inputs q_j and r_j are represented by n-bit numbers (e.g., n=8, 16, 32, and 64 bits). A metric value can be computed by summing the distances computed in each dimension. Circuitry to implement such a summation can include k−1 multiple-bit adders with maximum bit depth of n·p+┌log₂ k┐.

Various implementations of the described subject matter can reduce computational complexity associated with nearest neighbor searches at the circuit level. The input bit-depth of each arithmetic element can be incorporated into a complexity analysis.

FIGS. 2A and 2B show examples of various circuitry in some metric computation implementations. FIG. 2A shows an example of an adder circuit 205. FIG. 2B shows an example of a multiplier circuit 210. The size of the arithmetic circuit such as adder or multiplier circuits may increase with an input bit size. For example, computational complexity, circuit size, static and dynamic power consumption, computation delays of most basic arithmetic elements including adder or multiplier can be influenced by, and increase polynomially with, the input bit size. Therefore, quantization applied to partial distance terms in each dimension, e.g., as shown in FIG. 1a, can significantly reduce complexity associated with a summation process. In some applications such as video coding, very coarse quantization is possible (e.g., to 1 bit), which can result in reduced complexity in a summation process while leaving video coding performance nearly unchanged.

Metric computations can use quantizers that eliminate a per dimension distance computation |q_j−x_j|^p, e.g., an implementation based on the architecture shown in FIG. 1B. In some cases, the quantizer thresholds }θ_i} and the query vector q are fixed for a given search query, so that only the x ε S being tested for their proximity to q vary. Therefore, candidate data x can be quantized directly with a quantizer Q′: {q±θ_i^1/P}, which can lead to the same result as computing |q_j−x_j |^P followed by quantization by Q: {θ_i}, but at a fraction of the complexity.

FIG. 3A shows an example of complexity behaviors for different metric computation techniques based on input bit size. FIG. 3B shows an example of complexity behaviors for different metric computation techniques based on dimensionality. In these examples, the metric computation techniques include conventional l₁ and l₂ norm metric computations and a proposed distance quantization based l_p norm metric computation. FIGS. 3A and 3B show that complexity increases as a function of the input bit size, dimensionality, and order p of metric (p-norm distance) for both conventional and proposed metric computations. Complexity can be measured, for example, in units of number of full-adder operations, e.g., basic building blocks of arithmetic logic circuits, under the assumption that n-bit addition, subtraction, and absolute value operations have the same complexity and that a square operation has equivalent complexity to that of an n²-bit addition. For a motion estimation example, the dimensionality represents the number of pixels per matching block and the input bit size represents pixel bit-depth. In these examples, the complexity of the proposed distance quantization remains constant over different input bit sizes and l_p norms, while the complexity slowly increases with dimensionality as compared to the conventional metric computations.

A quantized metric computation process can use an output of a quantizer optimization technique that determines one or more optimal quantizers. A quantizer optimization technique can include using a cost function to quantify the difference in performance between an arbitrary search algorithm and a chosen benchmark search algorithm. A cost function can be based on computing the average difference in distance between a query point and the, possibly different, nearest neighbors identified by each algorithm. The search dataset, a query, a metric, and a resulting nearest neighbor data point of a benchmark algorithm are represented by S, q, d, and NN(q), respectively. Here,

NN(q)={x ε S|∀x ε S ⊂ M,q ε M:d(x,q)≦d(x,q)}.

The search dataset, a query, a metric, and a resulting nearest neighbor data point of a target algorithm are represented by S, q, d, and NN(q) similar, respectively. Here,

NN (q)={ x ε S|∀x ε S⊂ S,q ε M: d( x, q)≦ d(x, q)}

A nearest neightbor cost function, E_NN, can be written as:

E _NN =E{d(NN(q),q)−d(NN(q),q)}.

E_NN can represent an average NNS error measure. In some implementations, the expectation E is with respect to the query data when S and S are fixed. In some implementations, the expectation E is with respect to the set {(q,S, S)_i}_i. The cost function can be further expressed as:

E _NN=∫_R−μ(a)f(a)da−∫_R+a f(a)da

where μ(a)=E{d(x,q)| d(x,q)=a,x ε S}, and minimum distance distribution functions f(a)=Pr( d( NN(q),q)=a), f(a)=Pr(d(NN(q),q)=a).

In some implementations, only the first terms in the equations for E_NN are considered because the target algorithm affects the first term and not the second term. Therefore, a cost function can be expressed as Ē=E {d( NN(q),q)}=∫_R+μ(a) f(a)da.

In some implementations, techniques and systems do not modify a data set S or a query point q, but instead use a quantizer within the Minkowski metric computation. Thus, the Minkowski metric can be used as a benchmark with S=S to find a quantizer that, for a given number of quantization levels N, can minimize E_NN. Instead of considering statistical information of x ε S and q separately, a cost function can be based on statistical characteristics of Y, a k -dimensional multivariate random variable representing the input data on which a quantizer is applied:

Y _i=(y_n, y₁₂, . . . , y_ik)=(|q₁−x_i1|^p,|q₂−x_i2|^p, . . . , q_k−x_ik|^p).

Quantized input can be described as:

Z _i=(z_i1, z_i2, . . . , z_ik)=Q(Y)=(q(y_i1),Q(y_i2), . . . , Q(y_ik)).

Corresponding benchmark and proposed target metrics are:

$d\left(Y_i\right)={\left(\sum _{j=1}^ky_{\mathrm{ij}}\right)}^{1/p}$ $\stackrel{\_}{d}\left(Y_i\right)=d\left(Q\left(Y_i\right)\right)={\left(\sum _{j=1}^kz_{\mathrm{ij}}\right)}^{1/p}.$

The number of candidates M and their dimensions k can be assumed to be fixed over the search process. A quantizer operating on y as a set of N non-overlapping intervals that cover all possible values of y: S={s_n;s_n=[θ_n,θ_n+1),n ε Φ56 , where Φ is a set of consecutive integers from 0 to N-1, and {θ_n} is an increasing sequence of thresholds. Therefore, for all Y_ij ε s_n, we assign z_ij=Q(y_ij)=n, and the probability mass function (pmf) p_ij and centroid of μ_ij of z_ij can be computed using f_yij, the probability density function (pdf) of y_ij as:

$z_{\mathrm{ij}}=Q\left(y_{\mathrm{ij}}\right)=\sum _nn1_{s_n}\left(y_{\mathrm{ij}}\right),p_{\mathrm{ij}}\left(n\right)={\int }_{s_n}f_{y_{\mathrm{ij}}}\left(y\right)y,\mathrm{and}$ ${\mu }_{\mathrm{ij}}\left(n\right)=\frac{{\int }_{s_n}{\mathrm{yf}}_{y_{\mathrm{ij}}}\left(y\right)y}{{\int }_{s_n}f_{y_{\mathrm{ij}}}\left(y\right)y}.$

The cumulative mass and centroid functions of z_ij is denoted as

$P_{\mathrm{ij}}\left(n\right)={\sum }_{s_0}^{s_n}p_{\mathrm{ij}}\left(n\right)$ $\mathrm{and}$ $U_{\mathrm{ij}}\left(n\right)={\sum }_{s_0}^{s_n}p_{\mathrm{ij}}\left(n\right){\mu }_{\mathrm{ij}}\left(n\right).$

A simple case with M random samples from a k-variate distribution f_Y with iid dimensions, i.e., all y_j following the same pdf f_y and are independent of each other. The k-dimensional space can be partitioned into hypercubes through quantization, so that each input sample Y=(y₁,y₂, . . . , y_k) falls into one of the hypercubes. Each hypercube can be represented by a vector Z=(z₁,z₂, . . . , z_k)=(_Q(y₁),Q(y₂), . . . , Q(y_k)) and all z_j have the same pmf p and the same centroid function μ. Each hypercube Z can be described by i) a probability mass M_z, ii) a centroid C_z, and iii) its corresponding total metric S_z:

$M_Z=\prod _jp\left(z_j\right),C_Z=\sum _j\mu \left(z_j\right),S_Z={Z}_1=\sum _jz_j.$

The pmf P_∥z∥1 represents the probability of a sample Y falling in one of the hypercubes having a given S_z:

$p_{{Z}_1}\left(x\right)=\sum _{{Z}_1=x}M_Z=\sum _{{Z}_1=x}\prod p\left(z_j\right)=p^{*k}\left(x\right),$

where p*^k is the k-fold power convolution of p. Some implementations can minimize the cost function

$\stackrel{\_}{E}\text{:}\stackrel{\_}{E}=\sum _a\stackrel{\_}{\mu }\left(a\right)\stackrel{\_}{p}\left(a\right),$

where p is the pmf of the minimum S_z value among M samples of Y:

$\stackrel{\_}{p}\left(a\right)={\left(\sum _{x=a}^{\infty }p_{{Z}_1}\left(x\right)\right)}^M-{\left(\sum _{x=a+1}^{\infty }p_{{Z}_1}\left(x\right)\right)}^M,\mathrm{and}$ $\stackrel{\_}{p}=\nabla {\left({\hat{P}}_{{Z}_1}\left(a\right)\right)}^M,$

where ∇ is a backward difference operator and we define a reverse cmf {circumflex over (P)}(x)=1−P(x)=Pr[X≧x]. μ(a) is the centroid of all hypercubes with the same S_z=a.

$\stackrel{\_}{\mu }\left(a\right)=\frac{\sum _{{Z}_1=a}M_ZC_Z}{\sum _{{Z}_1=a}M_Z}$ $\stackrel{\_}{\mu }=\frac{{\mathrm{kp}}^{*\left(k-1\right)}*\left(p\mu \right)}{p^{*k}}.$

The above formulation assumes p=1. Alternatively, it would be valid for cases when the benchmark metric does not include 1/p -th power computation, as is the case in most real search applications. Otherwise, redefining C, as

$C_Z={\left(\sum _j\mu \left(z_j\right)\right)}^{\frac{1}{p}}$

allows the same procedure to be used.

Extending this to the more general case, candidates Y_i can be considered to be drawn each from different f_Yi. Similarly, each vector dimension can have non-identical distributions. However, vector data is independent across dimensions and candidates with similar distance in terms of the benchmark metric d also share a similar distribution. The following function f_λ(λ)=Pr(d(x,q)=λ,x ε S), a distribution of M candidates Y_i can be denoted in terms of benchmark distance (λ). Representing candidates having same λ as Y_λ=(y_λ1,y_λ2, . . . , y_λk) with y_λj, following a pdf f_yλj, provides Z_λ=(z_λ1,z_λ2,z_λk) with z_λj following a pmf p_λj and its centroid function μ_λj. Thus, for each hypercube Z_λ,

$M_{Z_{\lambda }}=\prod _jp_{\lambda j}\left(z_{\lambda j}\right)$ $C_{Z_{\lambda }}=\sum _j{\mu }_{\lambda j}\left(z_{\lambda j}\right)$ $S_{Z_{\lambda }}={Z_{\lambda }}_1.$

A new operator

$\prod _{i=n}^mp_i^{*}\equiv p_n*p_{n+1}*\dots *p_m$

with which can be represented p_∥zλ∥1 as,

$p_{{Z_{\lambda }}_1}\left(x\right)=\sum _{{Z_{\lambda }}_1=x}M_{Z_{\lambda }}$ $p_{{Z_{\lambda }}_1}=\prod _{j=1}^kp_{\lambda j}^{*}.$

Consequently, p and μ of Ē=Σ_dμ(a) p(a) becomes

$\stackrel{\_}{p}=\nabla {\left(E_{\lambda }\left[{\hat{P}}_{{Z_{\lambda }}_1}\left(x\right)\right]\right)}^M,\mathrm{and}$ $\stackrel{\_}{\mu }=E_{\lambda }\left[\sum _{i=1}^k\left(\prod _{j\ne i}^{1\dots k}p_{\lambda j}^{*}\right)*\left(p_{\lambda i}{\mu }_{\lambda i}\right)/p_{{Z_{\lambda }}_1}\right].$

Given the cost function quantifying the performance loss, a quantizer is identified that leads to the minimum Ē. Considering the case when data is assumed to be independent identical distributed (iid) across dimensions, for a given input distribution f_y, a quantizer can be uniquely defined by two vectors μ, p ε, where p satisfies the probability axioms, e.g., it is uniquely defined given the set of centroids and the probability masses of each quantization bin. Note that given f_y, Ē is a function of p. Note also that Ē can be represented in terms of P and U, defined previously as cumulative mass and centroid functions of z_j, where P ε C such that Ē(P): and C is a convex subset of , C={x|x_i≦x_i+1,0≦x_i≦1,∀i,x ε. It can be shown that

Ē({circumflex over (P)})≧Ē(P)+({circumflex over (P)}−P)′∇Ē(P), ∀{circumflex over (P)},P ε C

where a gradient of

$\stackrel{\_}{E}\text{:}\nabla \stackrel{\_}{E}\left(F_z\right)={\left(\frac{\partial \stackrel{\_}{E}\left(P\right)}{\partial P\left(0\right)},\dots ,\frac{\partial \stackrel{\_}{E}\left(P\right)}{\partial P\left(N-1\right)}\right)}^{\prime },$

proving that Ē is convex over C.

Finding the optimal quantizer can be formulated as a constrained convex optimization problem with the goal to minimize Ē(P) subject to P ε C. The global minimum value represents the optimal performance attainable given input distribution and can be obtained using standard convex optimization techniques. A quantizer can be determined based on the P vector corresponding to the global minimum.

The techniques and systems as described in this document can be applied to motion estimation (ME) process used in video coding system, for example. Without requiring any filtering, transform, or sorting process, using simple hardware oriented mapping, one or more embodiments of the described techniques and systems can provide on average 0.05 dB loss using only 1 bit per dimension instead of 8 bits and 0.01 dB loss when 2 bits are used, when a 1₁ norm distance was used for distance computation. In another aspect, one or more embodiments based on the described techniques and systems can provide on average 0.02 dB loss using only 1 bit per dimension instead of 8 bits and 0.0 dB loss when 2 bits are used. Similar results can be obtained for general 1_p distances.

Various sequences are tested for simulation using a H.264/MPEG-4 AVC baseline encoder with 16×16 block partitions (256 dimensional vectors), a single reference, full pel resolution search, 8-bit depth pixel, and l₁ norm, e.g., sum of absolute difference for search metric, and the search window of ±16 resulting a data set size of 1089.

Statistical characteristics of general ME input data show input dimension distances, e.g., pixel distances, to have approximately independent identical distributions while distribution varies with different candidates, e.g., distant candidates showed higher variance than nearer ones). Therefore, p and μ associated with a cost function

$\stackrel{\_}{{\rm E}}=\sum _{a^{\prime }}\stackrel{\_}{\mu }\left(a\right)\stackrel{\_}{p}\left(a\right)$

for the general ME data becomes:

$\stackrel{\_}{p}=\nabla {\left(E_{\lambda }\left[{\hat{P}}_{{z}_1}\left(x\right)\right]\right)}^M$ $\stackrel{\_}{\mu }=E_{\lambda }\left[\frac{{\mathrm{kp}}^{*\left(k-1\right)*\left(p\mu \right)}}{p^{{}^{{}^{*k}}}}\right].$

FIGS. 4A, 4B, and 4C show different examples of comparisons of complexity-performance trade-offs for four different scenarios. The four scenarios show the trade-offs between complexity and performance for three different representative scenarios and a proposed distance quantization based metric computation based on the subject matter described herein. Each scenario reduces one of i) size of a data set S, ii) dimensionality of each data x ε S, iii) bit depth of each data dimension by truncating least significant bits (equally seen as uniform quantization on each data dimension), and iv) resolution of each dimension-distance via the proposed distance quantization. The X axis represents complexity percentage to that of original full computation. The Y axis represents the rate distortion (RD) performance loss measured in dB. FIGS. 4A, 4B, and 4C show performance examples based on Bus CIF, Foreman CIF, and Stefan CIF, respectively. The proposed approach provides a better trade-off and can also be used together with most of other existing algorithms to further improve the complexity reduction.

FIGS. 5A and 5B show examples of comparisons between different cost functions. FIGS. 5A shows comparisons of different cost functions such as Ē_NN uniform, rayleigh, log normal, and model with the expected performance error collected from numerically simulated experiments for different input distribution settings f_y. As the number of experiments increases, expected error converges the cost function, confirming the accuracy of the Ē formulation. FIGS. 5B shows comparisons of cost functions based on the collected ME data with simulated experiments for CIFs including Foreman CIF, Mobile CIF, and Stefan CIF.

FIG. 6 and FIGS. 7A and 7B compare the performances of at least one implemention of the described subject matter with three different thresholds each of which minimizes overall coding efficiency, Ē_NN measure, and a cost model. FIG. 6 shows examples of different techniques performances as a function of quantization thresholds. FIGS. 7A and 7B show examples of different techniques performances as a function of bitrate. These results show that quantizers obtained by optimizing a cost function described herein can achieve near optimal performance. FIG. 6 also provides some insight about the sensitivity of optimal threshold to input variation. Despite large variation of the input source characteristics, dimension-distances where quantization is applied exhibit more consistent statistical behavior.

Some implementations can compress a search metric computation resolution by applying non-uniform scalar quantization, based on one or more query points, to candidate points prior to a metric computation summation process. Potential advantages of such implementations include removing certain computationally expensive arithmetic operations completely and can reduce the complexity of the rest of arithmetic operations significantly, complexity does not increase with the order of 1_p norm, and, most importantly, the penalty to be paid in performance for the complexity reduction is surprisingly quite small if designed optimally. In some implementations, quantization at the output of each dimension-distance into 1-bit results in maximized complexity reduction yet the performance tends to be almost unchanged for many applications because dimension-distances tends to exhibit very compact low-variance statistical characteristics unlike the actual source data q, r ε S. Moreover, the search metric computation resolution can be compressed such that computational complexity reduction is maximized and its impact on nearest neighbor search result is minimized. One way of accomplishing this is to apply non-uniform scalar quantization at the output of each dimension-distance dist_j(q,r)=|q_j−r_j|^p prior to the summation process.

Some implementations can determine a quantizer based on the statistical characteristic of input query data. Quantization can be used to map high rate data into lower rate data so as to minimize digital storage or transmission channel capacity requirement while preserving the essential data fidelity. While conventional optimal quantizer for compression and reconstruction purpose targets to minimize the reconstruction distortion given the input probability function, optimal quantizer embedded within the search metric computation however, has to minimize the search performance degradation cost given the input statistics. This quantization can be designed in such a way that for the given bit rate the fidelity of compressed data as a search metric measure is preserved in maximum.

Implementations of the described subject matter can include processing video data. One of the factors of video compression efficiency is how well the temporal redundancy is exploited by motion compensated prediction. Performance of the motion estimation (ME) process can relate to the video compression performance. The encoder searches for and selects the motion vector (MV) with minimum distance based on the metric d among all possible MVs. Then it performs the residual coding by encoding the difference block (prediction residual) between the original and motion compensated block. Each residual block is transformed, quantized, and entropy coded. For motion estimation case, the data set S (all reference blocks within the search range) varies largely from query to query (current block). To evaluate the techniques and systems described in this document in experimental application and compare with others, various sequences are tested using a H.264/MPEG-4 AVC baseline encoder. As it is in a typical video coding setting, 16×16 block partitions, a single reference, full pel resolution search, 8-bit depth pixel, and 1₁ norm distance for search metric were considered for ME. A search window of ±32 is used resulting in the size of data set to be 4225.

FIGS. 8A, 8B, and 8C show example performance measures for the CIF resolution Foreman, Mobile, and Akiyo sequences, respectively. In these examples, comparisons were made for total six different scenarios (as indicated in figure legend): i) full computation (benchmark approach, which compares all candidates in full resolution/dimensions), ii) data set reduction (reducing the number of candidates by a factor of two) iii) dimension reduction (subsample of dimensions into half), iv) four least significant bits truncation of both queries and candidates, v) a proposed quantization technique using 8 bins that compresses an 8-bit depth to 3-bit depth, and vi) a proposed quantization technique using 2 bins that compresses an 8-bit depth to a 1-bit depth). Their approximate complexity ratio as a percentage of the benchmark scenario is shown in parenthesis in the figure legend.

FIG. 8D shows examples of different computational complexity costs. In particular,

FIG. 8D shows the ratio of the total computational complexity cost comparing these 6 different cases over different p (the order of Minkowski metric). FIGS. 8A, 8B, and 8C represent RD performance when p is 1. Note that the thick solid line (original) is the benchmark full complexity while thin solid lines have the same complexity which is half of original case. This essentially compares the performance of four different approaches for the given equal complexity.

This document includes descriptions of a quantization based nearest-neighbor-preserving metric (QNNM) approximation algorithm. The QNNM algorithm is based on three observations: (i) the query vector is fixed during the entire search process, (ii) the minimum distance exhibits an extreme value distribution, and (iii) there is high homogeneity of viewpoints. Based on these, QNNM approximates original/benchmark metric in terms of preserving the fidelity of nearest neighbor search (NNS) rather than the distance itself, while achieving significantly lower complexity using a query-dependent quantizer. A quantizer design can be formulated to minimize an average NNS error. Query adaptive quantizers can be designed off-line without prior knowledge of the query and present an efficient and specifically tailored off-line optimization algorithm to find such optimal quantizer.

Given a metric space (U, d) with a distance/dissimilarity metric d:U×U→[0,∞), a set R ⊂ U of N objects, and a query object q ε U in (U,d), the nearest neighbor search (NNS) problem is to find efficiently the (either exact or approximate) nearest object

$\begin{array}{cc}{r}^{*}=\underset{r}{\mathrm{argmin}}d\left(q,r\right),\forall r\in R.& \left(1\right)\end{array}$

Some NNS techniques can present serious computational challenges based on the size of data set N, the dimensionality of search space D, and the metric complexity of d. To reduce such complexity, some existing algorithms focus on how to preprocess a given data set R, so as to reduce either (i) the subset of data to be examined, by discarding a large portion of data points during the search process using efficient data structures and querying execution (e.g., variants of k-d tree, metric trees, ball-trees, or similarity hashing) and/or (ii) the dimensionality of the vectors by exploiting metric space transformations, such as metric embedding techniques or techniques based on linear transforms, e.g., principal component analysis. This document includes descriptions of techniques that reduce complexity reduction by allowing approximation within the metric computation, instead of computing the chosen distance metric to full precision. Reduction of metric computation cost has been considered only to a limited extent (e.g., simple heuristic methods such as avoiding the computation of square roots of l₂ norm, truncation of least significant bits, early stopping conditioning, etc.).

This document includes descriptions of a metric approximation algorithm which maps the original metric space to a simpler one while seeking to preserve, approximate nearest-neighbors to a given query. A metric approximation algorithm can be based on the following observations: (i) the query vector is fixed during the entire search process, (ii) when performing NNS for different queries the distances d(q, r*) between a query vector and its best match (NN) tend to be concentrated in a very narrow range (e.g., extreme value distribution of the sample minimum F^min(x)=Pr(d(q,r*)≦x)), and (iii) high homogeneity of viewpoints property.

The metric approximation algorithm can approximate the original metric d using a query-adaptive quantizer. For a given query q, based on Observation (i), a set of query-dependent scalar quantizers is applied to each of the components/dimensions of every candidate r ε R. The quantizer produces one integer index per dimension and the sum of these indices is used as an approximation of d(q,r). Based on Observation (ii), these quantizers can be very coarse (e.g., 1 or 2 bits per dimension) leading to very low complexity without affecting overall NNS performance. This is because we can afford to quantize coarsely the distance to candidates unlikely to be NN for a given query without affecting the outcome of the NNS. Based on Observation (iii), the problem of finding the optimal query-dependent quantization parameters can be formulated as an off-line optimization process, so that minimum complexity is required for each querying operation.

A QNNM algorithm can use a metric function d_obj to approximate a benchmark metric d in terms of preserving the fidelity of NNS while having significantly lower computational complexity than that of d. A metric approximation approach can be formulated as ψ:U→U_Q mapping the original metric space (U,d) into a simpler metric space (U_Q,d_Q) where NN search is performed with d_Q, metric. If ψ is the same for all queries, this metric space mapping can be seen as a preprocessing (e.g., space transformation to reduce dimensionality) aiming at simplifying the metric space while preserving relative distance between objects. A query-adaptive mapping ψ_q:U→U_Q can use the information of a given query location q such that its resulting (U_Q,d_Q) preserves a NN ouput, rather than relative distance between objects, without having to find the optimal ψ_q prior to each querying process:

$\begin{array}{cc}\left(U,d\right)\stackrel{{\psi }_q}{\to }\left(U_Q,d_Q\right),& \left(2\right)\\ d_{\mathrm{obj}}\left(q,r\right)=d_Q\left({\psi }_q\left(q\right),{\psi }_q\left(r\right)\right).& \left(3\right)\end{array}$

Some implementations can be based on D -dimensional Euclidean space U=R^D.

In some implementations, each dimensional dissimilarity is measured independently and then averaged together. e.g., generalized Minkowski (Euclidean, Manhattan, weighted Minkowski etc) metric, inner product, Canberra metric, etc. For example, It can be assumed that there are no cross-interference among dimensions in original metric d, e.g., general metric function structure d can be written as:

$\begin{array}{cc}d\left(q,r\right)=\sum _{j=1}^Dd_j\left(q_j,r_j\right),r\in U.& \left(4\right)\end{array}$

An NNS algorithm accuracy can be evaluated in terms of the expected solution quality, ε (closeness in terms of d metric between the original NN, r* based on d and a returned object r*_Q based on d_obj metric)

$\begin{array}{cc}\stackrel{\_}{\varepsilon }=E_q\left(\frac{d\left(q,r_Q^{*}\left(q\right)\right)-d\left(q,r^{*}\left(q\right)\right)}{d\left(q,r^{*}\left(q\right)\right)}\right).& \left(5\right)\end{array}$

It can be assumed that there exists a high homogeneity of viewpoints (towards nearest neighbors).

FIG. 9 shows an example of a quantization based on a nearest-neighbor-preserving metric approximation technique. FIG. 9 additionally shows the relation between ψ_q and Q and their related spaces. For a given query q, ψ_q is defined as:

ψ_q(r)=(ψ_q1(r₁),ψ_q2(r₂), . . . , ψ_qD(r_D), r ε U,   (6)

where each ψ_qj is a non-uniform scalar quantizer chosen based on the query. Quantization is chosen due to its computational efficiency and flexibility to adapt to queries by simply adjusting thresholds. Since ψ_q(q) of Eq. (3) is constant over a searching process given q, an objective metric d_obj becomes a function of only ψ_q(r). Based on Eq. (4), d_Q can be formulated to be the sum of scalar quantizer outputs:

$\begin{array}{cc}{d}_{\mathrm{obj}}\left(q,r\right)=d_Q\left({\psi }_q\left(r\right)\right)=\sum _{j=1}^D{\psi }_{\mathrm{qj}}\left(r_j\right).& \left(7\right)\end{array}$

Finding the optimal query-dependent ψ_q parameters minimizing ε (5) prior to each querying operation would not be practical. However, based on the homogeneity of viewpoint property, an off-line optimization can be used to design these query-dependent quantizers. The aggregate statistics of NNS dataset/candidates in terms of their distances with respect to a query q can be very similar regardless of a query/viewpoint position. This allows to consider a viewpoint space (U_v,d_v), where v denotes the vector of distances between a query point and a search point:

v=(d₁(q₁,r₁),d₂(q₂,r₂), . . . , d_D(q_D,r_D))εU_v.   (8)

Then, under the assumption of viewpoint homogeneity, we can generate off-line statistics over multiple queries and model a dataset by the an overall distance distribution F_v of v in U_v:

F _v(x)=Pr(v≦x),   (9)

where F_v represents the probability that there exist objects whose distance v to a given arbitrary query is smaller than x.

Given the query-independent F_v model, instead of directly finding ψ_q:U→U_Q minimizing ε for every q, we could equivalently look for its analogous mapping function Q:U_V→U_VQ such that

d _obj(q,r)=d_Q(ψ_q(r))=d_VQ(Q(v)),   (10)

where Q partitions the viewpoint space U_v into a set of hyper-rectangular cells U_VQ with d_VQ=d_Q. Each dimension of U_V is quantized independently with Q_j with successive bins mapped to consecutive integer values: the bin including the origin is mapped to 0, the next one mapped to 1, etc. Each cell is therefore represented with a vector of mapping symbols z ε U_VQ.

z=Q(v)=(Q₁(v₁),Q₂(v₂), . . . , Q_D(v_D))ε U_VQ.   (11)

The problem of finding the optimal ψ_q can be replaced by finding the optimal Q minimizing ε given F_V because: (i) Q is query-independent which allows off-line process to find optimal Q, (ii) ε of ψ_q:U→U_Q is identical to ε of Q:U_V→U_VQ, and (iii) conversion from Q to ψ_q for a given query q is very simple: once optimal Q minimizing ε is obtained off-line, given a query q prior to each querying operation, optimal ψ_q can be obtained by the following equation:

ψ_qj(r_j)=Q_j(v_j)=(d_j(q_j,r_j)), ∀_j.   (12)

For example, if d is l₂ norm and if we denote a quantization threshold from Q_j and its corresponding threshold from ψ_qj as θ and Θ respectively, then r_j≦Θ should be equivalent to v_j=d_j(q_j,r_j)=(q_j−r_j)² ≦θ, and therefore Θ=q_j±√{square root over (θ)} A set of √{square root over (θ)} needs to be obtained and stored off-line and only prior to each querying process with a given q, a set of Θ=q_j±√{square root over (θ)} need to be computed on the fly. Note that this computation is done only once given a query q before computing any d_obj for all data points to identify q's NN.

FIGS. 10A and 10B show examples of metric computation architectures that include one or more quantizers. The metric computation architecture 1005 in FIG. 10A uses a quantizer to quantize dimension-distance values. The metric computation architecture 1010 in FIG. 10B uses a quantizer to directly quantize canidate points. The quantizers in these architectures 1005, 1010 can be selected based on one or more query points.

An optimization algorithm to select the quantizer Q* that minimizes the average NNS error (5) given F_V as in (9) can have a form:

$\begin{array}{cc}{Q}^{*}=\underset{Q}{\mathrm{argmin}}\left\{f_{\mathrm{obj}}\left(Q\right):=\stackrel{\_}{\varepsilon }\right\}.& \left(13\right)\end{array}$

This problem is a stochastic optimization problem with an objective function f_obj= ε. Note that in this problem we aim to optimize the quantizer to be used in NNS. Thus, in the context of this optimization, we refer to the “search” for the optimal set of quantizer parameters, which should not be confused with the search performed in NNS itself. Optimization process in general consists of two phases: the search process (e.g., generating candidate solutions) and the evaluation process (evaluating solutions, e.g., f_obj computation). Stochastic optimization can be computationally expensive especially due to its evaluation process, e.g., a typical Monte Carlo simulation approach (for every candidate solution, training data samples are simulated to estimate its average performance ε) would have a total complexity of O(TN_s), where T is the size of training data which is sufficiently large and N_s is denoted as the total number of candidate solutions evaluated during the search process.

Our goal is to reduce complexity by formulating f_obj such that a large portion of f_obj computations can be shared and computed only once as a preprocessing step for a certain set of (quantizer) solution points, instead of computing f_obj for each solution point independently. This leads to the total optimization complexity to change from O(TN_s) to O(T+c₁+c₂N_s), where c₁ and c₂ are preprocessing cost and f_obj evaluation cost, respectively. This requires a joint design of the search and evaluation processes.

Since only E[d(q,r_Q*(g))] term of ε (5) changes with Q while E[d(q,r*(g))] is constant given F_V, f_obj can be reduced to:

$\begin{array}{cc}{f}_{\mathrm{obj}}=E\left[d\left(q,r_Q^{*}\left(q\right)\right)\right]=\sum _a{\mu }_Q\left(a\right)f_Q^{\min }\left(a\right),& \left(14\right)\end{array}$

where f_Q^min is the pdf of F_Q^min(a)=Pr(d_obj(q,r_Q*)≦a) and μ_Q(a)=E(d(q,r)|d_obj(q,r)=a,∀q,r εU).

Computing μ_Q and F_Q^min can include assigning three parameters to each cell c z of the set of hyper-rectangular cells defined by Q: (i) probability mass p_z, (ii) non-normalized centroid u z, and (iii) distance d_z=Σz_j. Then F_Q^min and μ_Q(a) are formulated as:

$\begin{array}{cc}{p}_z={\int }_{c_z}f_V\left(v\right)vu_z={\int }_{c_z}<v,1>f_V\left(v\right)v& \left(15\right)\\ F_Q\left(a\right)=\sum _{d_z\le a}p_zF_Q^{\min }\left(a\right)=1-{\left(1-F_Q\left(a\right)\right)}^N& \left(16\right)\\ {\mu }_Q\left(a\right)=\frac{\sum _{d_z=a}u_z}{\sum _{d_z=a}p_z}& \left(17\right)\end{array}$

Implementations can compute f_obj based on p_z, u_z for one or more cells c_z. However, if the following two data sets F_V and H_V are available or computed in a pre-processing stage:

$\begin{array}{cc}{F}_V\left(x\right)=\mathrm{Pr}\left(v\le x\right)H_V\left(x\right)=\sum _{v\le x}<v,1>,& \left(18\right)\end{array}$

then

$\mathrm{Pz}=\sum _{z^{\prime }\le z}p_{z^{\prime }}\mathrm{and}U_z=\sum _{z^{\prime }\le z}u_{z^{\prime }}$

can be easily computed for each cell c_z, so that all necessary p_z, u_z values can be obtained with only c₂=O(DN_c) cost. Here, N_C is total number of cells generated by

$Q·N_C=\prod _j\left(b_j+1\right)$

where b_j denotes the number of thresholds assigned by Q on j-dimension of U_V.

However, the computational (c₁) and storage complexity of F_V and H_V may increase exponentially (e.g., O(DW^D) assuming all dimensions are represented with the same resolution W). In some implementations, D is reducible depending on the input distribution F_V if certain dimensions are independent or interchangeable/commutative. In fact this is usually the case for real-world applications (e.g., for video coding, all pixels tend to be heavily correlated yet interchangeable statistical characteristics thus common 16×16 processing unit image block (D=256) can be reduced to D=1).

A search algorithm can maximally reuse F_V and H_V data and can update F_V and H_V in conjunction with the search process in order to reduce overall storage and computation. Observation: Given k arbitrary solution points on the search space, preprocessing cost S_k to build F_V and H_V containing only necessary data to compute f_obj of those k points is the same as that for computing f_obj of K different solution points which form a grid, where:

$\begin{array}{cc}K=\prod _j\left(\begin{array}{c}\left(k+1\right)b_j\\ b_j\end{array}\right)S_k=\prod _j\left({\mathrm{kb}}_j+1\right).& \left(19\right)\end{array}$

In other words, if a set of solution points form a grid, they maximally reuse data from F_V and H_V and thus lead to minimal preprocessing cost in both space and time complexity. A grid based iterative search algorithm framework with guaranteed convergence to the optimal solution can be based on the above observation. A quantization parameter can be represented by a marginal cumulative probability F_V(θ), such that the search space becomes [0,1]^D. This can facilitate increasing slope, reducing neutrality, ruggedness, or discontinuity of f_obj function, which can increase search speed. This also provides further indication regarding to the sensitivity to performance.

A QNNM algorithm can include (i) generating a grid G_i which equivalently indicates a set of solution points which correspond to all grid points, (ii) building minimum required preprocessed structures F_Vi and H_Vi for computing f_obj of all grid points on G_i, (iii) computing a set of f_obj and finding its minimizer Q_i* of G_i, and (iv) generating a next grid G_i+1 by either moving or scaling G_i based on Q_i* information. Implementations can model a grid G on the search space with its center/location C, grid spacing Δ, and size parameter ω, assuming it has equal spacing and size for all dimensions. Algorithm implementations can initialize a grid-size parameter ω, grid scaling rate γ, tolerance for convergence Δ_tol>0, grid-spacing parameter Δ₀, and initial grid G₀. For each each iteration i=0,1, . . . , the algorithm includes performing a preprocess routine to construct F_Vi and H_{Vi v}to evaluate G_i, a search routine to seek a minimizer Q_i* from G_i, and an update routine to generate a new grid G_i+1 based on Q_i*. The update routine can include moving the center of grid: C_i+1=Q_i*. The update routine can include performing a grid space update, where for a moving grid, if Q_i* is on the boundary of grid G_i, then Δ_i+1=Δ_i, where for a scaling grid, if Q_i* is not on the boundary of grid G_i, then Δ_i+1=Δ_i/γ. The update routine can terminate if Δ_i+1<Δ_tol. The update routine can generate G_i+1: with parameters ω, Δ_i+1, and C_i+1.

Some implementations can determine integer parameter values, w and γ, that minimize computational complexity. Optimization complexity can be quantified as

O(T+Lc₁+Lc₂N_s) c₁=O(Dω^B) c₂=O(DS₁).

Here, N_s depends on phase 2 grid search algorithm but roughly varies from O(ωD) to O(ωc^D). Here, c₁ is both time and space complexity of phase 1. L denotes the total number of iterations. Note that c₂ is fixed regardless of w and γ. Overall complexity can be reduced from O(L(T+c₁+c₂N_s)) to O(T+Lc₁+Lc₂N_s) by splitting and deleting portions of training data set at each iteration such that only relevant data is examined for each update. If we assume to continue iteration until it gets as fine as resolution W, total iteration number is

$L\approx \frac{\gamma }{\omega }{\log }_{\gamma }\frac{W}{w}.$

Therefore, γ≧1 minimizing γ log_γ W and minimum possible integer ω≧2 can minimize overall complexity in both time and space, e.g., γ=3 and ω=2.

FIG. 11 shows an example of a system configured to perform non-uniform quantized based metric computations. A system can include a processing apparatus 1105 and a video capture device 1110. The processing apparatus 1105 can receive video data from the video capture device 1110 and can process the video data. For example, a processing apparatus 1105 can perform motion estimation to compress the video data. A processing apparatus 1105 can include a memory 1120, processor electronics 1125, and one or more input/output (I/O) channel 1130 such as a network interface or a data port such as a Universal Serial Bus (USB). Memory 1120 can include random access memory. Processor electronics 1125 can include one or more processors. In some implementations, processor electronics 1125 can include specialized logic configured to perform quantized based metric computations. An input/output (I/O) channel 1130 can receive data from the video capture device 1110. A processing apparatus 1105 can be implemented in one or more integrated circuits. In some implementations, memory 1120 can store candidate points. In some implementations, memory 1120 can store processor instructions associated with a quantized based metric process.

FIG. 12 shows an example of a process that includes non-uniform quantized based metric computations. The process can access a query point and a set of candidate points (1205).

The process can quantize the candidate points based on one or more characteristics of the query point (1210). The process can generate metric values based on the quantized candidate points (1215). In some implementations, the metric values are indicative of respective proximities between the query point and the candidate points. The process can select one or more of the candidate points in response to the query point based on the metric values (1220).

In some implementations, the precision level of a distance measure can be taken into account for complexity reduction. Some implementations can alter the metric computation precision by compressing the search metric computation resolution through applying non-uniform scalar quantization within the metric computation process. Quantization of the output of a dimension-distance, such as |q_j−r_j|^p, can reduce complexity. Quantization can reduce the bit-depth of each dimension-distance output which leads to a significant complexity reduction in its following process (a tree of k−1 summations and 1/p-th power computation). A quantizer can be implemented in such a way that the input dimension-distance computation |q_j−r_j|^p does not have to be computed at all. In some implementations, the quantizer thresholds are fixed over queries and query vector q is also constant over searching many different candidate points r, thus only r is varying. Therefore r can be quantized directly and have the same result without having to compute |q_j−r_j|^p first and then to apply the quantization.

In some implementations, approximations of one or more quantizers can be used to minimize circuit complexity. Quantization can be query dependent, e.g., each query uses a different quantization. Some implementations can use reconfigurable hardware. For example, some implementations can reconfigure one or more portions of a system before processing a query. Some implementations can use circuitry that takes query q and candidate r as inputs and would approximate the quantization output of the optimized quantizer with minimal circuit complexity.

A few embodiments have been described in detail above, and various modifications are possible. The disclosed subject matter, including the functional operations described in this document, can be implemented in electronic circuitry, computer hardware, firmware, software, or in combinations of them, such as the structural means disclosed in this document and structural equivalents thereof, including potentially a program operable to cause one or more data processing apparatus to perform the operations described (such as a program encoded in a computer storage medium, which can be a memory device, a storage device, a machine-readable storage substrate, or other physical, machine-readable medium, or a combination of one or more of them).

The term “data processing apparatus” encompasses all apparatus, devices, and machines for processing data, including by way of example a programmable processor, a computer, or multiple processors or computers. The apparatus can include, in addition to hardware, code that creates an execution environment for the computer program in question, e.g., code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them.

A program (also known as a computer program, software, software application, script, or code) can be written in any form of programming language, including compiled or interpreted languages, or declarative or procedural languages, and it can be deployed in any form, including as a stand alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A program does not necessarily correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program in question, or in multiple coordinated files (e.g., files that store one or more modules, sub programs, or portions of code). A program can be deployed to be executed on one computer or on multiple computers that are located at one site or distributed across multiple sites and interconnected by a communication network.

While this document contains many specifics, these should not be construed as limitations on the scope of any invention or of what may be claimed, but rather as descriptions of features that may be specific to particular embodiments of particular inventions. Certain features that are described in this document in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination. Moreover, although features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be excised from the combination, and the claimed combination may be directed to a subcombination or variation of a subcombination.

Similarly, while operations are depicted in the drawings in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed, to achieve desirable results.

Only a few implementations and examples are described and other implementations, enhancements and variations can be made based on what is described and illustrated in this document.

Claims

1. A method performed by data processing apparatus, comprising: quantizing a set of candidate points based on one or more characteristics of a query point;generating metric values based on the quantized candidate points, respectively, the metric values being indicative of respective proximities between the query point and the candidate points; andselecting one or more of the candidate points in response to the query point based on the metric values.

2. The method of claim 1, wherein quantizing the candidate points comprises: accessing non-uniform intervals based on the query point, each non-uniform interval being described by one or more threshold values and associated with a range of inputs and an output; andquantizing the candidate points based on non-uniform intervals.

3. The method of claim 2, wherein the query point and the candidate points comprise elements that correspond to respective dimensions, wherein quantizing the candidate points comprises: using different sets of non-uniform intervals, associated with respective different ones of the dimensions, to quantize the dimensional elements of the candidate points, each set of non-uniform intervals selected based on a respective element of the query point.

4. The method of claim 3, wherein generating metric values based on quantized candidate points comprises: summing quantized elements of a quantized candidate point to produce a metric value.

5. The method of claim 1, comprising: determining one or more quantizers that preserve distance ranking between the query point and the candidate points, wherein quantizing the candidate points based on one or more characteristics of the query point comprises using the one or more quantizers.

6. The method of claim 5, wherein quantizing the candidate points based on one or more characteristics of the query point comprises using different quantizers, associated with different dimensions, to quantize elements.

7. The method of claim 5, wherein determining one or more quantizers comprises: determining a number of quantization levels, one or more quantization threshold values, and mapping values for one or more dimensions.

8. The method of claim 1, comprising: determining one or more statistical characteristics of multiple, related, query points, wherein the query points comprise elements that correspond to respective dimensions; anddetermining one or more quantizers based on the one or more statistical characteristics, each quantizer corresponding to at least one of the dimensions and operable to generate a quantized output based on an input.

9. The method of claim 8, wherein quantizing the candidate points based on one or more characteristics of the query point comprises using the one or more quantizers.

10. The method of claim 8, wherein determining one or more quantizers comprises determining a quantizer that maps successive bins of input values to respective integer values.

11. The method of claim 8, wherein determining one or more quantizers comprises determining threshold values that delineate non-uniform quantization intervals based on an iterative process that minimizes a nearest neighbor search measure.

12. The method of claim 1, comprising: performing motion estimation based on information comprising the selected one or more candidate points.

13. A method performed by data processing apparatus, comprising: accessing a set of candidate points from a memory; andoperating processor electronics to perform operations based on the set of candidate points with respect to a query point to produce values being indicative of respective proximities between the query point and the candidate points, and use the values to determine a nearest neighbor point from the set of candidate points, wherein the computations include applying non-uniform quantizations based on one or more characteristics of the query point.

14. The method of claim 13, wherein applying non-uniform quantizations comprises quantizing the candidate points based on non-uniform intervals, wherein the non-uniform intervals are described by a set of threshold values that are based on the query point, wherein each one of the quantized candidate points comprises quantized elements corresponding to a plurality of dimensions.

15. The method of claim 14, wherein operating processor electronics to perform operations comprises operating processor electronics to sum quantized elements of a corresponding one of the quantized candidate points to produce a corresponding one of the values.

16. The method of claim 14, wherein the query point comprises elements corresponding to a plurality of dimensions, wherein each one of the candidate points comprises elements corresponding to the plurality of dimensions, wherein operating processor electronics to perform operations comprises operating processor electronics to generate, for two or more of the dimensions, a partial distance term that is indicative of a distance between corresponding elements of the query point and each one of the candidate points.

17. The method of claim 16, wherein operating processor electronics to perform operations comprises operating processor electronics to quantize the partial distance terms based on the non-uniform intervals.

18. The method of claim 17, wherein operating processor electronics to perform operations comprises operating processor electronics to determine a metric value based on a summation of the quantized partial distance terms associated with the each one of the candidate points.

19. The method of claim 17, wherein the partial distance terms respectively comprise dimension-distance terms, wherein the quantizing reduces a bit-depth of each dimension-distance term.

20. A computer storage medium encoded with a computer program, the program comprising instructions that when executed by data processing apparatus cause the data processing apparatus to perform operations comprising: quantizing a set of candidate points based on one or more characteristics of a query point;generating metric values based on the quantized candidate points, respectively, the metric values being indicative of respective proximities between the query point and the candidate points; andselecting one or more of the candidate points in response to the query point based on the metric values.

21. The medium of claim 20, wherein quantizing the candidate points comprises: accessing non-uniform intervals based on the query point, each non-uniform interval being described by one or more threshold values and associated with a range of inputs and an output; andquantizing the candidate points based on non-uniform intervals.

22. The medium of claim 21, wherein the query point and the candidate points comprise elements that correspond to respective dimensions, wherein quantizing the candidate points comprises: using different sets of non-uniform intervals, associated with respective different ones of the dimensions, to quantize the dimensional elements of the candidate points, each set of non-uniform intervals selected based on a respective element of the query point.

23. The medium of claim 22, wherein generating metric values based on quantized candidate points comprises: summing quantized elements of a quantized candidate point to produce a metric value.

24. The medium of claim 20, wherein the operations comprise: determining one or more quantizers that preserve distance ranking between the query point and the candidate points, wherein quantizing the candidate points based on one or more characteristics of the query point comprises using the one or more quantizers.

25. The medium of claim 24, wherein quantizing the candidate points based on one or more characteristics of the query point comprises using different quantizers, associated with different dimensions, to quantize elements.

26. The medium of claim 24, wherein determining one or more quantizers comprises: determining a number of quantization levels, one or more quantization threshold values, and mapping values for one or more dimensions.

27. The medium of claim 20, wherein the operations comprise: determining one or more statistical characteristics of multiple, related, query points, wherein the query points comprise elements that correspond to respective dimensions; anddetermining one or more quantizers based on the one or more statistical characteristics, each quantizer corresponding to at least one of the dimensions and operable to generate a quantized output based on an input.

28. The medium of claim 27, wherein quantizing the candidate points based on one or more characteristics of the query point comprises using the one or more quantizers.

29. The medium of claim 27, wherein determining one or more quantizers comprises determining a quantizer that maps successive bins of input values to respective integer values.

30. The medium of claim 27, wherein determining one or more quantizers comprises determining threshold values that delineate non-uniform quantization intervals based on an iterative process that minimizes a nearest neighbor search measure.

31. The medium of claim 20, wherein the operations comprise: performing motion estimation based on information comprising the outputted one or more candidate points.

32. A system, comprising: a memory configured to store data points, wherein the data points comprise elements that correspond to respective dimensions; andprocessor electronics configured to access a query point, use one or more of the data points as candidate points, use one or more quantizers to quantize the candidate points based on one or more characteristics of the query point, generate metric values based on the quantized candidate points, respectively, the metric values being indicative of respective proximities between the query point and the candidate points, select one or more of the candidate points, based on the metric values, as an output to the query point.

33. The system of claim 32, wherein the processor electronics are configured to access non-uniform intervals based on the query point, each non-uniform interval being described by one or more threshold values and associated with a range of inputs and an output, and quantize the candidate points based on non-uniform intervals.

34. The system of claim 33, wherein the query point and the candidate points comprise elements that correspond to respective dimensions, wherein the processor electronics are configured to use different sets of non-uniform intervals, associated with respective different ones of the dimensions, to quantize the dimensional elements of the candidate points, each set of non-uniform intervals selected based on a respective element of the query point.

35. The system of claim 34, wherein the processor electronics are configured to sum quantized elements of a quantized candidate point to produce a metric value.

36. The system of claim 32, wherein the processor electronics are configured to determine the one or more quantizers to preserve distance ranking between the query point and the candidate points.

37. The system of claim 36, wherein the processor electronics are configured to use different quantizers, associated with different dimensions, to quantize elements.

38. The system of claim 36, wherein determining the one or more quantizers comprises determining a number of quantization levels, one or more quantization threshold values, and mapping values for one or more dimensions.

39. The system of claim 32, wherein the processor electronics are configured to determine one or more statistical characteristics of multiple, related, query points, wherein the query points comprise elements that correspond to respective dimensions and determine one or more quantizers based on the one or more statistical characteristics, each quantizer corresponding to at least one of the dimensions and operable to generate a quantized output based on an input.

40. The system of claim 39, wherein determining the one or more quantizers comprises determining a quantizer that maps successive bins of input values to respective integer values.

41. The system of claim 39, wherein determining the one or more quantizers comprises determining threshold values that delineate non-uniform quantization intervals based on an iterative process that minimizes a nearest neighbor search measure.

42. The system of claim 32, wherein the processor electronics are configured to perform motion estimation based on information comprising the outputted one or more candidate points.