Paligemma 2 Mix: un guide avec un projet de démo OCR

Le mélange Paligemma 2 est un modèle d'IA multimodal développé par Google. Il s'agit d'une version améliorée du modèle de langage de vision Paligemma (VLM), intégrant les capacités avancées du modèle Siglip Vision et des modèles de langue Gemma 2.

Dans ce tutoriel, je vais expliquer comment utiliser Paligemma 2 Mix pour construire un scanner de factures et un analyseur de dépenses alimenté par AI capable de:

• Extraction et catégoriser les dépenses des reçus de facture.
• Effectuer la reconnaissance des caractères optiques (OCR) pour récupérer les informations clés.
• résumer les dépenses basées sur des images fournies.

Bien que nous nous concentrons sur la création d'un outil d'insistance financière, vous pouvez utiliser ce que vous apprenez dans ce blog pour explorer d'autres cas d'utilisation de mix Paligemma 2, tels que la segmentation de l'image, la détection d'objets et la réponse aux questions.

Qu'est-ce que Paligemma 2 Mix?

Le mix Paligemma 2 est un modèle avancé de vision-langage (VLM) qui traite à la fois les images et le texte en entrée et génère des sorties de texte. Il est conçu pour gérer une gamme diversifiée de tâches d'IA multimodales tout en prenant en charge plusieurs langues.

Paligemma 2 est conçu pour un large éventail de tâches de langue visuelle, y compris l'image et le sous-titrage vidéo court, la réponse à la question visuelle, la reconnaissance des caractères optiques (OCR), la détection d'objets et la segmentation.

Source des images utilisées dans le diagramme: Google

Le modèle de mélange Paligemma 2 est conçu pour:

• Image et bref sous-titrage vidéo: générer des légendes précises et consacrées au contexte pour les images statiques et les courtes vidéos.
• Réponse de question visuelle (VQA): analyse des images et réponse aux questions basées sur le texte basées sur le contenu visuel.
• Reconnaissance optique des caractères (OCR): extraire et interpréter le texte des images, ce qui le rend utile pour les documents, les reçus et les matériaux numérisés.
• Détection et segmentation des objets: il identifie, étiquette et segments des objets dans une image d'analyse structurée.
• Prise en charge multi-langues: le modèle permet également la génération de texte et la compréhension dans plusieurs langues pour les applications globales.

Vous pouvez trouver plus d'informations sur le modèle de mix Paligemma 2 dans l'article de version officielle. 

Présentation du projet: Scanner de factures et analyseur de dépenses avec Paligemma 2 Mix

Décrivons les principales étapes que nous allons prendre:

1. Chargez et préparez l'ensemble de données: le processus commence par charger et préparer des images de réception en entrée.
2. Initialiser le modèle de mix Paligemma 2: nous configurons et chargeons le modèle pour traiter les tâches de langue visuelle.
3. Traitez les images d'entrée: ensuite, convertissez les images en format approprié (RVB) et préparez-les à l'analyse.
4. Extraire Informations clés: effectuer la reconnaissance des caractères optiques (OCR) pour récupérer le montant total.
5. Catégoriser les dépenses: classer les achats dans des catégories comme l'épicerie, les vêtements, l'électronique et autres.
6. Générer des informations sur les dépenses: nous résumons les dépenses catégorisées et générons un tableau de distribution de dépenses.
7. Créer une interface Gradio interactive: Enfin, nous créons une interface utilisateur où les utilisateurs peuvent télécharger plusieurs factures, extraire des données et analyser les dépenses visuellement.

Étape 1: Prérequis

Avant de commencer, assurez-vous que nous avons installé les outils et bibliothèques suivants:

• python 3.8
• torche
• Transformers
• pil
• matplotlib
• Gradio

Exécutez les commandes suivantes pour installer les dépendances nécessaires:

pip install gradio -U bitsandbytes -U transformers -q

Une fois les dépendances ci-dessus installées, exécutez les commandes d'importation suivantes:

import gradio as gr
import torch
import pandas as pd
import matplotlib.pyplot as plt
from transformers import PaliGemmaForConditionalGeneration, PaliGemmaProcessor, BitsAndBytesConfig
from transformers import BitsAndBytesConfig
from PIL import Image
import re

Étape 2: Initialisation du modèle

Nous configurons et chargeons le modèle de mélange Paligemma 2 avec la quantification pour optimiser les performances. Pour cette démo, nous utiliserons le modèle de paramètre 10b avec une résolution d'image d'entrée 448 x 448. Vous avez besoin d'un minimum de GPU T4 avec une mémoire de 40 Go (configuration Colab) pour exécuter ce modèle. 

device = "cuda" if torch.cuda.is_available() else "cpu"
# Model setup
model_id = "google/paligemma2-10b-mix-448" 
bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,  # Change to load_in_4bit=True for even lower memory usage
    llm_int8_threshold=6.0,
)

# Load model with quantization
model = PaliGemmaForConditionalGeneration.from_pretrained(
    model_id, quantization_config=bnb_config
).eval()

# Load processor
processor = PaliGemmaProcessor.from_pretrained(model_id)
# Print success message
print("Model and processor loaded successfully!")

La quantification des bitsandbytes aide à réduire l'utilisation de la mémoire tout en maintenant les performances, ce qui permet d'exécuter de grands modèles sur des ressources GPU limitées. Dans cette implémentation, nous utilisons la quantification 4 bits pour optimiser davantage l'efficacité de la mémoire.

Nous chargeons le modèle à l'aide de la classe PaligemMaforConditionAlGeneration de la bibliothèque Transformers en transmettant l'ID du modèle et la configuration de quantification. De même, nous chargeons le processeur, qui prépare les entrées dans les tenseurs avant de le passer au modèle.

Étape 3: Traitement d'images

Une fois les éclats du modèle chargés, nous traitons les images avant de les transmettre au modèle pour maintenir la compatibilité du format d'image et gagner l'uniformité. Nous convertissons les images au format RVB:

def ensure_rgb(image: Image.Image) -> Image.Image:
    if image.mode != "RGB":
        image = image.convert("RGB")
    return image

Maintenant, nos images sont prêtes à l'inférence.

Étape 4: Inférence avec Paligemma

Maintenant, nous avons configuré la fonction principale pour exécuter l'inférence avec le modèle. Cette fonction prend en place des images et des questions d'entrée, les intègre dans des invites et les transmet au modèle via le processeur pour l'inférence.

def ask_model(image: Image.Image, question: str) -> str:
    prompt = f"<image> answer en {question}"
    inputs = processor(text=prompt, images=image, return_tensors="pt").to(device)
    with torch.inference_mode():
        generated_ids = model.generate(
            **inputs,
            max_new_tokens=50,
            do_sample=False
        )
    result = processor.batch_decode(generated_ids, skip_special_tokens=True)
    return result[0].strip()</image>

Étape 5: Extraction d'informations clés

Maintenant que nous avons la fonction principale prête, nous travaillerons ensuite sur l'extraction des paramètres clés de l'image - dans notre cas, ce sont la catégorie totale de montants et de marchandises.

pip install gradio -U bitsandbytes -U transformers -q

La fonction extract_total_amount () traite une image pour extraire la quantité totale d'un reçu en utilisant OCR. Il construit une requête (question) demandant au modèle d'extraire uniquement des valeurs numériques, puis il appelle la fonction ASK_MODEL () pour générer une réponse à partir du modèle. 

import gradio as gr
import torch
import pandas as pd
import matplotlib.pyplot as plt
from transformers import PaliGemmaForConditionalGeneration, PaliGemmaProcessor, BitsAndBytesConfig
from transformers import BitsAndBytesConfig
from PIL import Image
import re

La fonction catégorize_goods () classe le type de biens dans une image en invitant le modèle avec une question prédéfinie énumérant les catégories possibles: épicerie, vêtements, électronique ou autre. La fonction ASK_MODEL () traite ensuite l'image et renvoie une réponse textuelle. Si la réponse traitée correspond à l'une des catégories valides prédéfinies, elle renvoie cette catégorie - autrement, elle par défaut la catégorie "autre".

Étape 6: Analyse des informations

Nous avons toutes les fonctions clés prêtes, alors analysons les sorties.

device = "cuda" if torch.cuda.is_available() else "cpu"
# Model setup
model_id = "google/paligemma2-10b-mix-448" 
bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,  # Change to load_in_4bit=True for even lower memory usage
    llm_int8_threshold=6.0,
)

# Load model with quantization
model = PaliGemmaForConditionalGeneration.from_pretrained(
    model_id, quantization_config=bnb_config
).eval()

# Load processor
processor = PaliGemmaProcessor.from_pretrained(model_id)
# Print success message
print("Model and processor loaded successfully!")

La fonction ci-dessus crée un graphique à secteurs pour visualiser la distribution des dépenses entre différentes catégories. Si aucune données de dépenses valides n'existe, elle génère un chiffre vide avec un message indiquant «pas de données de dépenses». Sinon, il crée un graphique à secteurs avec des étiquettes de catégorie et des valeurs de pourcentage, garantissant une visualisation proportionnelle et bien alignée.

Étape 6: Analyser plusieurs factures simultanément

Nous avons généralement plusieurs factures à analyser, alors créons une fonction pour traiter toutes nos factures simultanément.

def ensure_rgb(image: Image.Image) -> Image.Image:
    if image.mode != "RGB":
        image = image.convert("RGB")
    return image

Pour analyser plusieurs factures à la fois, nous effectuons les étapes suivantes:

1. Initialiser le stockage: nous créons des listes pour le stockage des résultats et des images, définissez Total_spending sur 0 et définissons un dictionnaire pour les totaux de catégorie.
2. traiter chaque facture:

• ouvrir et convertir l'image en RGB.
• Ajoutez l'image à la liste.
• Extraire le montant total de la réception.
• Catégorisez les marchandises dans la réception.
• Mettez à jour les dépenses totales et les totaux par catégorie.
• Stockez les données extraites dans une liste de résultats.

3. Générons des informations: nous créons un graphique à secteurs de distribution de dépenses ainsi qu'un résumé des dépenses totales.
4. Retour Résultats: Enfin, nous renvoyons la liste des images, un dataframe des résumés de factures, le résumé des dépenses totales et le tableau des dépenses.

Étape 7: Construisez l'interface Gradio

Maintenant, nous avons toutes les fonctions de logique clés en place. Ensuite, nous travaillons sur la construction d'une interface utilisateur interactive avec Gradio.

def ask_model(image: Image.Image, question: str) -> str:
    prompt = f"<image> answer en {question}"
    inputs = processor(text=prompt, images=image, return_tensors="pt").to(device)
    with torch.inference_mode():
        generated_ids = model.generate(
            **inputs,
            max_new_tokens=50,
            do_sample=False
        )
    result = processor.batch_decode(generated_ids, skip_special_tokens=True)
    return result[0].strip()</image>

Le code ci-dessus crée une interface utilisateur de gradio structurée avec un téléchargeur de fichiers pour plusieurs images et un bouton de soumission pour déclencher le traitement. Lors de la soumission, les images de factures téléchargées sont affichées dans une galerie, les données extraites sont affichées dans un tableau, les dépenses totales sont résumées dans le texte et un graphique à secteurs de distribution de dépenses est généré. 

La fonction connecte les entrées utilisateur à la fonction process_multiple_bills (), assurant une extraction et une visualisation de données transparentes. Enfin, la fonction démo.launch () démarre l'application Gradio pour l'interaction en temps réel.

J'ai également essayé cette démo avec deux factures basées sur l'image (Amazon Shopping Facture) et j'ai obtenu les résultats suivants.

Remarque: les VLM ont du mal à extraire des nombres, ce qui peut parfois entraîner des résultats incorrects. Par exemple, il a extrait le mauvais montant total pour le deuxième projet de loi ci-dessous. Ceci est corrigeable avec l'utilisation de modèles plus grands ou tout simplement affiner ceux existants.

Conclusion

Dans ce didacticiel, nous avons construit un scanner de factures multiples alimenté en AI à l'aide de Paligemma 2 Mix, qui peut nous aider à extraire et classer nos dépenses à partir de reçus. Nous avons utilisé les capacités de langue visuelle de Paligemma 2 Mix pour l'OCR et la classification pour analyser les informations sur les dépenses sans effort. Je vous encourage à adapter ce tutoriel à votre propre cas d'utilisation. 

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!