Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Generér embeddings til dine data

Lektion 3 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. Forbered dine data
  3. Generér embeddings i batches
  4. Gem embeddings
  5. Komplet pipeline: fra tekstfiler til embeddings
  6. Estimer omkostninger
  7. Vigtige pointer

Mål

  • Forbered dine tekstdata til embedding
  • Generér embeddings effektivt i stor skala
  • Gem vektorer til senere brug

Forbered dine data

Kvaliteten af dine embeddings afhænger direkte af kvaliteten af dine data. Tekst fyldt med tilfældige mellemrum, kontroltegn fra en fejlkonfigureret eksport eller uregelmæssige linjeskift producerer en vektor, der er en anelse skæv. Den afvigelse forstærkes ved hver søgning. Rengøring er ikke kosmetisk: det er den første og billigste optimering af relevans.

import re

def nettoyer_texte(texte: str) -> str:
    """Prepares text for embedding."""
    # Remove multiple spaces
    texte = re.sub(r"\s+", " ", texte)
    # Remove control characters
    texte = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", "", texte)
    # Trim
    texte = texte.strip()
    return texte

# Example
brut = "  Texte   avec   des   espaces\n\n\nen trop  "
propre = nettoyer_texte(brut)
print(propre)  # "Texte avec des espaces en trop"

Berig konteksten

Et isoleret uddrag fra dokumentation mister en del af sin betydning uden sin titel. Tag et afsnit, der starter med „Download the package from the official site”: uden kontekst indikerer intet, at det refererer til PostgreSQL, og den resulterende vektor vil aldrig matche en forespørgsel om PostgreSQL. Ved at sætte titel og sektion foran indholdet injicerer du den information tilbage i den tekst, modellen ser.

def enrichir_document(titre: str, section: str, contenu: str) -> str:
    """Creates enriched text for better embedding."""
    return f"Titre : {titre}\nSection : {section}\n\n{contenu}"

texte_enrichi = enrichir_document(
    titre="Installation de PostgreSQL",
    section="Getting Started Guide",
    contenu="Download the package from the official site..."
)

Generér embeddings i batches

På et reelt korpus med hundredvis eller tusindvis af dokumenter skal behandlingen opdeles i bidder og være modstandsdygtig over for netværksforstyrrelser. Funktionen nedenfor itererer gennem tekster i stykker, sorterer systematisk svaret efter index for at sikre, at vektor #7 matcher dokument #7, og forsøger én gang til efter en pause, hvis der opstår en fejl.

from openai import OpenAI
import time
import json

client = OpenAI()

def generer_embeddings(
    textes: list[str],
    model: str = "text-embedding-3-large",
    batch_size: int = 100
) -> list[list[float]]:
    """Generates embeddings in batches with error handling."""
    tous_les_embeddings = []

    for i in range(0, len(textes), batch_size):
        batch = textes[i:i + batch_size]
        print(f"Processing batch {i // batch_size + 1}/"
              f"{(len(textes) - 1) // batch_size + 1}")

        try:
            response = client.embeddings.create(
                input=batch,
                model=model
            )
            # Sort by index to guarantee order
            batch_embeddings = sorted(
                response.data, key=lambda x: x.index
            )
            tous_les_embeddings.extend(
                [item.embedding for item in batch_embeddings]
            )
        except Exception as e:
            print(f"Error on batch {i}: {e}")
            # Retry after a pause
            time.sleep(5)
            response = client.embeddings.create(
                input=batch,
                model=model
            )
            batch_embeddings = sorted(
                response.data, key=lambda x: x.index
            )
            tous_les_embeddings.extend(
                [item.embedding for item in batch_embeddings]
            )

    return tous_les_embeddings

Sortering efter index er en forholdsregel, du aldrig må springe over. Et stille skift på én række er nok til at knytte hvert dokument til naboens vektor. Symptomet, du vil observere, er „søgningen returnerer vrøvl”, uden nogen teknisk fejl, der peger dig i den rigtige retning.

Gem embeddings

Til et lille korpus på få tusinde dokumenter fungerer en simpel JSON-fil, der indeholder tekster, metadata og vektorer, perfekt. Den har fordelen at være læsbar for mennesker, når du skal fejlfinde et mærkeligt resultat.

import json

documents = [
    {"id": 1, "texte": "Premier document...", "metadata": {"source": "faq"}},
    {"id": 2, "texte": "Deuxième document...", "metadata": {"source": "docs"}},
]

# Generate embeddings
textes = [d["texte"] for d in documents]
embeddings = generer_embeddings(textes)

# Add vectors to documents
for doc, emb in zip(documents, embeddings):
    doc["embedding"] = emb

# Save
with open("corpus_embeddings.json", "w") as f:
    json.dump(documents, f)

Ud over den skala bliver JSON en flaskehals: hvert tal skrives ud i fuld længde, hvilket blæser filen op og pålægger dyr parsing ved hver indlæsning. NumPy gemmer de samme værdier binært på 4 byte og genindlæser øjeblikkeligt.

import numpy as np

# Convert to NumPy matrix
matrice = np.array(embeddings, dtype=np.float32)
print(f"Shape : {matrice.shape}")  # (n_docs, 3072)

# Save in binary format
np.save("embeddings.npy", matrice)

# Load
matrice_chargee = np.load("embeddings.npy")

Komplet pipeline: fra tekstfiler til embeddings

Lad os samle disse elementer i en funktion, der læser en mappe, rengør hver fil, genererer vektorer og opdeler lagringen i to: metadata i JSON (læsbart og redigerbart) og matricen i NumPy (kompakt og hurtig).

from openai import OpenAI
from pathlib import Path
import json
import numpy as np

client = OpenAI()

def pipeline_embeddings(dossier: str, model: str = "text-embedding-3-large"):
    """Complete pipeline: files → embeddings → storage."""
    dossier_path = Path(dossier)

    # 1. Read files
    documents = []
    for fichier in sorted(dossier_path.glob("*.txt")):
        contenu = fichier.read_text(encoding="utf-8")
        contenu = nettoyer_texte(contenu)
        if contenu:
            documents.append({
                "id": fichier.stem,
                "fichier": fichier.name,
                "texte": contenu
            })

    print(f"{len(documents)} documents found")

    # 2. Generate embeddings
    textes = [d["texte"] for d in documents]
    embeddings = generer_embeddings(textes, model=model)

    # 3. Save
    # Metadata in JSON
    meta = [{"id": d["id"], "fichier": d["fichier"]} for d in documents]
    with open("metadata.json", "w") as f:
        json.dump(meta, f, ensure_ascii=False, indent=2)

    # Vectors in NumPy
    np.save("embeddings.npy", np.array(embeddings, dtype=np.float32))

    print(f"Embeddings saved: {len(embeddings)} vectors "
          f"of {len(embeddings[0])} dimensions")

    return documents, embeddings

# Usage
documents, embeddings = pipeline_embeddings("./mes_documents/")

Bemærk sorted() på glob: uden det afhænger filrækkefølgen af filsystemet, og dine to outputfiler risikerer at komme ud af sync efter en simpel maskinændring.

Estimer omkostninger

Før du lancerer et massivt job, skal du tælle tokens lokalt med tiktoken. Operationen tager få sekunder og sparer dig for for sent at opdage, at et dårligt filtreret korpus indeholdt ti gange det forventede volumen.

import tiktoken

encoder = tiktoken.get_encoding("cl100k_base")

def estimer_cout(textes: list[str], model: str = "text-embedding-3-large"):
    """Estimates embedding cost for a list of texts."""
    total_tokens = sum(len(encoder.encode(t)) for t in textes)

    # Approximate prices per million tokens (check current rates)
    prix = {
        "text-embedding-3-large": 0.13,
        "text-embedding-3-small": 0.02,
    }

    cout = total_tokens / 1_000_000 * prix.get(model, 0.13)
    print(f"Estimated tokens: {total_tokens:,}")
    print(f"Estimated cost: ${cout:.4f}")
    return total_tokens, cout

Priserne i ordbogen er vejledende og forældes hurtigt: tjek altid de aktuelle satser, før du præsenterer et tilbud for en kunde.

Vigtige pointer

  • Rengør og berig dine tekster, før du genererer embeddings
  • Brug batch-behandling til store korpusser
  • Gem metadata i JSON og vektorer i NumPy
  • Estimer dine omkostninger, før du lancerer et massivt job