Embeddingek generálása az adataidhoz
Ezen az oldalon
Célok
- Szöveges adataid előkészítése embeddinghez
- Embeddingek hatékony generálása nagy mennyiségben
- Vektorok tárolása későbbi felhasználásra
Adataid előkészítése
Az embeddingek minősége közvetlenül függ az adataid minőségétől. A hibás exportból származó vezérlőkarakterekkel, tévedt szóközökkel vagy szabálytalan sortörésekkel teli szöveg kissé eltérő vektort eredményez. Ez az eltolódás minden keresésnél összeadódik. A tisztítás nem kozmetikai kérdés: ez az első és legolcsóbb relevancia-optimalizálás.
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"
Kontextus gazdagítása
Egy elszigetelt dokumentumrészlet cím nélkül elveszíti jelentésének egy részét. Vegyünk egy bekezdést, amely így kezdődik: „Töltsd le a csomagot a hivatalos oldalról“: kontextus nélkül semmi nem utal arra, hogy ez a PostgreSQL-re vonatkozik, és a kapott vektor sosem fog egyezést mutatni a PostgreSQL-rel kapcsolatos lekérdezésekkel. Ha a tartalmat megelőzöd a címmel és a szakasszal, ezt az információt visszajuttatod abba a szövegbe, amit a modell lát.
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..."
)
Embeddingek generálása kötegekben
Valós, több száz vagy ezer dokumentumból álló korpusz esetén a feldolgozást darabokra kell bontani, és ellenállónak kell lennie a hálózati ingadozásokkal szemben. Az alábbi függvény szeletekben iterál végig a szövegeken, szisztematikusan rendezi a választ az index alapján, hogy biztosítsa: a 7-es vektor a 7-es dokumentumhoz tartozzon, és hiba esetén egy szünet után egyszer újra próbálkozik.
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
Az index szerinti rendezés olyan óvintézkedés, amit sosem szabad kihagynod. Egy észrevétlen, egy soros eltolódás is elég ahhoz, hogy minden dokumentumot a szomszédja vektorához rendelj hozzá. A tünet, amit tapasztalni fogsz: „a keresés szemét eredményt ad“, anélkül, hogy technikai hiba mutatná az irányt.
Embeddingek tárolása
Néhány ezer dokumentumból álló kisebb korpusz esetén tökéletesen működik egy egyszerű JSON-fájl, amely tartalmazza a szövegeket, a metaadatokat és a vektorokat. Előnye, hogy emberi olvasásra alkalmas, amikor egy furcsa eredményt kell debuggolnod.
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)
Ezen méret beyond a JSON szűk keresztmetszetté válik: minden számot teljes alakjában ír ki, ami felfújja a fájlt, és minden betöltéskor költséges elemzést kényszerít ki. A NumPy ugyanazokat az értékeket binárisan, 4 bájtban tárolja, és azonnal újratölti őket.
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")
Teljes pipeline: szöveges fájloktól az embeddingekig
Foglaljuk össze ezeket az elemeket egy függvényben, amely beolvas egy mappát, megtisztít minden fájlt, generálja a vektorokat, és kettéosztja a tárolást: a metaadatok JSON-ban (olvasható és szerkeszthető), a mátrix pedig NumPy formátumban (tömör és gyors).
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/")
Figyeld meg a sorted() hívást a glob-on: enélkül a fájlok sorrendje a fájlrendszertől függ, és a két kimeneti fájl könnyen szinkronon kívül kerülhet egy egyszerű gépváltás után.
Költségek becslése
Mielőtt hatalmas feladatot indítanál, számold meg helyben a tokeneket a tiktoken segítségével. A művelet néhány másodpercet vesz igénybe, és megvéd attól, hogy túl későn fedezd fel: egy rosszul szűrt korpusz tízszer akkora volumenű volt a vártnál.
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
A szótárban szereplő árak tájékoztató jellegűek és gyorsan avulnak: mindig ellenőrizd az aktuális díjszabást, mielőtt árajánlatot adsz egy ügyfélnek.
Főbb megállapítások
- Tisztítsd és gazdagítsd szövegeidet az embeddingek generálása előtt
- Használj kötegelt feldolgozást nagy korpuszok esetén
- Tárold a metaadatokat JSON-ban, a vektorokat pedig NumPy-ban
- Becsüld meg költségeidet, mielőtt hatalmas feladatot indítanál