Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Generovanie vektorových reprezentácií pre vaše dáta

Lekcia 3 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Ciele
  2. Príprava dát
  3. Generovanie vektorových reprezentácií v dávkach
  4. Ukladanie vektorových reprezentácií
  5. Kompletný pipeline: od textových súborov po vektorové reprezentácie
  6. Odhad nákladov
  7. Kľúčové poznatky

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