Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Andmetüübid ja mõõtmed

Õppetund 7 / 18 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Suuruse ja kvaliteedi optimeerimine
  2. Viis väljundtüüpi
  3. Mõju kvaliteedile
  4. Mõõtmete vähendamine
  5. Valiku juhend
  6. Peamised punktid

Suuruse ja kvaliteedi optimeerimine

codestral-embed annab sulle täpse kontrolli kahe telje üle: mõõtmete arvu ja väärtuste andmetüübi (dtype) üle. Need parameetrid võimaldavad sul häälestada kompromissi otsingu kvaliteedi ning salvestus- või arvutusmaksumuse vahel.

See muutub kriitiliseks, kui mahud kasvavad. Kahe miljoni funktsiooni indeks 1536 ujukoma-mõõtmega kaalub umbes kaksteist gigabaiti ja ei mahu enam tavalise masina mällu; sama indeks int8-formaadis 768 mõõtmega langeb alla ühe gigabaidi ja muutub taas reaalajas päritavaks. Just see aritmeetika, mitte esteetiline eelistus, peaks sinu valikuid juhtima.

Viis väljundtüüpi

float (vaikimisi)

Tüüp float genereerib 32-bitiseid ujukomaarve. See on kõige täpsem formaat, ideaalne juhul, kui kvaliteet on prioriteet salvestusruumi ees.

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

Iga mõõde on täisarv vahemikus -128 kuni 127. See kasutab 4 korda vähem mälu kui float32, kaotades kvaliteeti minimaalselt. Võrdle kuvatavaid väärtusi eelmise näite omadega: tegemist on sama vektoriga, kvanditud jämedama skaalaga, ja tulemuste järjestus jääb peaaegu muutumatuks.

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

Sarnane int8-ga, kuid väärtused on vahemikus 0 kuni 255 (märgita). Kasulik teatud vektorotsingumootorite jaoks, mis aktsepteerivad ainult positiivseid väärtusi – piirang, mille avastad tavaliselt integreerimise käigus, mitte enne seda.

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

Kõige kompaktsem formaat. Iga mõõde kvanditakse 1 bitiks, seejärel grupeeritakse bitid kaheksakaupa int8 väärtusteks. Tulemuseks olev vektor on 32 korda väiksem kui float – allpool kuvatav pikkus 192 vastab täpselt algsetele 1536 mõõtmele, pakituna kaheksakaupa.

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

Identne binary-ga, kuid kasutab uint8 väärtusi (0–255) int8 (-128 kuni 127) asemel. Kahe vahel valimine sõltub sellest, mida sinu järgmine salvestusmootor aktsepteerib, mitte otsingu kvaliteedist.

Mõju kvaliteedile

Tihendamise näitajad ei ütle sulle, mida tegelikult kaotad. Järgnev funktsioon mõõdab seda konkreetsel näitel: palindroomi test, päring prantsuse keeles, kodeeritud järjest kolme erineva dtype-ga. Saadud sarnasused annavad sulle hinnangu degradatsiooni suurusest oma andmetel.

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

Pane tähele, et kood ja päring kodeeritakse tsükli sees alati sama dtype-ga. Tüüpide segamine indeksi ja päringu vahel annaks ebajärjekindlaid tulemusi ning viga on seda salakavalam, et see ei tekita erandit.

Mõõtmete vähendamine

Parameeter output_dimension kontrollib vektori mõõtmete arvu. Allpool olev tsükkel läbib kuut väärtust ja kuvab igaühe puhul ühe vektori mälumahtu, esmalt float-formaadis, seejärel int8-formaadis.

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äljund:

    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)

Korruta parem veerg oma tegelike vektorite arvuga ja saad kohe oma serveri suuruse hinnangu. 3072 mõõtme (float) ja 768 mõõtme (int8) vahel on suhe kuusteist: sama indeks kahaneb kaheteistkümnest gigabaidist seitsmesaja viiekümne megabaidini.

Valiku juhend

Järgmised konfiguratsioonid katavad kõige sagedasemaid stsenaariume:

KontekstKonfiguratsioonPõhjus
Prototüüp / arendusfloat + 1536 mõõdetvaikimisi, ilma kompromissideta
Tavatootminefloat + 1024 mõõdethea kvaliteedi ja kulu tasakaal
Suur maht (miljonid vektoreid)int8 + 768 mõõdet4 korda kompaktsem
Suuremahuline reaalajas otsingbinary + 1536 mõõdetkiire eelfiltreerimine, seejärel ümberjärjestamine float-vormingus
Manussüsteem / ääresseadmedint8 + 256 mõõdetminimaalne elujõuline lahendus

Rida „reaalajas“ kirjeldab kaheastmelist arhitektuuri, mida tasub mõista: väga kergekaaluline binary-indeks teenib sadade kandidaatide toomist millisekunditega; ainult need kandidaadid järjestatakse seejärel ümber, kasutades float-vektoreid, mis on kulukamad, kuid palju täpsemad. Saad binary kiiruse ja nimekirja tipus floati täpsuse.

Peamised punktid

  • codestral-embed toetab 5 väljundtüüpi: float, int8, uint8, binary, ubinary
  • Binary-tüüp on 32 korda kompaktsem kui float, aktsepteeritava kvaliteedikaduga eelfiltreerimiseks
  • Esimesed mõõtmed sisaldavad kõige rohkem informatsiooni (Matrjoška-esitus)
  • Kombineeri vähendatud mõõtmed + int8 väga kompaktsete indeksite jaoks
  • Testi alati oma reaalsetel andmetel enne tootmisparameetrite valimist