Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Typy dat a dimenze

Lekce 7 z 18 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Optimalizace velikosti a kvality
  2. Pět výstupních typů
  3. Dopad na kvalitu
  4. Redukce dimenzí
  5. Průvodce výběrem
  6. Klíčové poznatky

Optimalizace velikosti a kvality

codestral-embed ti dává přesnou kontrolu nad dvěma osami: počtem dimenzí a datovým typem (dtype) hodnot. Tyto parametry ti umožňují ladit kompromis mezi kvalitou vyhledávání a náklady na úložiště nebo výpočetní výkon.

To se stává kritickým, jak objemy rostou. Index dvou milionů funkcí s 1536 dimenzemi typu float váží přibližně dvanáct gigabajtů a již se nevejde do paměti běžného stroje; stejný index v int8 s 768 dimenzemi klesne pod jeden gigabajt a opět se stává dotazovatelným v reálném čase. Právě tato aritmetika, nikoliv estetická preference, by měla řídit tvá rozhodnutí.

Pět výstupních typů

float (výchozí)

Typ float produkuje 32bitové hodnoty s plovoucí řádovou čárkou. Jedná se o nejpřesnější formát, ideální, když má kvalita přednost před úložným prostorem.

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á dimenze je celé číslo mezi -128 a 127. Tento formát využívá 4× méně paměti než float32 s minimální ztrátou kvality. Porovnej zobrazené hodnoty s těmi v předchozím příkladu: jde o stejný vektor, kvantovaný na hrubší stupnici, a pořadí výsledků zůstává téměř nezměněno.

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é jako int8, ale s hodnotami mezi 0 a 255 (bez znaménka). Užitečné pro určité vyhledávací stroje vektorů, které přijímají pouze kladné hodnoty – toto omezení obvykle objevíš až během integrace, nikoliv předem.

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

Nejkompaktnější formát. Každá dimenze je kvantována na 1 bit, poté jsou bity seskupeny do balíčků po 8 do hodnot int8. Výsledný vektor je 32× menší než float – délka 192 zobrazená níže přesně odpovídá původním 1536 dimenzím, zabaleným po osmi.

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é jako binary, ale s hodnotami uint8 (0–255) místo int8 (-128 až 127). Volba mezi těmito dvěma závisí na tom, co přijímá tvůj downstream úložný engine, nikoliv na kvalitě vyhledávání.

Dopad na kvalitu

Čísla o kompresi ti neřeknou, co přesně ztrácíš. Následující funkce to měří na konkrétním příkladu: test palindromu, dotazovaný ve francouzštině, kódovaný postupně se třemi typy dtype. Výsledné podobnosti ti dají představu o řádu degradace na tvých vlastních datech.

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 i dotaz jsou uvnitř smyčky vždy kódovány se stejným dtype. Míchání typů mezi indexem a dotazem by vedlo k nekonzistentním skóre a chyba je tím zákeřnější, že nevyvolá žádnou výjimku.

Redukce dimenzí

Parametr output_dimension řídí počet dimenzí ve vektoru. Níže uvedená smyčka iteruje přes šest hodnot a pro každou zobrazuje paměťovou stopu jednoho vektoru, nejprve ve float a poté 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ý sloupec svým skutečným počtem vektorů a okamžitě získáš sizing svého serveru. Mezi 3072 dimenzemi ve float a 768 v int8 je poměr šestnáct: stejný index přejde z dvanácti gigabajtů na sedm set padesát megabajtů.

Průvodce výběrem

Následující konfigurace pokrývají nejčastější scénáře:

KontextKonfiguraceDůvod
Prototyp / vývojfloat + 1536 dimenzívýchozí, žádný kompromis
Standardní produkcefloat + 1024 dimenzídobrý poměr kvalita/cena
Vysoký objem (miliony vektorů)int8 + 768 dimenzí4× kompaktnější
Vyhledávání ve velkém měřítku v reálném časebinary + 1536 dimenzírychlé předběžné filtrování, poté přehodnocení ve float
Embedded / edgeint8 + 256 dimenzíminimum viable

Řádek „reálný čas“ popisuje dvoufázovou architekturu, kterou stojí za to pochopit: velmi lehký binární index slouží k získání několika stovek kandidátů v řádu milisekund; pouze tito kandidáti jsou následně přehodnoceni pomocí float vektorů, které jsou nákladnější, ale mnohem přesnější. Získáš tak rychlost binary a na vrcholu seznamu přesnost float.

Klíčové poznatky

  • codestral-embed podporuje 5 výstupních typů: float, int8, uint8, binary, ubinary
  • Typ binary je 32× kompaktnější než float, s přijatelnou ztrátou kvality pro předběžné filtrování
  • První dimenze obsahují nejvíce informací (reprezentace Matryoshka)
  • Kombinuj redukované dimenze + int8 pro velmi kompaktní indexy
  • Před výběrem produkčních parametrů vždy testuj na svých reálných datech