Mastering RAG Document Chunking: Ein Leitfaden für Chunking-Strategien zum Aufbau effizienter Retrieval-Systeme

Wenn Ihr RAG Die App liefert nicht die gewünschten Ergebnisse, also ist es vielleicht an der Zeit, Ihre Chunking-Strategie zu überdenken.Ein besseres Chunking bedeutet eine genauere Abfrage, was letztlich zu einer höheren Qualität der Antworten führt.

Das Chunking ist jedoch keine Einheitslösung, und kein Ansatz ist absolut optimal. Sie müssen die am besten geeignete Strategie in Abhängigkeit von den spezifischen Anforderungen des Projekts, den Merkmalen des Dokuments, dem Budget und anderen Faktoren auswählen.

Warum wirkt sich die Qualität des Chunking direkt auf die Qualität der RAG-Antworten aus?

Ich bin sicher, dass Sie nach der Lektüre dieses Artikels die grundlegenden Konzepte des Chunking und der RAG verstanden haben. Um es kurz zusammenzufassen: Die Kernidee der RAG ist es, die LLM Beantworten Sie die Fragen auf der Grundlage der gegebenen KontextinformationenDer Grund dafür ist, dass LLM zwar über eine umfangreiche Wissensbasis verfügt, sein Wissen aber nur mit Verzögerung aktualisiert und keinen direkten Zugriff auf private Daten hat. Der Grund dafür ist, dass das LLM zwar über eine umfangreiche Wissensbasis verfügt, aber sein Wissen erst mit Verzögerung aktualisiert und keinen direkten Zugang zu privaten Daten hat.

Die RAG kompensiert die Unzulänglichkeiten des LLM selbst, indem sie relevante Dokumentenfragmente (d.h. Kontext) in die Eingabeaufforderungen einfügt und das LLM anweist, Antworten auf der Grundlage dieser Fragmente zu generieren. Der Kontext kann auf verschiedene Weise beschafft werden, z. B. durch Datenbankabfrage, Internetsuche oder Extraktion aus PDF-Dokumenten.

Bei der Entwicklung einer effizienten RAG-Anwendung gibt es zwei wesentliche Herausforderungen:

1. Kontextfenster-Grenzen für LLMFrühe LLMs, wie GPT-2 und GPT-3, hatten kleine Kontextfenster, was die Menge an Text, die in einem einzigen Durchgang verarbeitet werden konnte, begrenzte. Inzwischen gibt es zwar Modelle, die größere Kontextfenster unterstützen, aber das bedeutet nicht, dass wir einfach ein ganzes Dokument in einen LLM stopfen können.
2. Kontextlärm-ProblemSelbst wenn das Kontextfenster des LLMs groß genug ist, kann es das Verständnis und die Beurteilung des LLMs beeinträchtigen, wenn die bereitgestellten Kontextinformationen viele Inhalte (Rauschen) enthalten, die für die Frage nicht relevant sind, was zu einer Verschlechterung der Qualität der Antwort oder sogar zu Halluzinationen führt.

Um diese Probleme zu lösen.Chunking von DokumentenDie Technologie war geboren. Die Kernidee besteht darin, große Dokumente in kleinere, semantisch kohärente Segmente (Chunks) aufzuteilen. In der Abrufphase werden dann nur die relevantesten Chunks als Kontext für das LLM ausgewählt.

Es gibt verschiedene Arten des Chunking von Dokumenten, wie z.B. einfaches Satz- und Absatz-Chunking, komplexes semantisches Chunking, Agentic Chunking, usw. Es ist wichtig, eine geeignete Chunking-Strategie zu wählen, die sich direkt auf die Effizienz des RAG-Systems und die Qualität der endgültigen Antwort auswirkt. Die Wahl einer geeigneten Chunking-Strategie ist von entscheidender Bedeutung und wirkt sich direkt auf die Abrufeffizienz des RAG-Systems und die Qualität der endgültigen Antwort aus.

In diesem Artikel befassen wir uns mit verschiedenen fortgeschrittenen und praktischen Strategien zum Chunking von Dokumenten, die Ihnen helfen, robustere RAG-Anwendungen zu erstellen. Wir überspringen das einfache Chunking von Sätzen und Absätzen und konzentrieren uns auf Techniken, die in realen RAG-Anwendungen wertvoller sind.

Als Nächstes werde ich einige Chunking-Strategien erläutern, die ich gelernt und praktiziert habe.

Rekursive Zeichensegmentierung: Ein schneller und kostengünstiger Basisansatz

Rekursives Zeichensplitting, man könnte meinen, dass dies die einfachste Methode ist. Sie ist in der Tat einfach, aber meiner Meinung nach immer noch eine der am häufigsten verwendeten und kostengünstigsten Chunking-Techniken. Sie ist leicht zu verstehen, einfach zu implementieren, schnell und kostengünstig, was sie besonders für Rapid Prototyping und kostensensitive Projekte geeignet macht.

Die Kernidee der rekursiven Zeichensegmentierung istVerwendung eines Schiebefensters mit fester Größeund erlaubt Überlappungen zwischen den Fenstern. Es erzeugt Textblöcke durch kontinuierliches Verschieben des Fensters von der Ausgangsposition des Dokuments mit einer voreingestellten Blockgröße und Anzahl der überlappenden Zeichen.

Die folgende Abbildung zeigt, wie die rekursive Zeichensegmentierung funktioniert:

Wie die rekursive Zeichensegmentierung funktioniert - gezeichnet von Thuwarakesh

Der Vorteil der rekursiven Zeichensegmentierung liegt in ihrer Einfachheit und Effizienz. Sie ermöglicht die schnelle Verarbeitung großer Dokumente und die Zerlegung von Geschäftsberichten auf Minuten-Ebene. Die Implementierung der rekursiven Zeichensegmentierung in Langchain ist sehr einfach:

from langchain.text_splitter import RecursiveCharacterTextSplitter
text = """
Hydroponics is an intelligent way to grow veggies indoors or in small spaces. In hydroponics, plants are grown without soil, using only a substrate and nutrient solution. The global population is rising fast, and there needs to be more space to produce food for everyone. Besides, transporting food for long distances involves lots of issues. You can grow leafy greens, herbs, tomatoes, and cucumbers with hydroponics.
"""
rc_splits = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
chunk_size=20, chunk_overlap=2
).split_text(text)

Schiebefenster-Varianten

In der Praxis können die Größe des Schiebefensters und der Schiebeschritt je nach Bedarf variiert werden:

• Zeichenbasierte vs. Token-basierte SchiebefensterDas obige Beispiel ist ein zeichenbasiertes Schiebefenster. Es ist auch möglich, ein zeichenbasiertes Token gleitendes Fenster, um sicherzustellen, dass die Blockgrößen besser mit der LLM-Verarbeitung übereinstimmen.Langchain's RecursiveCharacterTextSplitter Es werden sowohl der Zeichen- als auch der Token-Modus unterstützt.
• Dynamische Fenstergröße:: Während die rekursive Zeichensegmentierung durch feste Fenstergrößen gekennzeichnet ist, kann in bestimmten Szenarien auch eine dynamische Fenstergrößenanpassung in Betracht gezogen werden. Zum Beispiel kann die Fenstergröße adaptiv an die Länge des Satzes oder die Struktur des Absatzes angepasst werden, um die semantische Integrität des Blocks zu gewährleisten.

Einschränkungen

Die rekursive Zeichensegmentierung ist einePositionsbasierter Chunking-Ansatz. Er geht einfach davon aus, dass Text, der in einem Dokument an der gleichen Stelle steht, auch semantisch verwandt ist. Diese Annahme trifft jedoch in vielen Fällen nicht zu.

Überlegen Sie: Warum führt ortsbezogenes Chunking zu einer schlechten Leistung von RAGs? Wie kann man semantisches Chunking implementieren und bessere Ergebnisse erzielen?

So kann es vorkommen, dass der Autor in ein und demselben Kapitel zunächst mehrere unterschiedliche Konzepte erörtert, bevor er sie schließlich miteinander in Beziehung setzt. Wird nur eine rekursive Zeichensegmentierung verwendet, können Inhalte, die zur gleichen semantischen Einheit gehören sollten, aufgespalten oder semantisch nicht verwandte Inhalte kombiniert werden, was die Suche beeinträchtigt.

Trotz ihrer Einschränkungen ist die rekursive Zeichensegmentierung ideal für den Einstieg in RAG. In der Prototyping-Phase oder bei einfach strukturierten Dokumenten liefert sie oft zufriedenstellende Ergebnisse. Die rekursive Zeichensegmentierung ist auch eine lohnende Option, wenn Ihr Projekt hohe Anforderungen an Kosten und Geschwindigkeit stellt.

Semantisches Chunking: ein Chunking-Ansatz zum Verständnis der Bedeutung von Texten

Semantisches Chunking ist eine weitergehende Chunking-Strategie, dieAnstatt sich nur auf die Positionsinformationen des Textes zu verlassen, wird ein tieferes Verständnis der semantischen Bedeutung des Textes erreicht. Der Kerngedanke besteht darin, Dokumente zu segmentieren, wenn sich ihre Semantik signifikant ändert, und dabei sicherzustellen, dass sich jeder Chunk so weit wie möglich auf ein einziges Thema konzentriert.

Die folgende Abbildung zeigt, wie semantisches Chunking funktioniert:

Semantisches Chunking funktioniert - gezeichnet von Thuwarakesh

Im Gegensatz zur rekursiven Zeichensegmentierung werden beim semantischen Chunking Blöcke mit typischerweise variabler Länge erzeugt. Es bestimmt die Grenzen des Blocks auf der Grundlage der semantischen Integrität, anstatt eine feste Anzahl von Zeichen oder Token vorzugeben.

Wichtige Schritte zum semantischen Chunking

Die Schwierigkeit beim semantischen Chunking besteht darin, wieProgrammiert, um die Semantik von Sätzen zu verstehen**. Dies geschieht in der Regel mit Hilfe vonModelle einbettenzu implementieren. Die Einbettung von Modellen wie dem von OpenAI text-einbettung-3-großSätze können in Vektordarstellungen umgewandelt werden, und Vektoren sind in der Lage, die semantischen Informationen eines Satzes zu erfassen. Sätze, die semantisch ähnlich sind, haben Vektoren, die auch im Raum näher beieinander liegen. **

Ein typischer Prozess für semantisches Chunking besteht aus den folgenden fünf Schritten:

• Konstruktion des AnfangsblocksDie Funktion teilt das Dokument zunächst in Sätze oder Absätze auf und verbindet benachbarte Sätze oder Absätze zu einem ersten Block.
• Blockeinbettung generierenEinbettungsmodell: Verwenden Sie das Einbettungsmodell, um Vektoreinbettungen für jeden Ausgangsblock zu erzeugen.
• Berechnen Sie den Abstand zwischen den BlöckenBerechnung des semantischen Abstands zwischen benachbarten Blöcken. Zu den häufig verwendeten Abstandsmetriken gehören der Kosinusabstand und so weiter. Je größer der Abstand, desto größer ist der semantische Unterschied.
• Bestimmen Sie den Splitpunkt: Legen Sie einen Abstandsschwellenwert fest. Wenn der Abstand zwischen benachbarten Blöcken den Schwellenwert überschreitet, werden sie getrennt, um neue semantische Blöcke zu bilden. Die Auswahl des Schwellenwerts muss an das jeweilige Dokument und den experimentellen Effekt angepasst werden.
• Visualisierung (optional)Die Visualisierung des Abstands zwischen den Blöcken hilft, den Chunking-Effekt intuitiver zu verstehen und die Schwellenwerte anzupassen.

Der folgende Code zeigt, wie das semantische Chunking implementiert werden kann:

# Step 1 : Create initial chunks by combining concecutive sentences.
# ------------------------------------------------------------------
#Split the text into individual sentences.
sentences = re.split(r"(?<=[.?!])\s+", text)
initial_chunks = [
{"chunk": str(sentence), "index": i} for i, sentence in enumerate(sentences)
]
# Function to combine chunks with overlapping sentences
def combine_chunks(chunks):
for i in range(len(chunks)):
combined_chunk = ""
if i > 0:
combined_chunk += chunks[i - 1]["chunk"]
combined_chunk += chunks[i]["chunk"]
if i < len(chunks) - 1:
combined_chunk += chunks[i + 1]["chunk"]
chunks[i]["combined_chunk"] = combined_chunk
return chunks
# Combine chunks
combined_chunks = combine_chunks(initial_chunks)
# Step 2 : Create embeddings for the initial chunks.
# ------------------------------------------------------------------
# Embed the combined chunks
chunk_embeddings = embeddings.embed_documents(
[chunk["combined_chunk"] for chunk in combined_chunks]
# If you haven't created combined_chunk, use the following.
# [chunk["chunk"] for chunk in combined_chunks]
)
# Add embeddings to chunks
for i, chunk in enumerate(combined_chunks):
chunk["embedding"] = chunk_embeddings[i]
# Step 3 : Calculate distance between the chunks
# ------------------------------------------------------------------
def calculate_cosine_distances(chunks):
distances = []
for i in range(len(chunks) - 1):
current_embedding = chunks[i]["embedding"]
next_embedding = chunks[i + 1]["embedding"]
similarity = cosine_similarity([current_embedding], [next_embedding])[0][0]
distance = 1 - similarity
distances.append(distance)
chunks[i]["distance_to_next"] = distance
return distances
# Calculate cosine distances
distances = calculate_cosine_distances(combined_chunks)
# Step 4 : Find chunks with significant different to it's previous ones.
# ----------------------------------------------------------------------
import numpy as np
threshold_percentile = 90
threshold_value = np.percentile(cosine_distances, threshold_percentile)
crossing_points = [
i for i, distance in enumerate(distances) if distance > threshold_value
]
len(crossing_points)
# Step 5 (Optional) : Create a plot of chunk distances to get a better view
# -------------------------------------------------------------------------
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
def visualize_cosine_distances_with_thresholds_multicolored(
cosine_distances, threshold_percentile=90
):
# Calculate the threshold value based on the percentile
threshold_value = np.percentile(cosine_distances, threshold_percentile)
# Identify the points where the cosine distance crosses the threshold
crossing_points = [0]  # Start with the first segment beginning at index 0
crossing_points += [
i
for i, distance in enumerate(cosine_distances)
if distance > threshold_value
]
crossing_points.append(
len(cosine_distances)
)  # Ensure the last segment goes to the end
# Set up the plot
plt.figure(figsize=(14, 6))
sns.set(style="white")  # Change to white to turn off gridlines
# Plot the cosine distances
sns.lineplot(
x=range(len(cosine_distances)),
y=cosine_distances,
color="blue",
label="Cosine Distance",
)
# Plot the threshold line
plt.axhline(
y=threshold_value,
color="red",
linestyle="--",
label=f"{threshold_percentile}th Percentile Threshold",
)
# Highlight segments between threshold crossings with different colors
colors = sns.color_palette(
"hsv", len(crossing_points) - 1
)  # Use a color palette for segments
for i in range(len(crossing_points) - 1):
plt.axvspan(
crossing_points[i], crossing_points[i + 1], color=colors[i], alpha=0.3
)
# Add labels and title
plt.title(
"Cosine Distances Between Segments with Multicolored Threshold Highlighting"
)
plt.xlabel("Segment Index")
plt.ylabel("Cosine Distance")
plt.legend()
# Adjust the x-axis limits to remove extra space
plt.xlim(0, len(cosine_distances) - 1)
# Display the plot
plt.show()
return crossing_points
# Example usage with cosine_distances and threshold_percentile
crossing_poings = visualize_cosine_distances_with_thresholds_multicolored(
distances, threshold_percentile=bp_threashold
)

Seborn-Diagramm zur Visualisierung von Entfernungen:

Dient zur Veranschaulichung des semantischen Chunking Seaborn-Diagramms - gezeichnet von Thuwarakesh

Vorteile von Semantic Chunking und Anwendungsszenarien

Der Vorteil des semantischen Chunking ist die FähigkeitErfasst die semantische Struktur von Dokumenten besser und fasst semantisch verwandte Textfragmente zusammen, wodurch die Retrievalqualität des RAG-Systems verbessert wird. Es ist besser geeignet für die Verarbeitung der folgenden Arten von Dokumenten:

• Dokumente mit komplexen Strukturen und vielfältigen Themenz. B. längere Berichte, technische Dokumente, Bücher usw., die mehrere Unterthemen enthalten.
• Dokumente mit hohen semantischen SprüngenAutorinnen und Autoren können beim Schreiben in ihren Gedanken herumspringen, und die semantische Gliederung kann diesem Schreibstil besser gerecht werden.

Im Vergleich zur rekursiven Zeichensegmentierung ist das semantische Chunking derDie Berechnungen sind teurer** und langsamer. Dies liegt vor allem daran, dass die Berechnung des Einbettungsvektors und der Abstandsmetrik erforderlich ist. Daher müssen in ressourcenbeschränkten Szenarien Kompromisse in Betracht gezogen werden.

Agentisches Chunking: Chunking-Strategien, die das menschliche Verständnis nachahmen

Agentisches Chunking ist ein weiterer Schritt in Richtung intelligentes Chunking. EsIn Anlehnung an die Art und Weise, wie Menschen Dokumente lesen und verstehen, wird LLM als "intelligenter Agent" eingesetzt, um bei der Chunking-Funktion zu helfen.

Die menschlichen Lesegewohnheiten sind nicht völlig linearAgentic Chunking versucht, diesen menschlichen Verstehensprozess zu simulieren. Wenn wir lesen, springen wir von Thema zu Thema oder von Konzept zu Konzept und bauen die logische Struktur eines Dokuments in unserem Kopf auf.

Im Gegensatz zu den beiden vorhergehenden Methoden ist das Agentic Chunkinggeht nicht davon aus, dass semantisch ähnliche Inhalte nacheinander in einem Dokument vorkommen**. Es kann verstreute, aber semantisch verwandte Teile eines Dokuments zu semantischen Blöcken zusammenfassen, die mit der menschlichen Wahrnehmung besser vereinbar sind.

Agentischer Chunking-Arbeitsablauf

Die Kernidee des Agentic Chunking istLassen Sie LLM das Dokument wie einen Menschen "lesen", indem er die Kernkonzepte und -themen des Dokuments identifiziert und auf der Grundlage dieser Konzepte und Themen chunked. Ein typischer Agentic Chunking-Prozess umfasst:

• AngebotKonvertierung jedes Satzes in einem Dokument in einen unabhängigeren Satz. Zum Beispiel, indem man unbekannte Pronomen durch Objekte ersetzt, um jedem Satz eine vollständigere semantische Bedeutung zu geben.
• Baustein-ContainerChunk-Container: Erstellen Sie einen oder mehrere Chunk-Container für semantisch verwandte Aussagen. Jeder Chunk Container kann einen Titel und eine Zusammenfassung haben, die das Thema des Containers beschreiben.
• Agentengesteuerte propositionale ZuweisungLLM als Agent verwenden, einen Vorschlag nach dem anderen "lesen" und bestimmen, zu welchem Blockcontainer der Vorschlag gehören soll.
  • Wenn der Agent der Ansicht ist, dass der Vorschlag für das Thema eines der vorhandenen Blockcontainer relevant ist, wird er diesem Container hinzugefügt.
  • Wenn der Agent der Meinung ist, dass der Vorschlag ein neues Thema vorschlägt, erstellt er einen neuen Blockcontainer, der den Vorschlag enthält.
• Wiederaufbereitung von BlockbehälternNachbearbeitung von Blockcontainern, z.B. Generierung von verfeinerten Blockzusammenfassungen und -titeln auf der Grundlage von Propositionen innerhalb des Containers.

Der folgende Code zeigt die Implementierung von Agentic Chunking:

from langchain import hub
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field
# Step 1: Convert paragraphs to propositions.
# --------------------------------------------
# Load the propositioning prompt from langchain hub
obj = hub.pull("wfh/proposal-indexing")
# Pick the LLM
llm = ChatOpenAI(model="gpt-4o")
# A Pydantic model to extract sentences from the passage
class Sentences(BaseModel):
sentences: List[str]
extraction_llm = llm.with_structured_output(Sentences)
# Create the sentence extraction chain
extraction_chain = obj | extraction_llm
# NOTE: text is your actual document
paragraphs = text.split("\n\n")
propositions = []
for i, p in enumerate(paragraphs):
propositions = extraction_chain.invoke(p
propositions.extend(propositions)
# Step 2: Create a placeholder to store chunks
chunks = {}
# Step 3: Deine helper classes and functions for agentic chunking.
class ChunkMeta(BaseModel):
title: str = Field(description="The title of the chunk.")
summary: str = Field(description="The summary of the chunk.")
def create_new_chunk(chunk_id, proposition):
summary_llm = llm.with_structured_output(ChunkMeta)
summary_prompt_template = ChatPromptTemplate.from_messages(
[
(
"system",
"Generate a new summary and a title based on the propositions.",
),
(
"user",
"propositions:{propositions}",
),
]
)
summary_chain = summary_prompt_template | summary_llm
chunk_meta = summary_chain.invoke(
{
"propositions": [proposition],
}
)
chunks[chunk_id] = {
"summary": chunk_meta.summary,
"title": chunk_meta.title,
"propositions": [proposition],
}
def add_proposition(chunk_id, proposition):
summary_llm = llm.with_structured_output(ChunkMeta)
summary_prompt_template = ChatPromptTemplate.from_messages(
[
(
"system",
"If the current_summary and title is still valid for the propositions return them."
"If not generate a new summary and a title based on the propositions.",
),
(
"user",
"current_summary:{current_summary}\n\ncurrent_title:{current_title}\n\npropositions:{propositions}",
),
]
)
summary_chain = summary_prompt_template | summary_llm
chunk = chunks[chunk_id]
current_summary = chunk["summary"]
current_title = chunk["title"]
current_propositions = chunk["propositions"]
all_propositions = current_propositions + [proposition]
chunk_meta = summary_chain.invoke(
{
"current_summary": current_summary,
"current_title": current_title,
"propositions": all_propositions,
}
)
chunk["summary"] = chunk_meta.summary
chunk["title"] = chunk_meta.title
chunk["propositions"] = all_propositions
# Step 5: The main functino that creates chunks from propositions.
def find_chunk_and_push_proposition(proposition):
class ChunkID(BaseModel):
chunk_id: int = Field(description="The chunk id.")
allocation_llm = llm.with_structured_output(ChunkID)
allocation_prompt = ChatPromptTemplate.from_messages(
[
(
"system",
"You have the chunk ids and the summaries"
"Find the chunk that best matches the proposition."
"If no chunk matches, return a new chunk id."
"Return only the chunk id.",
),
(
"user",
"proposition:{proposition}" "chunks_summaries:{chunks_summaries}",
),
]
)
allocation_chain = allocation_prompt | allocation_llm
chunks_summaries = {
chunk_id: chunk["summary"] for chunk_id, chunk in chunks.items()
}
best_chunk_id = allocation_chain.invoke(
{"proposition": proposition, "chunks_summaries": chunks_summaries}
).chunk_id
if best_chunk_id not in chunks:
best_chunk_id = create_new_chunk(best_chunk_id, proposition)
return
add_proposition(best_chunk_id, proposition)

Beispiele für die Propositionalisierung

原始文本
===================
A crow sits near the pond. It's a white one.
命题化文本
==================
A crow sits near the pond. This crow is a white one.

Vorteile und Herausforderungen des Agentic Chunking

Agentisch gechunkertDer größte Vorteil ist seine Flexibilität und Intelligenz**. Es kann die tiefe semantische Struktur von Dokumenten besser verstehen und semantische Chunks generieren, die der menschlichen Wahrnehmung besser entsprechen, und ist besonders gut im Umgang mit den folgenden Arten von Dokumenten:**

• Nichtlineare Struktur DokumentationZum Beispiel Dokumente, die gedanklich hin und her springen und viel Hintergrundwissen oder implizite Informationen enthalten.
• Dokumente, die Informationen über Absätze und Abschnitte hinweg integrieren müssenAgentic Chunking: Agentic Chunking ermöglicht die Aggregation von semantisch verwandten Fragmenten, die an verschiedenen Stellen in einem Dokument verstreut sind.

Allerdings gibt es auch beim Agentic Chunking einige Herausforderungen:

• hohe KostenAgentisches Chunking erfordert häufige Aufrufe des LLM, was rechenintensiv und zeitaufwendig ist.
• Projektabhängigkeiten abfragenDie Effektivität von Agentic Chunking hängt stark von der Gestaltung des Prompts ab. Prompts müssen sorgfältig entworfen werden, um LLM zum effektiven Chunking anzuleiten.
• Ungewissheit des ErgebnissesEs kann eine gewisse Unsicherheit in der Ausgabe des LLM bestehen, was zu instabilen Chunking-Ergebnissen führt.

Agentische Chunking-Anwendungsszenarien

Agentic Chunking ist zwar kostspieliger, aber in einigen Szenarien, in denen die Effektivität der RAG von entscheidender Bedeutung ist, dennoch eine erwägenswerte Option. Beispiel:

• Wissensbasis in spezialisierten BereichenZum Beispiel erfordern Wissensdatenbanken in den Bereichen Recht, Medizin, Finanzen usw. eine extrem hohe Abrufgenauigkeit und -erinnerung.
• komplexes Frage- und AntwortsystemEin Frage- und Antwortsystem, das mit komplexen Fragen umgehen muss, die logisches Denken und die Integration von Informationen erfordern.

Vertiefende Lektüre:Agentisches Chunking: KI-Agenten-gesteuerte semantische Textverknüpfung

Chunking-Strategien für verschiedene Dokumentenformate

Die bisherige Diskussion konzentrierte sich hauptsächlich auf das Chunking von einfachem Text. In der Praxis stößt man jedoch häufig auf eine Vielzahl unterschiedlicher Dokumentformate, wie Markdown, HTML, PDF, Code usw. Für unterschiedliche Formate ist eine verfeinerte Chunking-Strategie erforderlich, um die strukturellen Informationen des Dokuments vollständig zu nutzen.

Chunking von Markdown- und HTML-Dokumenten

Markdown- und HTML-Dokumente verfügen über strukturierte Tagging-Informationen wie Überschriften, Absätze, Listen, Code-Blöcke und so weiter. Wir könnenVerwenden Sie diese Bezeichnungen als Grundlage für das Chunking** für eine genauere Chunking. **

• Block nach TitelÜberschrift: Behandeln Sie jede Überschrift und den darunter liegenden Inhalt als einen separaten Block. Dies eignet sich für klar strukturierte Dokumente mit unterschiedlichen Abschnitten.
• Stückchen: Behandeln Sie jeden Absatz als ein Chunk. Absätze sind in der Regel semantisch vollständige Einheiten und eignen sich als grundlegende Chunking-Einheiten.
• chunkingKombinieren Sie Überschriften und Absätze für das Chunking. Teilen Sie das Dokument zum Beispiel zuerst nach Überschriften der ersten Ebene auf, dann nach dem Inhalt unter jeder Überschrift der ersten Ebene und dann nach Absätzen.

Beispiel: HTML-Tag-basiertes Chunking (Python)

from bs4 import BeautifulSoup
html_text = """
<h1>Section 1</h1>
<p>This is the first paragraph of section 1.</p>
<p>This is the second paragraph of section 1.</p>
<h2>Subsection 1.1</h2>
<ul>
<li>List item 1</li>
<li>List item 2</li>
</ul>
"""
soup = BeautifulSoup(html_text, 'html.parser')
chunks = []
# 按 h1 标题分块
for h1_tag in soup.find_all('h1'):
chunk_text = h1_tag.text + "\n"
next_sibling = h1_tag.find_next_sibling()
while next_sibling and next_sibling.name not in ['h1', 'h2']: #  假设按 h1 和 h2 分级
chunk_text += str(next_sibling) + "\n" #  保留 HTML 标签，或 next_sibling.text  只保留文本
next_sibling = next_sibling.find_next_sibling()
chunks.append(chunk_text)
#  可以类似地处理 h2, p, ul, ol 等标签
print(chunks)

Gruppierung von PDF-Dokumenten

Das Chunking von PDF-Dokumenten ist relativ komplex, da es sich bei PDF im Wesentlichen um ein Satzformat handelt, bei dem Textinhalte und typografische Informationen miteinander vermischt sind. Die Aufteilung von PDFs direkt nach Zeichen oder Zeilen kann die semantische Integrität zerstören.

Die wichtigsten Schritte beim Chunking von PDF-Dateien sind in der Regel:

• PDF-Text-ExtraktionVerwendung von PDF-Parsing-Bibliotheken (z. B. PyPDF2, pdfminer oder professionellere unstrukturiert.io), um Textinhalte aus PDF-Dateien zu extrahieren.
• Textbereinigung und VorverarbeitungStörende Zeichen entfernen, Zeilenumbrüche behandeln, OCR-Fehler beheben und vieles mehr.
• Extraktion strukturierter InformationenVersuchen Sie, strukturierte Informationen aus PDFs zu extrahieren, z. B. Titel, Kopf- und Fußzeilen, Tabellen, Listen und so weiter. Einige fortgeschrittene PDF-Parsing-Bibliotheken (z. B. unstructured.io) können bei der Extraktion strukturierter Informationen helfen.
• Optionen der Chunking-StrategieAuswahl geeigneter Chunking-Strategien (z. B. semantisches Chunking, rekursive Zeichensegmentierung usw.) auf der Grundlage der extrahierten Textinhalte und Strukturinformationen.

auf etw. aufmerksam machen: unstrukturiert.io ist ein leistungsfähiges Werkzeug, das mit einer Vielzahl von Dokumentformaten (einschließlich PDF) umgehen kann und versucht, strukturierte Informationen aus Dokumenten zu extrahieren, was den Prozess des PDF-Chunking vereinfacht.

Code Dokumentation Chunking

Das Chunking von Codedokumenten (z. B. Python-, Java-, C++-Code-Dateien) erfordert die Berücksichtigung der syntaktischen Struktur und der logischen Einheiten des Codes. Eine einfache Aufteilung des Codes nach Zeilen oder Zeichen würde wahrscheinlich die Integrität und Ausführbarkeit des Codes zerstören.

Gängige Strategien für das Chunking der Code-Dokumentation sind:

• Chunking nach Funktion/Klasse: Behandeln Sie jede Funktion oder Klasse als einen separaten Block. Funktionen und Klassen sind in der Regel logische Einheiten von Code.
• Chunking nach CodeblockIdentifiziert Logikblöcke im Code (z. B. Schleifen, bedingte Anweisungen, Try-Except-Blöcke usw.), wobei jeder Block als ein Chunk behandelt wird.
• Kombiniert mit Code-Kommentar-ChunkingCode-Kommentare sind in der Regel Erläuterungen zur Funktionalität und Logik des Codes. Codekommentare und die zugehörigen Codeblöcke können als Ganzes gechunked werden.

ArtefaktStrukturierte Analyse und Chunking von Code kann durch den Einsatz von Syntax-Parsing-Tools wie tree-sitter unterstützt werden, das Code in einer Vielzahl von Programmiersprachen analysiert und einen abstrakten Syntaxbaum (AST) generiert, der es einfach macht, Code entsprechend seiner syntaktischen Struktur zu chunking.

Auswahl der richtigen Größe und Überlappung von Chunks

Chunk-Größe und Chunk-Überlappung sind zwei wichtige Parameter in der Chunking-Politik, die sich direkt auf die Leistung des RAG-Systems auswirken.

• Stückchengröße: bezieht sich auf die Textmenge, die in jedem Chunk enthalten ist. Eine zu kleine Chunk-Größe kann zu unvollständigen semantischen Informationen führen; eine zu große Chunk-Größe kann zu Rauschen führen und die Abrufgenauigkeit verringern.
• Größe der ÜberlappungÜberlappung: Die Menge des Textes, die sich zwischen benachbarten Blöcken überlappt. Der Zweck der Überlappung besteht darin, die kontextuelle Kontinuität zu gewährleisten und den Verlust von Informationen an den Blockgrenzen zu vermeiden.

Wie wähle ich die richtige Chunk-Größe und Überlappung?

Es gibt keine absolut optimale Antwort auf die Wahl der richtigen Chunk-Größe und Überlappung, und sie muss normalerweise durch dieMerkmale des Dokumentsim Gesang antwortenexperimentelle Wirkungzu bestimmen. Hier sind einige Faustregeln und Vorschläge:

• heuristische Methode::
  • Basierend auf der Satz-/AbsatzlängeDie durchschnittliche Satz- oder Absatzlänge eines Dokuments kann als Referenz für die Chunk-Größe herangezogen werden. Wenn die durchschnittliche Absatzlänge z.B. 150 Token beträgt, können Sie versuchen, die Chunk-Größe auf 150-200 Token festzulegen.
  • Betrachten Sie das LLM-KontextfensterDie Blockgröße sollte nicht zu groß sein, um die Grenzen des Kontextfensters des LLM nicht zu überschreiten. Gleichzeitig sollte sie aber auch nicht zu klein sein, um sicherzustellen, dass der Block genügend semantische Informationen enthält.
• Erprobung und Bewertung:
  • Iterative Abstimmung: Legen Sie einen anfänglichen Satz von Parametern für die Chunk-Größe und die Überlappung fest (z. B. 500 Token für die Chunk-Größe und 50 Token für die Überlappung), erstellen Sie das RAG-System und bewerten Sie es. Dann passen Sie die Parameter schrittweise an, beobachten die Veränderungen bei der Suche und die Auswirkungen auf die Fragen und Antworten und wählen die optimale Kombination von Parametern.
  • Bewertung der IndikatorenQuantifizierung der Leistung des RAG-Systems mit Hilfe geeigneter Bewertungsmetriken wie Recall@k, Precision@k, NDCG (Normalised Discounted Cumulative Gain) usw. für das Retrieval. Diese Metriken können Ihnen helfen, die Effektivität der verschiedenen Chunking-Strategien objektiv zu bewerten.

Bewertungsinstrumente in Langchain

Langchain bietet eine Reihe von Evaluierungswerkzeugen, die bei der Evaluierung und Parametereinstellung von RAG-Systemen helfen können. Zum Beispiel können Tools wie DatasetEvaluator und RetrievalQAChain Ihnen helfen, die Auswirkungen von Kombinationen verschiedener Chunking-Strategien, Retrieval-Modelle und LLM-Modelle zu automatisieren.

Bewertung der Wirksamkeit der Chunking-Strategie

Wie kann man nach der Wahl der richtigen Chunking-Strategie deren Wirksamkeit bewerten? "Besseres Chunking bedeutet besseres Retrieval", aber wie lässt sich "besser" quantifizieren? Wir brauchen einige Metriken, um die Vorzüge von Chunking-Strategien zu bewerten.

Nachfolgend finden Sie einige gängige Bewertungskennzahlen, mit deren Hilfe Sie die Auswirkungen der Chunking-Strategie auf die Leistung des RAG-Systems beurteilen können:

• Abrufen von Indikatoren:
  • Rückruf (Rückruf@k): bezieht sich auf den Anteil relevanter Dokumente (oder Chunks) unter den Top-k-Ergebnissen. Je höher der Recall-Wert ist, desto mehr relevante Informationen werden durch die Chunking-Strategie abgerufen.
  • Genauigkeit (Precision@k): bezieht sich auf den Anteil der wirklich relevanten Dokumente (oder Chunks) unter den Top-k-Suchergebnissen. Je höher die Genauigkeit, desto höher ist die Qualität der Suchergebnisse.
  • NDCG (Normalisierter diskontierter kumulativer Gewinn)NDCG: ist eine feinere Metrik zur Bewertung der Ranking-Qualität, die das Relevanzniveau und die Position der abgerufenen Ergebnisse berücksichtigt. Ein höherer NDCG weist auf eine bessere Qualität des Retrieval-Rankings hin.
• Q&A Indikatoren:
  • Antwort RelevanzBewertung der Relevanz der vom LLM generierten Antworten auf die Frage. Je höher die Antwortrelevanz, desto besser ist das RAG-System in der Lage, sinnvolle Antworten auf der Grundlage der abgerufenen Informationen zu generieren.
    • Antwortgenauigkeit/TreueBewertung, ob die vom LLM generierten Antworten den abgerufenen Kontextinformationen treu sind und "Illusionen" und ungenaue Informationen vermeiden. Eine höhere Antwortgenauigkeit deutet darauf hin, dass die Chunking-Strategie eher in der Lage ist, verlässlichen Kontext zu liefern und das LLM dazu anzuleiten, glaubwürdigere Antworten zu generieren.
    • Geläufige und kohärente AntwortenObwohl sie hauptsächlich von den eigenen Fähigkeiten der LLMs beeinflusst wird, kann eine gute Chunking-Strategie auch indirekt die Geläufigkeit und Kohärenz der Antworten verbessern. Zum Beispiel bietet das semantische Chunking einen kohärenteren Kontext und hilft LLMs, eine natürlichere Sprache zu produzieren.

Bewertungsinstrumente und -methoden

• manuelle Bewertung:: Die direkteste und zuverlässigste Methode. Ein menschlicher Bewerter wird aufgefordert, die Suchergebnisse und Q&A-Antworten des RAG-Systems anhand von vordefinierten Bewertungskriterien zu bewerten. Die Nachteile der manuellen Bewertung sind, dass sie kostspielig, zeitaufwändig und sehr subjektiv ist.
• Automatisierte Bewertung:: Verwendung automatisierter Bewertungsindikatoren und -instrumente, zum Beispiel:
  • Abrufen von IndikatorenSo können z. B. Recall, Genauigkeit, NDCG usw. mit Hilfe von Standardinstrumenten zur Bewertung von Information Retrieval gemessen werden (z. B. rank_bm25, sentence-transformers usw.) für automatische Berechnungen.
  • Q&A IndikatorenEinige NLP-Bewertungsmetriken (z.B. BLEU, ROUGE, METEOR, BERTScore, etc.) können zur Unterstützung der Bewertung der Antwortqualität verwendet werden. Es sollte jedoch beachtet werden, dass automatisierte Q&A-Bewertungsmetriken immer noch Einschränkungen haben und die manuelle Bewertung nicht vollständig ersetzen können.
  • Langchain Assessment Tool: Langchain bietet eine Reihe von integrierten Evaluierungswerkzeugen, wie z. B. DatasetEvaluator im Gesang antworten RetrievalQAChainDies vereinfacht den automatisierten Bewertungsprozess des RAG-Systems.

Empfehlungen für den Bewertungsprozess

1. Aufbau des Bewertungsdatensatzes:: Bereiten Sie einen Evaluationsdatensatz mit Fragen und entsprechenden Standardantworten vor. Der Datensatz sollte, soweit möglich, typische Anwendungsszenarien und Fragetypen für RAG-Systeme abdecken.
2. Auswahl der Bewertungsindikatoren:: Auswahl geeigneter Such- und Frage-und-Antwort-Indikatoren je nach Zweck der Bewertung. Eine Kombination aus manueller und automatisierter Bewertung kann gleichzeitig verwendet werden.
3. Betrieb des RAG-SystemsAusführen des RAG-Systems auf dem Evaluierungsdatensatz unter Verwendung verschiedener Kombinationen von Chunking-Strategien, Retrieval-Modellen und LLM-Modellen, um die Evaluierungsergebnisse aufzuzeichnen.
4. Analyse und VergleichVergleichen Sie die Bewertungskennzahlen verschiedener Strategien, analysieren Sie ihre Stärken und Schwächen und wählen Sie die optimale Kombination von Strategien.
5. Iterative OptimierungAuf der Grundlage der Evaluierungsergebnisse werden die Parameter der Chunking-Strategie, des Retrieval-Modells und des LLM-Modells im Rahmen einer iterativen Optimierung kontinuierlich angepasst, um die Leistung des RAG-Systems zu verbessern.

Zusammenfassend: Wählen Sie die Chunking-Strategie, die für Sie am besten funktioniert

Dieses Papier bietet eine ausführliche Diskussion der Dokument-Chunking-Techniken, die in RAG-Anwendungen von entscheidender Bedeutung sind, von der grundlegenden rekursiven Zeichensegmentierung über intelligenteres semantisches Chunking und Agentic Chunking bis hin zu verfeinerten Chunking-Strategien für verschiedene Dokumentenformate sowie Methoden zur Auswahl und Bewertung von Chunk-Größen und Überlappungsparametern.

Überprüfung der wichtigsten Punkte

• Die Masse des Stücks bestimmt die RAG-MasseEine gute Chunking-Strategie ist der Grundstein für den Aufbau eines leistungsfähigen RAG-Systems.
• Es gibt keine pauschale Chunking-StrategieVerschiedene Chunking-Strategien haben ihre eigenen Vor- und Nachteile und sind für unterschiedliche Szenarien geeignet. Sie müssen die am besten geeignete Strategie auf der Grundlage der spezifischen Anforderungen Ihres Projekts, der Dokumenteneigenschaften und der Ressourcenbeschränkungen wählen.
• Rekursive ZeichensegmentierungEinfach, schnell und wirtschaftlich für Prototypen und kostensensitive Projekte.
• semantisches ChunkingDas Verstehen der Textsemantik und die Generierung semantisch kohärenter Chunks verbessert die Suchqualität, ist aber rechenintensiv.
• Agentisches ChunkingSimuliert das menschliche Verständnis, ist intelligenter, flexibler und kann komplexe Dokumente verarbeiten, ist aber kostspielig und Prompt Engineering ist komplex.
• Chunking für verschiedene FormateFür verschiedene Formate wie Markdown, HTML, PDF, Code usw. ist eine feinkörnige Chunking-Strategie erforderlich, um die Strukturinformationen des Dokuments zu nutzen.
• Chunk-Größe und ÜberlappungEs gibt keinen absolut optimalen Wert, der je nach den Merkmalen des Dokuments und den Versuchsergebnissen angepasst werden muss.
• Bewertung ist der Schlüssel:: Quantifizierung der Wirksamkeit der Chunking-Strategie durch Bewertungsmetriken und manuelle Bewertung sowie iterative Optimierung.

Wie soll man wählen? Mein Rat.

• Schnelles Prototyping:: Vorrangige VersucheRekursive ZeichensegmentierungDie RAG ist eine schnelle Möglichkeit, einen Prototyp einer RAG zu bauen und die Machbarkeit des Systems zu überprüfen.
• Das Streben nach höherer QualitätWenn eine hohe Nachfrage nach RAG-Qualität besteht und die Rechenressourcen es zulassen, können Sie versuchen, diesemantisches Chunking.
• Bearbeitung komplexer Dokumente:: Für Dokumente mit komplexen Strukturen und semantischen Sprüngen.Agentisches ChunkingDies mag die bevorzugte Option sein, aber Kosten und Wirksamkeit müssen sorgfältig abgewogen werden.
• FormatspezifischWenn Sie mit Dokumenten in einem bestimmten Format arbeiten, z. B. Markdown, HTML, PDF, Code usw., sollten Sie die OptionGezielte Chunking-StrategieDie Strukturinformationen des Dokuments werden vollständig genutzt.
• Kontinuierliche iterative Optimierung:: Die Wahl der Chunking-Strategie ist kein Prozess, der von heute auf morgen erfolgt. In realen Projekten ist es notwendig, ständigErprobung, Bewertung und iterative Optimierungum die beste Chunking-Lösung für Sie zu finden.

Ich hoffe, dieser Artikel kann Ihnen helfen, die RAG-Chunking-Technologie besser zu verstehen und geeignete Chunking-Strategien auszuwählen und in realen Projekten anzuwenden, um leistungsfähigere RAG-Anwendungen zu erstellen!