Chunking: Divizarea inteligentă a documentelor
Pe această pagină
Obiective
- Înțelegeți de ce chunking-ul este critic pentru calitatea RAG
- Stăpâniți diferite strategii de divizare
- Alegeți dimensiunea corectă a chunk-ului și suprapunerea optimă
De ce să divizați documentele?
Modelele de embedding au o limită de tokeni: 8.191 pentru OpenAI. Această limită este primul motiv pentru a diviza documentele, dar nu este cel mai important. Chiar și un document mult sub această plafonare produce rezultate slabe atunci când este codificat ca un singur bloc, deoarece vectorul rezultat face o medie a întregului conținut și pierde detaliile. Luați un manual de Resurse Umane de 40 de pagini care acoperă politicile de concediu, munca la distanță, rapoartele de cheltuieli și asigurările de sănătate: embedding-ul său unic nu seamănă cu adevărat cu niciunul dintre aceste patru subiecte, iar o căutare după „câte zile de concediu“ îl va clasifica sub un document mult mai scurt, dar mult mai țintit.
Chunking-ul rezolvă această problemă prin fragmentarea documentului în piese coerente, fiecare capturând o idee specifică sau un paragraf. Acesta este pasul în care un pipeline RAG câștigă sau pierde cea mai mare parte din calitate—chiar înainte de a alege un model de embedding.
Strategia 1: Chunking cu dimensiune fixă
Metoda cea mai simplă numără cuvintele și taie la intervale regulate. Ignoră complet structura textului, ceea ce o face brutală, dar necesită doar trei linii de cod și servește drept linie de bază esențială: orice strategie mai sofisticată trebuie să dovedească că performează mai bine decât aceasta.
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")
Parametrul overlap merită atenție. Fără suprapunere, o tăietură va ajunge inevitabil la mijlocul unei explicații: propoziția „perioada de preaviz este de trei luni“ ajunge într-un chunk, iar „exceptând perioada de probă“ în următorul. Niciunul nu răspunde corect la întrebare, iar al doilea este chiar înșelător. Prin suprapunerea chunk-urilor cu 10–20% din dimensiunea lor, garantați că fiecare idee există intactă cel puțin o dată undeva în index. Acesta este un punct de plecare bun; ajustați-l ulterior în funcție de densitatea documentelor dumneavoastră.
Strategia 2: Chunking bazat pe separatori
În loc să tăiați cuvânt cu cuvânt, puteți respecta limitele naturale ale textului. Ideea este să încercați mai întâi separatorul cel mai puternic—dubla linie nouă care separă două paragrafe—apoi să coborâți la separatori progresiv mai slabi atâta timp cât piesa rezultată depășește dimensiunea maximă. Un articol de blog va fi astfel divizat paragraf cu paragraf, iar doar un paragraf monstruos va fi fragmentat pe propoziții.
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 pe secțiuni Markdown
Când corpusul dumneavoastră constă în documentație structurată, titlurile fac deja munca pentru dumneavoastră: autorul a delimitat deja unitățile de sens. Divizarea la nivelurile de titlu # și ## produce chunk-uri care corespund exact secțiunilor, iar funcția de mai jos păstrează titlul alături de text, ceea ce vom folosi imediat după pentru îmbogățire.
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 semantic
Pentru textul fără structură explicită—un rezumat de ședință, o transcriere de apel—nici dimensiunea, nici separatorii nu știu unde se schimbă subiectul. Embedding-urile știu. Codificați fiecare propoziție, comparați fiecare propoziție cu cea anterioară și tăiați acolo unde similaritatea se prăbușește: exact acolo vorbitorul a trecut de la buget la recrutare. Rețineți că text-embedding-3-small este suficient aici, deoarece nu căutați o precizie absolută, ci o ruptură relativă.
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
Îmbogățirea chunk-urilor cu context
Un chunk izolat pierde adesea informația care îl făcea interpretabil. „Durata este de trei ani“ nu înseamnă nimic dacă cititorul—sau modelul de embedding—nu știe că provine din capitolul despre garanția producătorului. Adăugarea unui prefix fiecărui chunk cu titlul documentului și titlul secțiunii restaurează acest context direct în vectorul însuși, iar o căutare după „durata garanției“ va găsi apoi pasajul.
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}"
Ce dimensiune de chunk să alegeți?
Alegerea implică un compromis între precizie și context: un chunk scurt țintește fin, dar este amputat, în timp ce un chunk lung înțelege totul, dar diluează semnalul.
| Dimensiune (tokeni) | Avantaje | Dezavantaje |
|---|---|---|
| 100–200 | Foarte precis, granularitate bună | Pierde contextul |
| 300–500 | Compromis bun | Standard |
| 500–1000 | Context bogat | Mai puțin precis, costisitor |
| 1000+ | Context maxim | Diluează informația |
Nu există o valoare universală: dimensiunea ideală depinde de documentele și interogările dumneavoastră. Singura metodă fiabilă este să indexați același corpus cu două sau trei dimensiuni, apoi să măsurați folosind metricile din lecția 10 pe un set de întrebări reale. O bază de cunoștințe pentru suport formată din răspunsuri scurte tolerează 200 de tokeni; un corpus juridic va necesita 800.
Puncte cheie
- Chunking-ul este cel mai impactant pas în pipeline-ul RAG
- Folosiți dimensiunea fixă ca linie de bază, separatorii pentru a respecta structura
- Chunking-ul semantic detectează automat schimbările de subiect
- Suprapunerea și îmbogățirea contextuală îmbunătățesc calitatea
- Testați diferite dimensiuni și măsurați cu metrici de căutare