Chunking: Asiakirjojen älykäs pilkkominen
Tällä sivulla
- Tavoitteet
- Miksi asiakirjat kannattaa pilkkoa?
- Strategia 1: Kiinteän kokoinen chunking
- Strategia 2: Erotinmerkkeihin perustuva chunking
- Strategia 3: Markdown-osioihin perustuva chunking
- Strategia 4: Semanttinen chunking
- Chunkkien rikastaminen kontekstilla
- Minkä chunk-koon sinun pitäisi valita?
- 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) | Edut | Haitat |
|---|---|---|
| 100–200 | Erittäin tarkka, hyvä rakeisuus | Menettää kontekstin |
| 300–500 | Hyvä kompromissi | Vakio |
| 500–1000 | Rikas konteksti | Vähemmän tarkka, kallis |
| 1000+ | Maksimikonteksti | Laimentaa 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