Funções de distância

Introduzido em: v21.11.0

Calcula a distância entre dois pontos (os elementos dos vetores são as coordenadas) no espaço L1 (norma 1 (distância da geometria do táxi)).

Sintaxe

L1Distance(vector1, vector2)

Aliases: distanceL1

Argumentos

• vector1 — Primeiro vetor. Tuple(T) ou Array(T)
• vector2 — Segundo vetor. Tuple(T) ou Array(T)

Valor retornado

Retorna a distância L1. Para entradas Array, retorna Float32 se o menor supertipo comum dos tipos de elemento for Float32 ou BFloat16; caso contrário, Float64. Para entradas Tuple, o tipo de retorno segue o tipo de resultado aritmético das operações elemento a elemento (os tipos inteiros são preservados). (U)Int* ou Float*

Exemplos

Uso básico

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

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

Introduzido na versão: v21.11.0

Calcula a soma dos valores absolutos dos elementos de um vetor.

Sintaxe

L1Norm(vector)

Aliases: normL1

Argumentos

• vector — Vetor ou tupla de valores numéricos. Array(T) ou Tuple(T)

Valor retornado

Retorna a norma L1 ou a distância em geometria do táxi. UInt* ou Float* ou Decimal

Exemplos

Uso básico

SELECT L1Norm((1, 2))

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

Introduzido em: v21.11.0

Calcula o vetor unitário de um dado vetor (os elementos da tupla ou do array são as coordenadas) no espaço L1 (geometria do táxi).

Sintaxe

L1Normalize(vector)

Aliases: normalizeL1

Argumentos

• vector — Uma tupla ou array de valores numéricos. Tuple(T) ou Array(T)

Valor retornado

Retorna o vetor unitário. Para entradas Array, retorna Array(Float32) se o menor supertipo comum dos tipos de elemento for Float32 ou BFloat16; caso contrário, Array(Float64). Para entradas Tuple, sempre retorna Tuple(Float64). Tuple(Float64) ou Array(Float32) ou Array(Float64)

Exemplos

Uso básico

SELECT L1Normalize((1, 2))

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

Introduzido em: v21.11.0

Calcula a distância entre dois pontos (os elementos dos vetores são as coordenadas) no espaço euclidiano (distância euclidiana).

Sintaxe

L2Distance(vector1, vector2)

Aliases: distanceL2

Argumentos

• vector1 — Primeiro vetor. Tuple(T) ou Array(T)
• vector2 — Segundo vetor. Tuple(T) ou Array(T)

Valor retornado

Retorna a distância de norma 2. Para entradas Array, retorna Float32 se o menor supertipo comum dos tipos de elemento for Float32 ou BFloat16; caso contrário, Float64. Para entradas Tuple, sempre retorna Float64. Float*

Exemplos

Uso básico

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

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

Introduzido na: v25.10.0

Calcula a distância aproximada entre dois pontos (os valores dos vetores são as coordenadas) no espaço euclidiano (distância euclidiana).

Sintaxe

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

Aliases: distanceL2Transposed

Argumentos

• vectors — Vetores. QBit(T, UInt64[, UInt64])
• reference — Vetor de referência. Array(T)
• p — Número de bits de cada elemento do vetor a ser usado no cálculo da distância (de 1 até a largura de bits do elemento). O nível de quantização controla o equilíbrio entre precisão e velocidade. Usar menos bits resulta em E/S e cálculos mais rápidos, com menor precisão, enquanto usar mais bits aumenta a precisão à custa do desempenho. UInt
• used_dims — Opcional. Número de dimensões iniciais a serem lidas, para uma busca de dimensão reduzida (Matryoshka) em um QBit com stride. Deve ser um múltiplo do stride do QBit que não exceda sua dimensão, e o vetor de referência deve ter pelo menos esse número de elementos (quaisquer elementos extras no final são ignorados). Apenas os grupos de stride que abrangem essas dimensões são lidos. UInt

Valor retornado

Retorna a distância aproximada de norma 2. Sempre retorna Float64. Float64

Exemplos

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 │
└───────────────────────────────────────┘

Introduzido na: v26.7.0

Calcula a distância euclidiana aproximada entre um QBit(Int8) de códigos quantizeBFloat16ToInt8 (desquantizados em tempo de execução) e um vetor de referência. Um vetor de referência (consulta) Float é comparado diretamente com precisão Float32 — a precisão de reconstrução dos códigos desquantizados; assim, uma consulta Float64 é reduzida para Float32, enquanto uma consulta BFloat16 é ampliada para esse formato exatamente (cálculo de distância assimétrico); uma referência Array(Int8) é tratada como códigos quantizeBFloat16ToInt8 e desquantizada para seus níveis de reconstrução. Observe que p trunca apenas os códigos QBit armazenados; a referência Array(Int8) é, por si só, uma consulta completa e é sempre reconstruída com precisão total de 8 bits, portanto esta é uma distância simétrica entre quantizados apenas em p = 8 (para p < 8, apenas o lado armazenado é lido com precisão mais baixa). Ela deve estar no mesmo espaço em que os valores estavam antes da quantização (isto é, após a mesma rotação aleatória e o mesmo escalonamento), o que é responsabilidade de quem chama. A distância de cosseno é invariante à escala; o produto escalar e a distância L2 não são.

Sintaxe

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

Argumentos

• vectors — Vetores de códigos quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — Vetor de referência (consulta): um array de Float (a consulta, comparada com precisão Float32 – uma consulta Float64 é reduzida para Float32) ou um Array(Int8) de códigos quantizeBFloat16ToInt8 desquantizados em tempo de execução. Array(Float32) ou Array(Int8)
• p — Número dos bits mais altos de cada código QBit armazenado a serem usados (de 1 a 8). Menos bits reconstroem um quantizador embutido mais grosseiro usando os centroides de média condicional gaussiana dos intervalos de prefixo Lloyd-Max existentes, para E/S mais rápida, com menor precisão; 8 bits correspondem à reconstrução com precisão total. p trunca apenas o QBit armazenado; uma referência Array(Int8) é sempre reconstruída com precisão total de 8 bits. UInt
• used_dims — Opcional. Número de dimensões iniciais a serem lidas, para uma busca de dimensão reduzida (Matryoshka) em um QBit com stride. Deve ser um múltiplo do stride do QBit que não exceda sua dimensão, e o vetor de referência deve ter pelo menos essa quantidade de elementos (quaisquer elementos extras no final são ignorados). Apenas os grupos de stride que abrangem essas dimensões são lidos. UInt

Valor retornado

Retorna a distância aproximada de norma 2. Sempre retorna Float64. Float64

Exemplos

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 │
└──────────────────────────────────────────────────────────────────────────────┘

Introduzido em: v21.11.0

Calcula a raiz quadrada da soma dos quadrados dos elementos de um vetor.

Sintaxe

L2Norm(vector)

Aliases: normL2

Argumentos

• vector — Vetor ou tupla de valores numéricos. Tuple(T) ou Array(T)

Valor retornado

Retorna a norma L2, ou a distância euclidiana. UInt* ou Float*

Exemplos

Uso básico

SELECT L2Norm((1, 2))

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

Introduzido em: v21.11.0

Calcula o vetor unitário de um vetor fornecido (os elementos da tupla ou do array são as coordenadas) no espaço euclidiano (usando a distância euclidiana).

Sintaxe

L2Normalize(vector)

Aliases: normalizeL2

Argumentos

• vector — Uma tupla ou um array de valores numéricos. Tuple(T) ou Array(T)

Valor retornado

Retorna o vetor unitário. Para entradas Array, retorna Array(Float32) se o menor supertipo comum dos tipos de elemento for Float32 ou BFloat16; caso contrário, retorna Array(Float64). Para entradas Tuple, sempre retorna Tuple(Float64). Tuple(Float64) ou Array(Float32) ou Array(Float64)

Exemplos

Uso básico

SELECT L2Normalize((3, 4))

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

Introduzido em: v22.7.0

Calcula a soma dos quadrados das diferenças entre os elementos correspondentes de dois vetores.

Sintaxe

L2SquaredDistance(vector1, vector2)

Aliases: distanceL2Squared

Argumentos

• vector1 — Primeiro vetor. Tuple(T) ou Array(T)
• vector2 — Segundo vetor. Tuple(T) ou Array(T)

Valor retornado

Retorna a soma dos quadrados das diferenças entre os elementos correspondentes de dois vetores. Para entradas Array, retorna Float32 se o menor supertipo comum dos tipos de elemento for Float32 ou BFloat16; caso contrário, retorna Float64. Para entradas Tuple, o tipo de retorno segue o tipo de resultado aritmético das operações elemento a elemento (os tipos inteiros são preservados). (U)Int* ou Float*

Exemplos

Uso básico

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

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

Introduzido em: v22.7.0

Calcula o quadrado da raiz quadrada da soma dos quadrados dos elementos do vetor (a L2Norm).

Sintaxe

L2SquaredNorm(vector)

Aliases: normL2Squared

Argumentos

• vector — Vetor ou tupla de valores numéricos. Array(T) ou Tuple(T)

Valor retornado

Retorna o quadrado da norma L2. UInt* ou Float* ou Decimal

Exemplos

Uso básico

SELECT L2SquaredNorm((1, 2))

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

Introduzido na versão: v21.11.0

Calcula a distância entre dois pontos (os elementos dos vetores são as coordenadas) no espaço L_{inf} (norma máxima).

Sintaxe

LinfDistance(vector1, vector2)

Aliases: distanceLinf

Argumentos

• vector1 — Primeiro vetor. Tuple(T) ou Array(T)
• vector2 — Segundo vetor. Tuple(T) ou Array(T)

Valor retornado

Retorna a distância na norma infinita. Para entradas Array, retorna Float32 se o menor supertipo comum dos tipos de elemento for Float32 ou BFloat16; caso contrário, retorna Float64. Para entradas Tuple, sempre retorna Float64. Float*

Exemplos

Uso básico

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

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

Introduzido em: v21.11.0

Calcula o máximo dos valores absolutos dos elementos de um vetor.

Sintaxe

LinfNorm(vector)

Aliases: normLinf

Argumentos

• vector — Vetor ou tupla com valores numéricos. Array(T) ou Tuple(T)

Valor retornado

Retorna a norma Linf, ou seja, o maior valor absoluto. Float64

Exemplos

Uso básico

SELECT LinfNorm((1, -2))

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

Introduzido em: v21.11.0

Calcula o vetor unitário de um determinado vetor (os elementos da tupla ou array são as coordenadas) no espaço L_{inf} (usando a norma máxima).

Sintaxe

LinfNormalize(vector)

Aliases: normalizeLinf

Argumentos

• vector — Uma tupla ou array de valores numéricos. Tuple(T) ou Array(T)

Valor retornado

Retorna o vetor unitário. Para entradas do tipo Array, retorna Array(Float32) se o menor supertipo comum dos tipos dos elementos for Float32 ou BFloat16; caso contrário, retorna Array(Float64). Para entradas do tipo Tuple, sempre retorna Tuple(Float64). Tuple(Float64) ou Array(Float32) ou Array(Float64)

Exemplos

Uso básico

SELECT LinfNormalize((3, 4))

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

Introduzido em: v21.11.0

Calcula a distância entre dois pontos (os elementos dos vetores são as coordenadas) no espaço Lp (distância da norma p).

Sintaxe

LpDistance(vector1, vector2, p)

Aliases: distanceLp

Argumentos

• vector1 — Primeiro vetor. Tuple(T) ou Array(T)
• vector2 — Segundo vetor. Tuple(T) ou Array(T)
• p — A potência. Valores possíveis: número real em [1; inf). UInt* ou Int* ou Float*

Valor retornado

Retorna a distância da norma-p. Para entradas Array, retorna Float32 se o menor supertipo comum dos tipos de elemento for Float32 ou BFloat16; caso contrário, Float64. Para entradas Tuple, sempre retorna Float64. Float*

Exemplos

Uso básico

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

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

Introduzido em: v21.11.0

Calcula a norma p de um vetor, que é a raiz p-ésima da soma das p-ésimas potências dos valores absolutos de seus componentes.

Casos especiais:

• Quando p=1, é equivalente a L1Norm (distância de Manhattan).
• Quando p=2, é equivalente a L2Norm (distância euclidiana).
• O valor de p deve ser um número finito não inferior a um; para a norma máxima (o limite para p→∞), use LinfNorm.

Sintaxe

LpNorm(vector, p)

Aliases: normLp

Arguments

• vector — Vetor ou tupla de valores numéricos. Tuple(T) ou Array(T)
• p — A potência. Os valores possíveis são números reais no intervalo [1; inf). UInt* ou Int* ou Float*

Returned value

Retorna a norma Lp. Float64

Examples

Basic usage

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

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

Introduzido em: v21.11.0

Calcula o vetor unitário de um dado vetor (os elementos da tupla ou do array são as coordenadas) no espaço Lp (usando a norma p).

Sintaxe

LpNormalize(vector, p)

Aliases: normalizeLp

Argumentos

• vector — Uma tupla ou um array de valores numéricos. Tuple(T) ou Array(T)
• p — A potência. Os valores possíveis são números reais no intervalo [1; inf). UInt* ou Int* ou Float*

Valor retornado

Retorna o vetor unitário. Para entradas Array, retorna Array(Float32) se o menor supertipo comum dos tipos dos elementos for Float32 ou BFloat16; caso contrário, retorna Array(Float64). Para entradas Tuple, sempre retorna Tuple(Float64). Tuple(Float64) ou Array(Float32) ou Array(Float64)

Exemplos

Exemplo de uso

SELECT LpNormalize((3, 4), 5)

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

Introduzido em: v21.11.0

Calcula a distância de cosseno entre dois vetores (os elementos das tuplas são as coordenadas). Quanto menor for o valor retornado, mais semelhantes serão os vetores.

Sintaxe

cosineDistance(vector1, vector2)

Aliases: distanceCosine

Argumentos

• vector1 — Primeira tupla. Tuple(T) ou Array(T)
• vector2 — Segunda tupla. Tuple(T) ou Array(T)

Valor retornado

Retorna a distância de cosseno (um menos a similaridade de cosseno). Para entradas Array, retorna Float32 se o menor supertipo comum dos tipos dos elementos for Float32 ou BFloat16; caso contrário, Float64. Para entradas Tuple, sempre retorna Float64. Float*

Exemplos

Uso básico

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

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

Introduzido em: v26.1.0

Calcula a distância de cosseno aproximada entre dois pontos (os valores dos vetores são as coordenadas). Quanto menor o valor retornado, mais semelhantes são os vetores.

Sintaxe

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

Aliases: distanceCosineTransposed

Argumentos

• vectors — Vetores. QBit(T, UInt64[, UInt64])
• reference — Vetor de referência. Array(T)
• p — Número de bits de cada elemento do vetor usados no cálculo da distância (de 1 até a largura de bits do elemento). O nível de quantização controla o equilíbrio entre precisão e velocidade. Usar menos bits resulta em E/S e cálculos mais rápidos, com menor precisão, enquanto usar mais bits aumenta a precisão ao custo do desempenho. UInt
• used_dims — Opcional. Número de dimensões iniciais a serem lidas, para uma busca de dimensão reduzida (Matryoshka) em um QBit com stride. Deve ser um múltiplo do stride do QBit, sem exceder sua dimensão, e o vetor de referência deve ter pelo menos essa quantidade de elementos (quaisquer elementos adicionais no final são ignorados). Somente os grupos de stride que cobrem essas dimensões são lidos. UInt

Valor retornado

Retorna a distância de cosseno aproximada (um menos a similaridade de cosseno). Sempre retorna Float64. Float64

Exemplos

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 │
└───────────────────────────────────────────┘

Introduzido em: v26.7.0

Calcula a distância de cosseno aproximada entre um QBit(Int8) de códigos quantizeBFloat16ToInt8 (desquantizados em tempo de execução) e um vetor de referência. Quanto menor o valor retornado, mais semelhantes são os vetores. Um vetor de referência (consulta) Float é comparado diretamente com precisão Float32 — a precisão de reconstrução dos códigos desquantizados; assim, uma consulta Float64 é reduzida para Float32, enquanto uma consulta BFloat16 é ampliada exatamente para Float32 (cálculo de distância assimétrica). Já uma referência Array(Int8) é tratada como códigos quantizeBFloat16ToInt8 e desquantizada para seus níveis de reconstrução. Observe que p trunca apenas os códigos QBit armazenados; a referência Array(Int8) é, por si só, uma consulta completa e sempre é reconstruída com precisão total de 8 bits, portanto esta é uma distância simétrica entre quantizados somente em p = 8 (para p < 8, apenas o lado armazenado é lido com precisão mais baixa). Ela deve estar no mesmo espaço em que os valores estavam antes da quantização (isto é, após a mesma rotação aleatória e o mesmo escalonamento), o que é responsabilidade de quem faz a chamada. A distância de cosseno é invariante à escala; produto escalar e distância L2 não são.

Sintaxe

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

Argumentos

• vectors — Vetores de códigos quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — Vetor de referência (consulta): um array de Float (a consulta é comparada com precisão Float32 — uma consulta Float64 é reduzida para Float32), ou um Array(Int8) de códigos quantizeBFloat16ToInt8 desquantizados em tempo de execução. Array(Float32) ou Array(Int8)
• p — Número de bits mais altos de cada código QBit armazenado a serem usados (de 1 a 8). Menos bits reconstroem um quantizador embutido mais grosseiro usando os centroides de média condicional gaussiana dos intervalos de prefixo Lloyd-Max existentes, para E/S mais rápida com menor precisão; 8 bits correspondem à reconstrução em precisão total. p trunca apenas o QBit armazenado; uma referência Array(Int8) é sempre reconstruída com precisão total de 8 bits. UInt
• used_dims — Opcional. Número de dimensões iniciais a serem lidas, para uma busca de dimensão reduzida (Matryoshka) em um QBit com stride. Deve ser um múltiplo do stride do QBit, sem exceder sua dimensão, e o vetor de referência deve ter pelo menos essa quantidade de elementos (quaisquer elementos extras ao final são ignorados). Apenas os grupos de stride que cobrem essas dimensões são lidos. UInt

Valor retornado

Retorna a distância de cosseno aproximada (um menos a similaridade de cosseno). Sempre retorna Float64. Float64

Exemplos

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 │
└──────────────────────────────────────────────────────────────────────────────────┘

Introduzido em: v26.7.0

Calcula o produto escalar aproximado (produto interno) de dois vetores (os valores dos vetores são as coordenadas). Ao contrário das funções de distância, esta é uma medida de similaridade: quanto maior o valor retornado, mais semelhantes são os vetores.

Sintaxe

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

Aliases: scalarProductTransposed

Argumentos

• vectors — Vetores. QBit(T, UInt64[, UInt64])
• reference — Vetor de referência. Array(T)
• p — Número de bits de cada elemento do vetor usados no cálculo (de 1 até a largura de bits do elemento). O nível de quantização controla o equilíbrio entre precisão e velocidade. Usar menos bits resulta em E/S e cálculos mais rápidos, com menor precisão, enquanto usar mais bits aumenta a precisão ao custo do desempenho. UInt
• used_dims — Opcional. Número de dimensões iniciais a serem lidas, para uma busca de dimensão reduzida (Matryoshka) em um QBit com stride. Deve ser um múltiplo do stride do QBit que não exceda sua dimensão, e o vetor de referência deve ter pelo menos esse número de elementos (quaisquer elementos extras no final são ignorados). Somente os grupos de stride que abrangem essas dimensões são lidos. UInt

Valor retornado

Retorna o produto escalar aproximado dos dois vetores. Sempre retorna Float64. Float64

Exemplos

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 │
└───────────────────────────────────────┘

Introduzido em: v26.7.0

Calcula o produto escalar aproximado (produto interno) entre um QBit(Int8) de códigos quantizeBFloat16ToInt8 (desquantizados em tempo de execução) e um vetor de referência. Esta é uma medida de similaridade: quanto maior o valor retornado, mais semelhantes são os vetores. Um vetor de referência Float (consulta) é comparado diretamente com precisão Float32 — a precisão de reconstrução dos códigos desquantizados —, de modo que uma consulta Float64 é reduzida para Float32, enquanto uma consulta BFloat16 é ampliada exatamente para esse formato (cálculo de distância assimétrico); uma referência Array(Int8) é tratada como códigos quantizeBFloat16ToInt8 e desquantizada para seus níveis de reconstrução. Observe que p trunca apenas os códigos QBit armazenados; a referência Array(Int8) é, por si só, uma consulta completa e sempre é reconstruída com precisão total de 8 bits, portanto esta é uma distância simétrica entre quantizados somente em p = 8 (para p < 8, apenas o lado armazenado é lido com precisão mais baixa). Ela deve estar no mesmo espaço em que os valores estavam antes da quantização (isto é, após a mesma rotação aleatória e o mesmo escalonamento), o que é responsabilidade do chamador. A distância de cosseno é invariante à escala; o produto escalar e a distância L2 não são.

Sintaxe

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

Argumentos

• vectors — Vetores de códigos quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — Vetor de referência (consulta): um array de Float (a consulta, comparada com precisão Float32 – uma consulta Float64 é reduzida para Float32), ou um Array(Int8) de códigos quantizeBFloat16ToInt8 desquantizados em tempo de execução. Array(Float32) ou Array(Int8)
• p — Número de bits mais altos de cada código QBit armazenado a serem usados (de 1 a 8). Menos bits reconstroem um quantizador embutido mais grosseiro usando os centroides de média condicional gaussiana dos intervalos de prefixo Lloyd-Max existentes, para E/S mais rápida, com menor precisão; 8 bits correspondem à reconstrução com precisão total. p trunca apenas o QBit armazenado; uma referência Array(Int8) é sempre reconstruída com precisão total de 8 bits. UInt
• used_dims — Opcional. Número de dimensões iniciais a serem lidas, para uma busca de dimensão reduzida (Matryoshka) em um QBit com stride. Deve ser um múltiplo do stride do QBit que não exceda sua dimensão, e o vetor de referência deve ter pelo menos esse número de elementos (quaisquer elementos extras no final são ignorados). Somente os grupos de stride que abrangem essas dimensões são lidos. UInt

Valor retornado

Retorna o produto escalar aproximado dos dois vetores. Sempre retorna Float64. Float64

Exemplos

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 │
└──────────────────────────────────────────────────────────────────────────────┘