Adattípusok és dimenziók
Ezen az oldalon
Méret és minőség optimalizálása
A codestral-embed precíz kontrollt biztosít két tengely felett: a dimenziók száma és az értékek adattípusa (dtype) fölött. Ezekkel a paraméterekkel hangolhatod a keresés minősége és a tárolási vagy számítási költségek közötti kompromisszumot.
Ez akkor válik kritikussá, amikor a mennyiségek növekednek. Kétmillió függvényt tartalmazó index 1536 float dimenzióval körülbelül tizenkét gigabájtot nyom, és már nem fér be egy szabványos gép memóriájába; ugyanez az index int8 formátumban, 768 dimenzióval egy gigabájt alá csökken, és újra valós időben lekérdezhetővé válik. Nem esztétikai preferenciának, hanem ennek a számtani ténynek kell vezérelnie a döntéseidet.
Az öt kimeneti típus
float (alapértelmezett)
A float típus 32 bites lebegőpontos értékeket állít elő. Ez a legpontosabb formátum, ideális akkor, amikor a minőség elsőbbséget élvez a tárhellyel szemben.
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
Minden dimenzió egy egész szám -128 és 127 között. Ez négyszer kevesebb memóriát használ, mint a float32, minimális minőségvesztéssel. Hasonlítsd össze a megjelenített értékeket az előző példában lévőkkel: ugyanarról a vektorról van szó, amelyet durvább skálára kvantáltak, és az eredmények rangsora szinte változatlan marad.
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
Hasonló az int8-hoz, de az értékek 0 és 255 között vannak (előjel nélküli). Olyan vektorkereső motoroknál hasznos, amelyek csak pozitív értékeket fogadnak el – ez egy olyan kényszer, amit általában már az integráció során fedezel fel, nem előtte.
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
A legkompaktabb formátum. Minden dimenziót 1 bitre kvantálnak, majd a biteket 8-as csomagokba rendezik int8 értékekké. A kapott vektor 32-szer kisebb, mint a float – az alább megjelenített 192-es hossz pontosan megfelel az eredeti 1536 dimenziónak, nyolcasával csomagolva.
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
Ugyanaz, mint a binary, de uint8 értékekkel (0–255) az int8 (-128–127) helyett. A kettő közötti választás attól függ, mit fogad el a downstream tárolómotorod, nem pedig a keresés minőségétől.
Hatás a minőségre
A tömörítési arányok nem árulják el, pontosan mit veszítesz. A következő függvény ezt méri egy konkrét példán: egy palindróma-teszten, amelyet franciául kérdezel le, és három különböző dtype-tal kódolsz egymás után. A kapott hasonlósági értékek megadják a saját adataidon tapasztalható degradáció nagyságrendjét.
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}")
Figyeld meg, hogy a kód és a lekérdezés mindig ugyanazzal a dtype-tal kerül kódolásra a cikluson belül. Ha vegyítenéd a típusokat az index és a lekérdezés között, inkonzisztens pontszámokat kapnál, és a hiba annál alattomosabb, mert nem dob kivételt.
Dimenziók csökkentése
Az output_dimension paraméter szabályozza a vektor dimenzióinak számát. Az alábbi ciklus hat értéket jár be, és megjeleníti egyetlen vektor memóriafoglalását mindegyikhez, először floatban, majd int8-ban.
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)")
Kimenet:
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)
Szorozd meg a jobb oldali oszlopot a vektoraid tényleges számával, és máris megkapod a szervered méretezését. 3072 dimenzió floatban és 768 dimenzió int8-ban között az arány tizenhatos: ugyanaz az index tizenkét gigabájtról hétszázötven megabájtra csökken.
Kiválasztási útmutató
Az alábbi konfigurációk lefedik a leggyakoribb forgatókönyveket:
| Kontextus | Konfiguráció | Ok |
|---|---|---|
| Prototípus / fejlesztés | float + 1536 dim | alapértelmezett, kompromisszumok nélkül |
| Szabványos éles környezet | float + 1024 dim | jó minőség/költség egyensúly |
| Nagy volumen (millió vektor) | int8 + 768 dim | 4-szer kompaktabb |
| Nagy léptékű valós idejű keresés | binary + 1536 dim | gyors előszűrés, majd újrarangsorolás floatban |
| Beágyazott / peremhálózat (edge) | int8 + 256 dim | minimálisan életképes |
A „valós idejű“ sor egy kétszintű architektúrát ír le, amit érdemes megérteni: a rendkívül könnyű binary index szolgál arra, hogy milliszekundumok alatt visszanyerjen néhány száz jelöltet; csak ezeket a jelölteket rangsorolják újra a float vektorok segítségével, amelyek költségesebbek, de sokkal finomabbak. Így megkapod a binary sebességét, és a lista elején a float pontosságát.
Főbb megállapítások
- A codestral-embed 5 kimeneti típust támogat: float, int8, uint8, binary, ubinary
- A binary típus 32-szer kompaktabb, mint a float, elfogadható minőségvesztéssel az előszűréshez
- Az első dimenziók tartalmazzák a legtöbb információt (Matrjoska-reprezentáció)
- Kombináld a csökkentett dimenziókat az int8-cal a nagyon kompakt indexekért
- Mindig teszteld a valós adataidon, mielőtt kiválasztanád az éles paramétereket