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

Chunking: Asiakirjojen älykäs pilkkominen

Oppitunti 12 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Miksi asiakirjat kannattaa pilkkoa?
  3. Strategia 1: Kiinteän kokoinen chunking
  4. Strategia 2: Erotinmerkkeihin perustuva chunking
  5. Strategia 3: Markdown-osioihin perustuva chunking
  6. Strategia 4: Semanttinen chunking
  7. Chunkkien rikastaminen kontekstilla
  8. Minkä chunk-koon sinun pitäisi valita?
  9. Keskeiset asiat

Tavoitteet

  • Ymmärrä, miksi chunking on ratkaisevan tärkeää RAG-laadulle
  • Hallitse erilaiset pilkkomisstrategiat
  • Valitse oikea chunk-koko ja päällekkäisyys

Miksi asiakirjat kannattaa pilkkoa?

Upotusmalleilla on token-rajoitus: OpenAI:n mallilla se on 8 191. Tämä rajoitus on ensimmäinen syy pilkkoa asiakirjoja, mutta ei tärkein. Jopa kattoa huomattavasti pienempi asiakirja tuottaa heikkoja tuloksia, jos se koodataan yhtenä lohkona, koska syntyvä vektori keskiarvoistaa koko sisällön ja menettää yksityiskohdat. Ota esimerkiksi 40-sivuinen henkilöstökäsikirja, joka käsittelee lomakäytäntöjä, etätyötä, kulukorvauksia ja sairausvakuutusta: sen yksittäinen upotus ei vastaa todellisuudessa mitään näistä neljästä aiheesta, ja haku sanalla “kuinka monta lomapäivää” sijoittaa sen paljon lyhyemmän mutta huomattavasti kohdistetumman asiakirjan alapuolelle.

Chunking ratkaisee tämän ongelman jakamalla asiakirjan yhtenäisiksi paloiksi, joista kukin sieppaa tietyn idean tai kappaleen. Tämä on vaihe, jossa RAG-putki voittaa tai häviää eniten laatua – jo ennen kuin valitset upotusmallin.

Strategia 1: Kiinteän kokoinen chunking

Yksinkertaisin menetelmä laskee sanat ja leikkaa säännöllisin välein. Se jättää tekstirakenteen täysin huomiotta, mikä tekee siitä raakaa, mutta se vaatii vain kolme riviä koodia ja toimii välttämättömänä perustasona: minkä tahansa kehittyneemmän strategian on osoitettava suorittavansa tätä paremmin.

def chunker_fixed_size(
    text: str,
    size: int = 500,
    overlap: int = 100
) -> list[str]:
    """Splits text into fixed-size chunks with overlap."""
    words = text.split()
    chunks = []

    for i in range(0, len(words), size - overlap):
        chunk = " ".join(words[i:i + size])
        if chunk.strip():
            chunks.append(chunk)

    return chunks

long_text = "A very long document... " * 500
chunks = chunker_fixed_size(long_text, size=300, overlap=50)
print(f"{len(chunks)} chunks generated")

Parametri overlap ansaitsee huomiota. Ilman päällekkäisyyttä leikkaus osuu ennemmin tai myöhemmin keskelle selitystä: lause “irtisanomisaika on kolme kuukautta” päätyy yhteen chunkiin ja “lukuun ottamatta koeaikaa” seuraavaan. Kumpikaan ei vastaa kysymykseen oikein, ja jälkimmäinen on jopa harhaanjohtava. Päällekkäistämällä chunkeja 10–20 % niiden koosta varmistat, että jokainen idea esiintyy ehjänä vähintään kerran jossain indeksissä. Tämä on hyvä lähtökohta; säädä sitä myöhemmin asiakirjojesi tiheyden perusteella.

Strategia 2: Erotinmerkkeihin perustuva chunking

Sanojen leikkaamisen sijaan voit kunnioittaa tekstin luonnollisia rajoja. Ajatus on kokeilla ensin vahvinta erotinta – kahta rivinvaihtoa, jotka erottavat kaksi kappaletta – ja siirtyä sitten asteittain heikompiin erottimiin niin kauan kuin syntyvä pala ylittää enimmäiskoon. Blogikirjoitus pilkotaan näin kappale kappaleelta, ja vain valtava kappale pilkotaan lauseisiin.

import re

def chunker_separators(
    text: str,
    separators: list[str] = ["\n\n", "\n", ". ", " "],
    max_size: int = 1000
) -> list[str]:
    """Splits text while respecting natural separators."""
    chunks = []
    current_chunk = ""

    # Split by the strongest separator first
    segments = [text]
    for sep in separators:
        new_segments = []
        for segment in segments:
            parts = segment.split(sep)
            for part in parts:
                if len(part.split()) > max_size:
                    new_segments.append(part)
                else:
                    if (current_chunk and
                        len((current_chunk + sep + part).split()) > max_size):
                        chunks.append(current_chunk.strip())
                        current_chunk = part
                    else:
                        current_chunk = (
                            current_chunk + sep + part
                            if current_chunk else part
                        )
        segments = new_segments

    if current_chunk.strip():
        chunks.append(current_chunk.strip())

    return chunks

Strategia 3: Markdown-osioihin perustuva chunking

Kun aineistosi koostuu jäsennellystä dokumentaatiosta, otsikot tekevät työn puolestasi: kirjoittaja on jo rajannut merkitysyksiköt. Pilkkominen #- ja ##-otsikkotasoilla tuottaa chunkeja, jotka vastaavat tarkalleen osioita, ja alla oleva funktio säilyttää otsikon tekstin vieressä, mitä käytämme heti sen jälkeen rikastamiseen.

def chunker_markdown(text: str, max_level: int = 2) -> list[dict]:
    """Splits a Markdown document by sections."""
    chunks = []
    current_section = {"title": "", "content": "", "level": 0}

    for line in text.split("\n"):
        # Detect headings
        match = re.match(r"^(#{1,6})\s+(.+)$", line)
        if match:
            level = len(match.group(1))
            title = match.group(2)

            if level <= max_level and current_section["content"].strip():
                chunks.append({
                    "title": current_section["title"],
                    "text": current_section["content"].strip(),
                    "level": current_section["level"]
                })

            if level <= max_level:
                current_section = {
                    "title": title,
                    "content": "",
                    "level": level
                }
            else:
                current_section["content"] += line + "\n"
        else:
            current_section["content"] += line + "\n"

    if current_section["content"].strip():
        chunks.append({
            "title": current_section["title"],
            "text": current_section["content"].strip(),
            "level": current_section["level"]
        })

    return chunks

Strategia 4: Semanttinen chunking

Tekstille, jolla ei ole eksplisiittistä rakennetta – kuten kokousmuistio tai puhelun litterointi – neither koko eikä erottimet tiedä, missä aihe vaihtuu. Upotukset tietävät. Koodaat jokaisen lauseen, vertaat jokaista lausetta edelliseen ja leikkaat kohdassa, jossa samankaltaisuus romahtaa: juuri siinä puhuja siirtyi budjetista rekrytointiin. Huomaa, että text-embedding-3-small riittää tähän, koska et etsi absoluuttista tarkkuutta vaan suhteellista katkoa.

from openai import OpenAI
import numpy as np

client = OpenAI()

def chunker_semantic(
    text: str,
    similarity_threshold: float = 0.75,
    min_sentence_length: int = 20
) -> list[str]:
    """Groups sentences by semantic similarity."""
    # Split into sentences
    sentences = re.split(r"(?<=[.!?])\s+", text)
    sentences = [s for s in sentences if len(s) > min_sentence_length]

    if len(sentences) <= 1:
        return [text]

    # Embeddings for each sentence
    resp = client.embeddings.create(
        input=sentences,
        model="text-embedding-3-small"  # small is sufficient here
    )
    embs = np.array([d.embedding for d in sorted(resp.data, key=lambda x: x.index)])

    # Find break points
    chunks = []
    chunk_sentences = [sentences[0]]

    for i in range(1, len(sentences)):
        sim = float(np.dot(embs[i], embs[i - 1]))
        if sim < similarity_threshold:
            # Semantic break detected
            chunks.append(" ".join(chunk_sentences))
            chunk_sentences = [sentences[i]]
        else:
            chunk_sentences.append(sentences[i])

    if chunk_sentences:
        chunks.append(" ".join(chunk_sentences))

    return chunks

Chunkkien rikastaminen kontekstilla

Eristetty chunk menettää usein tiedon, joka teki siitä tulkittavan. “Kesto on kolme vuotta” ei tarkoita mitään, jos lukija – tai upotusmalli – ei tiedä sen olevan valmistajan takuuluvusta. Jokaisen chunkin etuliittäminen asiakirjan otsikolla ja osion otsikolla palauttaa tämän kontekstin suoraan vektoriin itsessään, jolloin haku sanalla “takuun kesto” löytää kohdan.

def enrich_chunk(chunk: str, doc_title: str, section: str = "") -> str:
    """Adds context to the chunk for better embedding."""
    prefix = f"Document: {doc_title}"
    if section:
        prefix += f" | Section: {section}"
    return f"{prefix}\n\n{chunk}"

Minkä chunk-koon sinun pitäisi valita?

Valinta on kompromissi tarkkuuden ja kontekstin välillä: lyhyt chunk kohdistuu hienovaraisesti, mutta on silvottu, kun taas pitkä chunk ymmärtää kaiken, mutta laimentaa signaalia.

Koko (tokenia)EdutHaitat
100–200Erittäin tarkka, hyvä rakeisuusMenettää kontekstin
300–500Hyvä kompromissiVakio
500–1000Rikas kontekstiVähemmän tarkka, kallis
1000+MaksimikontekstiLaimentaa informaatiota

Yleispätevää arvoa ei ole: ihanteellinen koko riippuu asiakirjoistasi ja kyselyistäsi. Ainoa luotettava menetelmä on indeksoida sama aineisto kahdella tai kolmella eri koolla ja mitata sitten tulokset käyttämällä tunnuslukuja oppitunnilta 10 todellisten kysymysten joukossa. Lyhyisiin vastauksiin perustuva tukitietokanta sietää 200 tokenia; juridinen aineisto vaatii 800.

Keskeiset asiat

  • Chunking on vaikuttavin vaihe RAG-putkessa
  • Käytä kiinteää kokoa perustasona ja erottimia rakenteen kunnioittamiseen
  • Semanttinen chunking havaitsee aiheenvaihdokset automaattisesti
  • Päällekkäisyys ja kontekstuaalinen rikastaminen parantavat laatua
  • Testaa eri kokoja ja mittaa tuloksia hakumetriikoilla