Gegevenstypen en Dimensies
Op deze pagina
Optimalisatie van Grootte en Kwaliteit
codestral-embed biedt u nauwkeurige controle over twee assen: het aantal dimensies en het gegevenstype (dtype) van de waarden. Met deze parameters kunt u de afweging tussen zoekkwaliteit en opslag- of rekenkosten fine-tunen.
Dit wordt cruciaal naarmate de volumes groeien. Een index van twee miljoen functies met 1536 float-dimensies weegt ongeveer twaalf gigabyte en past niet meer in het geheugen van een standaardmachine; dezelfde index in int8 met 768 dimensies daalt tot onder de één gigabyte en wordt weer in real-time doorzoekbaar. Het is deze rekenkunde, en geen esthetische voorkeur, die uw keuzes moet sturen.
De Vijf Uitvoertypen
float (standaard)
Het type float produceert 32-bits drijvende-kommawaarden. Dit is het meest nauwkeurige formaat, ideaal wanneer kwaliteit voorrang heeft op opslagruimte.
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
Elke dimensie is een geheel getal tussen -128 en 127. Dit verbruikt 4x minder geheugen dan float32 met minimaal kwaliteitsverlies. Vergelijk de weergegeven waarden met die in het vorige voorbeeld: het is dezelfde vector, gekwantiseerd naar een grovere schaal, en de rangschikking van de resultaten blijft nagenoeg ongewijzigd.
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
Vergelijkbaar met int8, maar met waarden tussen 0 en 255 (unsigned). Handig voor bepaalde vectorzoekmachines die alleen positieve waarden accepteren; een beperking die u meestal pas tijdens de integratie ontdekt, niet daarvoor.
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
Het meest compacte formaat. Elke dimensie wordt gekwantiseerd tot 1 bit, waarna de bits in groepen van 8 worden verpakt tot int8-waarden. De resulterende vector is 32x kleiner dan float; de hieronder weergegeven lengte van 192 komt exact overeen met de oorspronkelijke 1536 dimensies, acht aan acht verpakt.
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
Identiek aan binary, maar met uint8-waarden (0-255) in plaats van int8 (-128 tot 127). De keuze tussen de twee hangt af van wat uw downstream-opslagengine accepteert, niet van de zoekkwaliteit.
Impact op Kwaliteit
Compressiecijfers vertellen u niet wat u precies verliest. De volgende functie meet dit aan de hand van een concreet voorbeeld: een palindroomtest, bevraagd in het Frans, achtereenvolgens gecodeerd met drie dtypes. De resulterende overeenkomsten geven u de orde van grootte van de degradatie op uw eigen gegevens.
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}")
Merk op dat de code en de query binnen de lus altijd met hetzelfde dtype worden gecodeerd. Het mengen van typen tussen de index en de query zou inconsistente scores opleveren, en de fout is des te verraderlijk omdat er geen uitzondering wordt gegenereerd.
Dimensies Verminderen
De parameter output_dimension bepaalt het aantal dimensies in de vector. De onderstaande lus doorloopt zes waarden en toont voor elk de geheugenfootprint van een enkele vector, eerst in float en vervolgens in 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)")
Uitvoer:
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)
Vermenigvuldig de rechterkolom met uw werkelijke aantal vectoren en u krijgt direct de benodigde servercapaciteit. Tussen 3072 dimensies in float en 768 in int8 bedraagt de verhouding zestien: dezelfde index gaat van twaalf gigabyte naar zevenhonderdvijftig megabyte.
Selectiegids
De volgende configuraties dekken de meest voorkomende scenario’s:
| Context | Configuratie | Reden |
|---|---|---|
| Prototype / ontwikkeling | float + 1536 dims | standaard, geen compromissen |
| Standaardproductie | float + 1024 dims | goede balans kwaliteit/kosten |
| Hoog volume (miljoenen vectoren) | int8 + 768 dims | 4x compacter |
| Real-time zoeken op grote schaal | binary + 1536 dims | snelle pre-filtering, daarna opnieuw rangschikken in float |
| Embedded / edge | int8 + 256 dims | minimaal haalbare |
De regel “real-time” beschrijft een tweefasen-architectuur die het waard is om te begrijpen: de zeer lichte binary-index dient om binnen milliseconden een paar honderd kandidaten op te halen; alleen deze kandidaten worden vervolgens opnieuw gerangschikt met behulp van de float-vectoren, die kostbaarder maar veel fijner zijn. U krijgt de snelheid van binary en, bovenaan de lijst, de precisie van float.
Belangrijkste punten
- codestral-embed ondersteunt 5 uitvoertypen: float, int8, uint8, binary, ubinary
- Het binary-type is 32x compacter dan float, met aanvaardbaar kwaliteitsverlies voor pre-filtering
- De eerste dimensies bevatten de meeste informatie (Matroesjka-representatie)
- Combineer verminderde dimensies + int8 voor zeer compacte indexen
- Test altijd op uw reële gegevens voordat u productieparameters kiest