Tipo de dato QBit

Documentación del tipo de dato QBit en ClickHouse, que permite una cuantización de grano fino para la búsqueda vectorial aproximada

El tipo de dato QBit reorganiza el almacenamiento de vectores para acelerar las búsquedas aproximadas. En lugar de almacenar juntos los elementos de cada vector, agrupa las mismas posiciones de bits en todos los vectores. Esto permite almacenar los vectores con precisión completa y, al mismo tiempo, elegir el nivel de cuantización de grano fino en el momento de la búsqueda: leer menos bits para reducir el I/O y acelerar los cálculos, o más bits para obtener mayor precisión. Obtienes las ventajas de velocidad de la cuantización —menos transferencia de datos y menos cómputo—, pero todos los datos originales siguen disponibles cuando se necesitan.

Para declarar una columna de tipo QBit, usa la siguiente sintaxis:

column_name QBit(element_type, dimension)

• element_type – el tipo de cada elemento del vector. Los tipos permitidos son Int8, BFloat16, Float32 y Float64
• dimension – la cantidad de elementos de cada vector

​

Crear QBit

Uso del tipo QBit en la definición de una columna de tabla:

CREATE TABLE test (id UInt32, vec QBit(Float32, 8)) ENGINE = Memory;
INSERT INTO test VALUES (1, [1, 2, 3, 4, 5, 6, 7, 8]), (2, [9, 10, 11, 12, 13, 14, 15, 16]);
SELECT vec FROM test ORDER BY id;

┌─vec──────────────────────┐
│ [1,2,3,4,5,6,7,8]        │
│ [9,10,11,12,13,14,15,16] │
└──────────────────────────┘

​

Conversión de arrays a QBit

Los arrays se convierten en QBit cuando la longitud del array coincide con la dimensión de QBit. El tipo de elemento del array no tiene que coincidir con el tipo de elemento de QBit. Cualquier tipo de elemento numérico se convierte automáticamente a este. Esto permite mover una columna existente de embeddings directamente a una columna QBit:

CREATE TABLE embeddings (id UInt32, embedding Array(Float32)) ENGINE = Memory;
INSERT INTO embeddings VALUES (1, [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]), (2, [0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1]);

CREATE TABLE vectors (id UInt32, vec QBit(Float32, 8)) ENGINE = Memory;
INSERT INTO vectors SELECT id, embedding FROM embeddings;

SELECT * FROM vectors ORDER BY id;

┌─id─┬─vec───────────────────────────────┐
│  1 │ [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8] │
│  2 │ [0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1] │
└────┴───────────────────────────────────┘

La conversión también se puede realizar explícitamente con CAST, por ejemplo CAST(embedding AS QBit(Float32, 8)).

​

Conversión de QBit a arrays

La conversión inversa reconstruye el vector original a partir de la representación con bits transpuestos, por lo que convertir un QBit a un Array devuelve los valores almacenados. Esto es lo inverso de convertir arrays a QBit:

SELECT [1, 2, 3, 4]::QBit(Float32, 4)::Array(Float32) AS vec;

┌─vec───────┐
│ [1,2,3,4] │
└───────────┘

El array reconstruido usa el tipo de elemento de QBit, y luego sus elementos se convierten al tipo de elemento del array solicitado. Por lo tanto, también funciona un cast que además cambia el tipo de elemento, como de QBit(Float32, N) a Array(Float64).

Un recorrido de ida y vuelta Array -> QBit -> Array no pierde información para Int8, Float32 y Float64. En el caso de BFloat16, coincide con una conversión directa a BFloat16: la única precisión que se pierde es la propia de BFloat16.

Cuando la dimension no es un múltiplo de 8, los elementos de relleno finales presentes en la representación interna se descartan, por lo que el resultado siempre tiene exactamente dimension elementos.

​

Subcolumnas de QBit

QBit implementa un patrón de acceso a subcolumnas que permite acceder a planos de bits individuales de los vectores almacenados. Se puede acceder a cada posición de bit mediante la sintaxis .N, donde N es la posición del bit:

CREATE TABLE test (id UInt32, vec QBit(Float32, 8)) ENGINE = Memory;
INSERT INTO test VALUES (1, [0, 0, 0, 0, 0, 0, 0, 0]);
INSERT INTO test VALUES (1, [-0, -0, -0, -0, -0, -0, -0, -0]);
SELECT bin(vec.1) FROM test;

┌─bin(tupleElement(vec, 1))─┐
│ 00000000                  │
│ 11111111                  │
└───────────────────────────┘

La cantidad de subcolumnas accesibles depende del tipo de elemento:

• Int8: 8 subcolumnas (1-8)
• BFloat16: 16 subcolumnas (1-16)
• Float32: 32 subcolumnas (1-32)
• Float64: 64 subcolumnas (1-64)

​

Funciones de búsqueda vectorial

Estas son las funciones de distancia para la búsqueda de similitud vectorial que utilizan el tipo de dato QBit:

• L2DistanceTransposed
• cosineDistanceTransposed
• dotProductTransposed