Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Typer och dimensioner av data

Lektion 7 av 18 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Optimering av storlek och kvalitet
  2. De fem utdatatyperna
  3. Påverkan på kvalitet
  4. Reducering av dimensioner
  5. Valguide
  6. Viktiga punkter

Optimering av storlek och kvalitet

codestral-embed ger dig exakt kontroll över två axlar: antalet dimensioner och datatypen (dtype) för värdena. Dessa parametrar låter dig finjustera avvägningen mellan sökkvalitet och lagrings- eller beräkningskostnader.

Detta blir avgörande när volymerna växer. Ett index med två miljoner funktioner vid 1536 float-dimensioner väger cirka tolv gigabyte och får inte längre plats i minnet på en vanlig maskin; samma index i int8 vid 768 dimensioner sjunker under en gigabyte och blir återigen frågbart i realtid. Det är denna aritmetik, inte en estetisk preferens, som bör styra dina val.

De fem utdatatyperna

float (standard)

Typen float producerar 32-bitars flyttalsvärden. Detta är det mest precisa formatet, idealiskt när kvalitet prioriteras framför lagringsutrymme.

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

Varje dimension är ett heltal mellan -128 och 127. Detta använder 4 gånger mindre minne än float32 med minimal kvalitetsförlust. Jämför de visade värdena med de i föregående exempel: det är samma vektor, kvantiserad till en grövre skala, och rangordningen av resultaten förblir nästan oförändrad.

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

Liknar int8 men med värden mellan 0 och 255 (osignerade). Användbart för vissa vektorsökmotorer som endast accepterar positiva värden – en begränsning du oftast upptäcker under integrationen, inte innan.

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 kompakta formatet. Varje dimension kvantiseras till 1 bit, varefter bitarna grupperas i paket om 8 till int8-värden. Den resulterande vektorn är 32 gånger mindre än float – längden på 192 som visas nedan motsvarar exakt de ursprungliga 1536 dimensionerna, packade åtta och åtta.

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

Identiskt med binary men med uint8-värden (0–255) istället för int8 (-128 till 127). Valet mellan de två beror på vad din nedströms lagringsmotor accepterar, inte på sökkvaliteten.

Påverkan på kvalitet

Komprimeringssiffror berättar inte vad du faktiskt förlorar. Följande funktion mäter detta på ett konkret exempel: ett palindromtest, frågat på franska, kodat successivt med tre dtypes. De resulterande likheterna ger dig storleksordningen på försämringen för dina egna 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}")

Observera att koden och frågan alltid kodas med samma dtype inuti loopen. Att blanda typer mellan indexet och frågan skulle producera inkonsistenta poäng, och felet är desto mer lömskt eftersom det inte väcker något undantag.

Reducering av dimensioner

Parametern output_dimension styr antalet dimensioner i vektorn. Loopen nedan itererar genom sex värden och visar minnesavtrycket för en enskild vektor för var och en, först i float och sedan 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)")

Utdata:

    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)

Multiplicera höger kolumn med ditt faktiska antal vektorer så får du omedelbart din serverdimensionering. Mellan 3072 dimensioner i float och 768 i int8 är förhållandet sexton: samma index går från tolv gigabyte till sjuttiofemtio megabyte.

Valguide

Följande konfigurationer täcker de vanligaste scenarierna:

KontextKonfigurationAnledning
Prototyp / utvecklingfloat + 1536 dimsstandard, inga kompromisser
Standardproduktionfloat + 1024 dimsbra balans mellan kvalitet och kostnad
Hög volym (miljoner vektorer)int8 + 768 dims4 gånger mer kompakt
Storskalig sökning i realtidbinary + 1536 dimssnabb förfiltrering, sedan omrangordning i float
Inbäddad / edgeint8 + 256 dimsminsta möjliga

Raden “realtid” beskriver en tvåstegsarkitektur värd att förstå: det mycket lätta binary-indexet används för att hämta några hundra kandidater på millisekunder; endast dessa kandidater omrangordnas sedan med hjälp av float-vektorerna, som är dyrare men mycket finare. Du får hastigheten hos binary och, högst upp i listan, precisionen hos float.

Viktiga punkter

  • codestral-embed stöder 5 utdatatyper: float, int8, uint8, binary, ubinary
  • Typen binary är 32 gånger mer kompakt än float, med acceptabel kvalitetsförlust för förfiltrering
  • De första dimensionerna innehåller mest information (Matryoshka-representation)
  • Kombinera reducerade dimensioner + int8 för mycket kompakta index
  • Testa alltid på dina verkliga data innan du väljer produktionsparametrar