거리 함수 - ClickHouse Documentation

L1Distance

도입 버전: v21.11.0 벡터의 원소를 좌표로 하는 두 점 사이의 거리를 L1 공간(1-노름, taxicab geometry 거리)에서 계산합니다. 구문

L1Distance(vector1, vector2)

별칭: distanceL1 인수

vector1 — 첫 번째 벡터입니다. Tuple(T) 또는 Array(T)
vector2 — 두 번째 벡터입니다. Tuple(T) 또는 Array(T)

반환 값 1-노름 거리를 반환합니다. Array 입력의 경우, 요소 타입의 최소 공통 상위 타입이 Float32 또는 BFloat16이면 Float32를 반환하고, 그렇지 않으면 Float64를 반환합니다. Tuple 입력의 경우 반환 타입은 요소별 연산의 산술 결과 타입을 따릅니다(정수 타입은 유지됨). (U)Int* 또는 Float* 예시 기본 사용법

Query

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

Response

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

L1Norm

도입된 버전: v21.11.0 벡터 각 요소의 절댓값 합을 계산합니다. 구문

L1Norm(vector)

별칭: normL1 인수

vector — 숫자 값으로 이루어진 벡터 또는 튜플. Array(T) 또는 Tuple(T)

반환 값 L1 노름 또는 taxicab geometry 거리를 반환합니다. UInt* 또는 Float* 또는 Decimal 예시 기본 사용법

Query

SELECT L1Norm((1, 2))

Response

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

L1Normalize

도입 버전: v21.11.0 주어진 벡터의 단위 벡터를 L1 공간(taxicab geometry)에서 계산합니다. 튜플의 요소는 좌표입니다. 구문

L1Normalize(tuple)

별칭: normalizeL1 인수

tuple — 숫자 값으로 구성된 튜플입니다. Tuple(T)

반환 값 단위 벡터를 반환합니다. Tuple(Float64) 예시 기본 사용법

Query

SELECT L1Normalize((1, 2))

Response

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

L2Distance

도입 버전: v21.11.0 유클리드 공간(Euclidean space)에서 두 점 사이의 거리(벡터의 원소는 각 점의 좌표)를 계산합니다(유클리드 거리). 구문

L2Distance(vector1, vector2)

별칭: distanceL2 인수

vector1 — 첫 번째 벡터. Tuple(T) 또는 Array(T)
vector2 — 두 번째 벡터. Tuple(T) 또는 Array(T)

반환 값 2-노름 거리를 반환합니다. Array 입력에서는 요소 타입의 최소 공통 상위 타입이 Float32 또는 BFloat16이면 Float32를 반환하고, 그렇지 않으면 Float64를 반환합니다. Tuple 입력에서는 항상 Float64를 반환합니다. Float* 예시 기본 사용법

Query

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

Response

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

L2DistanceTransposed

도입 버전: v25.10.0 유클리드 공간(유클리드 거리)에서 두 점 사이의 근사 거리를 계산합니다(벡터의 값이 좌표임). 구문

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

별칭: distanceL2Transposed 인수

vectors — 벡터. QBit(T, UInt64[, UInt64])
reference — 기준 벡터. Array(T)
p — 거리 계산에 사용할 각 벡터 요소의 비트 수(1부터 요소의 비트 폭까지)입니다. 양자화 수준은 정밀도와 속도 사이의 균형을 결정합니다. 더 적은 비트를 사용하면 정확도는 낮아지지만 I/O 및 계산 속도는 빨라지고, 더 많은 비트를 사용하면 성능 저하를 감수하는 대신 정확도는 높아집니다. UInt
used_dims — 선택 사항입니다. stride된 QBit에서 축소 차원(Matryoshka) 검색을 위해 읽을 선행 차원의 수입니다. QBit stride의 배수여야 하고 차원을 초과할 수 없으며, 기준 벡터에는 최소한 이 개수만큼의 요소가 있어야 합니다(뒤에 추가로 있는 요소는 무시됩니다). 이 차원들을 포함하는 stride 그룹만 읽습니다. UInt

반환 값 근사 2-노름 거리를 반환합니다. 반환 타입은 항상 Float64입니다. Float64 예시 기본 사용법

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([0, 1], [1, 2], 16)─┐
│                       1.3922918381215914 │
└──────────────────────────────────────────┘

L2DistanceTransposedQuantized

도입 버전: v26.7.0 quantizeBFloat16ToInt8 코드의 QBit(Int8)(실행 중 즉시 역양자화됨)와 기준 벡터 사이의 근사 유클리드 거리를 계산합니다. Float 기준(쿼리) 벡터는 역양자화된 코드의 복원 정밀도인 Float32 정밀도에서 직접 비교되므로, Float64 쿼리는 Float32로 축소되고 BFloat16 쿼리는 여기에 정확히 맞춰 확장됩니다(비대칭 거리 계산). Array(Int8) 기준은 그 자체로 quantizeBFloat16ToInt8 코드로 간주되며 해당 복원 수준으로 역양자화됩니다. p는 저장된 QBit 코드에만 절단을 적용합니다. Array(Int8) 기준은 완전한 쿼리이므로 항상 전체 8비트 정밀도로 재구성되며, 따라서 이는 p = 8일 때만 대칭적인 양자화 대 양자화 거리입니다(p < 8에서는 저장된 쪽만 더 낮은 정밀도로 읽음). 이는 양자화 이전 값이 존재하던 동일한 공간(즉, 동일한 무작위 회전 및 스케일링 이후)에 있어야 하며, 이는 호출자의 책임입니다. 코사인 거리는 스케일 불변이지만, 내적과 L2 거리는 그렇지 않습니다. 구문

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

인수

vectors — quantizeBFloat16ToInt8 코드의 벡터. QBit(Int8, UInt64[, UInt64])
reference — 기준(쿼리) 벡터: Float 배열(쿼리이며 Float32 정밀도로 비교됨 — Float64 쿼리는 Float32로 축소됨) 또는 quantizeBFloat16ToInt8 코드의 Array(Int8)로, 사용 시 즉석에서 역양자화됩니다. Array(Float32) 또는 Array(Int8)
p — 사용할 저장된 QBit 코드의 상위 비트 수(1~8)입니다. 더 적은 비트를 사용하면 더 거친 내장 양자화기가 복원되어 I/O는 빨라지지만 정확도는 낮아집니다. 8비트는 전체 정밀도 복원입니다. p는 저장된 QBit에만 절단을 적용하며, Array(Int8) 기준 벡터는 항상 전체 8비트 정밀도로 복원됩니다. UInt
used_dims — 선택 사항입니다. stride된 QBit에서 축소 차원(Matryoshka) 검색을 위해 읽을 선행 차원의 수입니다. QBit stride의 배수여야 하고 차원을 초과할 수 없으며, 기준 벡터에는 최소한 이 개수만큼의 원소가 있어야 합니다(추가로 뒤에 있는 원소는 무시됨). 이 차원들을 포함하는 stride 그룹만 읽습니다. UInt

반환 값 근사 2-노름 거리를 반환합니다. 반환 타입은 항상 Float64입니다. Float64 예시 기본 사용법

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;

L2Norm

도입 버전: v21.11.0 벡터 요소 제곱합의 제곱근을 계산합니다. 구문

L2Norm(vector)

별칭: normL2 인수

vector — 숫자형 값으로 이루어진 벡터 또는 튜플입니다. Tuple(T) 또는 Array(T)

반환 값 L2 노름 또는 유클리드 거리를 반환합니다. UInt* 또는 Float* 예시 기본 사용법

Query

SELECT L2Norm((1, 2))

Response

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

L2Normalize

도입 버전: v21.11.0 주어진 벡터의 단위 벡터를 계산합니다(튜플의 원소는 좌표임). 유클리드 거리를 사용해 유클리드 공간에서 계산합니다. 구문

L2Normalize(tuple)

별칭: normalizeL2 인수

tuple — 숫자 값으로 구성된 튜플입니다. Tuple(T)

반환 값 단위 벡터를 반환합니다. Tuple(Float64) 예시 기본 사용법

Query

SELECT L2Normalize((3, 4))

Response

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

L2SquaredDistance

도입 버전: v22.7.0 두 벡터에서 서로 대응하는 원소 간 차이의 제곱합을 계산합니다. 구문

L2SquaredDistance(vector1, vector2)

별칭: distanceL2Squared 인수

vector1 — 첫 번째 벡터입니다. Tuple(T) 또는 Array(T)
vector2 — 두 번째 벡터입니다. Tuple(T) 또는 Array(T)

반환 값 두 벡터에서 대응하는 요소끼리의 차이를 제곱한 뒤 모두 더한 값을 반환합니다. Array 입력의 경우, 요소 타입의 최소 공통 상위 타입(least common supertype)이 Float32 또는 BFloat16이면 Float32를 반환하고, 그렇지 않으면 Float64를 반환합니다. Tuple 입력의 경우, 반환 타입은 요소별 연산의 산술 결과 타입을 따릅니다(정수 타입은 유지됨). (U)Int* 또는 Float* 예시 기본 사용법

Query

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

Response

┌─L2SquaredDis⋯ [0, 0, 0])─┐
│                       14 │
└──────────────────────────┘

L2SquaredNorm

도입 버전: v22.7.0 벡터 원소 제곱합의 제곱근인 L2Norm을 다시 제곱한 값을 계산합니다. 구문

L2SquaredNorm(vector)

별칭: normL2Squared 인수

vector — 숫자 값으로 이루어진 벡터 또는 튜플입니다. Array(T) 또는 Tuple(T)

반환 값 L2 노름의 제곱을 반환합니다. UInt* 또는 Float* 또는 Decimal 예시 기본 사용법

Query

SELECT L2SquaredNorm((1, 2))

Response

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

LinfDistance

도입 버전: v21.11.0 L_{inf} 공간에서 두 점 사이의 거리(벡터의 원소가 좌표임)를 계산합니다(최대 노름). 구문

LinfDistance(vector1, vector2)

별칭: distanceLinf 인수

vector1 — 첫 번째 벡터. Tuple(T) 또는 Array(T)
vector2 — 두 번째 벡터. Tuple(T) 또는 Array(T)

반환 값 무한 노름 거리를 반환합니다. Array 입력의 경우, 요소 타입의 최소 공통 상위 타입이 Float32 또는 BFloat16이면 Float32를, 그렇지 않으면 Float64를 반환합니다. Tuple 입력의 경우 항상 Float64를 반환합니다. Float* 예시 기본 사용법

Query

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

Response

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

LinfNorm

도입 버전: v21.11.0 벡터 원소 절댓값의 최댓값을 계산합니다. 구문

LinfNorm(vector)

별칭: normLinf 인수

vector — 숫자형 값으로 이루어진 벡터 또는 튜플입니다. Array(T) 또는 Tuple(T)

반환 값 Linf 노름 또는 절댓값의 최댓값을 반환합니다. Float64 예시 기본 사용법

Query

SELECT LinfNorm((1, -2))

Response

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

LinfNormalize

도입 버전: v21.11.0 주어진 벡터의 단위 벡터를 계산합니다(튜플의 원소는 좌표를 나타냅니다). L_{inf} 공간에서 최대 노름을 사용합니다. 구문

LinfNormalize(tuple)

별칭: normalizeLinf 인수

tuple — 숫자형 값으로 이루어진 튜플입니다. Tuple(T)

반환 값 단위 벡터를 반환합니다. Tuple(Float64) 예시 기본 사용법

Query

SELECT LinfNormalize((3, 4))

Response

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

LpDistance

도입 버전: v21.11.0 Lp 공간에서 두 점 사이의 거리(벡터의 원소가 좌표임)를 계산합니다(p-norm distance). 구문

LpDistance(vector1, vector2, p)

별칭: distanceLp 인수

vector1 — 첫 번째 벡터입니다. Tuple(T) 또는 Array(T)
vector2 — 두 번째 벡터입니다. Tuple(T) 또는 Array(T)
p — 거듭제곱 값입니다. 가능한 값: [1; inf) 범위의 실수입니다. UInt* 또는 Float*

반환 값 p-노름 거리를 반환합니다. Array 입력의 경우 요소 타입의 최소 공통 상위 타입(least common supertype)이 Float32 또는 BFloat16이면 Float32를 반환하고, 그렇지 않으면 Float64를 반환합니다. Tuple 입력의 경우 항상 Float64를 반환합니다. Float* 예시 기본 사용법

Query

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

Response

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

LpNorm

도입 버전: v21.11.0 벡터의 p-노름을 계산합니다. 각 원소의 절댓값을 p제곱한 값들을 모두 더한 뒤, 그 합의 p제곱근을 구한 값입니다. 특수한 경우:

p=1이면 L1Norm(맨해튼 거리)와 동일합니다.
p=2이면 L2Norm(유클리드 거리)와 동일합니다.
p=∞이면 LinfNorm(최대 노름)와 동일합니다.

구문

LpNorm(vector, p)

별칭: normLp 인수

vector — 숫자 값으로 구성된 벡터 또는 튜플입니다. Tuple(T) 또는 Array(T)
p — 거듭제곱 값입니다. 가능한 값은 [1; inf) 범위의 실수입니다. UInt* 또는 Float*

반환 값 Lp-노름을 반환합니다. Float64 예시 기본 사용법

Query

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

Response

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

LpNormalize

도입 버전: v21.11.0 주어진 벡터의 단위 벡터를 Lp 공간에서 계산합니다(튜플의 각 요소는 좌표를 의미하며, p-노름을 사용합니다). 구문

LpNormalize(tuple, p)

별칭: normalizeLp 인수

tuple — 숫자 값으로 이루어진 튜플입니다. Tuple(T)
p — 거듭제곱 값입니다. 가능한 값은 [1; inf) 범위의 모든 숫자입니다. UInt* 또는 Float*

반환 값 단위 벡터를 반환합니다. Tuple(Float64) 예시 사용 예시

Query

SELECT LpNormalize((3, 4), 5)

Response

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

cosineDistance

Introduced in: v21.11.0 두 벡터 간의 코사인 거리를 계산합니다(튜플의 요소는 좌표입니다). 반환 값이 작을수록 두 벡터는 더 유사합니다. 구문

cosineDistance(vector1, vector2)

별칭: distanceCosine 인수

vector1 — 첫 번째 튜플. Tuple(T) 또는 Array(T)
vector2 — 두 번째 튜플. Tuple(T) 또는 Array(T)

반환 값 코사인 거리(코사인 유사도에서 1을 뺀 값)를 반환합니다. Array 입력의 경우, 요소 타입의 최소 공통 상위 타입이 Float32 또는 BFloat16이면 Float32를 반환하고, 그렇지 않으면 Float64를 반환합니다. Tuple 입력의 경우 항상 Float64를 반환합니다. Float* 예시 기본 사용법

Query

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

Response

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

cosineDistanceTransposed

도입 버전: v26.1.0 두 점 사이의 근사 코사인 거리를 계산합니다(벡터의 값이 좌표입니다). 반환 값이 작을수록 벡터는 더 유사합니다. 구문

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

별칭: distanceCosineTransposed 인수

vectors — 벡터. QBit(T, UInt64[, UInt64])
reference — 기준 벡터. Array(T)
p — 거리 계산에 사용할 각 벡터 요소의 비트 수(1부터 요소 비트 폭까지). 양자화 수준은 정밀도와 속도 간의 상충 관계를 제어합니다. 더 적은 비트를 사용하면 정확도는 낮아지지만 I/O 및 계산 속도는 빨라지고, 더 많은 비트를 사용하면 성능 저하를 감수하는 대신 정확도가 높아집니다. UInt
used_dims — 선택 사항입니다. stride된 QBit에서 축소 차원(Matryoshka) 검색을 수행하기 위해 읽을 선행 차원의 수입니다. QBit stride의 배수이면서 해당 차원을 초과하지 않아야 하며, 기준 벡터는 최소한 이 개수만큼의 원소를 가져야 합니다(추가로 뒤에 있는 원소는 무시됩니다). 이러한 차원을 포함하는 stride 그룹만 읽습니다. UInt

반환 값 근사 코사인 거리(코사인 유사도에서 1을 뺀 값)를 반환합니다. 반환 타입은 항상 Float64입니다. Float64 예시 기본 사용법

Query

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;

Response

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

cosineDistanceTransposedQuantized

도입 버전: v26.7.0 quantizeBFloat16ToInt8 코드의 QBit(Int8)(실행 중 필요할 때 즉시 역양자화됨)와 기준 벡터 사이의 근사 코사인 거리를 계산합니다. 반환 값이 작을수록 벡터는 더 유사합니다. Float 참조(쿼리) 벡터는 역양자화된 코드의 복원 정밀도인 Float32 정밀도에서 직접 비교됩니다. 따라서 Float64 쿼리는 Float32로 축소되고, BFloat16 쿼리는 정확히 Float32로 확장됩니다(비대칭 거리 계산). Array(Int8) 참조는 그 자체로 quantizeBFloat16ToInt8 코드로 간주되며, 해당 복원 수준으로 역양자화됩니다. p는 저장된 QBit 코드에만 적용되어 잘린다는 점에 유의하십시오. Array(Int8) 참조는 완전한 쿼리이므로 항상 전체 8비트 정밀도로 복원됩니다. 따라서 이는 p = 8일 때만 대칭적인 양자화 대 양자화 거리이며(p < 8이면 저장된 쪽만 더 거친 정밀도로 읽힘), 값은 양자화 전과 동일한 공간(즉, 동일한 무작위 회전과 스케일링 이후의 공간)에 있어야 합니다. 이는 호출자가 보장해야 합니다. 코사인 거리는 스케일 불변이지만, 점곱과 L2 거리는 그렇지 않습니다. 구문

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

인수

vectors — quantizeBFloat16ToInt8 코드로 이루어진 벡터입니다. QBit(Int8, UInt64[, UInt64])
reference — 기준(쿼리) 벡터입니다. Float 배열(Float32 정밀도로 비교되는 쿼리이며 Float64 쿼리는 Float32로 축소됨) 또는 실행 중 즉시 역양자화되는 quantizeBFloat16ToInt8 코드의 Array(Int8)입니다. Array(Float32) 또는 Array(Int8)
p — 저장된 각 QBit 코드에서 사용할 상위 비트 수입니다(1~8). 비트 수가 적을수록 더 거친 양자화 표현으로 재구성되므로 I/O는 빨라지지만 정확도는 낮아집니다. 8비트는 전체 정밀도 재구성입니다. p는 저장된 QBit에만 적용되며, Array(Int8) 기준 벡터는 항상 전체 8비트 정밀도로 재구성됩니다. UInt
used_dims — 선택 사항입니다. stride된 QBit에서 축소 차원(Matryoshka) 검색을 수행하기 위해 읽을 선행 차원 수입니다. QBit stride의 배수여야 하고 차원을 초과할 수 없으며, 기준 벡터에는 최소한 이 개수만큼의 원소가 있어야 합니다(추가로 뒤에 있는 원소는 무시됩니다). 이러한 차원을 포함하는 stride 그룹만 읽습니다. UInt

반환 값 근사 코사인 거리(cosine similarity에서 1을 뺀 값)를 반환합니다. 반환 타입은 항상 Float64입니다. Float64 예시 기본 사용법

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

dotProductTransposed

도입 버전: v26.7.0 두 벡터의 근사 점곱(내적)을 계산합니다(벡터의 값이 좌표입니다). 거리 함수와 달리 이것은 유사도 척도이므로 반환 값이 클수록 벡터는 더 유사합니다. 구문

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

별칭: scalarProductTransposed 인수

vectors — 벡터. QBit(T, UInt64[, UInt64])
reference — 기준 벡터. Array(T)
p — 계산에 사용할 각 벡터 요소의 비트 수(1부터 요소 비트 폭까지). 양자화 수준은 정밀도와 속도 간의 상충 관계를 제어합니다. 더 적은 비트를 사용하면 정확도는 낮아지지만 I/O 및 계산 속도는 빨라지고, 더 많은 비트를 사용하면 성능 저하를 감수하는 대신 정확도가 높아집니다. UInt
used_dims — 선택 사항입니다. stride된 QBit에서 축소 차원(Matryoshka) 검색을 위해 읽을 선행 차원의 수입니다. QBit stride의 배수여야 하고 차원을 초과해서는 안 되며, 기준 벡터는 최소한 이 수만큼의 요소를 가져야 합니다(추가로 뒤에 오는 요소는 무시됩니다). 이 차원들을 포함하는 stride 그룹만 읽습니다. UInt

반환 값 두 벡터의 근사 내적을 반환합니다. 반환 타입은 항상 Float64입니다. Float64 예시 기본 사용법

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([0, 1], [1, 2], 16)─┐
│                                   2.0625 │
└──────────────────────────────────────────┘

dotProductTransposedQuantized

도입 버전: v26.7.0 quantizeBFloat16ToInt8 코드의 QBit(Int8)와 기준 벡터 사이의 근사 점곱(내적)을 계산합니다(역양자화는 필요한 시점에 수행됨). 이것은 유사도 척도이므로 반환 값이 클수록 벡터는 더 유사합니다. Float 기준(쿼리) 벡터는 역양자화된 코드의 복원 정밀도인 Float32 정밀도에서 직접 비교되므로 Float64 쿼리는 Float32로 축소되고 BFloat16 쿼리는 정확히 Float32로 확장됩니다(비대칭 거리 계산). Array(Int8) 기준은 그 자체로 quantizeBFloat16ToInt8 코드로 처리되며 해당 복원 수준으로 역양자화됩니다. p는 저장된 QBit 코드만 잘라낸다는 점에 유의하십시오. Array(Int8) 기준은 완전한 쿼리이며 항상 전체 8비트 정밀도로 복원되므로, 이것이 대칭적인 양자화 대 양자화 거리 계산이 되는 경우는 p = 8일 때뿐입니다(p < 8에서는 저장된 쪽만 더 거친 정밀도로 읽음). 이는 값이 양자화되기 전과 동일한 공간(즉, 동일한 무작위 회전과 스케일링 이후)에 있어야 하며, 이는 호출자의 책임입니다. 코사인 거리는 스케일 불변이지만 점곱과 L2 거리는 그렇지 않습니다. 구문

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

인수

vectors — quantizeBFloat16ToInt8 코드의 벡터. QBit(Int8, UInt64[, UInt64])
reference — 기준(쿼리) 벡터: Float 배열(Float32 정밀도로 비교되는 쿼리이며 Float64 쿼리는 Float32로 축소됨) 또는 필요 시 역양자화되는 quantizeBFloat16ToInt8 코드의 Array(Int8)입니다. Array(Float32) 또는 Array(Int8)
p — 사용할 저장된 각 QBit 코드의 상위 비트 수(1~8)입니다. 비트 수가 적을수록 정확도는 낮아지지만 더 빠른 I/O를 위해 더 거친 내장 양자화기를 재구성하며, 8비트는 전체 정밀도 재구성입니다. p는 저장된 QBit만 잘라내며, Array(Int8) 기준 벡터는 항상 전체 8비트 정밀도로 재구성됩니다. UInt
used_dims — 선택 사항입니다. stride된 QBit에서 축소 차원(Matryoshka) 검색을 위해 읽을 선행 차원의 수입니다. QBit stride의 배수여야 하고 차원을 초과해서는 안 되며, 기준 벡터는 최소한 이 수만큼의 원소를 가져야 합니다(추가 후행 원소는 무시됨). 이 차원들을 포함하는 stride 그룹만 읽습니다. UInt

반환 값 두 벡터의 근사 내적을 반환합니다. 반환 타입은 항상 Float64입니다. Float64 예시 기본 사용법

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;

​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