Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Valmistele data

Oppitunti 10 / 18 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. RAG-laatu riippuu datastasi
  2. Datan noutaminen
  3. Datan siivoaminen
  4. Osioittamisstrategiat
  5. Täydellinen valmistelupipeline
  6. Keskeiset asiat

RAG-laatu riippuu datastasi

RAG-pipeline on vain yhtä hyvä kuin indeksoimasi data. Voit suunnitella täydellisen kehotteen ja valita parhaan generointimallin, mutta jos haettu tekstinpätkä katkaisee määritelmän puolivälistä tai sisältää hyödytöntä toistuvaa alatunnistetta kelvollisen tekstin sijaan, vastauksesi kärsii. Valmistelu tapahtuu kolmessa vaiheessa: nouda data sen sijaintipaikasta, poista kaikki merkityksetön ja jaa se indeksointia varten optimoituihin osiin.

Datan noutaminen

Todelliset tekstikorpukset ovat harvoin homogeenisiä. Sinulla on tyypillisesti Markdown-dokumentaatiota repositoriossa, muutama sivu julkiselta verkkosivustolta ja kourallinen sääntelyyn liittyviä PDF-tiedostoja. Jokainen lähde tarvitsee oman lataimensa, mutta kaikkien on tuotettava sama rakenne – sisältö, lähde ja tyyppi – jotta loput pipelinesta pysyvät riippumattomina tekstin alkuperästä.

Tekstitiedostojen osalta rekursiivinen hakemistoläpikäynti riittää, ja suodatus tiedostopäätteen perusteella estää binääritiedostojen vahingossa lataamisen.

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

Verkkosivut haetaan HTTP:n yli, mutta saatavasi on HTML:ää. Alla oleva ekstraktio poistaa tagit säännöllisillä lausekkeilla ja tiivistää useat välilyönnit yhdeksi. Tämä riittää prototyyppiin, mutta kommentti muistuttaa, että tuotantoympäristössä BeautifulSoup hoitaa taulukot ja sisäkkäiset listat huomattavasti paremmin.

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-tiedostot ansaitsevat erityiskohtelun. Koko dokumentin yhdistämisen sijaan pidä yksi merkintä sivua kohden ja koodaa sivunumero lähteeseen muodossa file.pdf#page=12. Kun assistenttisi lainaa tätä kohtaa, käyttäjä tietää tarkasti, mistä hän voi varmistaa tiedon.

# 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

Datan siivoaminen

Siivoaminen on kriittistä hakulaadun kannalta, sillä jokainen harhaileva merkki kuluttaa tilaa tekstinpätkästä ja sameuttaa syntyvän vektorin. Seuraava funktio ketjuttaa neljä käsittelytapaa: se poistaa muotoilumuunnoksista jääneet ohjausmerkit, normalisoi rivinvaihtojen ja välilyöntien jonoja, poistaa PDF-tiedostoille tyypilliset sivunumerointimerkit ja korvaa loputtomat URL-osoitteet yksinkertaisella paikkamerkillä, jotta ne eivät syö koko tekstinpätkää.

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

Osioittamisstrategiat

Osioittaminen on valmistelun tärkein vaihe: osion koko ja menetelmä vaikuttavat suoraan hakulaatuun. Kolme lähestymistapaa on olemassa, mekaanisesta rakenteen huomioivaan.

Kiinteän kokoinen osioittaminen etenee tekstissä säännöllisin leikkein. Se jättää merkityksen täysin huomiotta, mikä tekee siitä sovellettavan mihin tahansa lähteeseen, mutta se katkoo usein lauseita puolivälistä. Päällekkäisyys korjaa tätä virhettä osittain: asetuksella overlap=200 kunkin osion loppu toistuu seuraavan alussa, varmistaen, että halkaistu ajatus pysyy kokonaisena vähintään toisessa kahdesta osasta.

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

Kappaleisiin perustuva osioittaminen, jota suositellaan dokumentaatioon, luottaa tekstin luonnollisiin rajoihin sen sijaan. Se kerää kappaleita niin kauan kuin ne pysyvät max_size-rajan alapuolella ja avaa sitten uuden osion. min_size-kynnys estää yksinäisen otsikon tai eristetyn rivin indeksoinnin, mikä tuottaisi vektorin ilman käyttökelpoista sisältöä.

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-osioihin perustuva osioittaminen hyödyntää kirjoittajan jo tarjoamaa informaatiota: otsikoita. Jokaisesta osiosta tulee itsenäinen tekstinpätkä, mikä takaa, että kysymys aiheesta “autentikointi” hakee koko osion eikä pelkkää fragmenttia. Liian pitkät osiot palaavat kappaleosioittamiseen, mikä varmistaa, ettei mikään osio ylitä rajaa.

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äydellinen valmistelupipeline

Lopuksi ketjuta kolme operaatiota yhteen ja valitse osioittamisstrategia tiedostotyypin perusteella: .md-tiedostot käyvät läpi osioittamisen, kaikki muu kappaleittain. Jokainen osio kantaa mukanaan metadataansa – lähde, sijainti dokumentissa ja kyseisen dokumentin osioiden kokonaismäärä. Ilman tätä et pysty jäljittämään vastausta. Kaksi viimeistä riviä näyttävät laajenemisasteen ja keskimääräisen koon: jos tämä keskiarvo laskee huomattavasti alle chunk_size-arvosi, dokumentti on odotettua pirstaleisempi, ja sinun on tarkistettava osioittamisstrategiasi.

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

Keskeiset asiat

  • RAG-laatu riippuu suoraan datan laadusta ja osioittamisstrategiasta
  • Siivoa data ennen indeksointia (poista harhailevat merkit, pitkät URL-osoitteet, duplikaatit)
  • Kappale- tai Markdown-osioittaminen säilyttää semanttisen koherenssin
  • 10–15 %:n päällekkäisyys osioiden välillä estää ajatusten halkaisemisen
  • Säilytä metadata (lähde, sivu, sijainti) vastausten jäljitettävyyden vuoksi