Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Adattípusok és dimenziók

7. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Méret és minőség optimalizálása
  2. Az öt kimeneti típus
  3. Hatás a minőségre
  4. Dimenziók csökkentése
  5. Kiválasztási útmutató
  6. Főbb megállapítások

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:

KontextusKonfigurációOk
Prototípus / fejlesztésfloat + 1536 dimalapértelmezett, kompromisszumok nélkül
Szabványos éles környezetfloat + 1024 dimjó minőség/költség egyensúly
Nagy volumen (millió vektor)int8 + 768 dim4-szer kompaktabb
Nagy léptékű valós idejű keresésbinary + 1536 dimgyors előszűrés, majd újrarangsorolás floatban
Beágyazott / peremhálózat (edge)int8 + 256 dimminimá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