Le modèle Gemini 2.0, introduit par Google DeepMind, améliore considérablement le traitement des documents PDF. Comparé aux solutions traditionnelles en termes de précision, de coût et d'évolutivité, Gemini 2.0 optimise considérablement le processus d'analyse du PDF grâce à l'extraction de données structurées, au découpage sémantique et à un traitement par lots efficace, et propose diverses options de modèle pour équilibrer les performances et les coûts.
- Ce résumé est généré par une IA qui analyse le contenu de l'article à des fins d'information uniquement.
Les documents PDF, en tant que support important pour le stockage d'informations d'entreprise et personnelles, ont toujours constitué un défi majeur dans le domaine du traitement des données. Avec l'introduction du modèle Gemini 2.0 par Google DeepMind, ce domaine connaît des changements sans précédent. Dans cet article, nous allons explorer Gemini 2.0 pour voir comment changer complètement le modèle de traitement des PDF, et à travers des exemples de code réels pour montrer comment utiliser cette technologie pour traiter différents types de documents PDF.
Défis traditionnels du traitement des PDF
Depuis longtemps, la conversion de documents PDF en données structurées lisibles par une machine est le "grand problème" de l'IA et du traitement des données. Les solutions traditionnelles peuvent être divisées en trois catégories :
- modèle open source de bout en boutLes personnes qui ont des difficultés à reconnaître les tableaux, les graphiques et les typographies spéciales sont souvent dépassées par la complexité de la mise en page.
- Programme de combinaison multi-modèle: par exemple, nv-ingest de NVIDIA nécessite 8 services et plusieurs GPU à déployer sur Kubernetes, ce qui est non seulement complexe à déployer mais aussi coûteux à programmer.
- Rémunération commerciale à l'acteLes systèmes d'information sur la santé : Bien qu'ils offrent une certaine commodité, la précision n'est pas constante lorsqu'il s'agit de configurations complexes et les coûts augmentent de façon exponentielle lorsqu'ils sont appliqués sur une grande échelle.
Ces solutions ont du mal à trouver un équilibre entre précision, évolutivité et rentabilité, en particulier lorsqu'il s'agit de traiter des centaines de millions de pages de documents, et le coût est souvent prohibitif.

Configuration de l'environnement et installation de Gemini 2.0
Pour commencer à utiliser Gemini 2.0 pour traiter des documents PDF, vous devez d'abord configurer l'environnement et créer un client d'inférence. Voici les étapes spécifiques :
Installer les bibliothèques nécessaires
%pip install "google-genai>=1"
Création de clients et de configurations de modèles
from google import genai
# Créer un client
api_key = "YOUR_API_KEY" # Remplacez par votre clé API.
client = genai.Client(api_key=api_key)
# Définir le modèle à utiliser
model_id = "gemini-2.0-flash" # Utilisez également "gemini-2.0-flash-lite-preview-02-05" ou "gemini-2.0-pro-exp-02-05"
Téléchargement et traitement de fichiers PDF
# Téléchargement d'un fichier PDF
invoice_pdf = client.files.upload(file="invoice.pdf", config={'display_name' : 'invoice'})
# Voir combien de jetons le fichier est converti en
file_size = client.models.count_tokens(model=model_id, contents=invoice_pdf)
print(f'File : {invoice_pdf.display_name} equals to {file_size.total_tokens} tokens')
# Exemple de sortie : File : invoice equals to 821 tokens
Avec les étapes ci-dessus, nous avons terminé la configuration de l'environnement de base et téléchargé avec succès le premier fichier PDF pour traitement. Il convient de noter que l'API Gemini File permet de stocker jusqu'à 20 Go de fichiers par projet, avec un maximum de 2 Go par fichier, et que les fichiers téléchargés sont sauvegardés pendant 48 heures.
Pratique d'extraction de données PDF structurées
Gemini 2.0 offre une fonctionnalité puissante : la possibilité d'extraire des données structurées à partir de fichiers PDF. Nous montrons ci-dessous comment utiliser le modèle Pydantic avec Gemini pour réaliser cette fonction à travers des exemples pratiques.
Définir des méthodes génériques d'extraction de données
Tout d'abord, nous définissons une méthode générique pour traiter les fichiers PDF et renvoyer des données structurées :
def extract_structured_data(file_path : str, model : BaseModel).
# Téléchargement d'un fichier vers l'API File
file = client.files.upload(file=file_path, config={'display_name' : file_path.split('/')[-1].split('.') [0]})
# Génération d'une réponse structurée à l'aide de l'API Gemini
prompt = f "Extraire les données structurées du fichier PDF suivant"
response = client.models.generate_content(model=model_id,
contents=[prompt, file], config={'response_mime_content')
'response_schema' : model})
# transforme la réponse en un modèle Pydantique et le renvoie
return response.parsed
Cas 1 : Extraction des données de la facture
Pour la classe de factures PDF, nous pouvons définir le modèle suivant pour extraire les informations clés :
from pydantic import BaseModel, Field
class Item(BaseModel).
description : str = Field(description="La description de l'article")
quantity : float = Field(description="La quantité de l'article")
gross_worth : float = Field(description="La valeur brute de l'article")
class Invoice(BaseModel).
"""Extraire le numéro de facture, la date et tous les éléments de la liste avec la description, la quantité et la valeur brute, ainsi que la valeur brute totale.""""
invoice_number : str = Field(description="Le numéro de la facture, par exemple 1234567890")
date : str = Field(description="La date de la facture, par exemple 2024-01-01")
items : list[Item] = Field(description="La liste des articles avec leur description, leur quantité et leur valeur brute")
total_gross_worth : float = Field(description="La valeur brute totale de la facture")
# Extraction des données à l'aide de ce modèle
result = extract_structured_data("invoice.pdf", Invoice)
# Sortie des résultats
print(f "Facture extraite : {numéro_de_la_facture} le {date_du_résultat} avec une valeur brute totale {résultat.valeur_brute_totale}")
for item in result.items : print(f "Item : {item_gross_worth}")
print(f "Article : {article.description} avec la quantité {article.quantité} et la valeur brute {article.valeur_brutale}")

Cas 2 : Traitement de formulaires avec contenu manuscrit
Pour les formulaires contenant un contenu manuscrit, nous pouvons également définir des modèles spécialisés :
class Form(BaseModel).
"""Extraire le numéro de formulaire, la date de début d'exercice, la date de fin d'exercice et le passif du plan au début de l'année et à la fin de l'année.""""
form_number : str = Field(description="The Form Number")
start_date : str = Field(description="Date d'entrée en vigueur")
beginning_of_year : float = Field(description="Les engagements du régime au début de l'année")
end_of_year : float = Field(description="Les engagements du régime à la fin de l'année")
# Données extraites
result = extract_structured_data("handwriting_form.pdf", Form)
Résultats de la sortie #
print(f'Extracted Form Number : {result.form_number} with start date {result.start_date}. \nPassif du plan au début de l'année {résultat.début_de_l'année} et à la fin de l'année {résultat.fin_de_l'année}')
# Exemple de sortie : Numéro de formulaire extrait : CA530082 avec date de début 02/05/2022.
# Passif du plan au début de l'année 40000.0 et à la fin de l'année 55000.0
L'exemple ci-dessus montre que Gemini 2.0 peut identifier avec précision le contenu textuel du PDF, y compris le texte manuscrit, et le convertir en un format de données JSON structuré, ce qui simplifie grandement le processus d'extraction des données.
Applications avancées : regroupement de documents et compréhension sémantique
Dans les systèmes RAG (Retrieval Augmented Generation), le découpage des documents est une étape clé en plus de l'extraction de texte de base, et Gemini 2.0 nous permet d'effectuer l'OCR et le découpage sémantique en une seule étape.
Exemple de découpage sémantique du PDF
Voici une astuce pour convertir un PDF en Markdown et faire du chunking sémantique en même temps :
CHUNKING_PROMPT = """OCR la page suivante en Markdown. Les tableaux doivent être formatés en HTML.
N'entourez pas vos résultats de triples crochets.
Découpez le document en sections d'environ 250 à 1000 mots. Notre objectif est le suivant
Notre objectif est d'identifier les parties de la page ayant le même thème sémantique.
Ces morceaux seront intégrés et utilisés dans un pipeline RAG.
Entourez les morceaux avec des balises html .""""
# utilise cette invite pour le traitement
response = client.models.generate_content(
model=model_id,
contents=[CHUNKING_PROMPT, pdf_file]
)
chunked_content = response.text
Cette approche identifie les limites sémantiques d'un document et génère des morceaux de texte plus significatifs, ce qui améliore considérablement la précision de la recherche ultérieure. Par rapport au découpage mécanique traditionnel basé sur le nombre de caractères, le découpage sémantique est mieux à même de maintenir la cohérence et l'intégrité du contenu.
Extraction de données complexes avec Pydantic
Pour des scénarios plus complexes, nous pouvons définir des modèles pydantiques imbriqués afin de gérer plusieurs niveaux de données :
class Person(BaseModel) : first_name : str = Field(description="Le prénom de la personne")
first_name : str = Field(description="Le prénom de la personne")
last_name : str = Champ(description="Le nom de famille de la personne")
last_name : str = Field(description="Le nom de famille de la personne") last_name : str = Field(description="Le nom de famille de la personne")
work_topics : list[Topic] = Field(description="Les domaines d'intérêt de la personne, s'ils ne sont pas renseignés, veuillez renvoyer une liste vide")
# Générer une réponse à l'aide du modèle Personne
prompt = "Philipp Schmid est ingénieur principal chargé des relations avec les développeurs d'IA chez Google DeepMind et travaille sur Gemini, Gemma, dont la mission est d'aider tous les développeurs à construire et à tirer profit de l'IA de manière simple et rapide. à construire et à bénéficier de l'IA de manière responsable."
response = client.models.generate_content(
model=model_id,
contents=prompt,
config={'response_mime_type' : 'application/json', 'response_schema' : Person}
)
Le SDK # convertit automatiquement la réponse en un modèle Pydantic
philipp : Person = response.parsed
print(f "Le prénom est {philipp.first_name}")
Optimisation des performances et bonnes pratiques
Voici quelques bonnes pratiques pour améliorer l'efficacité et la précision du traitement des documents PDF à grande échelle :
Traitement par lots et optimisation des jetons
Si vous devez traiter un grand nombre de scènes PDF, vous pouvez effectuer un traitement par lots pour améliorer l'efficacité :
async def batch_process_pdfs(file_paths, model, batch_size=10): : results = [].
résultats = [].
for i in range(0, len(file_paths), batch_size): : batch = file_paths[i:i+batch_size) : batch = file_paths[i:i
batch = file_paths[i:i+batch_size] : results = [] for i in range(0, len(file_paths), batch_size).
tasks = [extract_structured_data(path, model) for path in batch]
batch_results = await asyncio.gather(*tasks)
results.extend(batch_results)
print(f "Traitement du lot {i//batch_size + 1}/{(len(file_paths)+batch_size-1)//batch_size}")
Retourner les résultats
Sélection du modèle et contrôle des coûts
Le choix d'une variante de modèle adaptée aux besoins réels peut réduire les coûts de manière significative :
- Gemini 2.0 FlashLa solution idéale pour les scénarios d'utilisation générale, avec un excellent rapport prix/performances
- Lampe flash Gemini 2.0Le rapport qualité/prix est plus intéressant pour les documents simples.
- Gemini 2.0 ProLes documents et les scènes extrêmement complexes qui nécessitent une grande précision.
Voici une comparaison de l'efficacité de traitement des différents modèles :
| modélisation | Pages PDF traitées par dollar (conversion Markdown) |
|---|---|
| Gemini 2.0 Flash | Environ 6 000 pages |
| Gemini 2.0 Flash Lite | Environ 12 000 pages |
| Gemini 1.5 Flash | Environ 10 000 pages |
| OpenAI 4-mini | Environ 450 pages |
| OpenAI 4o | Environ 200 pages |
| Claude Anthropique-3.5 | Environ 100 pages |
Traitement des erreurs et mécanisme de réessai
Dans un environnement de production, il est essentiel de mettre en œuvre des mécanismes robustes de gestion des erreurs :
def extract_with_retry(file_path, model, max_retries=3): : for attempt in range(max_retries)
for attempt in range(max_retries).
try.
return extract_structured_data(file_path, model) : for attempt in range(max_retries) : try.
except Exception as e : if attempt == max_retries
if attempt == max_retries - 1 : print(f "Échec de l'accès au fichier.
print(f "Échec du traitement de {chemin_du_fichier} après {max_retries} tentatives : {e}")
return None
print(f "La tentative {tentative+1} a échoué, réessai : {e}")
time.sleep(2 ** attempt) # stratégie exponentielle de réessai

Optimisation du traitement des formes
Pour les PDF contenant des formulaires complexes, les mots-clés suivants peuvent être utilisés pour améliorer la précision de la reconnaissance des formulaires :
TABLE_EXTRACTION_PROMPT = """Extraire tous les tableaux du PDF en tant que tableaux HTML.
Préservez la structure exacte, y compris les cellules fusionnées, les en-têtes et le formatage.
Chaque tableau doit être sémantiquement complet et conserver les relations entre les cellules.
Pour les valeurs numériques, conservez leur format exact tel qu'il apparaît dans le document.""""
remarques finales
Grâce aux méthodes et aux exemples de code présentés dans cet article, vous pouvez déjà commencer à utiliser Gemini 2.0 pour construire un puissant système de traitement de documents PDF. De la simple extraction de texte à l'analyse complexe de données structurées, puis au découpage sémantique, Gemini 2.0 a démontré d'excellentes performances et un très bon rapport coût-efficacité.
Bien que des améliorations soient encore possibles dans des domaines tels que la reconnaissance des boîtes englobantes, nous avons des raisons de croire que le traitement des PDF deviendra de plus en plus intelligent et efficace à mesure que la technologie continuera d'évoluer. Pour tout besoin de traitement à grande échelle de données documentaires pour des particuliers ou des organisations, Gemini 2.0 mérite sans aucun doute l'attention et l'adoption d'avancées technologiques.


评论功能已关闭。