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

Príprava dát

Lekcia 10 z 18 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Kvalita RAG závisí od tvojich dát
  2. Získavanie dát
  3. Čistenie dát
  4. Stratégie chunkovania (rozdelenia na úryvky)
  5. Kompletný pipeline prípravy
  6. Kľúčové poznatky

Kvalita RAG závisí od tvojich dát

Pipeline RAG je len taká dobrá, ako sú dáta, ktoré indexuje. Môžeš vytvoriť dokonalejší prompt a vybrať najlepší generačný model, ale ak získaný úryvok rozpolí definíciu napoly alebo natiahne opakujúcu sa pätičku namiesto užitočného textu, tvoja odpoveď bude trpieť. Príprava prebieha v troch fázach: získaj dáta tam, kde sa nachádzajú, odstráň všetko bezvýznamné a rozdeľ ich na úryvky optimalizované pre indexovanie.

Získavanie dát

Reálne korpusy sú zriedka homogénne. Zvyčajne budeš mať dokumentáciu vo formáte Markdown v repozitári, niekoľko stránok z verejnej webovej stránky a zopár regulačných PDF súborov. Každý zdroj potrebuje vlastný načítavač, ale všetky musia produkovať rovnakú štruktúru – obsah, zdroj a typ – aby zostatok pipeline zostal nezávislý od pôvodu textu.

Pre textové súbory stačí rekurzívne prechádzanie adresárov a filtrovanie podľa prípony zabráni náhodnému načítaniu binárnych súborov.

import os

def load_text_files(directory, extensions=(".txt", ".md", ".rst")):
    """Load all text files from a directory."""
    documents = []
    for root, dirs, files in os.walk(directory):
        for f in files:
            if any(f.endswith(ext) for ext in extensions):
                filepath = os.path.join(root, f)
                with open(filepath, "r", encoding="utf-8") as fh:
                    content = fh.read()
                documents.append({
                    "content": content,
                    "source": filepath,
                    "type": "text",
                })
    return documents

docs = load_text_files("./data/")
print(f"{len(docs)} documents loaded")

Webové stránky prichádzajú cez HTTP, ale to, čo dostaneš, je HTML. Nasledujúca extrakcia odstraňuje tagy pomocou regulárnych výrazov a spája viacnásobné medzery. Toto stačí na prototyp, ale komentár ti pripomína, že v produkcii urobí BeautifulSoup oveľa lepšiu prácu s tabuľkami a vnorenými zoznamami.

import requests

def fetch_web_page(url):
    """Fetch the text content of a web page."""
    response = requests.get(url)
    response.raise_for_status()

    # Basic text extraction (use BeautifulSoup for production)
    text = response.text
    # Remove HTML tags
    import re
    text = re.sub(r'<[^>]+>', ' ', text)
    text = re.sub(r'\s+', ' ', text).strip()

    return {
        "content": text,
        "source": url,
        "type": "web",
    }

# Example
page = fetch_web_page("https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt")
print(f"Content: {len(page['content'])} characters")

PDF súbory si zaslúžia osobitné zaobchádzanie. Namiesto spojenia celého dokumentu uchovaj jeden záznam na stránku a zakóduj číslo stránky do zdroja ako file.pdf#page=12. Keď tvoj asistent cituje tento úsek, používateľ bude presne vedieť, kde si ho má overiť.

# pip install PyPDF2
from PyPDF2 import PdfReader

def load_pdf(filepath):
    """Extract text from a PDF."""
    reader = PdfReader(filepath)
    pages = []
    for i, page in enumerate(reader.pages):
        text = page.extract_text()
        if text.strip():
            pages.append({
                "content": text,
                "source": f"{filepath}#page={i+1}",
                "type": "pdf",
                "page": i + 1,
            })
    return pages

Čistenie dát

Čistenie je kritické pre kvalitu vyhľadávania, pretože každý cudzí znak spotrebúva miesto v úryvku a kalí výsledný vektor. Nasledujúca funkcia reťazí štyri úpravy: odstraňuje riadiace znaky zostávajúce po konverzii formátov, normalizuje sekvencie nových riadkov a medzier, vymazáva označenia stránok typické pre PDF a nahrádza nekonečné URL jednoduchým zástupným symbolom, aby nezjedli celý úryvok.

import re

def clean_text(text):
    """Clean text for RAG indexing."""
    # Remove control characters
    text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)

    # Normalize spaces and newlines
    text = re.sub(r'\n{3,}', '\n\n', text)
    text = re.sub(r' {2,}', ' ', text)

    # Remove repetitive headers/footers (PDF)
    text = re.sub(r'Page \d+ of \d+', '', text)

    # Remove very long URLs
    text = re.sub(r'https?://\S{100,}', '[URL]', text)

    return text.strip()

# Apply cleaning
for doc in docs:
    doc["content"] = clean_text(doc["content"])

Stratégie chunkovania (rozdelenia na úryvky)

Chunkovanie je najdôležitejším krokom prípravy: veľkosť úryvku a metóda priamo ovplyvňujú kvalitu vyhľadávania. Existujú tri prístupy, od mechanických až po tie, ktoré rešpektujú štruktúru.

Chunkovanie pevnej veľkosti prechádza textom v pravidelných úsekoch. Úplne ignoruje význam, čo ho robí použiteľným pre akýkoľvek zdroj, ale často rozdeľuje vety napoly. Prekrytie túto chybu čiastočne opravuje: pri overlap=200 sa koniec každého úryvku opakuje na začiatku ďalšieho, čím sa zabezpečí, že rozdelená myšlienka zostane celá aspoň v jednom z dvoch kusov.

def chunk_fixed_size(text, chunk_size=2048, overlap=200):
    """Fixed-size chunking with overlap."""
    chunks = []
    start = 0
    while start < len(text):
        end = min(start + chunk_size, len(text))
        chunk = text[start:end]
        if chunk.strip():
            chunks.append(chunk.strip())
        start += chunk_size - overlap
    return chunks

Chunkovanie založené na odsekoch, odporúčané pre dokumentáciu, namiesto toho využíva prirodzené hranice textu. Akumuluje odseky, pokiaľ zostávajú pod max_size, a potom otvorí nový úryvok. Prah min_size zabraňuje indexovaniu osamelých nadpisov alebo izolovaných riadkov, čo by vytvorilo vektor bez použiteľného obsahu.

def chunk_by_paragraphs(text, max_size=1500, min_size=100):
    """Intelligent paragraph-based chunking."""
    paragraphs = text.split("\n\n")
    chunks = []
    current = ""

    for para in paragraphs:
        para = para.strip()
        if not para:
            continue

        if len(current) + len(para) + 2 <= max_size:
            current = current + "\n\n" + para if current else para
        else:
            if len(current) >= min_size:
                chunks.append(current)
            current = para

    if current and len(current) >= min_size:
        chunks.append(current)

    return chunks

Chunkovanie podľa sekcií Markdown využíva informácie, ktoré už autor poskytol: svoje nadpisy. Každá sekcia sa stane samostatným úryvkom, čo zaručuje, že otázka týkajúca sa „autentifikácie“ získa celú sekciu, nie len fragment. Sekcie, ktoré sú príliš dlhé, sa vrátia k chunkovaniu po odsekoch, čím sa zabezpečí, že žiadny úryvok neprekročí limit.

def chunk_by_markdown_sections(text, max_size=2000):
    """Chunking by Markdown headings (## and ###)."""
    sections = re.split(r'\n(?=##\s)', text)
    chunks = []

    for section in sections:
        section = section.strip()
        if not section:
            continue
        if len(section) <= max_size:
            chunks.append(section)
        else:
            # Sub-chunk overly long sections
            sub_chunks = chunk_by_paragraphs(section, max_size=max_size)
            chunks.extend(sub_chunks)

    return chunks

Kompletný pipeline prípravy

Nakoniec spojíš tieto tri operácie dokopy a vyberieš stratégiu chunkovania na základe typu súboru: súbory .md prejdú cez sekcie, všetko ostatné cez odseky. Každý úryvok potom nesie svoje metadáta – zdroj, pozíciu v dokumente a celkový počet úryvkov z daného dokumentu. Bez toho nebudeš môcť dohľadať zdroj odpovede. Posledné dva riadky zobrazujú mieru expanzie a priemernú veľkosť: ak tento priemer klesne výrazne pod tvoju chunk_size, dokument je viac fragmentovaný, než sa očakávalo, a musíš prehodnotiť svoju stratégiu chunkovania.

def prepare_documents(raw_docs, chunk_size=1500, overlap=200):
    """Complete pipeline: clean, chunk, enrich with metadata."""
    all_chunks = []

    for doc in raw_docs:
        # 1. Clean
        clean = clean_text(doc["content"])

        # 2. Chunk based on type
        if doc.get("source", "").endswith(".md"):
            chunks = chunk_by_markdown_sections(clean, max_size=chunk_size)
        else:
            chunks = chunk_by_paragraphs(clean, max_size=chunk_size)

        # 3. Enrich with metadata
        for i, chunk in enumerate(chunks):
            all_chunks.append({
                "text": chunk,
                "source": doc["source"],
                "chunk_index": i,
                "total_chunks": len(chunks),
            })

    return all_chunks

# Execution
chunks = prepare_documents(docs)
print(f"{len(docs)} documents -> {len(chunks)} chunks")
print(f"Average size: {sum(len(c['text']) for c in chunks) / len(chunks):.0f} characters")

Kľúčové poznatky

  • Kvalita RAG priamo závisí od kvality dát a stratégie chunkovania
  • Pred indexovaním vyčisti dáta (odstráň cudzie znaky, dlhé URL, duplicity)
  • Chunkovanie po odsekoch alebo sekciách Markdown zachováva sémantickú súdržnosť
  • Prekrytie 10 – 15 % medzi úryvkami zabraňuje rozdeľovaniu myšlienok
  • Uchovávaj metadáta (zdroj, stránka, pozícia) pre sledovateľnosť odpovedí