Generuokite savo duomenų įterpinius (embeddings)
Šiame puslapyje
Tikslai
- Paruošti teksto duomenis įterpinių kūrimui
- Efektyviai generuoti įterpinius dideliu mastu
- Saugoti vektorius vėlesniam naudojimui
Duomenų paruošimas
Įterpinių kokybė tiesiogiai priklauso nuo jūsų duomenų kokybės. Tekstas, pilnas atsitiktinių tarpų, valdymo simbolių iš neteisingai sukonfigūruoto eksporto arba chaotiškų eilučių lūžių, sukuria šiek tiek nukrypusį vektorių. Tas nuokrypis kaupiasi kiekvienoje paieškoje. Valymas nėra kosmetinis: tai pirmoji ir pigiausia aktualumo optimizacija.
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"
Konteksto praturtinimas
Ištrauka iš dokumentacijos be pavadinimo praranda dalį savo prasmės. Paimkime pastraipą, prasidedančią „Atsisiųskite paketą iš oficialios svetainės“: be konteksto niekas nenurodo, kad tai susiję su PostgreSQL, todėl gautas vektorius niekada neatitiks užklausos apie PostgreSQL. Pridėję turinio pavadinimą ir skyrių kaip priešdėlį, jūs grąžinate tą informaciją į tekstą, kurį mato modelis.
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..."
)
Įterpinių generavimas grupėmis
Dirbant su realiu šimtų ar tūkstančių dokumentų korpusu, apdorojimas turi būti suskirstytas į dalis ir atsparus tinklo trikdžiams. Toliau pateikta funkcija iteruoja tekstus gabalais, sistemiškai rūšiuoja atsakymą pagal index, kad užtikrintų, jog vektorius Nr. 7 atitinka dokumentą Nr. 7, ir kartą pakartoja veiksmą po pauzės, jei įvyksta klaida.
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
Rūšiavimas pagal index yra atsargumo priemonė, kurios niekada negalima praleisti. Vienos eilutės poslinkis tyloje pakanka, kad kiekvienas dokumentas būtų susietas su kaimyno vektoriumi. Simptomas, kurį pastebėsite, bus „paieška grąžina šiukšles“, be jokios techninės klaidos, nukreipiančios jus teisinga linkme.
Įterpinių saugojimas
Nedideliam kelių tūkstančių dokumentų korpusui puikiai tinka paprastas JSON failas, kuriame yra tekstai, metaduomenys ir vektoriai. Jo privalumas tas, kad jis yra žmogui skaitomas, kai reikia derinti keistus rezultatus.
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)
Viršijus šį mastą, JSON tampa „butelio kakleliu“: kiekvienas skaičius užrašomas pilnai, išpūsdamas failą ir reikalaudamas brangaus analizavimo kiekvieno įkėlimo metu. NumPy tuos pačius reikšmes saugo binarine forma po 4 baitus ir įkelia akimirksniu.
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")
Pilna grandinė: nuo tekstinių failų iki įterpinių
Sujunkime šiuos elementus į funkciją, kuri nuskaitytų aplanką, išvalytų kiekvieną failą, sugeneruotų vektorius ir padalintų saugyklą į dvi dalis: metaduomenis JSON formatu (skaitomi ir redaguojami) bei matricą NumPy formatu (kompaktiška ir greita).
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/")
Atkreipkite dėmesį į sorted() naudojimą „glob“: be jo, failų tvarka priklauso nuo failų sistemos, ir jūsų du išvesties failai gali nesutapti po paprasto kompiuterio pakeitimo.
Išlaidų įvertinimas
Prieš paleisdami masinį darbą, suskaičiuokite tokenus vietoje naudodami „tiktoken“. Operacija trunka kelias sekundes ir apsaugo jus nuo per vėlo sužinojimo, kad blogai filtruotame korpuse buvo dešimt kartų daugiau nei tikėtasi.
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
Žodyne pateiktos kainos yra orientacinės ir greitai sensta: prieš teikdami sąmatą klientui, visada patikrinkite dabartinius tarifus.
Svarbiausi punktai
- Išvalykite ir praturtinkite savo tekstus prieš generuodami įterpinius
- Dideliems korpusams naudokite grupinį apdorojimą
- Metaduomenis saugokite JSON, o vektorius – NumPy formatu
- Prieš pradėdami masinį darbą, įvertinkite savo išlaidas