Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Tipi un dimensijas datiem

Nodarbība 7 no 18 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Lieluma un kvalitātes optimizēšana
  2. Pieci izvades tipi
  3. Ietekme uz kvalitāti
  4. Dimensiju samazināšana
  5. Izvēles ceļvedis
  6. Galvenās atziņas

Lieluma un kvalitātes optimizēšana

codestral-embed dod tev precīzu kontroli pār divām asīm: dimensiju skaitu un vērtību datu tipu (dtype). Šie parametri ļauj tev pielāgot līdzsvaru starp meklēšanas kvalitāti un krātuves vai aprēķinu izmaksām.

Tas kļūst kritiski svarīgi, apjomam pieaugot. Divu miljonu funkciju indekss ar 1536 float dimensijām sver aptuveni divpadsmit gigabaitus un vairs neietilpst standarta datoru operatīvajā atmiņā; tas pats indekss formātā int8 ar 768 dimensijām noslīd zem viena gigabaita un atkal kļūst pieejams vaicājumiem reāllaikā. Tieši šī aritmētika, nevis estētiska preference, ir tā, kam jāvadās tava izvēle.

Pieci izvades tipi

float (noklusējums)

Tips float ģenerē 32 bitu peldošā komata vērtības. Tas ir visprecīzākais formāts, ideāls gadījumos, kad kvalitātei ir prioritāte pār krātuves vietu.

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

Katra dimensija ir vesels skaitlis robežās no -128 līdz 127. Tas izmanto 4 reizes mazāk atmiņas nekā float32 ar minimālu kvalitātes zudumu. Salīdzini attēlotās vērtības ar iepriekšējā piemērā redzamajām: tas ir tas pats vektors, kvantēts uz rupjāku skalu, un rezultātu rangs paliek gandrīz nemainīgs.

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

Līdzīgs int8, bet ar vērtībām no 0 līdz 255 (bez zīmes). Noderīgs noteiktiem vektoru meklēšanas dzinējiem, kas pieņem tikai pozitīvas vērtības – ierobežojums, ko parasti atklāj integrācijas laikā, nevis pirms tam.

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

Visskompaktākais formāts. Katra dimensija tiek kvantēta līdz 1 bitam, pēc tam biti tiek sagrupēti pa 8 int8 vērtībās. Iegūtais vektors ir 32 reizes mazāks nekā float – turpmāk attēlotais garums 192 precīzi atbilst sākotnējām 1536 dimensijām, sapakotām pa astoņām.

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

Identisks binary, bet ar uint8 vērtībām (0–255) int8 (-128 līdz 127) vietā. Izvēle starp abiem ir atkarīga no tā, ko pieņem tavs nākamais krātuves dzinējs, nevis no meklēšanas kvalitātes.

Ietekme uz kvalitāti

Saspiešanas rādītāji nepasaka, ko tieši tu zaudē. Tālāk esošā funkcija to mēra konkrētā piemērā: palindroma tests, vaicāts franču valodā, kodēts secīgi ar trim dtypes. Iegūtās līdzības dod tev priekšstatu par degradācijas lieluma kārtu taviem pašiem datiem.

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

Ņem vērā, ka kods un vaicājums ciklā vienmēr tiek kodēti ar vienu un to pašu dtype. Tipu sajaukšana starp indeksu un vaicājumu radītu nekonsistentus rezultātus, un kļūda ir jo mānīga, ka tā neizraisa izņēmumu.

Dimensiju samazināšana

Parametrs output_dimension kontrolē vektora dimensiju skaitu. Tālāk esošais cikls iterē cauri sešām vērtībām un attēla viena vektora atmiņas pēdas nospiedumu katrai no tām, vispirms float, tad int8 formātā.

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

Izvade:

    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)

Reizini labo kolonnu ar savu faktisko vektoru skaitu, un tu uzreiz iegūsi sava servera izmēra aprēķinu. Starp 3072 dimensijām float un 768 int8 attiecība ir sešpadsmit: tas pats indekss samazinās no divpadsmit gigabaitiem uz septiņsimt piecdesmit megabaitiem.

Izvēles ceļvedis

Tālāk minētās konfigurācijas aptver visbiežāk sastopamos scenārijus:

KontekstsKonfigurācijaIemesls
Prototips / izstrādefloat + 1536 dimsnoklusējums, bez kompromisiem
Standarta produkcijafloat + 1024 dimslabs kvalitātes/izmaksu līdzsvars
Liels apjoms (miljoniem vektoru)int8 + 768 dims4x kompaktāks
Reāllaika meklēšana lielā mērogābinary + 1536 dimsātra prefiltrēšana, tad pārkārtot float
Iegultās sistēmas / edgeint8 + 256 dimsminimāli nepieciešamais

Rinda „reāllaiks” apraksta divu posmu arhitektūru, ko ir vērts saprast: ļoti vieglais binary indekss kalpo, lai milisekundēs izgūtu dažus simtus kandidātu; tikai šie kandidāti tiek pēc tam pārkārtoti, izmantojot float vektorus, kas ir dārgāki, bet daudz precīzāki. Tu iegūsti binary ātrumu un saraksta augšgalā – float precizitāti.

Galvenās atziņas

  • codestral-embed atbalsta 5 izvades tipus: float, int8, uint8, binary, ubinary
  • Binary tips ir 32 reizes kompaktāks nekā float ar pieņemamu kvalitātes zudumu prefiltrēšanai
  • Pirmās dimensijas satur visvairāk informācijas (Matrjoškas reprezentācija)
  • Apvieno samazinātas dimensijas + int8 ļoti kompaktiem indeksiem
  • Vienmēr testē uz saviem reālajiem datiem pirms ražošanas parametru izvēles