Типове данни и измерения
На тази страница
Оптимизиране на размера и качеството
codestral-embed Ви дава прецизен контрол над две оси: броят на измеренията и типът данни (dtype) на стойностите. Тези параметри Ви позволяват да балансирате между качеството на търсенето и разходите за съхранение или изчислителна мощ.
Това става критично с нарастването на обемите. Индекс от два милиона функции при 1536 измерения с плаваща запетая тежи около дванадесет гигабайта и вече не се събира в паметта на стандартна машина; същият индекс в int8 при 768 измерения спада под един гигабайт и отново става достъпен за заявки в реално време. Именно тази аритметика, а не естетическо предпочитание, трябва да направлява избора Ви.
Петте изходни типа
float (по подразбиране)
Типът float генерира 32-битови стойности с плаваща запетая. Това е най-прецизният формат, идеален когато качеството има приоритет пред мястото за съхранение.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
response = client.embeddings.create(
model="codestral-embed",
output_dtype="float",
inputs=["def hello(): print('world')"],
)
embedding = response.data[0].embedding
print(f"Type: float, Values: {embedding[:5]}")
# [0.0234375, -0.15625, 0.08984375, 0.01171875, -0.046875]
int8
Всяко измерение е цяло число между -128 и 127. Това използва 4 пъти по-малко памет от float32 с минимална загуба на качество. Сравнете показаните стойности с тези от предишния пример: това е същият вектор, квантуван до по-груба скала, а класирането на резултатите остава почти непроменено.
response = client.embeddings.create(
model="codestral-embed",
output_dtype="int8",
inputs=["def hello(): print('world')"],
)
embedding = response.data[0].embedding
print(f"Type: int8, Values: {embedding[:5]}")
# [3, -20, 11, 1, -6]
uint8
Подобно на int8, но със стойности между 0 и 255 (без знак). Полезно за определени двигатели за векторно търсене, които приемат само положителни стойности – ограничение, което обикновено откривате по време на интеграцията, а не преди нея.
response = client.embeddings.create(
model="codestral-embed",
output_dtype="uint8",
inputs=["def hello(): print('world')"],
)
embedding = response.data[0].embedding
print(f"Type: uint8, Values: {embedding[:5]}")
# [131, 108, 139, 129, 122]
binary
Най-компактният формат. Всяко измерение се квантува до 1 бит, след което битовете се групират в пакети по 8 в стойности int8. Полученият вектор е 32 пъти по-малък от float – дължината от 192, показана по-долу, съответства точно на оригиналните 1536 измерения, опаковани по осем.
response = client.embeddings.create(
model="codestral-embed",
output_dtype="binary",
inputs=["def hello(): print('world')"],
)
embedding = response.data[0].embedding
print(f"Type: binary, Length: {len(embedding)}")
# Length: 192 (instead of 1536 in float)
ubinary
Идентичен с binary, но със стойности uint8 (0-255) вместо int8 (-128 до 127). Изборът между двата зависи от това какво приема Вашият низходящ двигател за съхранение, а не от качеството на търсенето.
Влияние върху качеството
Числата за компресия не Ви казват какво точно губите. Следната функция измерва това на конкретен пример: тест за палиндром, заявен на френски, кодиран последователно с три типа данни. Получените сходства Ви дават порядъка на деградация върху Вашите собствени данни.
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
def compare_dtypes(code_snippet, query):
"""Compare search quality by dtype."""
dtypes = ["float", "int8", "uint8"]
results = {}
for dtype in dtypes:
# Encode code and query with the same dtype
resp_code = client.embeddings.create(
model="codestral-embed",
output_dtype=dtype,
inputs=[code_snippet],
)
resp_query = client.embeddings.create(
model="codestral-embed",
output_dtype=dtype,
inputs=[query],
)
emb_code = np.array(resp_code.data[0].embedding, dtype=np.float32)
emb_query = np.array(resp_query.data[0].embedding, dtype=np.float32)
sim = cosine_similarity([emb_code], [emb_query])[0][0]
results[dtype] = sim
return results
# Test
code = "def is_palindrome(s): return s == s[::-1]"
query = "fonction qui vérifie si un mot est un palindrome"
scores = compare_dtypes(code, query)
for dtype, score in scores.items():
print(f" {dtype:8s}: similarity = {score:.4f}")
Обърнете внимание, че кодът и заявката винаги се кодират с един и същи тип данни вътре в цикъла. Смесването на типове между индекса и заявката би довело до несъответстващи резултати, а грешката е толкова коварна, защото не предизвиква никакво изключение.
Намаляване на измеренията
Параметърът output_dimension контролира броя на измеренията във вектора. Цикълът по-долу итерира през шест стойности и показва отпечатъка в паметта на един вектор за всяка от тях, първо във float, след това в int8.
import numpy as np
# Compare different dimensions
dims = [256, 512, 768, 1024, 1536, 3072]
for dim in dims:
response = client.embeddings.create(
model="codestral-embed",
output_dimension=dim,
inputs=["def quicksort(arr): ..."],
)
emb = response.data[0].embedding
# Approximate memory size
size_float32 = dim * 4 # 4 bytes per float32
size_int8 = dim * 1 # 1 byte per int8
print(f" {dim:5d} dims -> {size_float32:6d} bytes (float) | {size_int8:5d} bytes (int8)")
Изход:
256 dims -> 1024 bytes (float) | 256 bytes (int8)
512 dims -> 2048 bytes (float) | 512 bytes (int8)
768 dims -> 3072 bytes (float) | 768 bytes (int8)
1024 dims -> 4096 bytes (float) | 1024 bytes (int8)
1536 dims -> 6144 bytes (float) | 1536 bytes (int8)
3072 dims -> 12288 bytes (float) | 3072 bytes (int8)
Умножете дясната колона по действителния брой вектори и веднага получавате оразмеряването на сървъра си. Между 3072 измерения във float и 768 в int8 съотношението е шестнадесет: един и същи индекс преминава от дванадесет гигабайта на седемстотин и петдесет мегабайта.
Ръководство за избор
Следните конфигурации покриват най-честите сценарии:
| Контекст | Конфигурация | Причина |
|---|---|---|
| Прототип / разработка | float + 1536 dims | по подразбиране, без компромиси |
| Стандартна продукция | float + 1024 dims | добър баланс качество/разходи |
| Голям обем (милиони вектори) | int8 + 768 dims | 4 пъти по-компактен |
| Векторно търсене в реално време в мащаб | binary + 1536 dims | бързо предварително филтриране, след това повторно класиране във float |
| Вградени системи / ръб (Edge) | int8 + 256 dims | минимално жизнеспособен |
Редът „реално време“ описва двуетапна архитектура, която си струва да разберете: много лекият binary индекс служи за извличане на няколкостотин кандидати за милисекунди; само тези кандидати след това се прекласират, използвайки float векторите, които са по-скъпи, но много по-фини. Получавате скоростта на binary и, в началото на списъка, прецизността на float.
Ключови изводи
- codestral-embed поддържа 5 изходни типа: float, int8, uint8, binary, ubinary
- Типът binary е 32 пъти по-компактен от float, с приемлива загуба на качество за предварително филтриране
- Първите измерения съдържат най-много информация (представяне Матрьошка)
- Комбинирайте намалени измерения + int8 за много компактни индекси
- Винаги тествайте върху реалните си данни, преди да изберете параметри за продукция