Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Sagatavo datus

Nodarbība 10 no 18 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. RAG kvalitāte ir atkarīga no taviem datiem
  2. Datu iegūšana
  3. Datu attīrīšana
  4. Fragmentēšanas stratēģijas
  5. Pilns sagatavošanas konveijers
  6. Galvenās atziņas

RAG kvalitāte ir atkarīga no taviem datiem

RAG konveijers ir tikpat labs, cik dati, ko tas indeksē. Tu vari izveidot ideālu uzvedni un izvēlēties labāko ģenerēšanas modeli, taču, ja izgūtā daļa pārgriež definīciju uz pusēm vai iekļauj atkārtojošu kājeni lietderīga teksta vietā, tava atbilde būs nekvalitatīva. Sagatavošana notiek trīs posmos: iegūst datus no to atrašanās vietas, izsvītro visu bezjēdzīgo un sadala tos fragmentos, kas optimizēti indeksēšanai.

Datu iegūšana

Reālas pasaules korpusi reti ir viendabīgi. Parasti tev būs Markdown dokumentācija repozitorijā, dažas lapas no publiskas vietnes un nedaudz normatīvo PDF failu. Katram avotam ir nepieciešams savs ielādētājs, taču visiem ir jāražo viena un tā pati struktūra — saturs, avots un tips —, lai pārējā konveijera daļa paliktu neatkarīga no teksta izcelsmes.

Teksta failiem pietiek ar rekursīvu direktoriju apgājienu, un filtrēšana pēc paplašinājuma novērš nejaušu bināro failu ielādi.

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

Tīmekļa lapas tiek saņemtas, izmantojot HTTP, taču tas, ko tu iegūsti, ir HTML. Tālāk redzamā ekstrakcija noņem tagus, izmantojot regulārās izteiksmes, un sapludina vairākas atstarpes. Prototipam tas ir pietiekami, taču komentārs tev atgādina, ka ražošanas vidē BeautifulSoup tiks galā daudz labāk ar tabulām un ligzdotiem sarakstiem.

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 faili ir pelnījuši īpašu attieksmi. Visa dokumenta sapludināšanas vietā saglabā vienu ierakstu uz lapu un iekodē lapas numuru avotā kā file.pdf#page=12. Kad tavs asistents citēs šo fragmentu, lietotājs precīzi zinās, kur to pārbaudīt.

# 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

Datu attīrīšana

Attīrīšana ir kritiska izgūšanas kvalitātei, jo katrs lieks simbols aizņem vietu fragmentā un piesārņo iegūto vektoru. Tālāk redzamā funkcija ķēdē četras apstrādes darbības: tā noņem vadības simbolus, kas palikuši pāri no formātu konvertēšanas, normalizē jaunu rindu un atstarpu virknes, dzēš PDF failiem raksturīgus lappušu numurēšanas marķierus un aizstāj bezgalīgus URL ar vienkāršu vieturi, lai tie neaizņemtu visu fragmentu.

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

Fragmentēšanas stratēģijas

Fragmentēšana ir vissvarīgākais sagatavošanas solis: fragmenta izmērs un metode tieši ietekmē izgūšanas kvalitāti. Pastāv trīs pieejas, sākot no mehāniskām līdz struktūru ņemošām vērā.

Fiksēta izmēra fragmentēšana pārvietojas caur tekstu regulāros griezumos. Tā pilnībā ignorē nozīmi, padarot to piemērotu jebkuram avotam, taču tā bieži pārgriež teikumus uz pusēm. Pārklāšanās daļēji labo šo trūkumu: ar overlap=200 katra fragmenta beigas atkārtojas nākamā sākumā, nodrošinot, ka sadalīta ideja vismaz vienā no abiem gabaliem paliek vesela.

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

Uz rindkopām balstīta fragmentēšana, kas ieteicama dokumentācijai, paļaujas uz teksta dabiskajām robežām. Tā uzkrāj rindkopas, kamēr tās nepārsniedz max_size, un pēc tam atver jaunu fragmentu. Slieksnis min_size novērš vientuļa virsraksta vai izolētas rindas indeksēšanu, kas radītu vektoru bez izmantojama satura.

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

Markdown sadaļu fragmentēšana izmanto informāciju, ko autors jau ir sniedzis: savus virsrakstus. Katra sadaļa kļūst par atsevišķu fragmentu, garantējot, ka jautājums par „autentifikāciju” izgūs visu sadaļu, nevis fragmentu. Sadaļas, kas ir pārāk garas, atgriežas pie rindkopu fragmentēšanas, nodrošinot, ka neviens fragments nepārsniedz limitu.

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

Pilns sagatavošanas konveijers

Visbeidzot, sasaisti trīs darbības kopā un izvēlies fragmentēšanas stratēģiju, pamatojoties uz faila tipu: .md faili iziet cauri sadaļām, viss pārējais — cauri rindkopām. Katrs fragments tad nes savu metadatus — avotu, pozīciju dokumentā un kopējo fragmentu skaitu no šī dokumenta. Bez tā tu nevarēsi izsekot atbildes avotam. Pēdējās divas rindas parāda izvēršanās koeficientu un vidējo izmēru: ja šis vidējais rādītājs krītas ievērojami zem tava chunk_size, dokuments ir vairāk sadrumstalots, nekā gaidīts, un tev ir jāpārskata sava fragmentēšanas stratēģija.

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

Galvenās atziņas

  • RAG kvalitāte ir tieši atkarīga no datu kvalitātes un fragmentēšanas stratēģijas
  • Attīri datus pirms indeksēšanas (noņem liekos simbolus, garos URL, dublikātus)
  • Fragmentēšana pa rindkopām vai Markdown sadaļām saglabā semantisko sakarību
  • 10–15% pārklāšanās starp fragmentiem novērš ideju sadalīšanu
  • Saglabā metadatus (avots, lapa, pozīcija), lai nodrošinātu atbilžu izsekojamību