Generera inbäddningar för din data
På denna sida
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