Typy údajov a dimenzie
Na tejto strane
Optimalizácia veľkosti a kvality
codestral-embed ti poskytuje presnú kontrolu nad dvoma osami: počtom dimenzií a typom údajov (dtype) hodnôt. Tieto parametre ti umožňujú vyvážiť kompromis medzi kvalitou vyhľadávania a nákladmi na úložisko alebo výpočtový výkon.
Toto sa stáva kritickým, keď objemy dát rastú. Index dvoch miliónov funkcií s 1536 rozmermi typu float váži približne dvanásť gigabajtov a už sa nezmestí do pamäte štandardného stroja; ten istý index v formáte int8 s 768 rozmermi klesne pod jeden gigabajt a opäť sa stáva dostupným pre dotazy v reálnom čase. Práve táto aritmetika, nie estetická preferencia, by mala viesť tvoje rozhodnutia.
Päť výstupných typov
float (predvolený)
Typ float produkuje 32-bitové hodnoty s pohyblivou desatinnou čiarkou. Toto je najpresnejší formát, ideálny vtedy, keď má kvalita prednosť pred úložným priestorom.
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
Každá dimenzia je celé číslo medzi -128 a 127. Tento formát využíva 4-krát menej pamäte než float32 pri minimálnej strate kvality. Porovnaj zobrazené hodnoty s tými z predchádzajúceho príkladu: ide o ten istý vektor, kvantovaný na hrubšiu stupnicu, a poradie výsledkov zostáva takmer nezmenené.
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
Podobné ako int8, ale s hodnotami medzi 0 a 255 (bez znamienka). Užitočné pre určité vyhľadávacie stroje pre vektory, ktoré akceptujú iba kladné hodnoty – obmedzenie, na ktoré zvyčajne narazíš až počas integrácie, nie pred ňou.
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
Najkompaktnejší formát. Každá dimenzia je kvantovaná na 1 bit, následne sú bity zoskupené do balíčkov po 8 do hodnôt int8. Výsledný vektor je 32-krát menší než float – dĺžka 192 zobrazená nižšie presne zodpovedá pôvodným 1536 dimenziám, zabaleným po ôsmich.
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
Identické ako binary, ale s hodnotami uint8 (0-255) namiesto int8 (-128 až 127). Výber medzi týmito dvoma závisí od toho, čo akceptuje tvoje downstreamové úložné engine, nie od kvality vyhľadávania.
Vplyv na kvalitu
Čísla o kompresii ti nepovedia, čo presne strácaš. Nasledujúca funkcia to meria na konkrétnom príklade: teste palindrómu, kde je dotaz vo francúzštine a kódovanie sa vykonáva postupne s tromi typmi dtype. Výsledné podobnosti ti poskytnú predstavu o miere degradácie na tvojich vlastných dátach.
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}")
Všimni si, že kód aj dotaz sú vo vnútri cyklu vždy kódované s rovnakým typom dtype. Miešanie typov medzi indexom a dotazom by viedlo k nekonzistentným skóre a táto chyba je o to zákernejšia, že nespôsobí žiadnu výnimku.
Znižovanie dimenzií
Parameter output_dimension riadi počet dimenzií vo vektore. Nižšie uvedený cyklus prechádza šiestimi hodnotami a zobrazuje veľkosť pamäte pre jeden vektor pre každú z nich, najprv vo formáte float a potom v 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)")
Výstup:
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)
Vynásob pravý stĺpec svojím skutočným počtom vektorov a okamžite získaš odhad veľkosti svojho servera. Medzi 3072 dimenziami vo formáte float a 768 v int8 je pomer šestnásť: ten istý index prejde z dvanástich gigabajtov na sedemsto päťdesiat megabajtov.
Sprievodca výberom
Nasledujúce konfigurácie pokrývajú najčastejšie scenáre:
| Kontext | Konfigurácia | Dôvod |
|---|---|---|
| Prototyp / vývoj | float + 1536 dims | predvolené, žiadny kompromis |
| Štandardná produkcia | float + 1024 dims | dobrý pomer kvality a nákladov |
| Vysoký objem (milióny vektorov) | int8 + 768 dims | 4-krát kompaktnejšie |
| Vyhľadávanie vo veľkom meradle v reálnom čase | binary + 1536 dims | rýchle predbežné filtrovanie, následné prehodnotenie vo float |
| Embedded / edge zariadenia | int8 + 256 dims | minimum potrebné na fungovanie |
Riadok „reálny čas“ opisuje dvojstupňovú architektúru, ktorú stojí za to pochopiť: veľmi ľahký binárny index slúži na získanie niekoľkých stoviek kandidátov v priebehu milisekúnd; až následne sú títo kandidáti prehodnotení pomocou vektorov float, ktoré sú nákladnejšie, ale oveľa presnejšie. Získaš tak rýchlosť binárneho formátu a na vrchole zoznamu presnosť formátu float.
Kľúčové poznatky
- codestral-embed podporuje 5 výstupných typov: float, int8, uint8, binary, ubinary
- Typ binary je 32-krát kompaktnejší než float, so stratou kvality prijateľnou pre predbežné filtrovanie
- Prvé dimenzie obsahujú najviac informácií (reprezentácia Matryoška)
- Kombinuj znížený počet dimenzií + int8 pre veľmi kompaktné indexy
- Pred výberom produkčných parametrov vždy testuj na svojich reálnych dátach