Tietotyypit ja ulottuvuudet
Tällä sivulla
Koon ja laadun optimointi
codestral-embed antaa sinulle tarkan hallinnan kahteen akseliin: ulottuvuuksien määrään ja arvojen tietotyyppiin (dtype). Näiden parametrien avulla voit säätää hakulaadun sekä tallennus- tai laskentakustannusten välistä kompromissia.
Tämä muuttuu kriittiseksi volyymien kasvaessa. Kahden miljoonan funktion indeksi 1536 float-ulottuvuudella painaa noin kaksitoista gigatavua eikä mahdu enää tavallisen koneen muistiin; sama indeksi int8-muodossa 768 ulottuvuudella jää alle yhden gigatavun ja on taas kyseltävissä reaaliajassa. Juuri tämä laskutoimitus, ei esteettinen mieltymys, devrait ohjata valintojasi.
Viisi tulostyyppiä
float (oletus)
float-tyyppi tuottaa 32-bittisiä liukulukuja. Tämä on tarkin muoto, ihanteellinen silloin, kun laatu on etusijalla tallennustilaan nähden.
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
Jokainen ulottuvuus on kokonaisluku välillä -128–127. Tämä vie 4 kertaa vähemmän muistia kuin float32, ja laadun menetys on minimaalista. Vertaa näytettyjä arvoja edelliseen esimerkkiin: kyseessä on sama vektori, kvantisoitu karkeammalle asteikolle, ja tulosten järjestys pysyy lähes muuttumattomana.
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
Samanlainen kuin int8, mutta arvot ovat välillä 0–255 (etumerkitön). Hyödyllinen tietyille vektorihakukoneille, jotka hyväksyvät vain positiivisia arvoja – rajoitus, jonka huomaat yleensä vasta integraation aikana, et aiemmin.
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
Tiivein muoto. Jokainen ulottuvuus kvantisoidaan 1 bitiksi, jonka jälkeen bitit ryhmitellään 8 bitin paketteihin int8-arvoiksi. Tuloksena oleva vektori on 32 kertaa pienempi kuin float – alla näkyvä 192:n pituus vastaa täsmälleen alkuperäisiä 1536 ulottuvuutta, pakattuna kahdeksan kerrallaan.
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
Identtinen binaryn kanssa, mutta käyttää uint8-arvoja (0–255) int8-arvojen (-128–127) sijaan. Valinta näiden välillä riippuu siitä, mitä downstream-tallennusmoottorisi hyväksyy, ei hakulaadusta.
Vaikutus laatuun
Pakkaussuhteet eivät kerro, mitä todellisuudessa menetetään. Seuraava funktio mittaa tätä konkreettisella esimerkillä: palindromitesti, jossa kysely tehdään ranskaksi ja koodaus suoritetaan peräkkäin kolmella eri dtype-arvolla. Tuloksena saatavat samankaltaisuudet antavat sinulle käsityksen heikkenemisen suuruusluokasta omassa datassasi.
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}")
Huomaa, että koodi ja kysely koodataan aina silmukan sisällä samalla dtype-arvolla. Tyyppien sekoittaminen indeksin ja kyselyn välillä tuottaisi epäjohdonmukaisia pisteitä, ja virhe on sitä salakavalampi, ettei se aiheuta poikkeusta.
Ulottuvuuksien vähentäminen
output_dimension-parametri ohjaa vektorin ulottuvuuksien määrää. Alla oleva silmukka käy läpi kuusi arvoa ja näyttää yhden vektorin muistijalanjäljen kullekin, ensin float-muodossa ja sitten int8-muodossa.
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)")
Tuloste:
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)
Kerro oikeanpuoleinen sarake vektoridesi todellisella määrällä, niin saat heti selville palvelimesi mitoituksen. 3072 ulottuvuuden (float) ja 768 ulottuvuuden (int8) välinen suhde on kuusitoista: sama indeksi kutistuu kahdestatoista gigatavusta seitsemään sataan viiteenkymmeneen megatavuun.
Valintaopas
Seuraavat konfiguraatiot kattavat yleisimmät skenaariot:
| Konteksti | Konfiguraatio | Syy |
|---|---|---|
| Prototyyppi / kehitys | float + 1536 ulottuvuutta | oletus, ei kompromisseja |
| Vakiotuotanto | float + 1024 ulottuvuutta | hyvä laatu/kustannus-suhde |
| Suuri volyymi (miljoonia vektoreita) | int8 + 768 ulottuvuutta | 4 kertaa tiiviimpi |
| Laajamittainen reaaliaikahaku | binary + 1536 ulottuvuutta | nopea esisuodatus, sitten uudelleenjärjestys float-muodossa |
| Upotettu / edge | int8 + 256 ulottuvuutta | minimaalinen toimiva ratkaisu |
“Reaaliaika”-rivi kuvaa kaksivaiheista arkkitehtuuria, joka on syytä ymmärtää: erittäin kevyt binary-indeksi hakee muutamia satoja ehdokkaita millisekunneissa; vain nämä ehdokkaat järjestetään uudelleen käyttämällä float-vektoreita, jotka ovat kalliimpia mutta paljon tarkempia. Saat binaryn nopeuden ja listan kärjessä floatin tarkkuuden.
Keskeiset asiat
- codestral-embed tukee 5 tulostyyppiä: float, int8, uint8, binary, ubinary
- Binary-tyyppi on 32 kertaa tiiviimpi kuin float, ja laadun menetys on hyväksyttävä esisuodatukseen
- Ensimmäiset ulottuvuudet sisältävät eniten informaatiota (Matryoshka-esitys)
- Yhdistä vähennetyt ulottuvuudet ja int8 erittäin tiiviisiin indekseihin
- Testaa aina omalla todellisella datallasi ennen tuotantoparametrien valintaa