Funções de distância

L1Distance

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

Query

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

Response

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

L1Norm

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

Query

SELECT L1Norm((1, 2))

Response

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

L1Normalize

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

Query

SELECT L1Normalize((1, 2))

Response

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

L2Distance

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

Query

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

Response

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

L2DistanceTransposed

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

Query

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;

Response

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

L2DistanceTransposedQuantized

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

Query

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;

Response

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

L2Norm

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

Query

SELECT L2Norm((1, 2))

Response

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

L2Normalize

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

Query

SELECT L2Normalize((3, 4))

Response

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

L2SquaredDistance

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

Query

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

Response

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

L2SquaredNorm

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

Query

SELECT L2SquaredNorm((1, 2))

Response

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

LinfDistance

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

Query

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

Response

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

LinfNorm

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

Query

SELECT LinfNorm((1, -2))

Response

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

LinfNormalize

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

Query

SELECT LinfNormalize((3, 4))

Response

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

LpDistance

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

Query

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

Response

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

LpNorm

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

Query

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

Response

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

LpNormalize

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

Query

SELECT LpNormalize((3, 4), 5)

Response

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

cosineDistance

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

Query

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

Response

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

cosineDistanceTransposed

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

Query

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

Response

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

cosineDistanceTransposedQuantized

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

Query

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 round(cosineDistanceTransposedQuantized(vec, [0.1, -0.5]::Array(Float32), 8), 6) FROM qbit;

Response

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

dotProductTransposed

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

Query

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;

Response

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

dotProductTransposedQuantized

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

Query

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;

Response

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

Referência de SQL

Tipos de dados

Motores

Funções

Formatos

Configurações

Tabelas do sistema

Lagos de dados

L1Distance

L1Norm

L1Normalize

L2Distance

L2DistanceTransposed

L2DistanceTransposedQuantized

L2Norm

L2Normalize

L2SquaredDistance

L2SquaredNorm

LinfDistance

LinfNorm

LinfNormalize

LpDistance

LpNorm

LpNormalize

cosineDistance

cosineDistanceTransposed

cosineDistanceTransposedQuantized

dotProductTransposed

dotProductTransposedQuantized

​L1Distance

​L1Norm

​L1Normalize

​L2Distance

​L2DistanceTransposed

​L2DistanceTransposedQuantized

​L2Norm

​L2Normalize

​L2SquaredDistance

​L2SquaredNorm

​LinfDistance

​LinfNorm

​LinfNormalize

​LpDistance

​LpNorm

​LpNormalize

​cosineDistance

​cosineDistanceTransposed

​cosineDistanceTransposedQuantized

​dotProductTransposed

​dotProductTransposedQuantized

L1Distance

L1Norm

L1Normalize

L2Distance

L2DistanceTransposed

L2DistanceTransposedQuantized

L2Norm

L2Normalize

L2SquaredDistance

L2SquaredNorm

LinfDistance

LinfNorm

LinfNormalize

LpDistance

LpNorm

LpNormalize

cosineDistance

cosineDistanceTransposed

cosineDistanceTransposedQuantized

dotProductTransposed

dotProductTransposedQuantized