Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Paruoškite duomenis

Paskaita 10 iš 18 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. RAG kokybė priklauso nuo jūsų duomenų
  2. Duomenų gavimas
  3. Duomenų valymas
  4. Skaidymo strategijos
  5. Pilna paruošimo grandinė
  6. Svarbiausi punktai

RAG kokybė priklauso nuo jūsų duomenų

RAG sistema yra tokia gera, kokie yra jos indeksuojami duomenys. Galite sukurti tobulą užklausą (prompt) ir pasirinkti geriausią generavimo modelį, tačiau jei gautas teksto fragmentas nutraukia apibrėžimą pusiaujyje arba įtraukia pasikartojančią poraštę vietoj naudingo teksto, jūsų atsakymas bus prastas. Paruošimas vyksta trimis etapais: duomenų gavimas iš jų šaltinių, beprasmės informacijos pašalinimas ir skaidymas į indeksavimui optimizuotus fragmentus.

Duomenų gavimas

Realūs tekstynai retai būna vienalyčiai. Paprastai turite Markdown dokumentaciją saugykloje, kelis puslapius iš viešos svetainės ir keletą norminių PDF failų. Kiekvienam šaltiniui reikia savo įkeltuvo (loader), tačiau visi jie turi grąžinti tą pačią struktūrą – turinį, šaltinį ir tipą, kad likusi sistemos dalis būtų nepriklausoma nuo teksto kilmės.

Tekstiniams failams pakanka rekursyviai apeiti katalogus, o filtravimas pagal plėtinį apsaugo nuo atsitiktinio binarinių failų įkėlimo.

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

Tinklalapiai pasiekiami per HTTP, tačiau gaunate HTML kodą. Toliau pateiktas ištraukimas pašalina žymas naudodamas reguliariuosius reiškinius ir suglaudina daugybę tarpų. Prototipui to pakanka, tačiau komentaras primena, kad gamybinėje aplinkoje „BeautifulSoup“ daug geriau tvarkysis su lentelėmis ir įdėtiniais sąrašais.

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 failai nusipelno ypatingo dėmesio. Vietoj to, kad sujungtumėte visą dokumentą, sukurkite vieną įrašą kiekvienam puslapiui ir į šaltinį įtraukite puslapio numerį formatu file.pdf#page=12. Kai jūsų asistentas cituos šią ištrauką, vartotojas tiksliai žinos, kur ją patikrinti.

# 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

Duomenų valymas

Valymas yra kritiškai svarbus paieškos kokybei, nes kiekvienas pašalinis simbolis eikvoja vietą fragmente ir teršia gaunamą vektorių. Toliau pateikta funkcija sujungia keturis veiksmus: pašalina valdymo simbolius, likusius po formato konvertavimo, normalizuoja naujų eilučių ir tarpų sekas, ištrina PDF failams būdingus puslapių žymeklius ir pakeičia begalines URL nuorodas paprastu rezervuotu ženklu, kad jos neužimtų viso fragmento.

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

Skaidymo strategijos

Skaidymas į fragmentus yra svarbiausias paruošimo etapas: fragmento dydis ir metodas tiesiogiai veikia paieškos kokybę. Egzistuoja trys požiūriai – nuo mechaninio iki struktūrą atsižvelgiančio.

Fiksuoto dydžio skaidymas juda tekstu reguliariais pjūviais. Jis visiškai ignoruoja prasmę, todėl tinka bet kokiam šaltiniui, tačiau dažnai nutraukia sakinius pusiaujyje. Persidengimas iš dalies ištaiso šią klaidą: nustatžius overlap=200, kiekvieno fragmento pabaiga kartojasi kito pradžioje, užtikrinant, kad padalinta mintis bent viename iš dviejų gabalų išliktų vientisa.

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

Skaidymas pagal pastraipas, rekomenduojamas dokumentacijai, remiasi natūraliomis teksto ribomis. Jis kaupia pastraipas, kol jos neviršija max_size, tada atveria naują fragmentą. min_size slenkstis neleidžia indeksuoti vienišų antraščių ar izoliuotų eilučių, kurios sukurtų vektorių be naudingo turinio.

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

Skaidymas pagal Markdown skyrius naudoja autoriaus jau pateiktą informaciją – antraštes. Kiekvienas skyrius tampa savarankišku fragmentu, garantuojant, kad užklausa apie „autentifikavimą“ gaus visą skyrių, o ne jo fragmentą. Per ilgi skyriai grįžta prie skaidymo pastraipomis, užtikrinant, kad joks fragmentas neviršytų ribos.

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

Pilna paruošimo grandinė

Galiausiai sujunkite tris operacijas ir pasirinkite skaidymo strategiją pagal failo tipą: .md failai skaidomi pagal skyrius, visi kiti – pagal pastraipas. Kiekvienas fragmentas tada gauna savo metaduomenis – šaltinį, poziciją dokumente ir bendrą to dokumento fragmentų skaičių. Be to negalėsite nustatyti atsakymo šaltinio. Paskutinės dvi eilutės rodo išplėtimo koeficientą ir vidutinį dydį: jei šis vidurkis gerokai mažesnis už jūsų chunk_size, dokumentas yra labiau suskaidytas nei tikėtasi, ir turite peržiūrėti savo skaidymo strategiją.

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

Svarbiausi punktai

  • RAG kokybė tiesiogiai priklauso nuo duomenų kokybės ir skaidymo strategijos
  • Prieš indeksuodami išvalykite duomenis (pašalinkite pašalinius simbolius, ilgas URL nuorodas, dublikatus)
  • Skaidymas pagal pastraipas arba Markdown skyrius išlaiko semantinį vientisumą
  • 10–15 % fragmentų persidengimas neleidžia nutraukti minčių
  • Išsaugokite metaduomenis (šaltinį, puslapį, poziciją), kad būtų galima atsekti atsakymų kilmę