Dans ce tutoriel, vous utiliserez Docling d’IBM et la solution open source IBM Granite Vision, des embeddings textuels et des modèles d’IA générative pour créer un système RAG. Ces modèles sont disponibles via des frameworks open source. Dans ce tutoriel, nous utiliserons Replicate pour nous connecter à IBM Granite Vision et aux modèles d’IA générative, ainsi que Hugging Face pour nous connecter au modèle d’embeddings.
La génération augmentée par récupération est une technique qui relie les grands modèles de langage (LLM) à une base de connaissances autre que les données sur lesquelles ils ont été entraînés, sans avoir à effectuer un réglage fin. La RAG traditionnelle se limite aux cas d’utilisation textuels tels que la synthèse et les chatbots.
La RAG multimodale peut utiliser des LLM multimodaux (MLLM) pour traiter les informations provenant de plusieurs types de données à inclure dans la base de connaissances externe utilisée. Les données multimodales peuvent comprendre des textes, des images, des fichiers audio et vidéo, entre autres. Les LLM multimodaux les plus connus sont Gemini de Google, Llama 3.2 de Meta et GPT-4 et GPT-4o d’OpenAI.
Pour cette recette, vous utiliserez un modèle IBM Granite capable de traiter différentes modalités. Vous allez créer un système d’IA pour répondre aux requêtes utilisateur en temps réel à partir de données non structurées dans un PDF.
Bienvenue ! Dans ce tutoriel Granite, vous apprendrez à exploiter la puissance des outils avancés pour construire un pipeline RAG multimodal alimenté par l’IA. Ce tutoriel vous guidera tout au long des processus suivants :
Ce tutoriel utilise trois technologies de pointe :
À la fin de ce tutoriel, vous pourrez accomplir les tâches suivantes :
Ce tutoriel est conçu pour les développeurs d’IA, les chercheurs et les passionnés qui souhaitent approfondir leurs connaissances en matière de gestion documentaire et de traitement automatique du langage naturel (TAL). Le tutoriel est également disponible sur le GitHub Granite Snack Cookbook de la communauté IBM Granite, sous forme de Jupyter Notebook.
! echo "::group::Install Dependencies"
%pip install uv
! uv pip install git+https://github.com/ibm-granite-community/utils.git \
transformers \
pillow \
langchain_classic \
langchain_core \
langchain_huggingface sentence_transformers \
langchain_milvus 'pymilvus[milvus_lite]' \
docling \
'langchain_replicate @ git+https://github.com/ibm-granite-community/langchain-replicate.git'
! echo "::endgroup::"
Pour afficher certaines informations de journalisation, nous pouvons configurer le niveau de journalisation INFO.
REMARQUE : vous pouvez ignorer l'exécution de cette cellule.
Spécifiez le modèle d’embeddings à utiliser pour générer des embeddings vectoriels de texte. Nous utiliserons ici l’un des modèles d’embeddings Granite
Pour utiliser un modèle d’embeddings différent, remplacez cette cellule de code par une cellule de cette recette de modèle d’embeddings.
Spécifiez le MLLM à utiliser pour la compréhension d’images. Nous utiliserons le modèle de vision Granite.
Spécifiez le modèle de langage à utiliser pour l’opération de génération RAG. Ici, nous utilisons le client Replicate LangChain pour nous connecter à un modèle Granite depuis l’organisation ibm-granite sur Replicate.
Pour configurer Replicate, consultez la section Premiers pas avec Replicate. Pour vous connecter à un modèle sur un fournisseur autre que Replicate, remplacez cette cellule de code par une cellule de la recette du composant LLM.
Pour vous connecter à un modèle sur un fournisseur autre que Replicate, remplacez cette cellule de code par une cellule de la recette du composant LLM.
from langchain_replicate import ChatReplicate
model_path = "ibm-granite/granite-4.0-h-small"
model = ChatReplicate(
model=model_path,
replicate_api_token=get_env_var("REPLICATE_API_TOKEN"),
model_kwargs={
"max_tokens": 1000, # Set the maximum number of tokens to generate as output.
"min_tokens": 100, # Set the minimum number of tokens to generate as output.
},
)
Dans cet exemple, à partir d’un ensemble de documents sources, nous utilisons Docling pour convertir les documents en texte et en images. Le texte est ensuite divisé en morceaux. Les images sont traitées par le MLLM pour générer des synthèses d’images.
Docling téléchargera les documents PDF et les traitera afin que nous puissions obtenir le texte et les images qu’ils contiennent. Le fichier PDF contient différents types de données, notamment des textes, des tableaux, des graphiques et des images.
Une fois les documents traités, nous poursuivons le traitement des éléments textuels qu’ils contiennent. Nous les découpons en morceaux de taille appropriée pour le modèle d’embedding que nous utilisons. Une liste de documents LangChain est créée à partir des morceaux de texte.
Ensuite, nous traitons tous les tableaux contenus dans les documents. Nous convertissons les données des tableaux au format Markdown pour les transmettre au modèle de langage. Une liste de documents LangChain est créée à partir des rendus Markdown des tableaux.
Enfin, nous traitons toutes les images contenues dans les documents. Nous utilisons ici le modèle de langage-vision pour comprendre le contenu d’une image. Dans cet exemple, nous nous intéressons à toute information textuelle contenue dans l’image. Vous pouvez modifier le texte du prompt pour voir si cela peut améliorer les résultats.
REMARQUE : le traitement peut prendre beaucoup de temps, selon le nombre d’images et le service qui exécute le modèle de langage-vision.
Nous pouvons ensuite afficher les documents LangChain créés à partir des documents d’entrée.
En utilisant le modèle d’embedding, nous chargeons les documents à partir des morceaux de texte et des légendes d’images générées dans une base de données vectorielle. Cette base de données vectorielle nous permet d’effectuer facilement une recherche de similarité sémantique entre nos documents.
REMARQUE : Le remplissage de la base de données vectorielle peut prendre un certain temps selon votre modèle d’embedding et votre service.
Spécifiez la base de données à utiliser pour stocker et récupérer les vecteurs d’embedding.
Pour vous connecter à une base de données vectorielle autre que Milvus, remplacez cette cellule de code par une cellule issue de cette recette de base de données vectorielle.
Nous ajoutons maintenant tous les documents LangChain (textes, tableaux et descriptions d’images) à la base de données vectorielles.
Maintenant que nous avons converti et vectorisé nos documents, nous pouvons mettre en place notre pipeline RAG.
Ici, nous testons la base de données vectorielle en recherchant dans l’espace vectoriel les morceaux contenant des informations pertinentes pour notre requête. Nous affichons les documents associés à la description d’image récupérée.
N'hésitez pas à formuler d'autres requêtes.
Le document renvoyé doit répondre à la requête. Commençons donc à construire notre pipeline RAG.
Nous commençons par créer les prompts permettant à Granite d’effectuer la requête RAG. Nous utilisons le template de chat Granite et fournissons les valeurs d’espace réservé que le pipeline LangChain RAG remplacera.
Ensuite, nous construisons le pipeline RAG en utilisant les templates de prompts Granite créés précédemment.
from ibm_granite_community.langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_classic.chains.retrieval import create_retrieval_chain
from langchain_core.prompts import ChatPromptTemplate
# Create a Granite prompt for question-answering with the retrieved context
prompt_template = ChatPromptTemplate.from_template("{input}")
# Assemble the retrieval-augmented generation chain
combine_docs_chain = create_stuff_documents_chain(
llm=model,
prompt=prompt_template,
)
rag_chain = create_retrieval_chain(
retriever=vector_db.as_retriever(),
combine_docs_chain=combine_docs_chain,
)
Le pipeline utilise la requête pour localiser les documents de la base de données vectorielle et les utiliser comme contexte pour la requête.
from ibm_granite_community.notebook_utils import wrap_text
output = rag_chain.invoke({"input": query})
print(wrap_text(output['answer']))
Parfait ! Nous avons créé une application d’IA capable d’exploiter les connaissances contenues dans le texte et les images des documents sources.
Entraînez, validez, réglez et déployez une IA générative, des modèles de fondation et des capacités de machine learning avec IBM watsonx.ai, un studio d’entreprise nouvelle génération pour les générateurs d’IA. Créez des applications d’IA en peu de temps et avec moins de données.
Mettez l’IA au service de votre entreprise en vous appuyant sur l’expertise de pointe d’IBM dans le domaine de l’IA et sur son portefeuille de solutions.
Réinventez les workflows et les opérations critiques en ajoutant l’IA pour optimiser les expériences, la prise de décision et la valeur métier en temps réel.