Extraction d'informations précieuses à partir de PDF : Gemini 2.0 Structured Output Solution

La semaine dernière.Google DeepMind lance Gemini 2.0Il s'agit notamment de Gémeaux 2.0 Flash (entièrement disponible), Gemini 2.0 Flash-Lite (nouveau modèle économique) et Gemini 2.0 Pro (expérimental). Tous les modèles prennent en charge au moins 1 million Jeton de la fenêtre contextuelle d'entrée et prend en charge le texte, l'image et l'audio ainsi que les appels de fonction/la sortie structurée. Ce document sert également de Limites de l'OCR LLM : les défis de l'analyse de documents sous les feux de la rampe Le matériel de lecture de référence.

Cela ouvre la voie à d'excellents cas d'utilisation pour le traitement des PDF. La conversion de PDF en texte structuré ou lisible par une machine a toujours été un défi majeur. Imaginez que nous puissions convertir des documents PDF en données structurées ? C'est là que Gemini 2.0 entre en jeu.

Dans ce tutoriel, le lecteur apprendra à utiliser Gemini 2.0 pour extraire des informations structurées, telles que des numéros de factures, des dates, directement à partir de documents PDF :

1. Mise en place de l'environnement et création du client de raisonnement
2. Traitement des documents PDF et autres
3. Sortie structurée avec Gemini 2.0 et Pydantic
4. Extraction de données structurées à partir de PDF avec Gemini 2.0

1) Mise en place de l'environnement et création du client de raisonnement

La première tâche consiste à installer google-genai SDK Python et obtenir la clé API. Si le lecteur n'a pas encore la clé API, il peut l'obtenir à partir de l'adresse suivante Google AI Studio Obtenir :Obtenir la clé API de Gemini.

%pip install "google-genai>=1"

Une fois en possession du SDK et de la clé API, le lecteur peut créer un client et définir le modèle qui sera utilisé, à savoir le nouveau modèle Gemini 2.0 Flash, qui est disponible via un niveau gratuit avec 1 500 requêtes par jour (au 6 février 2025).

from google import genai
# Create a client
api_key = "XXXXX"
client = genai.Client(api_key=api_key)
 
# Define the model you are going to use
model_id =  "gemini-2.0-flash" # or "gemini-2.0-flash-lite-preview-02-05"  , "gemini-2.0-pro-exp-02-05"

Note : Si le lecteur souhaite utiliser Vertex AI, il lui fautCliquez iciApprendre à créer un client

2. traitement des documents PDF et autres

Le modèle Gemini est capable de traiterImages et vidéosCela peut être fait avec une chaîne de caractères base64 ou en utilisant la fonction files L'API Python comprend des méthodes de téléchargement et de suppression. Après avoir téléchargé un fichier, le lecteur peut inclure l'URI du fichier directement dans l'appel.L'API Python comprend des méthodes de téléchargement et de suppression.

Pour cet exemple, l'utilisateur dispose de 2 échantillons PDF, une facture de base et un formulaire avec des valeurs manuscrites.

!wget -q -O https://storage.googleapis.com/generativeai-downloads/data/pdf_structured_outputs/handwriting_form.pdf
!wget -q -O https://storage.googleapis.com/generativeai-downloads/data/pdf_structured_outputs/invoice.pdf

Le lecteur peut maintenant utiliser le client et upload pour télécharger un fichier. Essayons-la sur l'un des fichiers.

invoice_pdf = client.files.upload(file="invoice.pdf", config={'display_name': 'invoice'})

Remarque : l'API Fichiers permet de stocker jusqu'à 20 Go de fichiers par projet, avec une taille maximale de 2 Go par fichier. Les fichiers sont stockés pendant 48 heures. Pendant cette période, les fichiers peuvent être consultés à l'aide de la clé API de l'utilisateur, mais ne peuvent pas être téléchargés. Le téléchargement de fichiers est gratuit.

Une fois le fichier téléchargé, le lecteur peut vérifier en combien de tokens il a été converti, ce qui permet non seulement de comprendre le contexte dans lequel l'utilisateur évolue, mais aussi de suivre les coûts.

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')
# File: invoice equals to 821 tokens

3. sortie structurée à l'aide de Gemini 2.0 et Pydantic

La sortie structurée est une fonction qui garantit que Gemini génère toujours une réponse conforme à un format prédéfini, tel qu'un schéma JSON. Cela signifie que l'utilisateur a plus de contrôle sur la sortie et sur la manière dont elle est intégrée dans l'application, car il est garanti que la réponse renvoie des objets JSON valides avec un schéma défini par l'utilisateur.

Gemini 2.0 prend actuellement en charge 3 types différents de définitions de schémas JSON :

• Un seul type Python, comme dans le fichier annotation de typage Le même que celui utilisé dans la
• Pydantique Modèle de base
• genai.types.Schema / Modèle de base pydantique équivalent dictionnaire

Prenons un exemple rapide de texte.

from pydantic import BaseModel, Field
 
# Define a Pydantic model
# Use the Field class to add a description and default value to provide more context to the model
class Topic(BaseModel):
    name: str = Field(description="The name of the topic")
 
class Person(BaseModel):
    first_name: str = Field(description="The first name of the person")
    last_name: str = Field(description="The last name of the person")
    age: int = Field(description="The age of the person, if not provided please return 0")
    work_topics: list[Topic] = Field(description="The fields of interest of the person, if not provided please return an empty list")
 
 
# Define the prompt
prompt = "Philipp Schmid is a Senior AI Developer Relations Engineer at Google DeepMind working on Gemini, Gemma with the mission to help every developer to build and benefit from AI in a responsible way.  "
 
# Generate a response using the Person model
response = client.models.generate_content(model=model_id, contents=prompt, config={'response_mime_type': 'application/json', 'response_schema': Person})
 
# print the response as a json string
print(response.text)
 
# sdk automatically converts the response to the pydantic model
philipp: Person = response.parsed
 
# access an attribute of the json response
print(f"First name is {philipp.first_name}")

4. extraire des données structurées d'un PDF à l'aide de Gemini 2.0

Combinons maintenant l'API Fichier avec une sortie structurée pour extraire des informations du PDF. L'utilisateur peut créer une méthode simple qui prend un chemin de fichier local et un modèle Pydantic et renvoie des données structurées à l'utilisateur. La méthode.. :

1. Téléchargement de fichiers vers l'API Fichiers
2. utiliser API Gemini Générer une réponse structurée
3. Convertit la réponse en un modèle Pydantique et renvoie le modèle

def extract_structured_data(file_path: str, model: BaseModel):
    # Upload the file to the File API
    file = client.files.upload(file=file_path, config={'display_name': file_path.split('/')[-1].split('.')[0]})
    # Generate a structured response using the Gemini API
    prompt = f"Extract the structured data from the following PDF file"
    response = client.models.generate_content(model=model_id, contents=[prompt, file], config={'response_mime_type': 'application/json', 'response_schema': model})
    # Convert the response to the pydantic model and return it
    return response.parsed

Dans l'exemple, chaque PDF est différent des autres. Par conséquent, l'utilisateur doit définir un modèle pydantique unique pour chaque PDF afin de démontrer les performances de Gemini 2.0. Si l'utilisateur a des PDF très similaires et souhaite extraire les mêmes informations, le même modèle peut être utilisé pour tous les PDF.

• Invoice.pdfExtrait le numéro de la facture, la date et tous les éléments de la liste, y compris la description, la quantité, la valeur totale et la valeur brute totale.
• handwriting_form.pdfLes données de l'année sont les suivantes : numéro du formulaire de retrait, date de début du régime et engagements du régime au début et à la fin de l'année.

Note : En utilisant la fonctionnalité Pydantic, les utilisateurs peuvent ajouter plus de contexte au modèle pour le rendre plus précis et effectuer une certaine validation des données. L'ajout d'une description complète peut améliorer de manière significative les performances du modèle. Les bibliothèques telles que l'instructeur ajoutent des tentatives automatiques basées sur les erreurs de validation, ce qui peut être très utile, mais ajoute des coûts de requête supplémentaires.

Facture.pdf

from pydantic import BaseModel, Field
 
class Item(BaseModel):
    description: str = Field(description="The description of the item")
    quantity: float = Field(description="The Qty of the item")
    gross_worth: float = Field(description="The gross worth of the item")
 
class Invoice(BaseModel):
    """Extract the invoice number, date and all list items with description, quantity and gross worth and the total gross worth."""
    invoice_number: str = Field(description="The invoice number e.g. 1234567890")
    date: str = Field(description="The date of the invoice e.g. 2024-01-01")
    items: list[Item] = Field(description="The list of items with description, quantity and gross worth")
    total_gross_worth: float = Field(description="The total gross worth of the invoice")
 
 
result = extract_structured_data("invoice.pdf", Invoice)
print(type(result))
print(f"Extracted Invoice: {result.invoice_number} on {result.date} with total gross worth {result.total_gross_worth}")
for item in result.items:
    print(f"Item: {item.description} with quantity {item.quantity} and gross worth {item.gross_worth}")

Fantastique ! Le modèle fait un excellent travail d'extraction d'informations à partir des factures.

formulaire_écriture_main.pdf

class Form(BaseModel):
    """Extract the form number, fiscal start date, fiscal end date, and the plan liabilities beginning of the year and end of the year."""
    form_number: str = Field(description="The Form Number")
    start_date: str = Field(description="Effective Date")
    beginning_of_year: float = Field(description="The plan liabilities beginning of the year")
    end_of_year: float = Field(description="The plan liabilities end of the year")
 
result = extract_structured_data("handwriting_form.pdf", Form)
 
print(f'Extracted Form Number: {result.form_number} with start date {result.start_date}. \nPlan liabilities beginning of the year {result.beginning_of_year} and end of the year {result.end_of_year}')
# Extracted Form Number: CA530082 with start date 02/05/2022. 
# Plan liabilities beginning of the year 40000.0 and end of the year 55000.0

Bonnes pratiques et limites

Lorsque vous utilisez Gemini 2.0 pour le traitement des PDF, gardez à l'esprit les considérations suivantes :

1. Gestion de la taille des fichiers : bien que l'API File prenne en charge les fichiers volumineux, la meilleure pratique consiste à optimiser les PDF avant de les télécharger.
2. Limites de jetons : lorsque vous travaillez avec des documents volumineux, vérifiez le nombre de jetons pour vous assurer que les utilisateurs restent dans les limites du modèle et du budget.
3. Conception d'une sortie structurée : le modèle pydantique de l'utilisateur est soigneusement conçu pour capturer toutes les informations nécessaires tout en restant clair ; l'ajout de descriptions et d'exemples peut améliorer les performances du modèle.
4. Gestion des erreurs : mise en œuvre d'une gestion robuste des erreurs pour le téléchargement et le traitement des fichiers, y compris la relance et la gestion des messages d'erreur provenant des modèles.

rendre un verdict

Les capacités multimodales de Gemini 2.0, combinées à une sortie structurée, aident les utilisateurs à traiter et à extraire des informations à partir de PDF et d'autres documents. Cela permet d'éliminer les processus d'extraction de données manuels ou semi-automatiques complexes et fastidieux. Que vous construisiez un système de traitement de factures, un outil d'analyse de documents ou toute autre application centrée sur les documents, vous devriez essayer Gemini 2.0 car son test est gratuit dans un premier temps, puis seulement 0,1 dollar par million de jetons d'entrée. Google souligne que l'essai de Gemini 2.0 est gratuit dans un premier temps et qu'il ne coûte ensuite que 0,1 dollar par million de tokens, ce qui abaisse certainement la barrière qui empêche les utilisateurs d'essayer la nouvelle technologie, mais la rentabilité à long terme reste à voir.