Tipi podatkov in dimenzije
Na tej strani
Optimizacija velikosti in kakovosti
codestral-embed ti omogoča natančen nadzor nad dvema osema: številom dimenzij in tipom podatkov (dtype) vrednosti. Ti parametri ti omogočajo uravnavanje razmerja med kakovostjo iskanja ter stroški shranjevanja ali računanja.
To postane ključno, ko količine podatkov rastejo. Indeks dveh milijonov funkcij pri 1536 dimenzijah tipa float tehta približno dvanajst gigabajtov in se ne prilega več v pomnilnik standardnega stroja; isti indeks v formatu int8 pri 768 dimenzijah pade pod en gigabajt in ponovno omogoča poizvedbe v realnem času. Prav ta aritmetika, ne estetska preferenca, naj vodi tvoje odločitve.
Pet izhodnih tipov
float (privzeto)
Tip float proizvede 32-bitne vrednosti s plavajočo vejico. To je najbolj natančen format, idealen, ko ima kakovost prednost pred prostorom za shranjevanje.
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
Vsaka dimenzija je celo število med -128 in 127. To porabi 4-krat manj pomnilnika kot float32 z minimalno izgubo kakovosti. Primerjaj prikazane vrednosti s tistimi v prejšnjem primeru: gre za isti vektor, kvantiziran na grobjo lestvico, rangiranje rezultatov pa ostane skoraj nespremenjeno.
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
Podoben int8, vendar z vrednostmi med 0 in 255 (brez predznaka). Uporaben za določene iskalnike vektorskih podatkov, ki sprejemajo le pozitivne vrednosti – omejitev, ki jo običajno odkriješ med integracijo, ne pred njo.
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
Najbolj kompakten format. Vsaka dimenzija je kvantizirana na 1 bit, nato pa so biti združeni v pakete po 8 v vrednosti int8. Nastali vektor je 32-krat manjši od float – dolžina 192, prikazana spodaj, točno ustreza originalnim 1536 dimenzijam, zapakiranim po osem.
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čen binary, vendar z vrednostmi uint8 (0–255) namesto int8 (-128 do 127). Izbira med obema je odvisna od tega, kaj sprejme tvoj spodnji pogon za shranjevanje, ne od kakovosti iskanja.
Vpliv na kakovost
Številke o stiskanju ti ne povedo, kaj dejansko izgubljaš. Naslednja funkcija to izmeri na konkretnem primeru: testu palindroma, poizvedenem v francoščini, kodiranem zaporedoma s tremi tipi dtype. Dobljene podobnosti ti dajo red velikosti degradacije na tvojih lastnih podatkih.
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}")
Upoštevaj, da sta koda in poizvedba v zanki vedno kodirani z istim tipom dtype. Mešanje tipov med indeksom in poizvedbo bi proizvedlo nedosledne rezultate, napaka pa je toliko bolj zahrbtna, ker ne sproži izjeme.
Zmanjševanje dimenzij
Parameter output_dimension nadzira število dimenzij v vektorju. Spodnja zanka iterira skozi šest vrednosti in za vsako prikaže odtis v pomnilniku enega samega vektorja, najprej v float, nato 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)")
Izhod:
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)
Desni stolpec pomnoži s svojim dejanskim številom vektorjev in takoj dobiš velikost svojega strežnika. Razmerje med 3072 dimenzijami v float in 768 v int8 je šestnajst: isti indeks se zmanjša z dvanajstih gigabajtov na sedemsto petdeset megabajtov.
Vodnik za izbiro
Naslednje konfiguracije pokrivajo najpogostejše scenarije:
| Kontekst | Konfiguracija | Razlog |
|---|---|---|
| Prototip / razvoj | float + 1536 dim | privzeto, brez kompromisov |
| Standardna produkcija | float + 1024 dim | dobro razmerje kakovost/strošek |
| Velike količine (milijoni vektorjev) | int8 + 768 dim | 4-krat bolj kompaktno |
| Iskanje v realnem času v velikem obsegu | binary + 1536 dim | hitro predhodno filtriranje, nato ponovno rangiranje v float |
| Vgrajeni sistemi / robni računalniki | int8 + 256 dim | minimalno izvedljivo |
Vrstica „realni čas” opisuje dvostopenjsko arhitekturo, ki jo velja razumeti: zelo lahek binarni indeks služi za pridobivanje nekaj sto kandidatov v milisekundah; šele ti kandidati so nato ponovno rangirani z uporabo vektorjev float, ki so dražji, a veliko natančnejši. Tako dobiš hitrost binaryja in na vrhu seznama natančnost float.
Ključne ugotovitve
- codestral-embed podpira 5 izhodnih tipov: float, int8, uint8, binary, ubinary
- Tip binary je 32-krat bolj kompakten od float, z sprejemljivo izgubo kakovosti za predhodno filtriranje
- Prve dimenzije vsebujejo največ informacij (predstavitev Matroška)
- Združi zmanjšane dimenzije + int8 za zelo kompaktne indekse
- Pred izbiro produkcijskih parametrov vedno testiraj na svojih realnih podatkih