Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Embeddingek generálása az adataidhoz

3. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. Adataid előkészítése
  3. Embeddingek generálása kötegekben
  4. Embeddingek tárolása
  5. Teljes pipeline: szöveges fájloktól az embeddingekig
  6. Költségek becslése
  7. Főbb megállapítások

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