Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Embeddings-API'en: Modeller og dimensioner

Lektion 2 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. Det grundlæggende kald
  3. De to tilgængelige modeller
  4. Batch-embeddings
  5. Dimensionalitetsreduktion
  6. Token-håndtering
  7. Vigtige pointer

Mål

  • Behersk kaldet client.embeddings.create()
  • Forstå forskellene mellem embedding-modeller
  • Anvend dimensionalitetsreduktion

Det grundlæggende kald

Hele OpenAI’s Embeddings-API passer ind i én enkelt metode: client.embeddings.create(). Du sender en tekststreng og et modelnavn til den:

from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    input="Hello, how are you?",
    model="text-embedding-3-large"
)

embedding = response.data[0].embedding
print(f"Type: {type(embedding)}")        # list
print(f"Length: {len(embedding)}")      # 3072
print(f"Snippet: {embedding[:3]}")        # [0.023, -0.041, 0.012]

Det returnerede objekt er ikke selve vektoren, men en wrapper, der indeholder flere vektorer, fordi API’en er designet til at håndtere batches. Indeni finder du data, en liste over objekter, hvor hvert har et embedding-felt (vektoren) og et index-felt (dets position i det sendte batch); model, den faktiske model, der blev brugt; og usage.prompt_tokens, antallet af fakturerede tokens. Du bør logge dette sidste felt fra dag ét: det er det eneste pålidelige mål for, hvad din indeksering koster.

De to tilgængelige modeller

text-embedding-3-large er højtydende-modellen. Dens 3.072 dimensioner fanger de fineste semantiske nuancer, hvilket gør den ideel til søgning i store korpusser, krævende RAG-pipelines og generelt alle tilfælde, hvor præcision vejer tungere end omkostninger. Hvis en bruger formulerer spørgsmål indirekte, eller dine dokumenter dækker et tæt teknisk domæne, vil du se forskellen på, hvordan resultaterne rangeres.

text-embedding-3-small er mere kompakt med 1.536 dimensioner og tilbyder et fremragende pris-ydelses-forhold. Det er det rigtige valg til tekstklassificering, anbefalinger, hurtig prototyping og applikationer med højt volumen, hvor målet ikke er at skelne mellem to næsten identiske dokumenter, men at adskille klart forskellige temaer. En simpel løkke verificerer, hvad hver returnerer:

# Sammenlign de to modeller
for model_name in ["text-embedding-3-small", "text-embedding-3-large"]:
    resp = client.embeddings.create(
        input="Artificial intelligence",
        model=model_name
    )
    vec = resp.data[0].embedding
    print(f"{model_name}: {len(vec)} dimensions")

Batch-embeddings

Du indekserer ikke et ægte korpus én tekst ad gangen: hvert HTTP-kald koster en netværks-roundtrip, og behandling af tusind dokumenter individuelt betyder akkumulering af tusind latenser. API’en accepterer op til 2.048 tekster i et enkelt kald, og index-feltet lader dig mappe hver vektor tilbage til det korrekte dokument.

texts = [
    "Machine learning is advancing rapidly",
    "Deep learning is revolutionizing computer vision",
    "Vector databases store embeddings",
    "Python is the preferred language for data scientists"
]

response = client.embeddings.create(
    input=textes,
    model="text-embedding-3-large"
)

for item in response.data:
    print(f"Text {item.index}: vector of {len(item.embedding)} dimensions")

print(f"Tokens consumed: {response.usage.prompt_tokens}")

I praksis skal du gruppere dine tekster i batches på 100 til 2.048 afhængigt af dit volumen: mindre batches gør genopretning efter fejl lettere, mens større reducerer antallet af kald. Overvåg usage.prompt_tokens ved hver iteration for at estimere omkostninger undervejs i stedet for at opdage dem på regningen, og implementér eksponentiel backoff ved genforsøg: en overskridelse af rate-grænsen er en midlertidig fejl, ikke en grund til at afbryde et tre timer langt indekseringsjob.

Dimensionalitetsreduktion

text-embedding-3-*-modellerne accepterer en dimensions-parameter, der returnerer vektorer, der er kortere end deres oprindelige størrelse:

# Fuld vektor: 3072 dimensioner
full = client.embeddings.create(
    input="Reduction test",
    model="text-embedding-3-large"
)

# Reduceret vektor: 256 dimensioner
reduced = client.embeddings.create(
    input="Reduction test",
    model="text-embedding-3-large",
    dimensions=256
)

print(f"Full: {len(full.data[0].embedding)} dim")    # 3072
print(f"Reduced: {len(reduced.data[0].embedding)} dim")  # 256

Mekanismen er simpel: reduktionen afkorter vektoren og normaliserer den derefter. Da de første dimensioner bærer mest information, forbliver forringelsen meget gradvis. Tabellen nedenfor giver standardbenchmarks for afvejningen mellem kvalitet og lagring.

DimensionsRelative QualityStorageUse Case
3,072100%~24 KBHigh-precision search
1,536~98%~12 KBGood general compromise
512~93%~4 KBHigh volume, reduced cost
256~88%~2 KBPrototyping, simple classification

Husk, at dit valg af dimensioner binder dig: alle vektorer i et givent indeks skal have samme størrelse, og at ændre mening kræver genberegning af alt.

Token-håndtering

Embedding-modeller har et loft på 8.191 tokens per tekst, og API’en returnerer en fejl, hvis du overskrider dette. Det er bedre at måle før afsendelse end at fange en undtagelse midt i et batch:

import tiktoken

encoder = tiktoken.get_encoding("cl100k_base")

text = "A potentially long text..."
tokens = encoder.encode(text)

if len(tokens) > 8191:
    # Truncate
    truncated_text = encoder.decode(tokens[:8191])
    print(f"Text truncated from {len(tokens)} to 8191 tokens")

Afkortning er et sikkerhedsnet, ikke en strategi: et afkortet langt dokument mister sin slutning, og slutningen indeholder ofte det svar, du leder efter. Korrekt håndtering af store dokumenter indebærer opdeling i chunks, hvilket vi dækker senere i kurset.

Vigtige pointer

  • client.embeddings.create() accepterer en enkelt tekst eller en liste over tekster
  • Brug text-embedding-3-large (3.072 dim) til præcision, text-embedding-3-small (1.536 dim) til omkostningseffektivitet
  • Parameteren dimensions lader dig reducere vektorstørrelsen
  • Batch-behandling af tekster er mere effektiv end individuelle kald
  • Grænse på 8.191 tokens per tekst