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

Generera inbäddningar för din data

Lektion 3 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. Förbered din data
  3. Generera inbäddningar i batchar
  4. Lagra inbäddningar
  5. Kompletta flödet: från textfiler till inbäddningar
  6. Uppskatta kostnader
  7. Viktiga punkter

Mål

  • Förbereda din textdata för inbäddning
  • Generera inbäddningar effektivt i stor skala
  • Lagra vektorer för framtida bruk

Förbered din data

Kvaliteten på dina inbäddningar beror direkt på kvaliteten på din data. Text som är full av onödiga mellanslag, kontrolltecken från en felaktig export eller oregelbundna radbrytningar ger en vektor som hamnar lite fel. Detta fel ackumuleras vid varje sökning. Rengöring är inte bara kosmetiskt: det är den första och billigaste optimeringen för 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"

Berika kontexten

Ett isolerat utdrag ur dokumentationen förlorar en del av sin betydelse utan sin titel. Ta ett stycke som börjar med “Ladda ner paketet från den officiella webbplatsen”: utan kontext finns inget som indikerar att det gäller PostgreSQL, och den resulterande vektorn kommer aldrig att matcha en fråga om PostgreSQL. Genom att prefixa innehållet med dess titel och sektion matar du tillbaka den informationen i texten som 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..."
)

Generera inbäddningar i batchar

På ett riktigt korpus med hundratals eller tusentals dokument måste bearbetningen ske i bitar och vara motståndskraftig mot nätverksstörningar. Funktionen nedan itererar genom texter i segment, sorterar systematiskt svaret efter index för att säkerställa att vektor #7 matchar dokument #7, och försöker igen efter en paus om ett fel uppstår.

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

Att sortera efter index är en försiktighetsåtgärd du aldrig får hoppa över. En tyst förskjutning på en rad räcker för att koppla varje dokument till grannens vektor. Symptomet du kommer att observera är att “sökningen returnerar skräp”, utan något tekniskt fel som pekar dig i rätt riktning.

Lagra inbäddningar

För ett litet korpus på några tusen dokument fungerar en enkel JSON-fil som innehåller texter, metadata och vektorer utmärkt. Fördelen är att den är läsbar för människor när du behöver felsöka ett konstigt 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)

Utöver den skalan blir JSON en flaskhals: varje tal skrivs ut i sin helhet, vilket sväller filen och påtvingar kostsam parsning vid varje inläsning. NumPy lagrar samma värden binärt på 4 byte och laddas om omedelbart.

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")

Kompletta flödet: från textfiler till inbäddningar

Låt oss sammanföra dessa element i en funktion som läser en mapp, rengör varje fil, genererar vektorer och delar upp lagringen i två delar: metadata i JSON (läsbart och redigerbart) och matrisen i NumPy (kompakt och snabbt).

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/")

Notera sorted() på glob: utan det beror filordningen på filsystemet, och dina två utdatafiler riskerar att hamna i otakt efter ett enkelt maskinbyte.

Uppskatta kostnader

Innan du startar ett massivt jobb, räkna token lokalt med tiktoken. Operationen tar några sekunder och sparar dig från att för sent upptäcka att ett dåligt filtrerat korpus innehöll tio gånger den förväntade volymen.

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

Priserna i ordboken är vägledande och åldras snabbt: kontrollera alltid aktuella priser innan du presenterar en offert för en kund.

Viktiga punkter

  • Rengör och berika dina texter innan du genererar inbäddningar
  • Använd batchbearbetning för stora korpusar
  • Lagra metadata i JSON och vektorer i NumPy
  • Uppskatta dina kostnader innan du startar ett massivt jobb