Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Datatyper og dimensioner

Lektion 7 af 18 Opdateret 2. november 2026 Udvikler
På denne side
  1. Optimering af størrelse og kvalitet
  2. De fem outputtyper
  3. Påvirkning på kvaliteten
  4. Reducering af dimensioner
  5. Valgguide
  6. Vigtige pointer

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:

KontekstKonfigurationÅrsag
Prototype / udviklingfloat + 1536 dimsstandard, ingen kompromiser
Standard produktionfloat + 1024 dimsgod balance mellem kvalitet og omkostninger
Højt volumen (millioner af vektorer)int8 + 768 dims4 gange mere kompakt
Realtidssøgning i stor skalabinary + 1536 dimshurtig pre-filtering, derefter re-rank i float
Embedded / edgeint8 + 256 dimsminimum 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