Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Andmete ettevalmistamine

Õppetund 10 / 18 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. RAG-i kvaliteet sõltub sinu andmetest
  2. Andmete hankimine
  3. Andmete puhastamine
  4. Tükkideks jagamise strateegiad
  5. Täielik ettevalmistustorustik
  6. Peamised punktid

RAG-i kvaliteet sõltub sinu andmetest

RAG-i torustik on ainult nii hea, kui head on selle indekseeritavad andmed. Sa võid koostada täiusliku vihje (prompt) ja valida parima genereerimismudeli, kuid kui hangitud tekstilõik jätab definitsiooni pooleli või toob kasuliku teksti asemel kaasa korduva jaluse, kannatab sinu vastus. Ettevalmistus koosneb kolmest etapist: too andmed nende asukohast, eemalda kõik tähendusetu ja jaga need indekseerimiseks optimeeritud tükkideks.

Andmete hankimine

Reaalsed tekstikogumid on harva homogeensed. Tavaliselt on sul repositooriumis Markdown-dokumentatsioon, mõned lehed avalikust veebisaidist ja peotäis regulatiivseid PDF-faile. Iga allikas vajab oma laadijat, kuid kõik peavad tootma sama struktuuri – sisu, allikas ja tüüp –, et ülejäänud torustik jääks teksti päritolu suhtes sõltumatuks.

Tekstifailide puhul piisab rekursiivsest kataloogis läbikäimisest ja laiendi järgi filtreerimisest, et vältida juhuslikult binaarfailide laadimist.

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

Veebilehed saadetakse üle HTTP protokolli, kuid see, mida saad, on HTML. Allpool toodud ekstraheerimine eemaldab sildid regulaaravaldiste abil ja koondab mitmiktühikud. Prototüübi jaoks piisab sellest, kuid kommentaar tuletab meelde, et tootmises teeb BeautifulSoup tabelite ja pesastatud loenditega palju paremat tööd.

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-failid väärivad erikohtlemist. Kogu dokumendi liitmise asemel hoia iga lehe kohta üks kirje ja kodeeri lehenumber allikasse kujul file.pdf#page=12. Kui sinu assistent viitab sellele lõigule, teab kasutaja täpselt, kust seda kontrollida.

# 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

Andmete puhastamine

Puhastamine on otsingu kvaliteedi jaoks kriitiline, sest iga võõras märk tarbib tüki ruumi ja hägustab tulemusvektorit. Järgnev funktsioon aheldab neli töötlust: see eemaldab vormingu teisendustest jäänud juhtmärgid, normaliseerib rea- ja tühikujärjestusi, kustutab PDF-idele tüüpilised leheküljemärgistused ja asendab lõputud URL-id lihtsa kohahoidjaga, et need ei neelaks tervet tükki.

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

Tükkideks jagamise strateegiad

Tükkideks jagamine on ettevalmistuse kõige olulisem samm: tüki suurus ja meetod mõjutavad otsingu kvaliteeti otseselt. Eksisteerib kolm lähenemist, alates mehaanilisest kuni struktuuri arvestavani.

Fikseeritud suurusega tükkideks jagamine liigub tekstis regulaarsete lõikude kaupa. See eirab tähendust täielikult, muutes selle kohaldatavaks igale allikale, kuid sageli lõikab see laused pooleli. Ülekate (overlap) parandab seda viga osaliselt: väärtusega overlap=200 kordub iga tüki lõpp järgmise alguses, tagades, et poolitatud idee jääb vähemalt ühes kahest tükist tervikuks.

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

Lõikudel põhinev tükkideks jagamine, mida soovitatakse dokumentatsiooni jaoks, tugineb teksti loomulikele piiridele. See kogub lõike seni, kuni need jäävad alla max_size, ja avab seejärel uue tüki. Lävi min_size hoiab ära üksiku pealkirja või isoleeritud rea indekseerimise, mis tooks kaasa vektori ilma kasuliku sisuta.

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

Markdowni sektsioonidel põhinev tükkideks jagamine kasutab teavet, mille autor on juba esitanud: nende pealkirju. Iga sektsioon muutub iseseisvaks tükiks, tagades, et küsimus „autentimise“ kohta toob esile kogu sektsiooni, mitte ainult fragmendi. Liiga pikad sektsioonid lähevad üle lõikudel põhinevale jagamisele, tagades, et ükski tükk ei ületa limiiti.

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

Täielik ettevalmistustorustik

Lõpuks ahelda need kolm operatsiooni kokku ja vali tükkideks jagamise strateegia vastavalt failitüübile: .md failid läbivad sektsioonipõhise jagamise, kõik muu läbib lõigupõhise jagamise. Iga tükk kannab seejärel oma metaandmeid – allikas, positsioon dokumendis ja sellest dokumendist pärit tükkide koguarv. Ilma selleta ei saa sa vastust allikastada. Viimased kaks rida kuvavad laienemismäära ja keskmist suurust: kui see keskmine langeb oluliselt alla sinu chunk_size, on dokument oodatust killustatum ja pead oma tükkideks jagamise strateegia üle vaatama.

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

Peamised punktid

  • RAG-i kvaliteet sõltub otseselt andmete kvaliteedist ja tükkideks jagamise strateegiast
  • Puhasta andmed enne indekseerimist (eemalda võõrad märgid, pikad URL-id, dublikaadid)
  • Lõikudel või Markdowni sektsioonidel põhinev tükkideks jagamine säilitab semantilise sidususe
  • 10–15% ülekatet tükkide vahel hoiab ära ideede poolitamise
  • Säilita metaandmed (allikas, lehekülg, positsioon) vastuste jälgitavuse tagamiseks