Wird geladen

Text-Chunking-Strategien

Lektion 3410 Min.
Wird geladen

Text-Chunking ist einer der kritischsten Schritte beim Aufbau einer RAG-Pipeline (Retrieval Augmented Generation). Wie du deine Dokumente aufteilst, wirkt sich direkt auf die Qualität deines gesamten Systems aus. Eine schlechte Chunking-Strategie kann dazu führen, dass irrelevanter Kontext in deine Prompts eingefügt wird, wodurch deine KI völlig falsche Antworten gibt.

Ein Quelldokument, ein Jahresfinanzbericht, mit einem Pfeil zu sechs Kästchen mit der Beschriftung "Chunk #1" bis "Chunk #6".

Betrachte dieses Beispiel: Du hast ein Dokument mit Abschnitten zu medizinischer Forschung und Softwareentwicklung. Wenn du schlecht chunkst, könnte ein Nutzer, der fragt „Wie viele Bugs haben die Ingenieure dieses Jahr behoben?“, Informationen über medizinische Forschung statt über Softwareentwicklung erhalten, nur weil der medizinische Abschnitt zufällig das Wort „Bug“ in einem anderen Kontext enthielt.

Ausgabe-Chunks, bei denen im Abschnitt zur medizinischen Forschung von einem „Bug“ die Rede ist und der Abschnitt zur Softwareentwicklung „Infektionsvektoren“ erwähnt.

Das zeigt, warum die Chunking-Strategie so wichtig ist. Das Ziel ist es, Chunks zu erstellen, die semantische Kohärenz bewahren und bei ihrem Abruf nützlichen Kontext liefern.

Die Frage des Nutzers und ein Chunk des Dokuments, der XDR-47 als „Bug“ bezeichnet, fließen in die Tags user_question und report des Prompts ein.

Die drei wichtigsten Chunking-Strategien

Größenbasiert fügt Überlappung für Kontext hinzu, strukturbasiert benötigt eine bekannte Struktur, semantikbasiert ist aufwendig, aber relevanter.

Es gibt drei grundlegende Ansätze, um Text in Chunks aufzuteilen:

  • Größenbasiert: Text in Zeichenketten gleicher Länge aufteilen
  • Strukturbasiert: Aufteilung nach Dokumentstruktur (Überschriften, Absätze, Abschnitte)
  • Semantikbasiert: Zusammenhängende Sätze oder Abschnitte mithilfe von NLP-Techniken gruppieren

Größenbasiertes Chunking

Größenbasiertes Chunking ist der einfachste Ansatz. Du teilst dein Dokument einfach in Chunks mit ungefähr gleicher Zeichen- oder Wortanzahl auf. Es ist einfach zu implementieren und funktioniert zuverlässig bei verschiedenen Dokumenttypen.

Ein 325 Zeichen langes Dokument, aufgeteilt in 3 Chunks mit jeweils etwa 108 Zeichen, wobei Wörter mittendrin abgeschnitten werden, z. B. "signific" und dann "ant".

Dieser Ansatz hat jedoch klare Nachteile:

  • Wörter werden mitten im Satz abgeschnitten
  • Chunks verlieren wichtigen Kontext aus dem umgebenden Text
  • Zusammenhängende Inhalte können auf mehrere Chunks aufgeteilt werden

Drei größenbasierte Chunks, die mitten im Wort abgeschnitten sind: "signific" endet den ersten, "ant strides" beginnt den zweiten, und "ng" beginnt den dritten.

Überlappung hinzufügen

Um das Kontextproblem anzugehen, kannst du eine Überlappungsstrategie einsetzen. Jeder Chunk enthält einige Zeichen aus benachbarten Chunks, was zusätzlichen Kontext bietet und sicherstellt, dass wichtige Informationen an den Chunk-Grenzen nicht verloren gehen.

Überlappung erweitert einen Chunk im Quelldokument, sodass der Ausgabe-Chunk die vollständigen Überschriften von Abschnitt 1 und Abschnitt 2 behält.

Zwar entsteht dadurch eine gewisse Duplizierung, aber der Kompromiss lohnt sich in der Regel wegen des verbesserten Kontexts, den jeder Chunk erhält.

Strukturbasiertes Chunking

Wenn deine Dokumente eine konsistente Formatierung aufweisen (wie Markdown mit klaren Überschriften), kann strukturbasiertes Chunking hervorragende Ergebnisse liefern. Du teilst anhand struktureller Elemente wie Überschriften auf und erstellst Chunks, die sich an der natürlichen Organisation des Dokuments orientieren.

Quelldokument, aufgeteilt an seinen Markdown-Überschriften in drei Chunks: eine Eröffnungszeile, Medical Research und Software Engineering.

Das funktioniert hervorragend bei gut formatierten Dokumenten, erfordert aber Garantien über die Dokumentstruktur. Es funktioniert nicht zuverlässig bei reinen Textdateien oder uneinheitlich formatierten Dokumenten.

Implementierungsbeispiele

Hier sind drei praktische Chunking-Funktionen, die du implementieren kannst:

Zeichenbasiertes Chunking

python
def chunk_by_char(text, chunk_size=150, chunk_overlap=20):
    chunks = []
    start_idx = 0
    
    while start_idx < len(text):
        end_idx = min(start_idx + chunk_size, len(text))
        chunk_text = text[start_idx:end_idx]
        chunks.append(chunk_text)
        
        start_idx = (
            end_idx - chunk_overlap if end_idx < len(text) else len(text)
        )
    
    return chunks

Satzbasiertes Chunking

python
import re

def chunk_by_sentence(text, max_sentences_per_chunk=5, overlap_sentences=1):
    sentences = re.split(r"(?<=[.!?])\s+", text)
    chunks = []
    start_idx = 0
    
    while start_idx < len(sentences):
        end_idx = min(start_idx + max_sentences_per_chunk, len(sentences))
        current_chunk = sentences[start_idx:end_idx]
        chunks.append(" ".join(current_chunk))
        
        start_idx += max_sentences_per_chunk - overlap_sentences
        
        if start_idx < 0:
            start_idx = 0
    
    return chunks

Abschnittsbasiertes Chunking

python
def chunk_by_section(document_text):
    pattern = r"\n## "
    return re.split(pattern, document_text)

Die richtige Strategie wählen

Welche Chunking-Strategie du wählst, hängt ganz von deinem konkreten Anwendungsfall ab:

  • Zeichenbasiert: Die zuverlässigste Rückfalloption, funktioniert mit jedem Dokumenttyp
  • Satzbasiert: Gute Balance zwischen Kontext und Bedeutung für Fließtext
  • Abschnittsbasiert: Hervorragende Ergebnisse, wenn du strukturierte Dokumente hast

Bei von Nutzern hochgeladenen Dokumenten ohne Formatierungsgarantien ist zeichenbasiertes Chunking oft die sicherste Wahl. Bei gut strukturierten internen Dokumenten kann abschnittsbasiertes Chunking überlegene Ergebnisse liefern. Satzbasiertes Chunking funktioniert gut für die meisten Fließtexte, kann aber bei Code oder technischen Dokumenten, die Punkte auf unerwartete Weise verwenden, Schwierigkeiten bereiten.

Denke daran, dass Chunking oft ein iterativer Prozess ist. Beginne mit einem einfachen Ansatz, teste ihn mit deinen spezifischen Dokumenten und Anwendungsfällen, und verfeinere ihn dann basierend auf der Qualität der Ergebnisse, die du von deinem RAG-System erhältst.