Generiranje vdelav za vaše podatke
Na tej strani
Cilji
- Pripravi besedilne podatke za ustvarjanje vdelav
- Učinkovito generiraj vdelave v velikem obsegu
- Shrani vektorje za kasnejšo uporabo
Priprava podatkov
Kakovost tvojih vdelav je neposredno odvisna od kakovosti tvojih podatkov. Besedilo, polno odvečnih presledkov, nadzornih znakov zaradi napačno konfiguriranega izvoza ali nepravilnih prelomov vrstic, proizvede rahlo odmaknjen vektor. Ta odmerek se pri vsakem iskanju sešteva. Čiščenje ni le kozmetično: je prva in najcenejša optimizacija ustreznosti.
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"
Obogatitev konteksta
Iztržek dokumentacije brez naslova izgubi del svojega pomena. Vzemimo odstavek, ki se začne z „Prenesite paket z uradne strani”: brez konteksta nič ne kaže, da gre za PostgreSQL, in nastali vektor se nikoli ne bo ujemal z poizvedbo o PostgreSQL. Z dodajanjem naslova in razdelka pred vsebino te informacije ponovno vnesete v besedilo, ki ga vidi model.
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..."
)
Generiranje vdelav v serijah
Pri realnem korpusu s stotinami ali tisoči dokumentov mora biti obdelava razdeljena na dele in odporna na težave z omrežjem. Spodnja funkcija iterira skozi besedila v kosih, sistematično razvrsti odgovor po index, da zagotovi ujemanje vektorja št. 7 z dokumentom št. 7, in ob napaki enkrat poskusi znova po kratkem premoru.
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
Razvrščanje po index je previdnostni ukrep, ki ga nikoli ne smeš izpustiti. Tihi premik za eno vrstico zadostuje, da se vsak dokument poveže z vektorjem svojega soseda. Simptom, ki ga boš opazil, so „iskalni rezultati, ki so smeti”, brez tehnične napake, ki bi te usmerila v pravo smer.
Shranjevanje vdelav
Za majhen korpus nekaj tisoč dokumentov popolnoma zadostuje preprosta datoteka JSON, ki vsebuje besedila, metapodatke in vektorje. Prednost je berljivost za človeka, ko moraš razvozljati čuden rezultat.
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)
Onkraj tega obsega JSON postane ozko grlo: vsaka številka je zapisana v celoti, kar napihne datoteko in ob vsakem nalaganju zahteva drago razčlenjevanje. NumPy shrani iste vrednosti v binarni obliki na 4 bajte in se naloži takoj.
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")
Celoten potek: od besedilnih datotek do vdelav
Združimo te elemente v funkcijo, ki prebere mapo, očisti vsako datoteko, ustvari vektorje in shranjevanje razdeli na dva dela: metapodatki v JSON (berljivi in uredljivi) ter matrika v NumPy (kompaktna in hitra).
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/")
Upoštevaj sorted() pri globu: brez tega je vrstni red datotek odvisen od datotečnega sistema, tvoji dve izhodni datoteki pa tvegata neskladje že po preprosti menjavi stroja.
Ocena stroškov
Preden zaženeš obsežno opravilo, lokalno preštej žetone s tiktoken. Operacija traja nekaj sekund in te obvaruje pred prepoznim odkritjem, da je slabo filtriran korpus vseboval desetkrat večji obseg od pričakovanega.
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
Cene v slovarju so okvirne in hitro zastarajo: pred predstavitvijo ponudbe stranki vedno preveri trenutne tarife.
Ključne ugotovitve
- Očisti in obogati svoja besedila pred generiranjem vdelav
- Za velike korpuse uporabi serijsko obdelavo
- Metapodatke shrani v JSON, vektorje pa v NumPy
- Pred zagonom obsežnega opravila oceni svoje stroške