Typy dat a dimenze
Na této stránce
Optimalizace velikosti a kvality
codestral-embed ti dává přesnou kontrolu nad dvěma osami: počtem dimenzí a datovým typem (dtype) hodnot. Tyto parametry ti umožňují ladit kompromis mezi kvalitou vyhledávání a náklady na úložiště nebo výpočetní výkon.
To se stává kritickým, jak objemy rostou. Index dvou milionů funkcí s 1536 dimenzemi typu float váží přibližně dvanáct gigabajtů a již se nevejde do paměti běžného stroje; stejný index v int8 s 768 dimenzemi klesne pod jeden gigabajt a opět se stává dotazovatelným v reálném čase. Právě tato aritmetika, nikoliv estetická preference, by měla řídit tvá rozhodnutí.
Pět výstupních typů
float (výchozí)
Typ float produkuje 32bitové hodnoty s plovoucí řádovou čárkou. Jedná se o nejpřesnější formát, ideální, když má kvalita přednost před úložným prostorem.
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
Každá dimenze je celé číslo mezi -128 a 127. Tento formát využívá 4× méně paměti než float32 s minimální ztrátou kvality. Porovnej zobrazené hodnoty s těmi v předchozím příkladu: jde o stejný vektor, kvantovaný na hrubší stupnici, a pořadí výsledků zůstává téměř nezměněno.
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
Podobné jako int8, ale s hodnotami mezi 0 a 255 (bez znaménka). Užitečné pro určité vyhledávací stroje vektorů, které přijímají pouze kladné hodnoty – toto omezení obvykle objevíš až během integrace, nikoliv předem.
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
Nejkompaktnější formát. Každá dimenze je kvantována na 1 bit, poté jsou bity seskupeny do balíčků po 8 do hodnot int8. Výsledný vektor je 32× menší než float – délka 192 zobrazená níže přesně odpovídá původním 1536 dimenzím, zabaleným po osmi.
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
Identické jako binary, ale s hodnotami uint8 (0–255) místo int8 (-128 až 127). Volba mezi těmito dvěma závisí na tom, co přijímá tvůj downstream úložný engine, nikoliv na kvalitě vyhledávání.
Dopad na kvalitu
Čísla o kompresi ti neřeknou, co přesně ztrácíš. Následující funkce to měří na konkrétním příkladu: test palindromu, dotazovaný ve francouzštině, kódovaný postupně se třemi typy dtype. Výsledné podobnosti ti dají představu o řádu degradace na tvých vlastních datech.
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}")
Všimni si, že kód i dotaz jsou uvnitř smyčky vždy kódovány se stejným dtype. Míchání typů mezi indexem a dotazem by vedlo k nekonzistentním skóre a chyba je tím zákeřnější, že nevyvolá žádnou výjimku.
Redukce dimenzí
Parametr output_dimension řídí počet dimenzí ve vektoru. Níže uvedená smyčka iteruje přes šest hodnot a pro každou zobrazuje paměťovou stopu jednoho vektoru, nejprve ve float a poté 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)")
Výstup:
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)
Vynásob pravý sloupec svým skutečným počtem vektorů a okamžitě získáš sizing svého serveru. Mezi 3072 dimenzemi ve float a 768 v int8 je poměr šestnáct: stejný index přejde z dvanácti gigabajtů na sedm set padesát megabajtů.
Průvodce výběrem
Následující konfigurace pokrývají nejčastější scénáře:
| Kontext | Konfigurace | Důvod |
|---|---|---|
| Prototyp / vývoj | float + 1536 dimenzí | výchozí, žádný kompromis |
| Standardní produkce | float + 1024 dimenzí | dobrý poměr kvalita/cena |
| Vysoký objem (miliony vektorů) | int8 + 768 dimenzí | 4× kompaktnější |
| Vyhledávání ve velkém měřítku v reálném čase | binary + 1536 dimenzí | rychlé předběžné filtrování, poté přehodnocení ve float |
| Embedded / edge | int8 + 256 dimenzí | minimum viable |
Řádek „reálný čas“ popisuje dvoufázovou architekturu, kterou stojí za to pochopit: velmi lehký binární index slouží k získání několika stovek kandidátů v řádu milisekund; pouze tito kandidáti jsou následně přehodnoceni pomocí float vektorů, které jsou nákladnější, ale mnohem přesnější. Získáš tak rychlost binary a na vrcholu seznamu přesnost float.
Klíčové poznatky
- codestral-embed podporuje 5 výstupních typů: float, int8, uint8, binary, ubinary
- Typ binary je 32× kompaktnější než float, s přijatelnou ztrátou kvality pro předběžné filtrování
- První dimenze obsahují nejvíce informací (reprezentace Matryoshka)
- Kombinuj redukované dimenze + int8 pro velmi kompaktní indexy
- Před výběrem produkčních parametrů vždy testuj na svých reálných datech