Funciones de distancia

Introducido en: v21.11.0

Calcula la distancia entre dos puntos (los elementos de los vectores son las coordenadas) en el espacio L1 (norma 1 (distancia de la geometría del taxista)).

Sintaxis

L1Distance(vector1, vector2)

Alias: distanceL1

Argumentos

• vector1 — Primer vector. Tuple(T) o Array(T)
• vector2 — Segundo vector. Tuple(T) o Array(T)

Valor devuelto

Devuelve la distancia de norma 1. Para entradas Array, devuelve Float32 si el supertipo común más específico de los tipos de elemento es Float32 o BFloat16; de lo contrario, Float64. Para entradas Tuple, el tipo de retorno sigue el tipo de resultado aritmético de las operaciones elemento a elemento (los tipos enteros se conservan). (U)Int* o Float*

Ejemplos

Uso básico

SELECT L1Distance((1, 2), (2, 3))

┌─L1Distance((1, 2), (2, 3))─┐
│                          2 │
└────────────────────────────┘

Introducido en: v21.11.0

Calcula la suma de los valores absolutos de los elementos de un vector.

Sintaxis

L1Norm(vector)

Alias: normL1

Argumentos

• vector — Vector o tupla de valores numéricos. Array(T) o Tuple(T)

Valor devuelto

Devuelve la norma L1 o la distancia de la geometría del taxista. UInt* o Float* o Decimal

Ejemplos

Uso básico

SELECT L1Norm((1, 2))

┌─L1Norm((1, 2))─┐
│              3 │
└────────────────┘

Introducido en: v21.11.0

Calcula el vector unitario de un vector dado (los elementos de la tupla o matriz representan las coordenadas) en el espacio L1 (geometría del taxista).

Sintaxis

L1Normalize(vector)

Aliases: normalizeL1

Argumentos

• vector — Una tupla o un array de valores numéricos. Tuple(T) o Array(T)

Valor devuelto

Devuelve el vector unitario. Para las entradas Array, devuelve Array(Float32) si el supertipo común mínimo de los tipos de los elementos es Float32 o BFloat16; de lo contrario, devuelve Array(Float64). Para las entradas Tuple, siempre devuelve Tuple(Float64). Tuple(Float64) o Array(Float32) o Array(Float64)

Ejemplos

Uso básico

SELECT L1Normalize((1, 2))

┌─L1Normalize((1, 2))─────────────────────┐
│ (0.3333333333333333,0.6666666666666666) │
└─────────────────────────────────────────┘

Introducido en: v21.11.0

Calcula la distancia entre dos puntos (los elementos de los vectores son las coordenadas) en el espacio euclidiano (distancia euclidiana).

Sintaxis

L2Distance(vector1, vector2)

Aliases: distanceL2

Argumentos

• vector1 — Primer vector. Tuple(T) o Array(T)
• vector2 — Segundo vector. Tuple(T) o Array(T)

Valor devuelto

Devuelve la distancia L2. Para entradas Array, devuelve Float32 si el supertipo común mínimo de los tipos de elemento es Float32 o BFloat16; en caso contrario, Float64. Para entradas Tuple, siempre devuelve Float64. Float*

Ejemplos

Uso básico

SELECT L2Distance((1, 2), (2, 3))

┌─L2Distance((1, 2), (2, 3))─┐
│         1.4142135623730951 │
└────────────────────────────┘

Introducido en: v25.10.0

Calcula la distancia aproximada entre dos puntos (los valores de los vectores corresponden a las coordenadas) en el espacio euclidiano (distancia euclidiana).

Sintaxis

L2DistanceTransposed(vector1, vector2, p[, used_dims])

Alias: distanceL2Transposed

Argumentos

• vectors — Vectores. QBit(T, UInt64[, UInt64])
• reference — Vector de referencia. Array(T)
• p — Número de bits de cada elemento del vector que se usarán en el cálculo de la distancia (de 1 hasta el ancho de bits del elemento). El nivel de cuantización controla el equilibrio entre precisión y velocidad. Usar menos bits da lugar a operaciones de E/S y cálculos más rápidos, pero con menor exactitud, mientras que usar más bits aumenta la exactitud a costa del rendimiento. UInt
• used_dims — Opcional. Número de dimensiones iniciales que se leerán para una búsqueda de dimensión reducida (Matryoshka) en un QBit con stride. Debe ser un múltiplo del stride de QBit que no exceda su dimensión, y el vector de referencia debe tener al menos esa cantidad de elementos (los elementos adicionales al final se ignoran). Solo se leen los grupos de stride que cubren estas dimensiones. UInt

Valor devuelto

Devuelve la distancia L2 aproximada. Siempre devuelve Float64. Float64

Ejemplos

Uso básico

CREATE TABLE qbit (id UInt32, vec QBit(Float64, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, [0, 1]);
SELECT L2DistanceTransposed(vec, array(1, 2), 16) FROM qbit;

┌─L2DistanceTransposed(vec, [1, 2], 16)─┐
│                    1.3922918381215914 │
└───────────────────────────────────────┘

Introducido en: v26.7.0

Calcula la distancia euclidiana aproximada entre un QBit(Int8) de códigos quantizeBFloat16ToInt8 (descuantizados sobre la marcha) y un vector de referencia. Un vector de referencia (consulta) Float se compara directamente con precisión Float32 –la precisión de reconstrucción de los códigos descuantizados–, por lo que una consulta Float64 se reduce a Float32, mientras que una consulta BFloat16 se amplía a este exactamente (cálculo de distancia asimétrico); una referencia Array(Int8) se trata, a su vez, como códigos quantizeBFloat16ToInt8 y se descuantiza a sus niveles de reconstrucción. Tenga en cuenta que p trunca solo los códigos QBit almacenados; la referencia Array(Int8) es una consulta completa y siempre se reconstruye con precisión completa de 8 bits, por lo que esta es una distancia simétrica entre cuantizado y cuantizado solo cuando p = 8 (para p < 8, solo el lado almacenado se lee con una precisión más baja). Debe estar en el mismo espacio en el que estaban los valores antes de la cuantización (es decir, después de la misma rotación aleatoria y el mismo escalado), lo cual es responsabilidad del llamador. La distancia de coseno es invariante a la escala; el producto escalar y la distancia L2 no lo son.

Sintaxis

L2DistanceTransposedQuantized(vectors, reference, p[, used_dims])

Argumentos

• vectors — Vectores de códigos quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — Vector de referencia (consulta): un array Float (la consulta, comparada con precisión Float32 – una consulta Float64 se reduce a Float32), o un Array(Int8) de códigos quantizeBFloat16ToInt8 descuantizados sobre la marcha. Array(Float32) o Array(Int8)
• p — Número de bits superiores de cada código QBit almacenado que se usarán (de 1 a 8). Menos bits reconstruyen un cuantizador embebido más grueso utilizando los centroides de media condicional gaussiana de los intervalos de prefijo Lloyd-Max existentes, para una E/S más rápida con menor exactitud; 8 bits es la reconstrucción con precisión completa. p solo trunca el QBit almacenado; una referencia Array(Int8) siempre se reconstruye con precisión completa de 8 bits. UInt
• used_dims — Opcional. Número de dimensiones iniciales que se leerán para una búsqueda de dimensión reducida (Matryoshka) en un QBit con stride. Debe ser un múltiplo del stride de QBit que no exceda su dimensión, y el vector de referencia debe tener al menos esa cantidad de elementos (cualquier elemento adicional al final se ignora). Solo se leen los grupos de stride que cubren estas dimensiones. UInt

Valor devuelto

Devuelve la distancia L2 aproximada. Siempre devuelve Float64. Float64

Ejemplos

Uso básico

CREATE TABLE qbit (id UInt32, vec QBit(Int8, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, arrayMap(x -> quantizeBFloat16ToInt8(x), [0.1, -0.5]::Array(BFloat16)));
SELECT L2DistanceTransposedQuantized(vec, [0.1, -0.5]::Array(Float32), 8) FROM qbit;

┌─L2DistanceTransposedQuantized(vec, CAST('[0.1, -0.5]', 'Array(Float32)'), 8)─┐
│                                                         0.004942022755037076 │
└──────────────────────────────────────────────────────────────────────────────┘

Introducida en: v21.11.0

Calcula la raíz cuadrada de la suma de los cuadrados de los elementos de un vector.

Sintaxis

L2Norm(vector)

Alias: normL2

Argumentos

• vector — Vector o tupla de valores numéricos. Tuple(T) o Array(T)

Valor devuelto

Devuelve la norma L2 o la distancia euclidiana. UInt* o Float*

Ejemplos

Uso básico

SELECT L2Norm((1, 2))

┌───L2Norm((1, 2))─┐
│ 2.23606797749979 │
└──────────────────┘

Introducido en: v21.11.0

Calcula el vector unitario de un vector determinado (los elementos de la tupla o el array son las coordenadas) en el espacio euclidiano (mediante la distancia euclidiana).

Sintaxis

L2Normalize(vector)

Alias: normalizeL2

Argumentos

• vector — Una tupla o un array de valores numéricos. Tuple(T) o Array(T)

Valor devuelto

Devuelve el vector unitario. Para entradas de tipo Array, devuelve Array(Float32) si el supertipo común mínimo de los tipos de los elementos es Float32 o BFloat16; de lo contrario, devuelve Array(Float64). Para entradas de tipo Tuple, siempre devuelve Tuple(Float64). Tuple(Float64) o Array(Float32) o Array(Float64)

Ejemplos

Uso básico

SELECT L2Normalize((3, 4))

┌─L2Normalize((3, 4))─┐
│ (0.6,0.8)           │
└─────────────────────┘

Introducida en: v22.7.0

Calcula la suma de los cuadrados de las diferencias entre los elementos correspondientes de dos vectores.

Sintaxis

L2SquaredDistance(vector1, vector2)

Alias: distanceL2Squared

Argumentos

• vector1 — Primer vector. Tuple(T) o Array(T)
• vector2 — Segundo vector. Tuple(T) o Array(T)

Valor devuelto

Devuelve la suma de los cuadrados de las diferencias entre los elementos correspondientes de dos vectores. Para entradas Array, devuelve Float32 si el supertipo común mínimo de los tipos de elemento es Float32 o BFloat16; de lo contrario, Float64. Para entradas Tuple, el tipo de retorno sigue el tipo de resultado aritmético de las operaciones elemento a elemento (se conservan los tipos enteros). (U)Int* o Float*

Ejemplos

Uso básico

SELECT L2SquaredDistance([1, 2, 3], [0, 0, 0])

┌─L2SquaredDistance([1, 2, 3], [0, 0, 0])─┐
│                                      14 │
└─────────────────────────────────────────┘

Introducido en: v22.7.0

Calcula el cuadrado de la raíz cuadrada de la suma de los cuadrados de los elementos del vector (la L2Norm).

Sintaxis

L2SquaredNorm(vector)

Alias: normL2Squared

Argumentos

• vector — Vector o tupla de valores numéricos. Array(T) o Tuple(T)

Valor devuelto

Devuelve la norma L2 al cuadrado. UInt* o Float* o Decimal

Ejemplos

Uso básico

SELECT L2SquaredNorm((1, 2))

┌─L2SquaredNorm((1, 2))─┐
│                     5 │
└───────────────────────┘

Introducido en: v21.11.0

Calcula la distancia entre dos puntos (los elementos de los vectores son las coordenadas) en el espacio L_{inf} (norma máxima).

Sintaxis

LinfDistance(vector1, vector2)

Alias: distanceLinf

Argumentos

• vector1 — Primer vector. Tuple(T) o Array(T)
• vector2 — Segundo vector. Tuple(T) o Array(T)

Valor devuelto

Devuelve la distancia en norma infinito. Para entradas Array, devuelve Float32 si el supertipo común mínimo de los tipos de los elementos es Float32 o BFloat16; de lo contrario, Float64. Para entradas Tuple, siempre devuelve Float64. Float*

Ejemplos

Uso básico

SELECT LinfDistance((1, 2), (2, 3))

┌─LinfDistance((1, 2), (2, 3))─┐
│                            1 │
└──────────────────────────────┘

Introducido en: v21.11.0

Calcula el valor máximo absoluto de los elementos de un vector.

Sintaxis

LinfNorm(vector)

Alias: normLinf

Argumentos

• vector — Vector o tupla de valores numéricos. Array(T) o Tuple(T)

Valor devuelto

Devuelve la norma Linf, es decir, el valor absoluto máximo. Float64

Ejemplos

Uso básico

SELECT LinfNorm((1, -2))

┌─LinfNorm((1, -2))─┐
│                 2 │
└───────────────────┘

Introducido en: v21.11.0

Calcula el vector unitario de un vector dado (los elementos de la tupla o el array son las coordenadas) en el espacio L_{inf} (utilizando la norma máxima).

Sintaxis

LinfNormalize(vector)

Alias: normalizeLinf

Argumentos

• vector — Una tupla o un array de valores numéricos. Tuple(T) o Array(T)

Valor devuelto

Devuelve el vector unitario. Para entradas Array, devuelve Array(Float32) si el supertipo común mínimo de los tipos de elementos es Float32 o BFloat16; de lo contrario, devuelve Array(Float64). Para entradas Tuple, siempre devuelve Tuple(Float64). Tuple(Float64) o Array(Float32) o Array(Float64)

Ejemplos

Uso básico

SELECT LinfNormalize((3, 4))

┌─LinfNormalize((3, 4))─┐
│ (0.75,1)              │
└───────────────────────┘

Introducido en: v21.11.0

Calcula la distancia entre dos puntos (los elementos de los vectores son las coordenadas) en el espacio Lp (distancia según la norma p).

Sintaxis

LpDistance(vector1, vector2, p)

Alias: distanceLp

Argumentos

• vector1 — Primer vector. Tuple(T) o Array(T)
• vector2 — Segundo vector. Tuple(T) o Array(T)
• p — La potencia. Valores posibles: número real en [1; inf). UInt* o Int* o Float*

Valor devuelto

Devuelve la distancia de norma p. Para entradas Array, devuelve Float32 si el supertipo común mínimo de los tipos de elemento es Float32 o BFloat16; de lo contrario, Float64. Para entradas Tuple, siempre devuelve Float64. Float*

Ejemplos

Uso básico

SELECT LpDistance((1, 2), (2, 3), 3)

┌─LpDistance((1, 2), (2, 3), 3)─┐
│            1.2599210498948732 │
└───────────────────────────────┘

Introducido en: v21.11.0

Calcula la norma p de un vector, que es la raíz p-ésima de la suma de las potencias p-ésimas de los valores absolutos de cada uno de sus elementos.

Casos especiales:

• Cuando p=1, es equivalente a L1Norm (distancia de Manhattan).
• Cuando p=2, es equivalente a L2Norm (distancia euclidiana).
• El valor de p debe ser un número finito no menor que uno; para la norma máxima (el límite cuando p→∞), use LinfNorm.

Sintaxis

LpNorm(vector, p)

Alias: normLp

Argumentos

• vector — Vector o tupla de valores numéricos. Tuple(T) o Array(T)
• p — La potencia. Los valores posibles son números reales en el intervalo [1; inf). UInt* o Int* o Float*

Valor devuelto

Devuelve la norma p. Float64

Ejemplos

Uso básico

SELECT LpNorm((1, -2), 2)

┌─LpNorm((1, -2), 2)─┐
│   2.23606797749979 │
└────────────────────┘

Introducido en: v21.11.0

Calcula el vector unitario de un vector dado (los elementos de la tupla o el array son las coordenadas) en el espacio Lp (mediante la norma p).

Sintaxis

LpNormalize(vector, p)

Alias: normalizeLp

Argumentos

• vector — Una tupla o un array de valores numéricos. Tuple(T) o Array(T)
• p — La potencia. Los valores posibles son números reales en el intervalo [1; inf). UInt* o Int* o Float*

Valor devuelto

Devuelve el vector unitario. Para entradas de tipo Array, devuelve Array(Float32) si el mínimo supertipo común de los tipos de elemento es Float32 o BFloat16; de lo contrario, devuelve Array(Float64). Para entradas de tipo Tuple, siempre devuelve Tuple(Float64). Tuple(Float64) o Array(Float32) o Array(Float64)

Ejemplos

Ejemplo de uso

SELECT LpNormalize((3, 4), 5)

┌─LpNormalize((3, 4), 5)──────────────────┐
│ (0.7187302630182624,0.9583070173576831) │
└─────────────────────────────────────────┘

Introducido en: v21.11.0

Calcula la distancia de coseno entre dos vectores (los elementos de las tuplas son las coordenadas). Cuanto menor sea el valor devuelto, más similares serán los vectores.

Sintaxis

cosineDistance(vector1, vector2)

Alias: distanceCosine

Argumentos

• vector1 — Primera tupla. Tuple(T) o Array(T)
• vector2 — Segunda tupla. Tuple(T) o Array(T)

Valor devuelto

Devuelve la distancia de coseno (uno menos la similitud coseno). Para entradas de tipo Array, devuelve Float32 si el supertipo común de los tipos de elemento es Float32 o BFloat16; en caso contrario, Float64. Para entradas de tipo Tuple, siempre devuelve Float64. Float*

Ejemplos

Uso básico

SELECT cosineDistance((1, 2), (2, 3));

┌─cosineDistance((1, 2), (2, 3))─┐
│           0.007722123286332261 │
└────────────────────────────────┘

Introducido en: v26.1.0

Calcula la distancia de coseno aproximada entre dos puntos (los valores de los vectores son las coordenadas). Cuanto menor sea el valor devuelto, más similares serán los vectores.

Sintaxis

cosineDistanceTransposed(vector1, vector2, p[, used_dims])

Alias: distanceCosineTransposed

Argumentos

• vectors — Vectores. QBit(T, UInt64[, UInt64])
• reference — Vector de referencia. Array(T)
• p — Número de bits de cada elemento del vector que se usarán en el cálculo de la distancia (de 1 al ancho de bits del elemento). El nivel de cuantización controla el equilibrio entre precisión y velocidad. Usar menos bits da lugar a E/S y cálculos más rápidos, pero con menor exactitud, mientras que usar más bits aumenta la exactitud a costa del rendimiento. UInt
• used_dims — Opcional. Número de dimensiones iniciales que se leerán para una búsqueda de dimensión reducida (Matryoshka) en un QBit con stride. Debe ser un múltiplo del stride de QBit que no supere su dimensión, y el vector de referencia debe tener al menos esa cantidad de elementos (se ignoran los elementos adicionales al final). Solo se leen los grupos de stride que cubren estas dimensiones. UInt

Valor devuelto

Devuelve la distancia de coseno aproximada (uno menos la similitud coseno). Siempre devuelve Float64. Float64

Ejemplos

Uso básico

CREATE TABLE qbit (id UInt32, vec QBit(Float64, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, [0, 1]);
SELECT cosineDistanceTransposed(vec, array(1, 2), 16) FROM qbit;

┌─cosineDistanceTransposed(vec, [1, 2], 16)─┐
│                       0.10557280905788935 │
└───────────────────────────────────────────┘

Introducido en: v26.7.0

Calcula la distancia de coseno aproximada entre un QBit(Int8) de códigos quantizeBFloat16ToInt8 (descuantizados sobre la marcha) y un vector de referencia. Cuanto menor sea el valor devuelto, más similares serán los vectores. Un vector de referencia (de consulta) Float se compara directamente con precisión Float32 –la precisión de reconstrucción de los códigos descuantizados–, por lo que una consulta Float64 se reduce a Float32, mientras que una consulta BFloat16 se amplía exactamente a este formato (cálculo de distancia asimétrico); una referencia Array(Int8) se trata, a su vez, como códigos quantizeBFloat16ToInt8 y se descuantiza a sus niveles de reconstrucción. Tenga en cuenta que p trunca solo los códigos QBit almacenados; la referencia Array(Int8) es en sí misma una consulta completa y siempre se reconstruye con la precisión completa de 8 bits, por lo que esta es una distancia simétrica entre cuantizado y cuantizado solo cuando p = 8 (para p < 8, solo el lado almacenado se lee con una precisión más baja). Debe estar en el mismo espacio en el que estaban los valores antes de la cuantización (es decir, después de la misma rotación aleatoria y el mismo escalado), lo cual es responsabilidad del llamador. La distancia de coseno es invariante a la escala; el producto escalar y la distancia L2 no lo son.

Sintaxis

cosineDistanceTransposedQuantized(vectors, reference, p[, used_dims])

Argumentos

• vectors — Vectores de códigos quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — Vector de referencia (consulta): un array de Float (la consulta, comparada con precisión Float32 – una consulta Float64 se reduce a Float32), o un Array(Int8) de códigos quantizeBFloat16ToInt8 descuantizados sobre la marcha. Array(Float32) o Array(Int8)
• p — Número de bits superiores de cada código QBit almacenado que se usarán (de 1 a 8). Menos bits reconstruyen un cuantizador embebido más grueso mediante los centroides de media condicional gaussiana de los intervalos de prefijo Lloyd-Max existentes, para obtener una E/S más rápida con menor exactitud; 8 bits corresponden a la reconstrucción de precisión completa. p trunca solo el QBit almacenado; una referencia Array(Int8) siempre se reconstruye con precisión completa de 8 bits. UInt
• used_dims — Opcional. Número de dimensiones iniciales que se leerán, para una búsqueda de dimensión reducida (Matryoshka) en un QBit con stride. Debe ser un múltiplo del stride de QBit que no supere su dimensión, y el vector de referencia debe tener al menos esta cantidad de elementos (cualquier elemento adicional al final se ignora). Solo se leen los grupos de stride que cubren estas dimensiones. UInt

Valor devuelto

Devuelve la distancia de coseno aproximada (uno menos la similitud coseno). Siempre devuelve Float64. Float64

Ejemplos

Uso básico

CREATE TABLE qbit (id UInt32, vec QBit(Int8, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, arrayMap(x -> quantizeBFloat16ToInt8(x), [0.1, -0.5]::Array(BFloat16)));
SELECT cosineDistanceTransposedQuantized(vec, [0.1, -0.5]::Array(Float32), 8) FROM qbit;

┌─cosineDistanceTransposedQuantized(vec, CAST('[0.1, -0.5]', 'Array(Float32)'), 8)─┐
│                                                          0.000027192636379513857 │
└──────────────────────────────────────────────────────────────────────────────────┘

Introducido en: v26.7.0

Calcula el producto escalar aproximado (producto interno) de dos vectores (los valores de los vectores son las coordenadas). A diferencia de las funciones de distancia, esta es una medida de similitud: cuanto mayor sea el valor devuelto, más similares serán los vectores.

Sintaxis

dotProductTransposed(vector1, vector2, p[, used_dims])

Alias: scalarProductTransposed

Argumentos

• vectors — Vectores. QBit(T, UInt64[, UInt64])
• reference — Vector de referencia. Array(T)
• p — Número de bits de cada elemento del vector que se usarán en el cálculo (de 1 al ancho de bits del elemento). El nivel de cuantización controla el equilibrio entre precisión y velocidad. Usar menos bits da lugar a E/S y cálculos más rápidos, pero con menor exactitud, mientras que usar más bits aumenta la exactitud a costa del rendimiento. UInt
• used_dims — Opcional. Número de dimensiones iniciales que se leerán, para una búsqueda de dimensión reducida (Matryoshka) en un QBit con stride. Debe ser un múltiplo del stride de QBit que no exceda su dimensión, y el vector de referencia debe tener al menos esa cantidad de elementos (se ignoran los elementos adicionales al final). Solo se leen los grupos de stride que cubren estas dimensiones. UInt

Valor devuelto

Devuelve el producto escalar aproximado de los dos vectores. Siempre devuelve Float64. Float64

Ejemplos

Uso básico

CREATE TABLE qbit (id UInt32, vec QBit(Float64, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, [0, 1]);
SELECT dotProductTransposed(vec, array(1, 2), 16) FROM qbit;

┌─dotProductTransposed(vec, [1, 2], 16)─┐
│                                2.0625 │
└───────────────────────────────────────┘

Introducido en: v26.7.0

Calcula el producto escalar aproximado (producto interno) entre un QBit(Int8) de códigos quantizeBFloat16ToInt8 (descuantizados sobre la marcha) y un vector de referencia. Esta es una medida de similitud: cuanto mayor sea el valor devuelto, más similares serán los vectores. Un vector de referencia (consulta) Float se compara directamente con precisión Float32 – la precisión de reconstrucción de los códigos descuantizados, por lo que una consulta Float64 se reduce a Float32, mientras que una consulta BFloat16 se amplía exactamente a esa precisión (cálculo asimétrico de la distancia); una referencia Array(Int8) se trata como códigos quantizeBFloat16ToInt8 y se descuantiza a sus niveles de reconstrucción. Tenga en cuenta que p trunca solo los códigos QBit almacenados; la referencia Array(Int8) es en sí misma una consulta completa y siempre se reconstruye con la precisión completa de 8 bits, por lo que esta es una distancia simétrica entre cuantizado y cuantizado solo cuando p = 8 (para p < 8, solo el lado almacenado se lee con una precisión más baja). Debe estar en el mismo espacio en el que estaban los valores antes de la cuantización (es decir, después de la misma rotación aleatoria y el mismo escalado), lo cual es responsabilidad del llamador. La distancia de coseno es invariante a la escala; el producto escalar y la distancia L2 no lo son.

Sintaxis

dotProductTransposedQuantized(vectors, reference, p[, used_dims])

Argumentos

• vectors — Vectores de códigos quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — Vector de referencia (consulta): un array de Float (la consulta, comparada con precisión Float32 – una consulta Float64 se convierte a Float32), o un Array(Int8) de códigos quantizeBFloat16ToInt8 descuantizados sobre la marcha. Array(Float32) o Array(Int8)
• p — Número de bits superiores de cada código QBit almacenado que se usarán (de 1 a 8). Menos bits reconstruyen un cuantizador embebido más grueso utilizando los centroides de media condicional gaussiana de los intervalos de prefijo Lloyd-Max existentes, para una E/S más rápida con menor exactitud; 8 bits es la reconstrucción de precisión completa. p trunca solo el QBit almacenado; una referencia Array(Int8) siempre se reconstruuye con precisión completa de 8 bits. UInt
• used_dims — Opcional. Número de dimensiones iniciales que se leerán, para una búsqueda de dimensión reducida (Matryoshka) en un QBit con stride. Debe ser un múltiplo del stride de QBit que no exceda su dimensión, y el vector de referencia debe tener al menos esa cantidad de elementos (se ignoran los elementos adicionales al final). Solo se leen los grupos de stride que cubren estas dimensiones. UInt

Valor devuelto

Devuelve el producto escalar aproximado de los dos vectores. Siempre devuelve Float64. Float64

Ejemplos

Uso básico

CREATE TABLE qbit (id UInt32, vec QBit(Int8, 2)) ENGINE = Memory;
INSERT INTO qbit VALUES (1, arrayMap(x -> quantizeBFloat16ToInt8(x), [0.1, -0.5]::Array(BFloat16)));
SELECT dotProductTransposedQuantized(vec, [0.1, -0.5]::Array(Float32), 8) FROM qbit;

┌─dotProductTransposedQuantized(vec, CAST('[0.1, -0.5]', 'Array(Float32)'), 8)─┐
│                                                          0.25834959745407104 │
└──────────────────────────────────────────────────────────────────────────────┘