Andmetüübid ja mõõtmed
Sellel lehel
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:
| Kontekst | Konfiguratsioon | Põhjus |
|---|---|---|
| Prototüüp / arendus | float + 1536 mõõdet | vaikimisi, ilma kompromissideta |
| Tavatootmine | float + 1024 mõõdet | hea kvaliteedi ja kulu tasakaal |
| Suur maht (miljonid vektoreid) | int8 + 768 mõõdet | 4 korda kompaktsem |
| Suuremahuline reaalajas otsing | binary + 1536 mõõdet | kiire eelfiltreerimine, seejärel ümberjärjestamine float-vormingus |
| Manussüsteem / ääresseadmed | int8 + 256 mõõdet | minimaalne 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