Chunking: Inteligentny podział dokumentów
Na tej stronie
Cele
- Zrozumienie, dlaczego chunking jest kluczowy dla jakości RAG
- Opanowanie różnych strategii podziału tekstu
- Dobór odpowiedniego rozmiaru chunka i overlappu
Dlaczego dzielić dokumenty?
Modele embeddingowe mają limit tokenów: 8191 dla OpenAI. To pierwszy powód dzielenia dokumentów, ale nie najważniejszy. Nawet dokument znacznie krótszy od tego limitu da słabe wyniki, jeśli zostanie zakodowany jako jeden blok, ponieważ powstały wektor uśredni całą treść i straci szczegóły. Weźmy 40-stronicowy podręcznik HR obejmujący politykę urlopową, pracę zdalną, raporty wydatków i ubezpieczenie zdrowotne: jego pojedynczy embedding nie przypomina naprawdę żadnego z tych czterech tematów, a wyszukiwanie frazy „ile dni urlopu“ uplasuje go poniżej znacznie krótszego, ale znacznie bardziej ukierunkowanego dokumentu.
Chunking rozwiązuje ten problem, dzieląc dokument na spójne fragmenty, z których każdy chwytuje konkretną myśl lub akapit. To etap, na którym potok RAG zyskuje lub traci najwięcej na jakości – jeszcze zanim wybierzesz model embeddingowy.
Strategia 1: Chunking o stałym rozmiarze
Najprostsza metoda liczy słowa i tnie w regularnych odstępach. Całkowicie ignoruje strukturę tekstu, przez co jest brutalna, ale wymaga trzech linii kodu i służy jako niezbędna baza odniesienia: każda bardziej wyrafinowana strategia musi udowodnić, że działa lepiej niż ta.
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")
Parametr overlap zasługuje na uwagę. Bez overlappu cięcie w końcu trafi w środek wyjaśnienia: zdanie „okres wypowiedzenia wynosi trzy miesiące“ znajdzie się w jednym chunku, a „z wyjątkiem okresu próbnego“ w następnym. Żadne z nich nie odpowie poprawnie na pytanie, a drugie jest wręcz mylące. Nakładając na siebie chunki w zakresie 10–20% ich rozmiaru, gwarantujesz, że każda myśl istnieje nienaruszona przynajmniej raz gdzieś w indeksie. To dobry punkt wyjścia; dostosuj go później w zależności od gęstości Twoich dokumentów.
Strategia 2: Chunking oparty na separatorach
Zamiast ciąć słowo po słowie, możesz uszanować naturalne granice tekstu. Idea polega na wypróbowaniu najpierw najsilniejszego separatora – podwójnego znaku nowej linii oddzielającego dwa akapity – a następnie przechodzeniu do coraz słabszych separatorów, dopóki powstały fragment przekracza maksymalny rozmiar. Wpis na blogu zostanie więc podzielony akapit po akapicie, a jedynie monstrualny akapit zostanie pofragmentowany na zdania.
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: Chunking sekcji Markdown
Gdy Twój korpus składa się ze strukturyzowanej dokumentacji, nagłówki wykonują już pracę za Ciebie: autor już wyznaczył jednostki znaczeniowe. Podział na poziomie nagłówków # i ## tworzy chunki odpowiadające dokładnie sekcjom, a poniższa funkcja zachowuje nagłówek wraz z tekstem, co wykorzystamy natychmiast potem do wzbogacenia.
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: Chunking semantyczny
W przypadku tekstu bez wyraźnej struktury – podsumowania spotkania, transkrypcji rozmowy – ani rozmiar, ani separatory nie wiedzą, gdzie zmienia się temat. Wiedzą to embeddingi. Kodujesz każde zdanie, porównujesz każde zdanie z poprzednim i tniesz tam, gdzie podobieństwo gwałtownie spada: to dokładnie moment, w którym mówca przeszedł z budżetu na rekrutację. Pamiętaj, że text-embedding-3-small wystarczy tutaj, ponieważ nie szukasz absolutnej precyzji, lecz względnego punktu przerwania.
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
Wzbogacanie chunków o kontekst
Izolowany chunk często traci informacje, które czyniły go zrozumiałym. „Czas trwania wynosi trzy lata“ nie znaczy nic, jeśli czytelnik – lub model embeddingowy – nie wie, że pochodzi to z rozdziału o gwarancji producenta. Dodanie prefiksu z tytułem dokumentu i tytułem sekcji do każdego chunka przywraca ten kontekst bezpośrednio do samego wektora, a wyszukiwanie frazy „czas trwania gwarancji“ odnajdzie wtedy ten fragment.
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}"
Jaki rozmiar chunka wybrać?
Wybór wiąże się z kompromisem między precyzją a kontekstem: krótki chunk celuje precyzyjnie, ale jest okrojony, podczas gdy długi chunk rozumie wszystko, ale rozcieńcza sygnał.
| Rozmiar (tokeny) | Zalety | Wady |
|---|---|---|
| 100–200 | Bardzo precyzyjne, dobra granulacja | Utrata kontekstu |
| 300–500 | Dobry kompromis | Standard |
| 500–1000 | Bogaty kontekst | Mniejsza precyzja, droższe |
| 1000+ | Maksymalny kontekst | Rozcieńczenie informacji |
Nie ma uniwersalnej wartości: idealny rozmiar zależy od Twoich dokumentów i zapytań. Jedyną niezawodną metodą jest zaindeksowanie tego samego korpusu z dwoma lub trzema rozmiarami, a następnie zmierzenie wyników przy użyciu metryk z lekcji 10 na zestawie rzeczywistych pytań. Baza wiedzy wsparcia składająca się z krótkich odpowiedzi toleruje 200 tokenów; korpus prawny będzie wymagał 800.
Kluczowe wnioski
- Chunking to najbardziej wpływowy etap w potoku RAG
- Użyj stałego rozmiaru jako bazy, a separatorów do poszanowania struktury
- Chunking semantyczny automatycznie wykrywa zmiany tematyczne
- Overlapp i wzbogacenie kontekstem poprawiają jakość
- Testuj różne rozmiary i mierz je metrykami wyszukiwania