Les LLM vision sont aussi des analyseurs de PDF : lire des graphiques et des diagrammes pour le RAG

Les Vision LLM sont aussi des parseurs PDF : Lire les graphiques et diagrammes pour le RAG

La génération augmentée par récupération (RAG) est devenue un pilier des applications modernes d'IA, permettant aux modèles de langage d'accéder à des bases de connaissances externes. Mais les pipelines RAG traditionnels peinent souvent avec un type d'entrée critique : les PDF contenant des graphiques, diagrammes et données visuelles. Lorsque vous téléchargez un rapport financier ou un article scientifique, l'extraction de texte fonctionne bien, mais les diagrammes à barres, les courbes et les organigrammes restent invisibles pour la base vectorielle. C'est là qu'interviennent les Vision LLM (grands modèles de langage visuels) — ces modèles multimodaux peuvent interpréter les éléments visuels et les rendre interrogeables. Dans cet article, nous explorons comment les Vision LLM peuvent servir de parseurs PDF pour le RAG, transformant des graphiques statiques en données exploitables.

Le problème : pourquoi l'analyse PDF traditionnelle est insuffisante

Les pipelines RAG standards s'appuient sur des outils d'extraction de texte comme PyPDF2, pdfplumber ou des moteurs OCR. Ces outils fonctionnent bien pour les paragraphes et les listes à puces, mais ils ne parviennent pas à capturer les informations encodées dans les éléments visuels. Un graphique montrant la croissance trimestrielle des revenus, un diagramme d'architecture de réseau neuronal, ou une carte avec des données de ventes régionales — tout cela est perdu dans la traduction. Même lorsque l'OCR extrait le texte d'un graphique, il perd les relations spatiales et les motifs visuels qui donnent du sens. Par exemple, la tendance à la hausse d'une courbe n'est pas qu'un ensemble de chiffres ; c'est une histoire visuelle qu'un Vision LLM peut comprendre et décrire.

Comment les Vision LLM comblent le fossé

Les Vision LLM, comme GPT-4V, Google Gemini, et les modèles open source comme LLaVA, peuvent traiter des images et générer des descriptions en langage naturel. Appliqués aux pages PDF, ils peuvent :

• Identifier les types de graphiques (barres, courbes, secteurs, nuages de points).
• Extraire les valeurs numériques et les tendances des axes visuels.
• Décrire les relations entre les points de données.
• Reconnaître les composants des diagrammes (nœuds, flèches, étiquettes).

Ces descriptions peuvent ensuite être découpées et intégrées dans une base vectorielle, les rendant récupérables via une recherche sémantique. Le résultat : un système RAG capable de répondre à des questions comme « Quelle était la tendance des revenus au T3 ? » ou « Quel nœud du diagramme d'architecture se connecte à la couche de sortie ? »

Prérequis

Avant de plonger dans l'implémentation, assurez-vous d'avoir ce qui suit :

• **Python 3.10 ou supérieur** installé sur votre système.
• **Une clé API Vision LLM** (par exemple, clé API OpenAI GPT-4V) ou un accès à un modèle local comme LLaVA (nécessite un GPU).
• **Paquets Python** : `langchain`, `chromadb`, `pypdf2`, `pillow`, `requests`, et `openai` (ou l'équivalent pour votre modèle).
• **Exemples de PDF avec graphiques** pour les tests — vous pouvez utiliser des rapports financiers publics ou des articles scientifiques provenant de sources comme arXiv.

Installation étape par étape

1. Créer un environnement virtuel

Commencez par créer un environnement isolé pour éviter les conflits de dépendances. Ouvrez votre terminal et exécutez :

python -m venv vision_rag_env
source vision_rag_env/bin/activate  # Sur Windows : vision_rag_env\Scripts\activate

Cela crée un environnement Python propre pour notre projet.

2. Installer les paquets Python essentiels

Installez les bibliothèques requises avec pip :

pip install langchain chromadb pypdf2 pillow requests openai

• `langchain` fournit le cadre du pipeline RAG.
• `chromadb` est la base de données vectorielle pour stocker les embeddings.
• `pypdf2` extrait le texte des PDF (pour les parties non visuelles).
• `pillow` gère le traitement d'images.
• `requests` effectue les appels API aux Vision LLM.
• `openai` est la bibliothèque cliente pour les modèles OpenAI (adaptez si vous utilisez un autre fournisseur).

3. Installer les dépendances supplémentaires pour les modèles locaux (optionnel)

Si vous prévoyez d'utiliser un Vision LLM local comme LLaVA, installez des paquets supplémentaires :

pip install transformers torch accelerate bitsandbytes

Cette configuration n'est nécessaire que si vous disposez d'un GPU et souhaitez exécuter des modèles localement pour des raisons de confidentialité ou de coût.

4. Configurer les clés API

Stockez votre clé API en tant que variable d'environnement. Pour OpenAI, exécutez :

export OPENAI_API_KEY="votre-clé-api-ici"

Sur Windows (Invité de commandes) :

set OPENAI_API_KEY="votre-clé-api-ici"

Pour d'autres fournisseurs, ajustez le nom de la variable en conséquence (par exemple, `GOOGLE_API_KEY` pour Gemini).

Exemples d'utilisation

Exemple 1 : Analyser un seul graphique d'un PDF

Nous allons extraire une page contenant un graphique, l'envoyer à un Vision LLM et obtenir une description.

import base64
import requests
from PIL import Image
import io
import PyPDF2
from pdf2image import convert_from_path  # Installer : pip install pdf2image

# Étape 1 : Convertir une page PDF en image
def pdf_page_to_image(pdf_path, page_num):
    images = convert_from_path(pdf_path, first_page=page_num, last_page=page_num)
    return images[0]

# Étape 2 : Encoder l'image en base64
def image_to_base64(image):
    buffered = io.BytesIO()
    image.save(buffered, format="PNG")
    return base64.b64encode(buffered.getvalue()).decode("utf-8")

# Étape 3 : Appeler le Vision LLM (exemple avec OpenAI GPT-4V)
def describe_chart(image_base64):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {openai.api_key}"
    }
    payload = {
        "model": "gpt-4-vision-preview",
        "messages": [
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Décrivez ce graphique en détail. Incluez le type de graphique, les étiquettes des axes, les tendances des données et toute valeur notable."},
                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}}
                ]
            }
        ],
        "max_tokens": 500
    }
    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
    return response.json()["choices"][0]["message"]["content"]

# Utilisation
image = pdf_page_to_image("rapport.pdf", 3)  # La page 3 contient un graphique
image_b64 = image_to_base64(image)
description = describe_chart(image_b64)
print("Description du graphique :", description)

**Explication** : Ce script convertit une page PDF spécifique en image, l'encode et l'envoie à GPT-4V pour description. Le modèle renvoie un résumé en langage naturel du contenu du graphique.

Exemple 2 : Construire un pipeline RAG avec du contenu analysé visuellement

Intégrons maintenant les descriptions dans un pipeline RAG utilisant LangChain et ChromaDB.

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader
import os

# Étape 1 : Charger le PDF et extraire le texte des parties non visuelles
loader = PyPDFLoader("rapport.pdf")
documents = loader.load()

# Étape 2 : Pour chaque page, vérifier si elle contient un graphique (simplifié : on suppose la page 3)
chart_pages = [3]  # En pratique, utilisez un modèle de détection ou un mappage manuel
vision_descriptions = {}

for page_num in chart_pages:
    image = pdf_page_to_image("rapport.pdf", page_num)
    image_b64 = image_to_base64(image)
    desc = describe_chart(image_b64)
    vision_descriptions[page_num] = desc

# Étape 3 : Créer des documents à partir des descriptions
from langchain.schema import Document
vision_docs = []
for page_num, desc in vision_descriptions.items():
    vision_docs.append(Document(page_content=desc, metadata={"source": "rapport.pdf", "page": page_num, "type": "graphique"}))

# Combiner avec les documents texte
all_docs = documents + vision_docs

# Étape 4 : Diviser le texte en morceaux
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = text_splitter.split_documents(all_docs)

# Étape 5 : Créer les embeddings et les stocker dans la base vectorielle
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db")

# Étape 6 : Interroger le système RAG
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

qa = RetrievalQA.from_chain_type(
    llm=OpenAI(),
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

query = "Quelle était la tendance des revenus au T3 selon le graphique ?"
answer = qa.run(query)
print("Réponse :", answer)

**Explication** : Ce pipeline extrait le texte du PDF, ajoute les descriptions générées par vision pour les pages de graphiques, découpe le tout et l'indexe dans ChromaDB. Lorsqu'un utilisateur interroge le contenu d'un graphique, le système récupère la description pertinente et génère une réponse.

Exemple 3 : Gérer les diagrammes avec plusieurs composants

Les diagrammes comme les organigrammes ou les schémas d'architecture nécessitent des descriptions plus structurées. Voici une invite adaptée aux diagrammes :

def describe_diagram(image_base64):
    # Même appel API qu'avant, mais avec une invite spécifique
    prompt = "Décrivez ce diagramme. Listez tous les composants, leurs étiquettes et les connexions entre eux. Utilisez un format structuré comme 'Le nœud A se connecte au nœud B via une flèche pointant vers la droite.'"
    # ... (même appel API avec l'invite mise à jour)

Cette sortie structurée peut être analysée en une représentation graphique pour des requêtes RAG plus précises.

Bonnes pratiques pour l'analyse PDF basée sur la vision

1. **Utilisez des images haute résolution** : Les scans basse résolution dégradent les performances des Vision LLM. Convertissez les pages PDF à 300 DPI pour de meilleurs résultats. 2. **Traitement par lots** : Pour les grands PDF, traitez les pages en parallèle avec des appels asynchrones ou du multiprocessing pour accélérer la génération des descriptions. 3. **Gestion des coûts** : Les appels API des Vision LLM sont plus coûteux que les embeddings de texte. Limitez leur utilisation aux pages susceptibles de contenir des visuels — utilisez une heuristique simple comme la détection d'objets image dans les métadonnées PDF. 4. **Stratégie de repli** : Si un Vision LLM ne parvient pas à analyser un graphique (par exemple, à cause d'une mauvaise qualité), revenez à une extraction OCR pour le texte du graphique, puis reconstruisez le contexte. 5. **Étiquetage des métadonnées** : Étiquetez chaque morceau avec son type de source (texte, graphique, diagramme) afin que votre système RAG puisse prioriser ou filtrer les résultats.

Limites et considérations

• **Précision** : Les Vision LLM ne sont pas parfaits. Ils peuvent halluciner des valeurs ou mal interpréter des types de graphiques complexes (par exemple, les diagrammes circulaires 3D). Validez toujours les données critiques.
• **Latence** : Chaque appel API prend 2 à 5 secondes. Pour un PDF de 100 pages, cela s'accumule. Envisagez d'utiliser des modèles plus petits et plus rapides pour les premiers passages et réservez les modèles puissants pour les cas ambigus.
• **Confidentialité** : L'envoi de pages PDF à des API tierces peut violer les politiques de données. Utilisez des modèles locaux comme LLaVA ou Qwen-VL pour les documents sensibles.
• **Limites de tokens** : Les Vision LLM ont des fenêtres de contexte (par exemple, les 128k tokens de GPT-4V). Pour les très grands graphiques, vous devrez peut-être diviser l'image en plusieurs parties.

Conclusion

Les Vision LLM transforment l'analyse PDF pour le RAG en déverrouillant les informations cachées dans les graphiques, diagrammes et autres éléments visuels. En convertissant des images statiques en descriptions en langage naturel, vous permettez à votre système RAG de répondre à des questions nuancées sur les tendances, les relations et les structures que l'extraction de texte seule manque. L'implémentation est simple : convertissez les pages PDF en images, appelez un Vision LLM avec une invite adaptée, et indexez les descriptions résultantes avec le texte extrait. Bien qu'il y ait des compromis en termes de coût, de latence et de précision, les gains en qualité de récupération sont substantiels pour des domaines comme la finance, la science et l'ingénierie. À mesure que les Vision LLM continuent de s'améliorer, l'analyse PDF deviendra plus visuelle, plus intelligente et plus complète.