Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Gegevenstypen en Dimensies

Les 7 van 18 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Optimalisatie van Grootte en Kwaliteit
  2. De Vijf Uitvoertypen
  3. Impact op Kwaliteit
  4. Dimensies Verminderen
  5. Selectiegids
  6. Belangrijkste punten

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:

ContextConfiguratieReden
Prototype / ontwikkelingfloat + 1536 dimsstandaard, geen compromissen
Standaardproductiefloat + 1024 dimsgoede balans kwaliteit/kosten
Hoog volume (miljoenen vectoren)int8 + 768 dims4x compacter
Real-time zoeken op grote schaalbinary + 1536 dimssnelle pre-filtering, daarna opnieuw rangschikken in float
Embedded / edgeint8 + 256 dimsminimaal 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