Implementierung von RAG-Chunking-Strategien mit LangChain und watsonx.ai

In diesem Tutorial experimentieren Sie mit mehreren Chunking-Strategien, die LangChain und das neueste IBM Granite-Modell verwenden, das jetzt auf watsonx.ai verfügbar ist. Das übergeordnete Ziel ist es, eine Retrieval-Augmented Generation (RAG) durchzuführen.

Chunking bezieht sich auf den Prozess des Aufteilens großer Textstücke in kleinere Textsegmente oder Blöcke. Um die Bedeutung des Chunking zu unterstreichen, ist es hilfreich, RAG zu verstehen. RAG ist eine Technik in der Verarbeitung natürlicher Sprache (NLP), die Informationsabfrage und große Sprachmodelle (LLMs) kombiniert, um relevante Informationen aus ergänzenden Datensätzen abzurufen, um die Qualität der Ausgabe des LLMs zu optimieren. Um große Dokumente zu verwalten, können wir Chunking verwenden, um den Text in kleinere Snippets mit sinnvollen Blöcken aufzuteilen. Diese Textabschnitte können dann mithilfe eines Einbettungsmodells in eine Vektordatenbank eingebettet und gespeichert werden. Schließlich kann das RAG-System dann die semantische Suche verwenden, um nur die relevantesten Chunks abzurufen. Kleinere Chunks übertreffen tendenziell größere Chunks, da sie für Modelle mit kleinerer Kontextfenstergröße tendenziell besser zu handhaben sind.

Zu den wichtigsten Komponenten des Chunkings gehören:

• Chunking-Strategie: Die Wahl der richtigen Chunking-Strategie für Ihre RAG-Anwendung ist wichtig, da sie die Boundaries für das Festlegen von Chunks festlegt. Wir werden einige davon im nächsten Abschnitt erkunden.
• Chunk-Größe: Maximale Anzahl von Token, die sich in jedem Chunk befinden sollen. Die Bestimmung der geeigneten Chunk-Größe ist in der Regel mit einigem Experimentieren verbunden.  
• Chunk-Überlappung: Die Anzahl der Token, die sich zwischen den Chunks überlappen, um den Kontext zu erhalten. Dies ist ein optionaler Parameter.

Es stehen verschiedene Hacking-Strategien zur Auswahl. Es ist wichtig, die effektivste Chunking-Technik für den spezifischen Anwendungsfall Ihrer LLM-Anwendung auszuwählen. Einige häufig verwendete Chunking-Prozesse sind:r: 

• Feste Chunking-Größe: Text wird in Chunks einer bestimmten Größe aufgeteilt, wobei eine optionale Überlappung der Chunks möglich ist. Dieser Ansatz ist der gebräuchlichste und unkomplizierteste.
• Rekursives Chunking: Iterieren von Standard-Separatoren, bis eines von ihnen die bevorzugte Blockgröße erzeugt. Zu den Standardtrennzeichen gehören ["\n\n", "\n", " ", "]. Bei dieser Chunking-Methode werden hierarchische Trennzeichen verwendet, sodass Absätze, gefolgt von Sätzen und Wörtern, so weit wie möglich zusammengehalten werden.
• Semantisches Chunking: Das Zerlegen von Text auf eine Weise, die Sätze auf der Grundlage der semantischen Ähnlichkeit ihrer Einbettungen gruppiert. Einbettungen mit hoher semantischer Ähnlichkeit liegen näher beieinander als solche mit geringer semantischer Ähnlichkeit. Das Ergebnis sind kontextabhängige Chunks.
• Dokumentbasiertes Chunking: Aufteilung basierend auf der Dokumentstruktur. Dieser Splitter kann Markdown-Text, Bilder, Tabellen und sogar Python-Code-Klassen und -Funktionen zur Bestimmung der Struktur verwenden. Auf diese Weise können große Dokumente in Chunks aufgeteilt und vom LLM verarbeitet werden.
• Agentisches Chunking: Nutzt agentische KI, indem es dem LLM ermöglicht, anhand der semantischen Bedeutung sowie der Inhaltsstruktur wie Absatztypen, Abschnittsüberschriften, Schritt-für-Schritt-Anleitungen und mehr eine angemessene Aufteilung des Dokuments zu bestimmen. Dieser Chunking-Algorithmus befindet sich noch im Versuchsstadium und versucht, das menschliche Denken bei der Verarbeitung langer Dokumente zu simulieren.  

Sie können zwar aus mehreren Tools wählen, aber dieses Tutorial führt Sie durch die Einrichtung eines IBM Kontos für die Verwendung eines Jupyter Notebook.

1. Melden Sie sich bei watsonx.ai mit Ihrem IBM® Cloud-Konto an.

2. Erstellen Sie ein watsonx.ai-Projekt.

   Sie können Ihre Projekt-ID in Ihrem Projekt abrufen. Klicken Sie auf die Registerkarte Verwalten. Kopieren Sie dann die Projekt-ID aus dem Abschnitt Details der Seite Allgemein. Sie benötigen diese ID für dieses Tutorial.

3. Erstellen Sie ein Jupyter Notebook.

Dieser Schritt öffnet eine Notebook-Umgebung, in die Sie den Code aus diesem Tutorial kopieren können. Alternativ können Sie dieses Notebook auf Ihr lokales System herunterladen und als Asset in Ihr watsonx.ai-Projekt hochladen. Weitere Granite-Tutorials finden Sie in der IBM Granite-Community. Dieses Jupyter Notebook sowie die verwendeten Datensätze sind auf GitHub zu finden.

1. Erstellen Sie eine watsonx.ai Runtime -Service-Instanz (wählen Sie Ihre entsprechende Region aus und wählen Sie den Lite-Plan, der eine kostenlose Instanz ist).

2. Generieren Sie einen API-Schlüssel.

3. Verknüpfen Sie die Instanz des watsonx.ai-Runtime-Service mit dem Projekt, das Sie in watsonx.ai erstellt haben.

Um unsere Anmeldedaten festzulegen, benötigen wir den WATSONX_APIKEY und die WATSONX_PROJECT_ID, die Sie in Schritt 1 erstellt haben. Wir werden auch die URL festlegen, die als API-Endgerät dient.

Wir verwenden Granite 3.1 als LLM für dieses Tutorial. Um das LLM zu initialisieren, müssen wir die Modellparameter festlegen. Weitere Informationen zu diesen Modellparametern, z. B. den minimalen und maximalen Token-Grenzwerten, finden Sie in der Dokumentation.

Der Kontext, den wir für unsere RAG-Pipeline verwenden, ist die offizielle IBM-Ankündigung zur Veröffentlichung von Granite 3.1. Mit dem WebBaseLoader von LangChain können wir den Blog direkt von der Webseite in ein Dokument laden.

Stellen Sie Beispielcode für die Implementierung jeder der Chunking-Strategien bereit, die wir bereits in diesem Tutorial behandelt haben, das über LangChain verfügbar ist.

Chunking in fester Größe

Zur Implementierung von Chunking mit fester Größe können wir den CharacterTextSplitter von LangChain verwenden und sowohl eine chunk_size als auch ein chunk_overlap festlegen. Die chunk_size wird anhand der Anzahl der Zeichen gemessen. Experimentieren Sie gerne mit verschiedenen Werten. Wir werden auch das Trennzeichen auf das Zeilenumbruchzeichen setzen, damit wir zwischen den Absätzen unterscheiden können. Für die Tokenisierung können wir den granite-3.1-8b-instruct Tokenizer verwenden. Der Tokenizer zerlegt Text in Token, die vom LLM verarbeitet werden können.

Wir können einen der Chunks ausdrucken, um ihre Struktur besser zu verstehen.

Ausgabe: (abgeschnitten)

Wir können den Tokenizer auch zur Überprüfung unseres Prozesses und zur Kontrolle der Anzahl der in jedem Chunk vorhandenen Tokens verwenden. Dieser Schritt ist optional und dient lediglich zu Demonstrationszwecken.

Output:

Großartig! Es sieht so aus, als ob unsere Chunk-Größen angemessen implementiert wurden.

Rekursives Chunking

Für rekursives Chunking können wir den RecursiveCharacterTextSplitter von LangChain verwenden. Wie bei dem Chunking-Beispiel mit fester Größe können wir mit verschiedenen Chunk- und Überlappungsgrößen experimentieren.

Output:

Der Splitter hat den Text erfolgreich unter Verwendung der Standardtrennzeichen in Abschnitte unterteilt: [“\n\n”, “\n”, “ “, “”].

Semantisches Chunking

Semantisches Chunking erfordert ein Einbetten- oder Encodermodell. Als Einbetten-Modell können wir das Modell granite-embedding-30m-english verwenden. Wir können auch einen der Chunks drucken, um ein besseres Verständnis ihrer Struktur zu erhalten.

Ausgabe: (abgeschnitten)

Dokumentbasiertes Chunking

Dokumente verschiedener Dateitypen sind mit den dokumentenbasierten Textsplittern von LangChain kompatibel. Für die Zwecke dieses Tutorials verwenden wir eine Markdown-Datei. Beispiele für rekursives JSON-Splitting, Code-Splitting und HTML-Splitting finden Sie in der LangChain-Dokumentation.

Ein Beispiel für eine Markdown-Datei, die wir laden können, ist die README-Datei für Granite 3.1 auf GitHub von IBM.

Output:

Nun können wir den MarkdownHeaderTextSplitter von LangChain verwenden, um die Datei nach Header-Typ zu teilen, den wir in der Liste headers_to_split_on festgelegt haben. Wir werden einen der Chunks auch als Beispiel ausdrucken.

Output:

Wie Sie in der Ausgabe sehen können, hat das Chunking den Text erfolgreich nach Kopfzeilentyp aufgeteilt.

Nachdem wir nun verschiedene Chunking-Strategien erprobt haben, fahren wir mit der Implementierung von RAG fort. Für dieses Tutorial wählen wir die durch die semantische Aufteilung erzeugten Chunks aus und konvertieren sie in Vektoreinbettungen. Ein Open-Source-Vektorspeicher, den wir verwenden können, ist Chroma DB. Über das Paket langchain_chrona können wir ganz einfach auf die Chroma-Funktionalität zugreifen.

Zunächst initialisieren wir unsere Chroma-Vektordatenbank, stellen wir ihr unser Einbettungsmodell zur Verfügung und fügen wir unsere durch semantisches Chunking erstellten Dokumente hinzu.

Output:

Als Nächstes können wir eine Prompt-Vorlage für unser LLM erstellen. Diese Prompt-Vorlage ermöglicht es uns, mehrere Fragen zu stellen, ohne die ursprüngliche Promptstruktur zu ändern. Wir können auch unseren Vektorspeicher als Retriever bereitstellen. Mit diesem Schritt wird die RAG-Struktur finalisiert.

Rufen wir mit unserem abgeschlossenen RAG-Workflow eine Benutzerabfrage auf. Zunächst können wir das Modell ohne zusätzlichen Kontext aus dem von uns erstellten Vektorspeicher strategisch ansprechen, um zu testen, ob es sein eingebautes Wissen nutzt oder den RAG-Kontext. Der Granite 3.1 Ankündigungsblog verweist auf Docling,, das IBM Tool zum Parsen verschiedener Dokumenttypen und deren Umwandlung in Markdown oder JSON. Fragen wir das LLM nach Docling.

Output:

Es ist offensichtlich, dass das Modell nicht mit Informationen über Docling trainiert wurde und ohne externe Tools oder Informationen kann es uns diese Informationen nicht liefern. Versuchen wir nun, die gleiche Abfrage für die RAG-Kette bereitzustellen, die wir erstellt haben.

Output:

Großartig! Das Granite-Modell hat den RAG-Kontext korrekt verwendet, um uns die korrekten Informationen über Docling zu liefern und gleichzeitig die semantische Kohärenz zu bewahren. Wir haben bewiesen, dass das gleiche Ergebnis ohne den Einsatz von RAG nicht möglich war.

In diesem Tutorial haben Sie eine RAG-Pipeline erstellt und mit mehreren Chunking-Strategien experimentiert, um die Abrufgenauigkeit des Systems zu verbessern. Mit dem Granite 3.1-Modell haben wir erfolgreich geeignete Modellantworten auf eine Benutzeranfrage zu den als Kontext bereitgestellten Dokumenten erstellt. Der Text, den wir für diese RAG-Implementierung verwendet haben, stammt aus einem Blog auf ibm.com, in dem die Veröffentlichung von Granite 3.1 angekündigt wurde. Das Modell lieferte uns Informationen, die nur über den bereitgestellten Kontext zugänglich waren, da sie nicht Teil der ursprünglichen Wissensbasis des Modells waren.

Für diejenigen, die weiterführende Informationen suchen, bieten wir die Ergebnisse eines Projekts an, in dem die LLM-Leistung mit HTML Structured Chunking mit watsonx Chunking verglichen wird.