Créer une application de questions/réponses avec la RAG multimodale avec Gemini Pro

1. Introduction

Qu'est-ce que la RAG ?

La RAG (Retrieval Augmented Generation) est une technique qui associe la puissance des grands modèles de langage (LLM) à la capacité de récupérer des informations pertinentes à partir de sources de connaissances externes. Cela signifie qu'un LLM ne s'appuie pas seulement sur ses données d'entraînement internes. Il peut également accéder à des informations spécifiques à jour et les intégrer lorsqu'il génère des réponses.

La RAG gagne en popularité pour plusieurs raisons:

• Précision et pertinence accrues:la RAG permet aux LLM de fournir des réponses plus précises et pertinentes en les ancrées dans des informations factuelles provenant de sources externes. Cela est particulièrement utile dans les scénarios où des connaissances à jour sont cruciales, par exemple pour répondre à des questions sur des événements actuels ou fournir des informations sur des sujets spécifiques.
• Diminution des hallucinations:les LLM génèrent parfois des réponses qui semblent plausibles, mais en réalité incorrectes ou incompréhensibles. La RAG aide à atténuer ce problème en vérifiant les informations générées auprès de sources externes.
• Meilleure adaptabilité:la RAG rend les LLM plus adaptables à différents domaines et tâches. Grâce à différentes sources de connaissances, un LLM peut être facilement personnalisé pour fournir des informations sur un grand nombre de sujets.
• Expérience utilisateur améliorée:la RAG peut améliorer l'expérience utilisateur globale en fournissant des réponses plus informatives, fiables et pertinentes.

Pourquoi choisir plusieurs modales

Dans le monde actuel, riche en données, les documents combinent souvent du texte et des images pour transmettre des informations complètes. Cependant, la plupart des systèmes de Génération augmentée de récupération (RAG) négligent les informations précieuses contenues dans les images. Alors que les grands modèles de langage (LLM) multimodaux gagnent en proéminence, il est crucial d'explorer comment nous pouvons exploiter le contenu visuel en plus du texte dans la RAG, afin de mieux comprendre le paysage informationnel.

Deux options pour la RAG multimodale

• Représentations vectorielles continues multimodales : le modèle de représentations vectorielles continues multimodales génère des vecteurs de 1 408 dimensions* en fonction des données d'entrée que vous fournissez, qui peuvent inclure une combinaison de données d'images, de texte et de vidéos. Le vecteur de représentation vectorielle continue d'image et le vecteur de représentation vectorielle continue de texte se trouvent dans le même espace sémantique avec la même dimensionnalité. Par conséquent, ces vecteurs peuvent être utilisés de manière interchangeable pour des cas d'utilisation tels que la recherche d'image par du texte ou la recherche de vidéos par image. Regardez cette démonstration.

1. Utiliser l'intégration multimodale pour intégrer du texte et des images
2. Récupérer les deux à l'aide de la recherche de similarité
3. Transmettre à la fois l'image brute et les fragments de texte récupérés au LLM multimodal pour la synthèse des réponses

• Représentations vectorielles continues de texte :

1. Utiliser un LLM multimodal pour générer des résumés textuels des images
2. Intégrer et récupérer du texte
3. Transmettre le texte au LLM pour la synthèse des réponses

Qu'est-ce que le récupérateur multivecteur ?

La récupération multivecteur utilise des résumés des sections de document pour récupérer le contenu original en vue de la synthèse des réponses. Cela améliore la qualité du RAG en particulier pour les tâches intensives de tableaux, de graphiques, de diagrammes, etc. Pour en savoir plus, consultez le blog de Langchain.

Objectifs de l'atelier

Cas d'utilisation: développer un système de questions-réponses avec Gemini Pro

Imaginez que vous avez des documents contenant des graphiques ou des diagrammes complexes remplis d'informations. Vous souhaitez extraire ces données pour répondre à des questions ou des requêtes.

Dans cet atelier de programmation, vous allez effectuer les opérations suivantes:

• Chargement des données avec LangChain document_loaders
• Générez des résumés textuels à l'aide du modèle gemini-pro de Google
• Générer des résumés d'images à l'aide du modèle gemini-pro-vision de Google
• Créer une récupération multivectorielle à l'aide du modèle textembedding-gecko de Google avec Croma Db comme magasin de données vectorielles
• Développer une chaîne de RAG multimodale pour répondre aux questions

2. Avant de commencer

1. Dans la console Google Cloud, sur la page du sélecteur de projet, sélectionnez ou créez un projet Google Cloud.
2. Assurez-vous que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.
3. Activer toutes les API recommandées depuis le tableau de bord Vertex AI
4. Ouvrez Colab Notebook et connectez-vous au même compte que votre compte Google Cloud actif actuel.

3. Créer une RAG multimodale

Cet atelier de programmation utilise le SDK Vertex AI pour Python et Langchain pour montrer comment implémenter l'option 2 décrite ici avec Google Cloud.

Vous pouvez faire référence au code complet dans le fichier Multi-modal RAG with Google Cloud du dépôt référencé.

4. Étape 1: Installez et importez les dépendances

!pip install -U --quiet langchain langchain_community chromadb  langchain-google-vertexai
!pip install --quiet "unstructured[all-docs]" pypdf pillow pydantic lxml pillow matplotlib chromadb tiktoken

Saisissez l'ID de votre projet et procédez à l'authentification

#TODO : ENter project and location
PROJECT_ID = ""
REGION = "us-central1"

from google.colab import auth
auth.authenticate_user()

Initialiser Vertex AI Platform

import vertexai
vertexai.init(project = PROJECT_ID , location = REGION)

5. Étape 2: Préparez et chargez les données

Nous utilisons un fichier ZIP contenant un sous-ensemble des images et du PDF extraits de cet article de blog. Si vous souhaitez suivre la procédure dans son intégralité, veuillez utiliser l'exemple d'origine.

Commencez par télécharger les données

import logging
import zipfile
import requests

logging.basicConfig(level=logging.INFO)

data_url = "https://storage.googleapis.com/benchmarks-artifacts/langchain-docs-benchmarking/cj.zip"
result = requests.get(data_url)
filename = "cj.zip"
with open(filename, "wb") as file:
   file.write(result.content)

with zipfile.ZipFile(filename, "r") as zip_ref:
   zip_ref.extractall()

Charger le contenu textuel du document

from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader("./cj/cj.pdf")
docs = loader.load()
tables = []
texts = [d.page_content for d in docs]

Vérifier le contenu de la première page

texts[0]

Le résultat doit s'afficher

Nombre total de pages du document

len(texts)

Le résultat attendu est

6. Étape 3: Générez des résumés textuels

Importez d'abord les bibliothèques requises

from langchain_google_vertexai import VertexAI , ChatVertexAI , VertexAIEmbeddings
from langchain.prompts import PromptTemplate
from langchain_core.messages import AIMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableLambda

Obtenir des résumés textuels

# Generate summaries of text elements
def generate_text_summaries(texts, tables, summarize_texts=False):
   """
   Summarize text elements
   texts: List of str
   tables: List of str
   summarize_texts: Bool to summarize texts
   """

   # Prompt
   prompt_text = """You are an assistant tasked with summarizing tables and text for retrieval. \
   These summaries will be embedded and used to retrieve the raw text or table elements. \
   Give a concise summary of the table or text that is well optimized for retrieval. Table or text: {element} """
   prompt = PromptTemplate.from_template(prompt_text)
   empty_response = RunnableLambda(
       lambda x: AIMessage(content="Error processing document")
   )
   # Text summary chain
   model = VertexAI(
       temperature=0, model_name="gemini-pro", max_output_tokens=1024
   ).with_fallbacks([empty_response])
   summarize_chain = {"element": lambda x: x} | prompt | model | StrOutputParser()

   # Initialize empty summaries
   text_summaries = []
   table_summaries = []

   # Apply to text if texts are provided and summarization is requested
   if texts and summarize_texts:
       text_summaries = summarize_chain.batch(texts, {"max_concurrency": 1})
   elif texts:
       text_summaries = texts

   # Apply to tables if tables are provided
   if tables:
       table_summaries = summarize_chain.batch(tables, {"max_concurrency": 1})

   return text_summaries, table_summaries


# Get text summaries
text_summaries, table_summaries = generate_text_summaries(
   texts, tables, summarize_texts=True
)

text_summaries[0]

Le résultat attendu est

7. Étape 4: Générer des résumés d'images

Importez d'abord les bibliothèques requises

import base64
import os

from langchain_core.messages import HumanMessage

Générer des résumés d'images

def encode_image(image_path):
   """Getting the base64 string"""
   with open(image_path, "rb") as image_file:
       return base64.b64encode(image_file.read()).decode("utf-8")


def image_summarize(img_base64, prompt):
   """Make image summary"""
   model = ChatVertexAI(model_name="gemini-pro-vision", max_output_tokens=1024)

   msg = model(
       [
           HumanMessage(
               content=[
                   {"type": "text", "text": prompt},
                   {
                       "type": "image_url",
                       "image_url": {"url": f"data:image/jpeg;base64,{img_base64}"},
                   },
               ]
           )
       ]
   )
   return msg.content


def generate_img_summaries(path):
   """
   Generate summaries and base64 encoded strings for images
   path: Path to list of .jpg files extracted by Unstructured
   """

   # Store base64 encoded images
   img_base64_list = []

   # Store image summaries
   image_summaries = []

   # Prompt
   prompt = """You are an assistant tasked with summarizing images for retrieval. \
   These summaries will be embedded and used to retrieve the raw image. \
   Give a concise summary of the image that is well optimized for retrieval."""

   # Apply to images
   for img_file in sorted(os.listdir(path)):
       if img_file.endswith(".jpg"):
           img_path = os.path.join(path, img_file)
           base64_image = encode_image(img_path)
           img_base64_list.append(base64_image)
           image_summaries.append(image_summarize(base64_image, prompt))

   return img_base64_list, image_summaries


# Image summaries
img_base64_list, image_summaries = generate_img_summaries("./cj")

len(img_base64_list)

len(image_summaries)

image_summaries[0]

Le résultat devrait ressembler à ceci :

8. Étape 5: Créer une récupération multivecteur

Générons maintenant des résumés de texte et d'images, et enregistrons-les dans un keystore ChromaDB.

L'importation nécessite des bibliothèques

import uuid
from langchain.retrievers.multi_vector import MultiVectorRetriever
from langchain.storage import InMemoryStore
from langchain_community.vectorstores import Chroma
from langchain_core.documents import Document

Créer une récupération multivecteur

def create_multi_vector_retriever(
   vectorstore, text_summaries, texts, table_summaries, tables, image_summaries, images
):
   """
   Create retriever that indexes summaries, but returns raw images or texts
   """

   # Initialize the storage layer
   store = InMemoryStore()
   id_key = "doc_id"

   # Create the multi-vector retriever
   retriever = MultiVectorRetriever(
       vectorstore=vectorstore,
       docstore=store,
       id_key=id_key,
   )

   # Helper function to add documents to the vectorstore and docstore
   def add_documents(retriever, doc_summaries, doc_contents):
       doc_ids = [str(uuid.uuid4()) for _ in doc_contents]
       summary_docs = [
           Document(page_content=s, metadata={id_key: doc_ids[i]})
           for i, s in enumerate(doc_summaries)
       ]
       retriever.vectorstore.add_documents(summary_docs)
       retriever.docstore.mset(list(zip(doc_ids, doc_contents)))

   # Add texts, tables, and images
   # Check that text_summaries is not empty before adding
   if text_summaries:
       add_documents(retriever, text_summaries, texts)
   # Check that table_summaries is not empty before adding
   if table_summaries:
       add_documents(retriever, table_summaries, tables)
   # Check that image_summaries is not empty before adding
   if image_summaries:
       add_documents(retriever, image_summaries, images)

   return retriever


# The vectorstore to use to index the summaries
vectorstore = Chroma(
   collection_name="mm_rag_cj_blog",
   embedding_function=VertexAIEmbeddings(model_name="textembedding-gecko@latest"),
)

# Create retriever
retriever_multi_vector_img = create_multi_vector_retriever(
   vectorstore,
   text_summaries,
   texts,
   table_summaries,
   tables,
   image_summaries,
   img_base64_list,
)
 

9. Étape 6: Créer une RAG multimodale

1. Définir des fonctions utilitaires

import io
import re

from IPython.display import HTML, display
from langchain_core.runnables import RunnableLambda, RunnablePassthrough
from PIL import Image


def plt_img_base64(img_base64):
   """Disply base64 encoded string as image"""
   # Create an HTML img tag with the base64 string as the source
   image_html = f'<img src="data:image/jpeg;base64,{img_base64}" />'
   # Display the image by rendering the HTML
   display(HTML(image_html))


def looks_like_base64(sb):
   """Check if the string looks like base64"""
   return re.match("^[A-Za-z0-9+/]+[=]{0,2}$", sb) is not None


def is_image_data(b64data):
   """
   Check if the base64 data is an image by looking at the start of the data
   """
   image_signatures = {
       b"\xFF\xD8\xFF": "jpg",
       b"\x89\x50\x4E\x47\x0D\x0A\x1A\x0A": "png",
       b"\x47\x49\x46\x38": "gif",
       b"\x52\x49\x46\x46": "webp",
   }
   try:
       header = base64.b64decode(b64data)[:8]  # Decode and get the first 8 bytes
       for sig, format in image_signatures.items():
           if header.startswith(sig):
               return True
       return False
   except Exception:
       return False


def resize_base64_image(base64_string, size=(128, 128)):
   """
   Resize an image encoded as a Base64 string
   """
   # Decode the Base64 string
   img_data = base64.b64decode(base64_string)
   img = Image.open(io.BytesIO(img_data))

   # Resize the image
   resized_img = img.resize(size, Image.LANCZOS)

   # Save the resized image to a bytes buffer
   buffered = io.BytesIO()
   resized_img.save(buffered, format=img.format)

   # Encode the resized image to Base64
   return base64.b64encode(buffered.getvalue()).decode("utf-8")


def split_image_text_types(docs):
   """
   Split base64-encoded images and texts
   """
   b64_images = []
   texts = []
   for doc in docs:
       # Check if the document is of type Document and extract page_content if so
       if isinstance(doc, Document):
           doc = doc.page_content
       if looks_like_base64(doc) and is_image_data(doc):
           doc = resize_base64_image(doc, size=(1300, 600))
           b64_images.append(doc)
       else:
           texts.append(doc)
   if len(b64_images) > 0:
       return {"images": b64_images[:1], "texts": []}
   return {"images": b64_images, "texts": texts}

2. Définir une requête d'image spécifique au domaine

def img_prompt_func(data_dict):
   """
   Join the context into a single string
   """
   formatted_texts = "\n".join(data_dict["context"]["texts"])
   messages = []

   # Adding the text for analysis
   text_message = {
       "type": "text",
       "text": (
           "You are financial analyst tasking with providing investment advice.\n"
           "You will be given a mixed of text, tables, and image(s) usually of charts or graphs.\n"
           "Use this information to provide investment advice related to the user question. \n"
           f"User-provided question: {data_dict['question']}\n\n"
           "Text and / or tables:\n"
           f"{formatted_texts}"
       ),
   }
   messages.append(text_message)
   # Adding image(s) to the messages if present
   if data_dict["context"]["images"]:
       for image in data_dict["context"]["images"]:
           image_message = {
               "type": "image_url",
               "image_url": {"url": f"data:image/jpeg;base64,{image}"},
           }
           messages.append(image_message)
   return [HumanMessage(content=messages)]

3. Définir une chaîne RAG multimodale

def multi_modal_rag_chain(retriever):
   """
   Multi-modal RAG chain
   """

   # Multi-modal LLM
   model = ChatVertexAI(
       temperature=0, model_name="gemini-pro-vision", max_output_tokens=1024
   )

   # RAG pipeline
   chain = (
       {
           "context": retriever | RunnableLambda(split_image_text_types),
           "question": RunnablePassthrough(),
       }
       | RunnableLambda(img_prompt_func)
       | model
       | StrOutputParser()
   )

   return chain


# Create RAG chain
chain_multimodal_rag = multi_modal_rag_chain(retriever_multi_vector_img)

10. Étape 7: Testez vos requêtes

1. Récupérer les documents pertinents

query = "What are the EV / NTM and NTM rev growth for MongoDB, Cloudflare, and Datadog?"
docs = retriever_multi_vector_img.get_relevant_documents(query, limit=1)

# We get relevant docs
len(docs)

docs

         You may get similar output 

plt_img_base64(docs[3])

2. Exécuter notre RAG sur la même requête

result = chain_multimodal_rag.invoke(query)

from IPython.display import Markdown as md
md(result)

Exemple de résultat (peut varier lorsque vous exécutez le code)

11. Effectuer un nettoyage

Pour éviter que les ressources utilisées dans cet atelier de programmation soient facturées sur votre compte Google Cloud, procédez comme suit:

1. Dans la console Google Cloud, accédez à la page Gérer les ressources.
2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

12. Félicitations

Félicitations ! Vous venez de développer une RAG multimodale à l'aide de Gemini.