Tu suis la course aux modèles IA ?
Chaque sortie (GPT, Claude, Gemini, Mistral…) décryptée le soir même, en 5 min. Gratuit.
Inclus dès l'inscription : notre sélection des meilleurs guides & comparatifs IA.
Choisis ton rythme
Gratuit · Pas de spam · Désabonnement en 1 clic
Gemma 4 : Une nouvelle approche pour l'analyse des PDF
Les outils traditionnels d'extraction de texte à partir de PDF, comme pdfplumber, rencontrent souvent des difficultés lorsqu'ils sont confrontés à des documents scannés ou à des mises en page complexes. Par exemple, lorsqu'on utilise pdfplumber sur une facture scannée, le résultat est souvent inexistant. De même, pour un article de recherche à colonnes multiples, l'outil perd les relations spatiales essentielles de la mise en page. Quant aux formulaires PDF remplis, ils sont retournés sous forme de texte concaténé, rendant difficile la distinction entre les étiquettes de champ et leurs valeurs respectives.
Ces outils reposent sur l'hypothèse que le PDF contient une couche de texte sélectionnable. Cependant, cette hypothèse échoue dans de nombreux cas, comme avec les documents scannés ou les PDF qui ne contiennent que des images. Dans ces situations, les outils échouent silencieusement, produisant soit une sortie vide, soit un texte illisible, sans indication claire de l'erreur.
L'approche par image : Une solution innovante
L'approche par image propose une solution radicalement différente. En convertissant chaque page PDF en une image haute résolution, cette méthode permet d'alimenter un modèle de vision-langage qui interprète le contenu de la page comme un humain le ferait. Cela élimine le besoin de pipelines complexes de reconnaissance optique de caractères (OCR) ou de parseurs de mise en page.
Le modèle Gemma 4, développé par Google DeepMind et lancé le 2 avril 2026, incarne cette approche. Distribué sous licence Apache 2.0, Gemma 4 inclut le parsing de documents/PDF parmi ses nombreuses capacités, telles que l'OCR, la compréhension de graphiques, la reconnaissance d'écriture manuscrite et la compréhension d'écran. Fonctionnant entièrement en local, il assure que les données ne quittent jamais le serveur de l'utilisateur, éliminant ainsi le besoin de clés API ou d'appels au cloud.
Un pipeline d'entrée de documents locaux
L'un des cas d'utilisation illustratifs de Gemma 4 est le traitement des factures fournisseurs. Le modèle extrait efficacement le nom du fournisseur, le numéro de facture, les lignes d'articles, les totaux et la date d'échéance, et produit un fichier JSON structuré. Cette capacité s'applique aussi bien aux PDF scannés qu'aux PDF numériques.
Pourquoi traiter les PDF comme des images ?
Les PDF se divisent généralement en deux catégories : les PDF numériques et les PDF scannés. Les PDF numériques contiennent une couche de texte intégrée, rendant le texte sélectionnable et extractible. Des outils comme pdfplumber, PyPDF2 et pdfminer fonctionnent bien avec ces documents, restituant le texte dans l'ordre de lecture pour des documents simples à colonne unique.
En revanche, les PDF scannés sont essentiellement des images encapsulées dans un fichier PDF, sans couche de texte. Chaque mot y est représenté par des données de pixels, rendant les outils traditionnels inefficaces. L'approche par image unifie ces deux mondes en rendant chaque page, qu'elle provienne d'un scanner, d'une imprimante ou d'un générateur de PDF, en une image. Le modèle n'a pas besoin de connaître le type de PDF qu'il traite.
La mise en page et la structure
Même pour les PDF numériques avec du texte sélectionnable, les outils d'extraction traditionnels restituent souvent le texte dans un ordre qui perturbe la structure originale. Par exemple, une facture à deux colonnes avec des lignes d'articles à gauche et des totaux à droite peut être restituée de manière désordonnée, rendant l'analyse difficile. Les tableaux avec des cellules fusionnées posent un problème encore plus grand, car le texte extrait perd tout contexte de ligne et de colonne.
Un modèle de vision-langage, en revanche, interprète l'image comme un artefact visuel. Il perçoit les tableaux comme des tableaux, les colonnes comme des colonnes, et les formulaires comme des formulaires, permettant une lecture ligne par ligne des lignes d'articles.
Capacités et exigences matérielles de Gemma 4
Gemma 4 offre des budgets de jetons visuels variables, allant de 70 à 1120 jetons par image, permettant de contrôler le compromis entre précision et vitesse. Pour un parsing de documents dense, le budget de 1120 jetons est recommandé, tandis que pour une classification rapide ou l'extraction d'un seul champ, 280 jetons suffisent et accélèrent le processus.
Le modèle est disponible en quatre tailles, le choix dépendant principalement des capacités matérielles disponibles. Pour un fonctionnement optimal, certaines exigences matérielles sont à respecter :
- GPU VRAM (E4B-it) : 12 Go+ (RTX 3080 Ti / RTX 4080)
- GPU VRAM (E2B-it) : 8 Go+ (RTX 3060 / RTX 4060 Ti)
Bien que l'inférence sur CPU soit possible, elle est lente, prenant entre 30 et 90 secondes par page selon le budget de jetons et la machine. Pour ceux qui n'ont pas de GPU local, le GPU T4 gratuit de Google Colab (15 Go VRAM) est une alternative viable.
Un accès à Hugging Face est nécessaire, car les modèles Gemma 4 sont restreints. Il suffit de créer un compte gratuit sur huggingface.co, de visiter les pages google/gemma-4-E4B-it ou google/gemma-4-E2B-it, et d'accepter les conditions du modèle. Ensuite, un jeton de lecture peut être généré à huggingface.co/settings/tokens.
Installation et configuration
Pour utiliser Gemma 4, certaines dépendances doivent être installées et configurées. Voici les étapes à suivre :
- Python 3.10+ requis
python --version
- Créer un environnement virtuel
python -m venv gemma4-env
source gemma4-env/bin/activate # macOS / Linux
gemma4-env\Scripts\activate # Windows
- Installer les paquets
pip install "transformers>=4.51.0" \
"torch>=2.3.0" \
"accelerate>=0.30.0" \
"pymupdf>=1.24.0" \
"Pillow>=10.0.0" \
"bitsandbytes>=0.43.0"
- Connectez-vous à Hugging Face (collez votre jeton de lecture lorsque vous y êtes invité)
pip install huggingface_hub
huggingface-cli login
Vérification de la configuration
Avant de charger Gemma 4, il est conseillé de vérifier votre environnement de calcul avec le script device_check.py :
def detect_device():
# Détecte le meilleur appareil de calcul disponible.
# Retourne (device_str, dtype, load_kwargs) à utiliser avec from_pretrained.
python device_check.py
Conversion des PDF en images avec PyMuPDF
PyMuPDF (également connu sous le nom de pymupdf ou fitz) est l'outil idéal pour convertir les PDF en images. Il ne nécessite pas de dépendances externes comme Poppler ou Ghostscript, et permet de rendre les pages à une résolution arbitraire en points par pouce (DPI), produisant une sortie compatible avec PIL que le processeur de Gemma 4 accepte directement.
Le DPI joue un rôle crucial. Le rendu par défaut de PyMuPDF est à 72 DPI, ce qui est suffisant pour l'affichage à l'écran, mais insuffisant pour les textes denses. À 200 DPI, tout devient lisible, et à 300 DPI, la qualité est comparable à celle d'un scanner, idéale pour les contenus manuscrits et les documents multilingues avec de petits glyphes. Cependant, une résolution plus élevée entraîne une image plus grande et consomme plus de jetons visuels du contexte de Gemma 4.
Utilisation de pdf_renderer.py
Pour convertir les pages PDF en images, voici comment utiliser pdf_renderer.py :
Prérequis : pip install pymupdf Pillow
Utilisation : importez et instanciez PDFRenderer ; appelez render_page() ou render_all().
from PIL import Image
from pathlib import Path
class PDFRenderer:
# Convertit les pages PDF en images PIL pour l'inférence VLM en aval.
# Pas de dépendances externes au-delà de PyMuPDF -- pas de Poppler, pas de Ghostscript.
# Les images de sortie sont en mode RGB, prêtes pour une utilisation directe avec le processeur de Gemma 4.
def __init__(self, dpi: int = 200):
# dpi : Résolution de rendu.
# 150 -- passage de classification rapide (moins de jetons, qualité inférieure)
# 200 -- standard de production pour le texte tapé et les documents imprimés
# 300 -- haute fidélité, recommandé pour l'écriture manuscrite ou les petits glyphes
self._zoom = dpi / 72.0
self._matrix = pymupdf.Matrix(self._zoom, self._zoom)
def render_page(self, pdf_path: str, page_index: int = 0) -> Image.Image:
# Rendre une seule page PDF en une image PIL.
# pdf_path : Chemin vers le fichier PDF
# page_index : Index de page basé sur zéro (0 = première page)
# PIL.Image.Image en mode RGB, prête pour le processeur de Gemma 4
path = Path(pdf_path)
if not path.exists():
raise FileNotFoundError(f"PDF not found: {pdf_path}")
doc = pymupdf.open(str(path))
if page_index >= len(doc):
raise IndexError(f"Page index {page_index} out of range -- this PDF has {len(doc)} page(s)")
page = doc[page_index]
pix = page.get_pixmap(matrix=self._matrix)
return Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
def render_all(self, pdf_path: str) -> list[Image.Image]:
# Rendre chaque page d'un PDF en une liste d'images PIL.
# Retourne les pages dans l'ordre : index 0 = première page, index -1 = dernière page.
