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

Az adatok előkészítése

10. lecke 18 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. A RAG minősége az adataidon múlik
  2. Az adatok begyűjtése
  3. Az adatok tisztítása
  4. Szövegrészletekre osztási stratégiák (Chunking)
  5. Teljes előkészítő folyamatcső
  6. Főbb megállapítások

A RAG minősége az adataidon múlik

Egy RAG folyamatcső csak annyira jó, mint az indexelt adatok. Készíthetsz tökéletes promptot és választhatod a legjobb generációs modellt, de ha a visszakeresett szövegrészlet félbevág egy definíciót, vagy hasznos tartalom helyett ismétlődő láblécet húz be, a válaszod szenvedni fog. Az előkészítés három szakaszból áll: az adatok begyűjtése a forráshelyükről, a jelentéstartalom nélküli elemek eltávolítása, majd az indexelésre optimalizált szövegrészletekre (chunkokra) való felosztás.

Az adatok begyűjtése

A valós szövegkorpuszok ritkán homogének. Általában találsz Markdown dokumentációt egy tárolóban, néhány oldalt egy nyilvános webhelyről és egy maréknyi szabályozási PDF-et. Minden forráshoz saját betöltő (loader) kell, de mindegyiknek ugyanazt a struktúrát kell előállítania – tartalom, forrás és típus –, hogy a folyamatcső többi része független maradjon a szöveg eredetétől.

Szövegfájlok esetén elegendő a könyvtárak rekurzív bejárása, a kiterjesztés szerinti szűrés pedig megakadályozza, hogy véletlenül bináris fájlokat tölts be.

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")

A weboldalak HTTP-n keresztül érkeznek, de amit kapsz, az HTML. Az alábbi kinyerés reguláris kifejezésekkel távolítja el a címkéket és vonja össze a többszörös szóközöket. Ez elég egy prototípushoz, de a megjegyzés emlékeztet arra, hogy éles környezetben a BeautifulSoup sokkal jobb munkát végez a táblázatokkal és a beágyazott listákkal.

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")

A PDF-ek különleges bánásmódot igényelnek. A teljes dokumentum összefűzése helyett tarts meg egy bejegyzést oldalanként, és kódold az oldalszámot a forrásban így: file.pdf#page=12. Amikor az asszisztensed hivatkozik erre a részletre, a felhasználó pontosan tudni fogja, hol ellenőrizze azt.

# 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

Az adatok tisztítása

A tisztítás kritikus fontosságú a visszakeresés minősége szempontjából, mert minden idegen karakter helyet foglal el a szövegrészletben és elmosja a kapott vektort. Az alábbi függvény négy kezelést láncol össze: eltávolítja a formátumkonverziókból megmaradt vezérlőkaraktereket, normalizálja az újsorok és szóközök sorozatait, törli a PDF-ekre jellemző oldalszámozó jelöléseket, és lecseréli a végtelen URL-eket egy egyszerű helykitöltőre, hogy ne egyék fel az egész szövegrészletet.

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"])

Szövegrészletekre osztási stratégiák (Chunking)

A szövegrészletekre osztás (chunking) az előkészítés legfontosabb lépése: a szövegrészlet mérete és módszere közvetlenül befolyásolja a visszakeresés minőségét. Három megközelítés létezik, a mechanikustól a struktúra-aware megoldásokig.

A fix méretű szövegrészletekre osztás rendszeres szeletekben halad végig a szövegen. Teljesen figyelmen kívül hagyja a jelentést, így bármilyen forrásra alkalmazható, de gyakran félbevágja a mondatokat. Az átfedés (overlap) részben korrigálja ezt a hibát: overlap=200 esetén minden szövegrészlet vége megismétlődik a következő elején, biztosítva, hogy egy felosztott gondolat legalább az egyik darabban egészben maradjon.

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

A bekezdésalapú szövegrészletekre osztás, amely dokumentációhoz ajánlott, a szöveg természetes határait használja ki. Addig gyűjti a bekezdéseket, amíg azok a max_size alatt maradnak, majd új szövegrészletet nyit. A min_size küszöbérték megakadályozza egy elárvult címsor vagy elszigetelt sor indexelését, ami használható tartalom nélküli vektort eredményezne.

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

A Markdown szakaszok szerinti szövegrészletekre osztás kihasználja a szerző által már megadott információkat: a címsorokat. Minden szakasz önálló szövegrészletté válik, garantálva, hogy az „hitelesítésre“ vonatkozó kérdés a teljes szakaszt hozza vissza, nem pedig egy töredéket. A túl hosszú szakaszok visszaesnek a bekezdésalapú osztásra, biztosítva, hogy egyetlen szövegrészlet se lépje túl a limitet.

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

Teljes előkészítő folyamatcső

Végül láncold össze a három műveletet, és a fájltípus alapján válaszd ki a szövegrészletekre osztási stratégiát: a .md fájlok a szakaszok szerint, minden más a bekezdések szerint kerül feldolgozásra. Minden szövegrészlet ekkor megkapja a metaadatait – forrás, pozíció a dokumentumban és a dokumentumból származó szövegrészletek teljes száma. Enélkül nem tudod majd forrásolni a választ. Az utolsó két sor a bővülési rátát és az átlagos méretet jeleníti meg: ha ez az átlag jóval a chunk_size érték alá csökken, a dokumentum a vártnál töredezettebb, és felül kell vizsgálnod a szövegrészletekre osztási stratégiádat.

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")

Főbb megállapítások

  • A RAG minősége közvetlenül függ az adatok minőségétől és a szövegrészletekre osztási stratégiától
  • Indexelés előtt tisztítsd meg az adatokat (távolítsd el az idegen karaktereket, hosszú URL-eket, duplikációkat)
  • A bekezdés- vagy Markdown szakaszalapú szövegrészletekre osztás megőrzi a szemantikai koherenciát
  • A szövegrészletek közötti 10–15%-os átfedés megakadályozza a gondolatok széttördelését
  • Tartsd meg a metaadatokat (forrás, oldal, pozíció) a válaszok nyomon követhetősége érdekében