Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Generování vnoření pro vaše data

Lekce 3 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Příprava dat
  3. Generování vnoření v dávkách
  4. Ukládání vnoření
  5. Kompletní pipeline: od textových souborů k vnořením
  6. Odhad nákladů
  7. Klíčové poznatky

Cíle

  • Připrav svá textová data pro vytvoření vnoření
  • Efektivně generuj vnoření ve velkém měřítku
  • Ulož vektory pro pozdější použití

Příprava dat

Kvalita tvých vnoření závisí přímo na kvalitě tvých dat. Text plný náhodných mezer, řídicích znaků z chybně nastaveného exportu nebo nepravidelných zalomení řádků vytvoří mírně odlišný vektor. Tato odchylka se při každém vyhledávání kumuluje. Čištění není jen kosmetická úprava: je to první a nejlevnější optimalizace relevance.

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"

Obohacení kontextu

Osamocený úryvek dokumentace ztrácí bez svého nadpisu část významu. Vezmi si odstavec, který začíná „Stáhněte balíček z oficiálního webu“: bez kontextu nic nenasvědčuje tomu, že se týká PostgreSQL, a výsledný vektor nikdy neodpoví dotazu týkajícímu se PostgreSQL. Prefixováním obsahu jeho nadpisem a sekcí znovu vložíš tyto informace do textu, který 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..."
)

Generování vnoření v dávkách

U reálného korpusu stovek nebo tisíců dokumentů musí být zpracování rozděleno na části a odolné vůči výpadkům sítě. Níže uvedená funkce iteruje texty po úsecích, systematicky třídí odpověď podle index, aby zajistila, že vektor č. 7 odpovídá dokumentu č. 7, a v případě chyby jednou po pauze zkusí operaci opakovat.

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

Třídění podle index je preventivní opatření, které nikdy nesmíš vynechat. I tichý posun o jeden řádek stačí k tomu, aby se každý dokument spojil s vektorem svého souseda. Příznakem, který pozoruješ, bude „vyhledávání vrací nesmysly“, přičemž žádná technická chyba tě nenasměruje správným směrem.

Ukládání vnoření

Pro malý korpus několika tisíc dokumentů funguje dokonale jednoduchý soubor JSON obsahující texty, metadata a vektory. Má tu výhodu, že je čitelný pro člověka, když potřebuješ ladit podivný výsledek.

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 se JSON stává úzkým hrdlem: každé číslo je zapsáno v plném znění, což nafukuje soubor a při každém načtení ukládá nákladné parsování. NumPy ukládá stejné hodnoty binárně na 4 bajty a znovu se načte okamžitě.

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 souborů k vnořením

Spojme tyto prvky do funkce, která čte složku, vyčistí každý soubor, vygeneruje vektory a rozdělí úložiště na dvě části: metadata v JSON (čitelná a editovatelná) a matice v NumPy (kompaktní a rychlá).

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 toho závisí pořadí souborů na souborovém systému a tvé dva výstupní soubory riskují ztrátu synchronizace po jednoduché změně stroje.

Odhad nákladů

Než spustíš masivní úlohu, spočítej tokeny lokálně pomocí tiktoken. Operace trvá několik sekund a ušetří ti pozdní zjištění, že špatně filtrovaný korpus obsahoval desetkrát větší objem, než se očekávalo.

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 ve slovníku jsou orientační a rychle zastarávají: před předložením nabídky klientovi si vždy ověř aktuální sazby.

Klíčové poznatky

  • Před generováním vnoření své texty vyčisti a obohať
  • Pro velké korpusy používej dávkové zpracování
  • Metadata ukládej do JSON a vektory do NumPy
  • Před spuštěním masivní úlohy odhadni své náklady