Datatyper og dimensioner
På denne side
Optimering af størrelse og kvalitet
codestral-embed giver dig præcis kontrol over to akser: antallet af dimensioner og datatypen (dtype) for værdierne. Disse parametre lader dig afveje søgekvalitet mod lagrings- eller beregningsomkostninger.
Dette bliver afgørende, når volumenerne vokser. Et indeks på to millioner funktioner med 1536 float-dimensioner vejer omkring tolv gigabyte og passer ikke længere i hukommelsen på en standardmaskine; det samme indeks i int8 med 768 dimensioner falder til under én gigabyte og bliver igen søgbar i realtid. Det er denne aritmetik, ikke en æstetisk præference, der bør styre dine valg.
De fem outputtyper
float (standard)
Typen float producerer 32-bit flydende tal. Dette er det mest præcise format, ideelt når kvalitet har højere prioritet end lagringsplads.
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
Hver dimension er et heltal mellem -128 og 127. Dette bruger 4 gange mindre hukommelse end float32 med minimalt kvalitetstab. Sammenlign de viste værdier med dem i det foregående eksempel: det er den samme vektor, kvantiseret til en grovere skala, og rangeringen af resultaterne forbliver næsten uændret.
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
Ligner int8, men med værdier mellem 0 og 255 (usigneret). Nyttigt for visse vektorsøgemaskiner, der kun accepterer positive værdier – en begrænsning, du typisk opdager under integrationen, ikke før.
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
Det mest kompakte format. Hver dimension kvantiseres til 1 bit, hvorefter bits grupperes i pakker på 8 til int8-værdier. Den resulterende vektor er 32 gange mindre end float – længden på 192 vist nedenfor svarer nøjagtigt til de oprindelige 1536 dimensioner, pakket otte og otte.
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
Identisk med binary, men med uint8-værdier (0-255) i stedet for int8 (-128 til 127). Valget mellem de to afhænger af, hvad din downstream-lagringsmotor accepterer, ikke af søgekvaliteten.
Påvirkning på kvaliteten
Komprimeringstal fortæller dig ikke, hvad du faktisk mister. Følgende funktion måler dette på et konkret eksempel: en palindrom-test, forespurgt på fransk, kodet successivt med tre dtypes. De resulterende ligheder giver dig størrelsesordenen af forringelsen på dine egne data.
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}")
Bemærk, at koden og forespørgslen altid kodes med samme dtype inde i løkken. At blande typer mellem indekset og forespørgslen ville producere inkonsistente scorer, og fejlen er så much mere snigende, fordi den ikke udløser nogen undtagelse.
Reducering af dimensioner
Parameteren output_dimension styrer antallet af dimensioner i vektoren. Løkken nedenfor itererer gennem seks værdier og viser hukommelsesaftrykket for en enkelt vektor for hver, først i float og derefter i 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)")
Output:
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)
Gang højre kolonne med dit faktiske antal vektorer, så får du straks din server-dimensionering. Mellem 3072 dimensioner i float og 768 i int8 er forholdet seksten: det samme indeks går fra tolv gigabyte til syvhundrede og halvtreds megabyte.
Valgguide
Følgende konfigurationer dækker de hyppigste scenarier:
| Kontekst | Konfiguration | Årsag |
|---|---|---|
| Prototype / udvikling | float + 1536 dims | standard, ingen kompromiser |
| Standard produktion | float + 1024 dims | god balance mellem kvalitet og omkostninger |
| Højt volumen (millioner af vektorer) | int8 + 768 dims | 4 gange mere kompakt |
| Realtidssøgning i stor skala | binary + 1536 dims | hurtig pre-filtering, derefter re-rank i float |
| Embedded / edge | int8 + 256 dims | minimum levedygtigt |
Linjen „realtid” beskriver en to-trins arkitektur, det er værd at forstå: det meget lette binary-indeks bruges til at hente et par hundrede kandidater på millisekunder; kun disse kandidater bliver derefter omrangere ved hjælp af float-vektorerne, som er dyrere, men meget finere. Du får hastigheden fra binary og, øverst på listen, præcisionen fra float.
Vigtige pointer
- codestral-embed understøtter 5 outputtyper: float, int8, uint8, binary, ubinary
- Typen binary er 32 gange mere kompakt end float, med acceptabelt kvalitetstab til pre-filtering
- De første dimensioner indeholder mest information (Matryoshka-repræsentation)
- Kombiner reducerede dimensioner + int8 for meget kompakte indeks
- Test altid på dine rigtige data, før du vælger produktionsparametre