Tipuri de date și dimensiuni
Pe această pagină
Optimizarea dimensiunii și a calității
codestral-embed vă oferă un control precis asupra a două axe: numărul de dimensiuni și tipul de date (dtype) al valorilor. Acești parametri vă permit să reglați compromisul dintre calitatea căutării și costurile de stocare sau de calcul.
Această alegere devine critică pe măsură ce volumele de date cresc. Un index de două milioane de funcții la 1536 de dimensiuni float ocupă aproximativ doisprezece gigabytes și nu mai încap în memoria unei mașini standard; același index în int8 la 768 de dimensiuni scade sub un gigabyte și devine din nou interogabil în timp real. Este această aritmetică, nu o preferință estetică, cea care trebuie să vă ghideze alegerile.
Cele cinci tipuri de ieșire
float (implicit)
Tipul float produce valori în virgulă mobilă pe 32 de biți. Acesta este formatul cel mai precis, ideal atunci când calitatea are prioritate față de spațiul de stocare.
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
Fiecare dimensiune este un număr întreg între -128 și 127. Acest format utilizează de 4 ori mai puțină memorie decât float32, cu o pierdere minimă de calitate. Comparați valorile afișate cu cele din exemplul anterior: este același vector, cuantizat la o scară mai grosieră, iar clasamentul rezultatelor rămâne aproape neschimbat.
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
Similar cu int8, dar cu valori între 0 și 255 (fără semn). Util pentru anumite motoare de căutare vectorială care acceptă doar valori pozitive – o constrângere pe care o descoperiți de obicei în timpul integrării, nu înainte.
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
Cel mai compact format. Fiecare dimensiune este cuantizată la 1 bit, apoi biții sunt grupați în pachete de câte 8 în valori int8. Vectorul rezultat este de 32 de ori mai mic decât float – lungimea de 192 afișată mai jos corespunde exact celor 1536 de dimensiuni originale, împachetate câte opt.
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
Identical cu binary, dar cu valori uint8 (0-255) în loc de int8 (-128 până la 127). Alegerea dintre cele două depinde de ceea ce acceptă motorul de stocare din aval, nu de calitatea căutării.
Impactul asupra calității
Cifrele de compresie nu vă spun exact ce pierdeți. Funcția următoare măsoară acest aspect pe un exemplu concret: un test de palindrom, interogat în franceză, codificat succesiv cu trei tipuri de date. Similaritățile rezultate vă oferă ordinul de mărime al degradării pe propriile dumneavoastră date.
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}")
Rețineți că codul și interogarea sunt întotdeauna codificate cu același dtype în interiorul buclei. Amestecarea tipurilor între index și interogare ar produce scoruri inconsistente, iar eroarea este cu atât mai insidioasă cu cât nu generează nicio excepție.
Reducerea dimensiunilor
Parametrul output_dimension controlează numărul de dimensiuni din vector. Bucla de mai jos iterează prin șase valori și afișează amprenta de memorie a unui singur vector pentru fiecare, mai întâi în float, apoi în 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)")
Rezultat:
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)
Înmulțiți coloana din dreapta cu numărul real de vectori și obțineți imediat dimensionarea serverului dumneavoastră. Între 3072 de dimensiuni în float și 768 în int8, raportul este de șaisprezece: același index trece de la doisprezece gigabytes la șapte sute cincizeci de megabytes.
Ghid de selecție
Configurațiile următoare acoperă cele mai frecvente scenarii:
| Context | Configurație | Motiv |
|---|---|---|
| Prototip / dezvoltare | float + 1536 dims | implicit, fără compromis |
| Producție standard | float + 1024 dims | bun echilibru calitate/cost |
| Volum mare (milioane de vectori) | int8 + 768 dims | de 4 ori mai compact |
| Căutare în timp real la scară largă | binary + 1536 dims | pre-filtrare rapidă, apoi re-clasificare în float |
| Încorporat / edge | int8 + 256 dims | minimul viabil |
Linia „timp real“ descrie o arhitectură în două etape care merită înțeleasă: indexul binary foarte ușor servește la recuperarea câtorva sute de candidați în milisecunde; doar acești candidați sunt apoi re-clasificați folosind vectorii float, care sunt mai costisitori, dar mult mai fini. Obțineți viteza binary și, în vârful listei, precizia float.
Puncte cheie
- codestral-embed suportă 5 tipuri de ieșire: float, int8, uint8, binary, ubinary
- Tipul binary este de 32 de ori mai compact decât float, cu o pierdere de calitate acceptabilă pentru pre-filtrare
- Primele dimensiuni conțin cea mai mare parte a informației (reprezentare Matryoshka)
- Combinați dimensiuni reduse + int8 pentru indexuri foarte compacte
- Testați întotdeauna pe datele reale înainte de a alege parametrii de producție