Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Tipovi i dimenzije podataka

Lekcija 7 od 18 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Optimizacija veličine i kvalitete
  2. Pet izlaznih tipova
  3. Utjecaj na kvalitetu
  4. Smanjenje dimenzija
  5. Vodič za odabir
  6. Ključne točke

Optimizacija veličine i kvalitete

codestral-embed daje ti preciznu kontrolu nad dvije osi: brojem dimenzija i tipom podataka (dtype) vrijednosti. Ovi parametri omogućuju ti podešavanje kompromisa između kvalitete pretraživanja te troškova pohrane ili računanja.

Ovo postaje ključno kako volumeni rastu. Indeks od dva milijuna funkcija na 1536 float dimenzija teži oko dvanaest gigabajta i više ne staje u memoriju standardnog stroja; isti indeks u int8 formatu na 768 dimenzija pada ispod jednog gigabajta i ponovno postaje upitan u stvarnom vremenu. Upravo ta aritmetika, a ne estetska preferencija, treba voditi tvoj izbor.

Pet izlaznih tipova

float (zadano)

Tip float proizvodi 32-bitne vrijednosti s pomičnim zarezom. Ovo je najprecizniji format, idealan kada je kvaliteta prioritet nad prostorom za pohranu.

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

Svaka dimenzija je cijeli broj između -128 i 127. Ovo koristi 4 puta manje memorije od float32 uz minimalan gubitak kvalitete. Usporedi prikazane vrijednosti s onima iz prethodnog primjera: radi se o istom vektoru, kvantiziranom na grublju skalu, a rangiranje rezultata ostaje gotovo nepromijenjeno.

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

Slično kao int8, ali s vrijednostima između 0 i 255 (nepredznačeno). Korisno za određene motore za vektorsko pretraživanje koji prihvaćaju samo pozitivne vrijednosti – ograničenje koje obično otkriješ tijekom integracije, a ne prije.

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

Najkompaktniji format. Svaka dimenzija kvantizirana je na 1 bit, zatim se bitovi grupiraju u pakete od 8 u int8 vrijednosti. Rezultirajući vektor je 32 puta manji od float formata – duljina od 192 prikazana u nastavku točno odgovara izvornih 1536 dimenzija, spakiranih osam po osam.

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

Identično kao binary, ali s uint8 vrijednostima (0-255) umjesto int8 (-128 do 127). Izbor između ova dva ovisi o tome što tvoj silazni engine za pohranu prihvaća, a ne o kvaliteti pretraživanja.

Utjecaj na kvalitetu

Brojke o kompresiji ne govore ti što točno gubiš. Sljedeća funkcija mjeri to na konkretnom primjeru: test palindroma, upit na francuskom, kodiran sukcesivno s tri različita dtype-a. Rezultirajuće sličnosti daju ti red veličine degradacije na tvojim vlastitim podacima.

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}")

Imaj na umu da su kod i upit uvijek kodirani s istim dtype-om unutar petlje. Miješanje tipova između indeksa i upita proizvelo bi nekonzistentne rezultate, a greška je utoliko podmuklija jer ne izaziva nikakvu iznimku.

Smanjenje dimenzija

Parametar output_dimension kontrolira broj dimenzija u vektoru. Donja petlja iterira kroz šest vrijednosti i prikazuje memorijski otisak jednog vektora za svaku, prvo u float, zatim u int8 formatu.

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)")

Izlaz:

    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)

Pomnoži desni stupac sa svojim stvarnim brojem vektora i odmah dobivaš dimenzioniranje poslužitelja. Između 3072 dimenzije u float formatu i 768 u int8 formatu, omjer je šesnaest: isti indeks prelazi s dvanaest gigabajta na sedamsto pedeset megabajta.

Vodič za odabir

Sljedeće konfiguracije pokrivaju najčešće scenarije:

KontekstKonfiguracijaRazlog
Prototip / razvojfloat + 1536 dimzadano, bez kompromisa
Standardna produkcijafloat + 1024 dimdobra ravnoteža kvalitete i troškova
Veliki volumen (milijuni vektora)int8 + 768 dim4 puta kompaktnije
Pretraživanje u stvarnom vremenu velikih razmjerabinary + 1536 dimbrzo predfiltriranje, zatim ponovno rangiranje u float
Ugrađeni sustavi / rubni uređajiint8 + 256 dimminimalno održivo

Redak „stvarno vrijeme“ opisuje dvostupanjsku arhitekturu koju vrijedi razumjeti: vrlo lagani binary indeks služi za dohvat nekoliko stotina kandidata u milisekundama; tek se ti kandidati zatim ponovno rangiraju korištenjem float vektora, koji su skuplji, ali mnogo precizniji. Dobivaš brzinu binary formata i, na vrhu liste, preciznost float formata.

Ključne točke

  • codestral-embed podržava 5 izlaznih tipova: float, int8, uint8, binary, ubinary
  • Binary tip je 32 puta kompaktniji od float formata, s prihvatljivim gubitkom kvalitete za predfiltriranje
  • Prve dimenzije sadrže najviše informacija (Matrjoška reprezentacija)
  • Kombiniraj smanjene dimenzije + int8 za vrlo kompaktne indekse
  • Uvijek testiraj na svojim stvarnim podacima prije odabira produkcijskih parametara