1. Introduction
Qu'est-ce que la génération augmentée de récupération (RAG) ?
La génération augmentée par récupération (RAG) est une technique qui combine la puissance des grands modèles de langage (LLM) avec la capacité de récupérer des informations pertinentes à partir de sources de connaissances externes. Cela signifie qu'un LLM ne s'appuie pas uniquement sur ses données d'entraînement internes, mais qu'il peut également accéder à des informations spécifiques et à jour et les intégrer lors de la génération de réponses.
Le RAG gagne en popularité pour plusieurs raisons:
- Précision et pertinence améliorées:le RAG permet aux LLM de fournir des réponses plus précises et pertinentes en les appuyant sur des informations factuelles récupérées à partir de sources externes. Cela est particulièrement utile dans les cas où des informations à jour sont essentielles, par exemple pour répondre à des questions sur l'actualité ou fournir des informations sur des sujets spécifiques.
- Réduction des hallucinations:les LLM peuvent parfois générer des réponses qui semblent plausibles, mais qui sont en réalité incorrectes ou absurdes. Le RAG permet de limiter ce problème en vérifiant les informations générées par rapport à des sources externes.
- Adaptabilité accrue:le RAG rend les LLM plus adaptables à différents domaines et tâches. En exploitant différentes sources de connaissances, un LLM peut être facilement personnalisé pour fournir des informations sur un large éventail de sujets.
- Amélioration de l'expérience utilisateur:le RAG peut améliorer l'expérience utilisateur globale en fournissant des réponses plus informatives, fiables et pertinentes.
Pourquoi le multimodisme ?
Dans le monde actuel, riche en données, les documents combinent souvent du texte et des images pour transmettre des informations de manière exhaustive. Toutefois, la plupart des systèmes de génération augmentée par récupération (RAG) passent à côté des insights précieux contenus dans les images. À mesure que les grands modèles de langage (LLM) multimodaux gagnent en importance, il est essentiel d'explorer comment nous pouvons exploiter le contenu visuel avec le texte dans la génération augmentée par récupération, afin de mieux comprendre le paysage informationnel.
Deux options pour le RAG multimodal
- Embeddings multimodaux : le modèle d'embeddings multimodaux génère des vecteurs de 1 408 dimensions* à partir de l'entrée que vous fournissez, qui peut inclure une combinaison de données d'image, textuelles et vidéo. Le vecteur de représentations vectorielles continues d'images et le vecteur de représentations vectorielles continues 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 les cas d'utilisation comme la recherche d'image par texte ou la recherche de vidéo par image. Regardez cette démonstration.
- Utiliser l'embedding multimodal pour intégrer du texte et des images
- Récupérer les deux à l'aide d'une recherche de similarité
- Transmettez à la fois l'image brute récupérée et les fragments de texte à un LLM multimodal pour synthétiser la réponse.
- Embeddings textuels :
- Utiliser un LLM multimodal pour générer des résumés textuels des images
- Intégrer et récupérer du texte
- Transmettre des extraits de texte au LLM pour la synthèse de réponses
Qu'est-ce que le Multi-Vector Retriever ?
La récupération multivectorielle utilise des résumés des sections du document pour récupérer le contenu d'origine afin de synthétiser les réponses. Il améliore la qualité du RAG, en particulier pour les tâches intensives impliquant des tableaux, des graphiques, etc. Pour en savoir plus, consultez le blog de Langchain.
Objectifs de l'atelier
Cas d'utilisation: développer un système de réponse aux questions à l'aide de Gemini Pro
Imaginez que vous disposez de documents contenant des graphiques ou des diagrammes complexes regorgeant 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 de données à l'aide de LangChain
document_loaders
- Générer 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 entrepôt de vecteurs - Développer une chaîne RAG multimodale pour la réponse aux questions
2. Avant de commencer
- Dans la console Google Cloud, sur la page du sélecteur de projet, sélectionnez ou créez un projet Google Cloud.
- 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.
- Activez toutes les API recommandées dans le tableau de bord Vertex AI.
- Ouvrez Colab Notebook et connectez-vous au même compte que votre compte Google Cloud actif actuel.
3. Créer un RAG multimodal
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 consulter le 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 votre ID de projet et finalisez l'authentification.
#TODO : ENter project and location
PROJECT_ID = ""
REGION = "us-central1"
from google.colab import auth
auth.authenticate_user()
Initialise la plate-forme Vertex AI
import vertexai
vertexai.init(project = PROJECT_ID , location = REGION)
5. Étape 2: Préparer et charger les données
Nous utilisons un fichier ZIP contenant un sous-ensemble des images et des PDF extraits de cet article de blog. Si vous souhaitez suivre l'intégralité du flux, veuillez utiliser l'exemple d'origine.
Téléchargez d'abord 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]
Vous devriez obtenir le résultat suivant :
Nombre total de pages du document
len(texts)
Le résultat attendu est
6. Étape 3: Générer des résumés textuels
Importer 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 de texte
# 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
Importer 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]
Vous devriez obtenir un résultat semblable à ceci :
8. Étape 5: Créer une récupération multivectorielle
Générez des résumés de texte et d'images, puis enregistrez-les dans un magasin de vecteurs ChromaDB.
Importer les bibliothèques requises
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 multivectorielle
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 un RAG multimodal
- 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}
- 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)]
- Définir la 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: Tester vos requêtes
- Récupérez 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])
- Exécuter notre évaluation de la qualité de l'API 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 ne soient facturées sur votre compte Google Cloud, procédez comme suit:
- Dans la console Google Cloud, accédez à la page Gérer les ressources.
- Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
- 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 avez développé une génération augmentée par récupération multimodale à l'aide de Gemini.