Generovanie vektorových reprezentácií pre vaše dáta
Na tejto strane
Ciele
- Pripraviť svoje textové dáta na vytvorenie vektorových reprezentácií
- Efektívne generovať vektorové reprezentácie vo veľkom meradle
- Uložiť vektory na neskoršie použitie
Príprava dát
Kvalita tvojich vektorových reprezentácií priamo závisí od kvality tvojich dát. Text plný náhodných medzier, riadiacich znakov z chybného exportu alebo nepravidelných zalomení riadkov vytvorí mierne nepresný vektor. Táto odchýlka sa kumuluje pri každom vyhľadávaní. Čistenie nie je len kozmetická úprava: je to prvá a najlacnejšia optimalizácia relevantnosti.
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"
Obohatenie kontextu
Osamelý úryvok z dokumentácie stráca bez svojho nadpisu časť svojho významu. Vezmi si odsek, ktorý začína slovami „Stiahnite si balík z oficiálnej stránky“: bez kontextu nič nenaznačuje, že ide o PostgreSQL, a výsledný vektor sa nikdy nezhoduje s dopytom týkajúcim sa PostgreSQL. Prefixovaním obsahu jeho nadpisom a sekciou vraciaš túto informáciu späť do textu, ktorý model vidí.
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..."
)
Generovanie vektorových reprezentácií v dávkach
Pri reálnom korpuse stoviek alebo tisícov dokumentov musí byť spracovanie rozdelené na časti a odolné voči výpadkom siete. Nižšie uvedená funkcia prechádza textami po úsekoch, systematicky zoradí odpoveď podľa index, aby sa zabezpečilo, že vektor č. 7 zodpovedá dokumentu č. 7, a v prípade chyby sa po pauze jedenkrát opakuje.
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
Zoradenie podľa index je preventívne opatrenie, ktoré nikdy nesmieš vynechať. Stačí tichý posun o jeden riadok a každý dokument sa priradí k vektoru svojho suseda. Príznakom, ktorý pozoruješ, bude „vyhľadávanie vracia nezmysly“, bez technickej chyby, ktorá by ťa nasmerovala správnym smerom.
Ukladanie vektorových reprezentácií
Pre malý korpus niekoľkých tisíc dokumentov funguje dokonale jednoduchý súbor JSON obsahujúci texty, metadáta a vektory. Má tú výhodu, že je čitateľný človekom, keď potrebuješ odladiť zvláštny výsledok.
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)
Nad touto škálou sa JSON stáva úzkym hrdlom: každé číslo sa vypíše v plnom znení, čo zväčšuje súbor a pri každom načítaní ukladá nákladné parsovanie. NumPy ukladá rovnaké hodnoty binárne na 4 bajty a znovu sa načítajú okamžite.
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")
Kompletný pipeline: od textových súborov po vektorové reprezentácie
Spojme tieto prvky do funkcie, ktorá číta priečinok, vyčistí každý súbor, vygeneruje vektory a rozdelí ukladanie na dve časti: metadáta v JSON (čitateľné a upraviteľné) a matica v NumPy (kompaktná a rýchla).
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/")
Všimni si sorted() na glob: bez neho závisí poradie súborov od súborového systému a tvoje dva výstupné súbory sa môžu po jednoduchej zmene stroja dostať mimo synchronizáciu.
Odhad nákladov
Pred spustením masívnej úlohy spočítaj tokeny lokálne pomocou tiktoken. Operácia trvá niekoľko sekúnd a ušetrí ti oneskorené zistenie, že zle filtrovaný korpus obsahoval desaťnásobok očakávaného objemu.
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
Ceny v slovníku sú orientačné a rýchlo zastarávajú: pred predložením cenovej ponuky klientovi si vždy over aktuálne sadzby.
Kľúčové poznatky
- Vyčisti a obohať svoje texty pred generovaním vektorových reprezentácií
- Používaj dávkové spracovanie pre veľké korpusy
- Ukladaj metadáta do JSON a vektory do NumPy
- Odhadni svoje náklady pred spustením masívnej úlohy