Generér embeddings til dine data
På denne side
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