Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Typy údajov a dimenzie

Lekcia 7 z 18 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Optimalizácia veľkosti a kvality
  2. Päť výstupných typov
  3. Vplyv na kvalitu
  4. Znižovanie dimenzií
  5. Sprievodca výberom
  6. Kľúčové poznatky

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:

KontextKonfiguráciaDôvod
Prototyp / vývojfloat + 1536 dimspredvolené, žiadny kompromis
Štandardná produkciafloat + 1024 dimsdobrý pomer kvality a nákladov
Vysoký objem (milióny vektorov)int8 + 768 dims4-krát kompaktnejšie
Vyhľadávanie vo veľkom meradle v reálnom časebinary + 1536 dimsrýchle predbežné filtrovanie, následné prehodnotenie vo float
Embedded / edge zariadeniaint8 + 256 dimsminimum 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