Mettre en œuvre des stratégies de découpage RAG avec LangChain et watsonx.ai

Dans ce tutoriel, vous allez expérimenter plusieurs stratégies de découpage à l’aide de LangChain et du dernier modèle IBM Granite désormais disponible sur watsonx.ai. L'objectif général est de réaliser une génération augmentée de récupération (RAG).

Le découpage (ou fragmentation) fait référence au processus consistant à décomposer de gros éléments de texte en segments de texte ou en blocs plus petits. Pour souligner l’importance du découpage, il est utile de comprendre la RAG. La RAG est une technique de traitement automatique du langage naturel (NLP) qui combine la récupération d’informations et de grands modèles de langage (LLM) pour récupérer des informations pertinentes à partir de jeux de données supplémentaires afin d’optimiser la qualité de la sortie du LLM. Pour gérer les documents volumineux, nous pouvons utiliser le découpage pour diviser le texte en plus petits extraits de blocs significatifs. Ces morceaux de texte peuvent ensuite être incorporés et stockés dans une base de données vectorielle à l’aide d’un modèle d’embedding. Enfin, le système RAG peut ensuite utiliser la recherche sémantique pour récupérer uniquement les morceaux les plus pertinents. Les petits blocs ont tendance à être plus performants que les gros morceaux, car ils ont tendance à être plus gérables pour les modèles avec une plus petite taille de fenêtre contextuelle.

Voici quelques-uns des éléments clés du découpage :

• Stratégie de découpage : il est important de choisir la bonne stratégie de découpage pour votre application, car elle détermine les limites de définition des fragments. Nous en découvrirons certaines dans la section suivante.
• Taille de bloc : nombre maximal de tokens pouvant se trouver dans chaque bloc. Déterminer la taille de bloc appropriée implique généralement quelques expérimentations.  
• Chevauchement des blocs : le nombre de tokens qui se chevauchent entre les blocs pour préserver le contexte. Il s’agit d’un paramètre facultatif.

Il existe plusieurs stratégies de découpage différentes. Il est important de sélectionner la technique de découpage la plus efficace pour le cas d’utilisation spécifique de votre application LLM. Voici quelques-uns des processus de découpage couramment utilisés : 

• Découpage à taille fixe : fractionnement du texte avec une taille de bloc spécifique et chevauchement facultatif des blocs. Cette approche est la plus courante et la plus simple.
• Découpage récursif : itération des séparateurs par défaut jusqu’à ce que l’un d’entre eux produise la taille de bloc préférée. Les séparateurs par défaut incluent ["\n\n", "\n", " ", ""]. Cette méthode de découpage utilise des séparateurs hiérarchiques afin que les paragraphes, suivis de phrases, puis de mots, restent ensemble autant que possible.
• Découpage sémantique : découpage du texte de manière à regrouper les phrases en fonction de la similarité sémantique de leurs embeddings. Les embeddings de similarité sémantique élevée sont plus proches que ceux de similarité sémantique faible. Cela donne des fragments qui tiennent compte du contexte.
• Découpage basé sur les documents : découpage basé sur la structure des documents. Ce séparateur peut utiliser du texte, des images, des tableaux et même des classes de code et des fonctions Python comme moyens de déterminer la structure. Ce faisant, des documents volumineux peuvent être fragmentés et traités par le LLM.
• Découpage agentique : exploite l’IA agentique en permettant au LLM de déterminer le découpage approprié des documents en fonction de la signification sémantique ainsi que de la structure de contenu comme les types de paragraphes, les en-têtes de section, les instructions étape par étape, etc. Ce segmentateur est expérimental et tente de simuler le raisonnement humain lors du traitement de longs documents.  

Bien que vous puissiez faire votre choix parmi plusieurs outils, ce tutoriel vous guide pas à pas pour configurer un compte IBM à l’aide d’un Jupyter Notebook.

1. Connectez-vous à watsonx.ai depuis votre compte IBM Cloud.

2. Créez un projet watsonx.ai.

   Vous pouvez obtenir l’ID de votre projet à partir de ce dernier. Cliquez sur l’onglet Manage (Gérer). Ensuite, copiez l’ID du projet à partir de la section Details (Détails) de la page General (Général). Vous aurez besoin de cet ID pour ce tutoriel.

3. Créez un Jupyter Notebook.

Cette étape ouvre un environnement de notebook dans lequel vous pouvez copier le code de ce tutoriel. Vous pouvez également télécharger ce notebook sur votre système local et le charger dans votre projet watsonx.ai en tant qu’actif. Pour voir d'autres tutoriels Granite, consultez la Communauté IBM  Granite. Ce Jupyter Notebook, ainsi que les jeux de données utilisés, se trouvent sur GitHub.

1. Créez une instance de service d’exécution watsonx.ai (sélectionnez votre région et choisissez le plan Lite, qui est une instance gratuite).

2. Générez une clé d’API.

3. Associez l'instance de service Runtime watsonx.ai au projet que vous avez créé dans watsonx.ai.

Pour définir nos identifiants, nous avons besoin des identifiants WATSONX_APIKEY et WATSONX_PROJECT_ID que vous avez générés à l’étape 1. Nous définirons également l’URL servant de point de terminaison de l’API.

Nous utiliserons Granite 3.1 comme LLM pour ce tutoriel. Pour initialiser le LLM, nous devons définir les paramètres du modèle. Pour en savoir plus sur ces paramètres de modèle, tels que les limites minimales et maximales de token, reportez-vous à la documentation.

Le contexte que nous utilisons pour notre pipeline RAG est le communiqué officiel d’IBM pour la sortie de Granite 3.1. Nous pouvons charger le blog dans un document directement à partir de la page Web à l’aide du WebBaseLoader de LangChain.

Prenons un exemple de code pour implémenter chacune des stratégies de découpage abordées plus haut dans ce tutoriel, disponible via LangChain.

Découpage à taille fixe

Pour implémenter un découpage en blocs à taille fixe, nous pouvons utiliser le CharacterTextSplitter de LangChain, définir une chunk_size et un chunk_overlap. La chunk_size est mesurée par le nombre de caractères. N'hésitez pas à expérimenter d'autres valeurs. Nous définirons également le séparateur comme caractère de nouvelle ligne afin de pouvoir différencier les paragraphes. Pour la tokenisation, nous pouvons utiliser le tokenizer granite-3.1-8b-instruct. Le tokeniseur divise le texte en tokens pouvant être traités par le LLM.

Nous pouvons imprimer un des blocs pour une meilleure compréhension de leur structure.

Sortie : (tronquée)

Nous pouvons également utiliser le tokenizer pour vérifier notre processus et contrôler le nombre de tokens présents dans chaque bloc. Cette étape est facultative et destinée à des fins de démonstration.

Output:

Super ! Il semble que nos tailles de fragments aient été correctement mises en œuvre.

Découpage récursif

Pour le découpage récursif, on peut utiliser le RecursiveCharacterTextSplitter de LangChain. Comme pour l’exemple du découpage à taille fixe, nous pouvons expérimenter avec différentes tailles de blocs et de chevauchements.

Output:

Le séparateur a réussi à segmenter le texte en utilisant les séparateurs par défaut : [“\n\n”, “\n”, “ “, “”].

Découpage sémantique

Le découpage sémantique nécessite un modèle d'embedding ou d'encodeur. Nous pouvons utiliser le modèle granite-embedding-30m-english comme modèle d'embedding. Nous pouvons également imprimer un des blocs pour une meilleure compréhension de leur structure.

Sortie : (tronquée)

Découpage basé sur les documents

Les documents de différents types de fichiers sont compatibles avec les séparateurs de texte basés sur les documents de LangChain. Pour les besoins de ce tutoriel, nous utiliserons un fichier Markdown. Pour des exemples de partitionnement récursif en JSON, de code et de HTML, consultez la documentation de LangChain.

Le fichier README pour Granite 3.1 sur le GitHub d’IBM est un exemple de fichier Markdown.

Output:

Maintenant, nous pouvons utiliser le MarkdownHeaderTextSplitter de LangChain pour découper le fichier par type d’en-tête, que nous avons défini dans la liste « headdown_to_split_on ». Nous imprimerons également l’un des blocs à titre d’exemple.

Output:

Comme vous pouvez le voir dans la sortie, le découpage a réussi à diviser le texte par type d’en-tête.

Maintenant que nous avons expérimenté différentes stratégies de découpage, passons à notre implémentation RAG. Pour ce tutoriel, nous allons choisir les blocs produits par la division sémantique et les convertir en embeddings. Pour cela, nous pouvons utiliser la base de données vectorielle open source Chroma DB. Nous pouvons facilement accéder aux fonctionnalités de Chroma via le package langchain_chroma. 

Initialisons notre base de données vectorielle Chroma, fournissons-lui notre modèle d’embeddings et ajoutons nos documents produits par découpage semantique.

Output:

Ensuite, nous pouvons passer à la création d'un modèle de prompt pour notre LLM. Ce modèle de prompt nous permet de poser plusieurs questions sans modifier la structure initiale du prompt. Nous pouvons également fournir notre base de données vectorielle comme récupérateur. Cette étape finalise la structure RAG.

À l'aide de notre workflow RAG terminé, nous allons invoquer une requête utilisateur. Tout d’abord, nous pouvons envoyer un prompt stratégique au modèle sans aucun contexte supplémentaire à partir de la base de données vectorielle que nous avons construit pour tester si le modèle utilise ses connaissances intégrées ou véritablement en utilisant le contexte RAG. Le blog annonçant Granite 3.1 fait référence à Docling, l'outil d'IBM permettant d'analyser divers types de documents et de les convertir en Markdown ou JSON. Interrogons le LLM sur Docling.

Output:

Il est évident que le modèle n'a pas été formé à partir d'informations sur Docling et, sans outils ou informations externes, il ne peut pas nous fournir ces informations. Essayons maintenant de soumettre la même requête à la chaîne RAG que nous avons construite.

Output:

Super ! Le modèle Granite a correctement utilisé le contexte RAG pour nous fournir des informations exactes sur Docling tout en préservant la cohérence sémantique. Nous avons prouvé que ce même résultat n’était pas possible sans l’utilisation de la RAG.

Dans ce tutoriel, vous avez créé un pipeline RAG et expérimenté plusieurs stratégies de découpage pour améliorer la précision de récupération du système. En utilisant le modèle Granite 3.1, nous avons réussi à produire des réponses de modèle appropriées à une requête d’utilisateur concernant les documents fournis en tant que contexte. Le texte que nous avons utilisé pour cette implémentation RAG provient d’un blog sur ibm.com annonçant la publication de Granite 3.1. Le modèle nous a fourni des informations accessibles uniquement via le contexte fourni, car celui-ci ne faisait pas partie de la base de connaissances initiale du modèle.

Pour ceux qui souhaitent en savoir plus, consultez les résultats d’un projet comparant les performances d’un LLM à l’aide du découpage structuré HTML par rapport au découpage watsonx.