Функции расстояния

​

L1Distance

L1Distance(vector1, vector2)

• vector1 — Первый вектор. Tuple(T) или Array(T)
• vector2 — Второй вектор. Tuple(T) или Array(T)

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

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

​

L1Norm

L1Norm(vector)

• vector — Вектор или кортеж числовых значений. Array(T) или Tuple(T)

SELECT L1Norm((1, 2))

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

​

L1Normalize

L1Normalize(vector)

• vector — Кортеж или массив числовых значений. Tuple(T) или Array(T)

SELECT L1Normalize((1, 2))

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

​

L2Distance

L2Distance(vector1, vector2)

• vector1 — Первый вектор. Tuple(T) или Array(T)
• vector2 — Второй вектор. Tuple(T) или Array(T)

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

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

​

L2DistanceTransposed

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

• vectors — Векторы. QBit(T, UInt64[, UInt64])
• reference — Опорный вектор. Array(T)
• p — Количество битов из каждого элемента вектора, используемых при вычислении расстояния (от 1 до битовой ширины элемента). Уровень квантования определяет компромисс между точностью и скоростью. Использование меньшего количества битов ускоряет операции ввода-вывода и вычисления, но снижает точность, тогда как большее количество битов повышает точность ценой производительности. UInt
• used_dims — Необязательно. Количество первых размерностей, которые нужно считывать, для поиска с уменьшенной размерностью в QBit со stride. Должно быть кратно stride в QBit и не превышать его размерность, а опорный вектор должен содержать как минимум столько элементов (любые дополнительные конечные элементы игнорируются). Считываются только те группы stride, которые покрывают эти размерности. UInt

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

​

L2DistanceTransposedQuantized

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

• vectors — Векторы кодов quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — Опорный вектор (запрос): массив Float (запрос сравнивается с точностью Float32 — запрос Float64 приводится к Float32) или Array(Int8) из кодов quantizeBFloat16ToInt8, деквантованных на лету. Array(Float32) или Array(Int8)
• p — Количество старших битов каждого сохранённого кода QBit, которые следует использовать (от 1 до 8). Меньшее количество битов восстанавливает более грубый встроенный квантизатор, использующий центроиды гауссовских условных средних для существующих префиксных интервалов Ллойда — Макса, обеспечивая более быстрый ввод-вывод ценой снижения точности; 8 бит — это восстановление с полной точностью. p усекает только сохранённый QBit; опорный Array(Int8) всегда восстанавливается с полной 8-битной точностью. UInt
• used_dims — Необязательно. Количество первых размерностей, которые нужно считывать, для поиска с уменьшенной размерностью (Matryoshka) в QBit со stride. Должно быть кратно stride в QBit и не превышать его размерность, а опорный вектор должен содержать как минимум столько элементов (любые дополнительные конечные элементы игнорируются). Считываются только те группы stride, которые покрывают эти размерности. UInt

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

​

L2Norm

L2Norm(vector)

• vector — Вектор или кортеж из числовых значений. Tuple(T) или Array(T)

SELECT L2Norm((1, 2))

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

​

L2Normalize

L2Normalize(vector)

• vector — кортеж или массив числовых значений. Tuple(T) или Array(T)

SELECT L2Normalize((3, 4))

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

​

L2SquaredDistance

L2SquaredDistance(vector1, vector2)

• vector1 — Первый вектор. Tuple(T) или Array(T)
• vector2 — Второй вектор. Tuple(T) или Array(T)

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

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

​

L2SquaredNorm

L2SquaredNorm(vector)

• vector — Вектор или кортеж числовых значений. Array(T) или Tuple(T)

SELECT L2SquaredNorm((1, 2))

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

​

LinfDistance

LinfDistance(vector1, vector2)

• vector1 — Первый вектор. Tuple(T) или Array(T)
• vector2 — Второй вектор. Tuple(T) или Array(T)

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

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

​

LinfNorm

LinfNorm(vector)

• vector — Вектор или кортеж из числовых значений. Array(T) или Tuple(T)

SELECT LinfNorm((1, -2))

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

​

LinfNormalize

LinfNormalize(vector)

• vector — Кортеж или массив числовых значений. Tuple(T) или Array(T)

SELECT LinfNormalize((3, 4))

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

​

LpDistance

LpDistance(vector1, vector2, p)

• vector1 — Первый вектор. Tuple(T) или Array(T)
• vector2 — Второй вектор. Tuple(T) или Array(T)
• p — Степень. Возможные значения: действительное число в диапазоне [1; inf). UInt* или Int* или Float*

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

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

​

LpNorm

• При p=1 эквивалентна L1Norm (манхэттенское расстояние).
• При p=2 эквивалентна L2Norm (евклидово расстояние).
• Значение p должно быть конечным числом не меньше единицы; для максимальной нормы (предел при p→∞) используйте LinfNorm.

LpNorm(vector, p)

• vector — Вектор или кортеж числовых значений. Tuple(T) или Array(T)
• p — Степень. Возможные значения — действительные числа в диапазоне [1; inf). UInt* или Int* или Float*

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

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

​

LpNormalize

LpNormalize(vector, p)

• vector — кортеж или массив числовых значений. Tuple(T) или Array(T)
• p — степень. Допустимые значения: действительные числа в диапазоне [1; inf). UInt* или Int* или Float*

SELECT LpNormalize((3, 4), 5)

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

​

cosineDistance

cosineDistance(vector1, vector2)

• vector1 — Первый кортеж. Tuple(T) или Array(T)
• vector2 — Второй кортеж. Tuple(T) или Array(T)

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

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

​

cosineDistanceTransposed

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

• vectors — Векторы. QBit(T, UInt64[, UInt64])
• reference — Опорный вектор. Array(T)
• p — Количество битов из каждого элемента вектора, используемых при вычислении расстояния (от 1 до разрядности элемента в битах). Уровень квантования определяет компромисс между точностью и скоростью. Использование меньшего количества битов ускоряет операции ввода-вывода и вычисления, но снижает точность, тогда как большее количество битов повышает точность ценой производительности. UInt
• used_dims — Необязательно. Количество начальных размерностей для чтения при поиске с уменьшенной размерностью (Matryoshka) по QBit со stride. Должно быть кратно stride QBit и не превышать его размерность, а опорный вектор должен содержать как минимум столько элементов (любые дополнительные конечные элементы игнорируются). Считываются только группы stride, покрывающие эти размерности. UInt

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;

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

​

cosineDistanceTransposedQuantized

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

• vectors — Векторы кодов quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — Опорный вектор (запрос): массив Float (запрос сравнивается с точностью Float32 — запрос Float64 приводится к Float32) или Array(Int8) с кодами quantizeBFloat16ToInt8, деквантуемыми на лету. Array(Float32) или Array(Int8)
• p — Число старших битов каждого сохранённого кода QBit, которое нужно использовать (от 1 до 8). Чем меньше битов, тем грубее восстанавливаемый встроенный квантизатор, использующий центроиды условных средних гауссовского распределения для существующих префиксных интервалов Ллойда — Макса, но тем быстрее ввод-вывод и ниже точность; 8 бит — это восстановление с полной точностью. p усекает только сохранённый QBit; опорный вектор Array(Int8) всегда восстанавливается с полной 8-битной точностью. UInt
• used_dims — Необязательно. Количество начальных размерностей, которые нужно считывать для поиска с уменьшенной размерностью (Matryoshka) по QBit со stride. Должно быть кратно stride QBit и не превышать его размерность, а опорный вектор должен содержать как минимум столько элементов (любые дополнительные конечные элементы игнорируются). Считываются только группы stride, покрывающие эти размерности. UInt

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;

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

​

dotProductTransposed

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

• vectors — Векторы. QBit(T, UInt64[, UInt64])
• reference — Опорный вектор. Array(T)
• p — Количество битов из каждого элемента вектора, используемых при вычислении (от 1 до разрядности элемента в битах). Уровень квантования определяет компромисс между точностью и скоростью. Использование меньшего количества битов ускоряет операции ввода-вывода и вычисления, но снижает точность, тогда как большее количество битов повышает точность ценой производительности. UInt
• used_dims — Необязательно. Количество начальных размерностей, которые нужно считывать, для поиска с уменьшенной размерностью (Matryoshka) по QBit со stride. Должно быть кратно stride QBit и не превышать его размерность, а опорный вектор должен содержать как минимум столько элементов (любые дополнительные элементы в конце игнорируются). Считываются только группы stride, покрывающие эти размерности. UInt

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

​

dotProductTransposedQuantized

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

• vectors — Векторы кодов quantizeBFloat16ToInt8. QBit(Int8, UInt64[, UInt64])
• reference — Опорный вектор (запрос): массив Float (запрос сравнивается с точностью Float32 — запрос типа Float64 приводится к Float32) или Array(Int8) из кодов quantizeBFloat16ToInt8, деквантуемых на лету. Array(Float32) или Array(Int8)
• p — Количество старших битов каждого сохранённого кода QBit, используемых при вычислении (от 1 до 8). Меньшее количество битов даёт более грубое восстановление встроенного квантизатора с использованием центроидов, соответствующих условным средним гауссовского распределения в существующих префиксных интервалах Ллойда — Макса, что ускоряет ввод-вывод ценой снижения точности; 8 бит — это восстановление с полной точностью. p усекает только сохранённый QBit; опорный Array(Int8) всегда восстанавливается с полной 8-битной точностью. UInt
• used_dims — Необязательно. Количество начальных размерностей, которые нужно считывать, для поиска с уменьшенной размерностью (Matryoshka) по QBit со stride. Должно быть кратно stride QBit и не превышать его размерность, а опорный вектор должен содержать как минимум столько элементов (все дополнительные элементы в конце игнорируются). Считываются только группы stride, покрывающие эти размерности. UInt

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