Extraction des données de documents non structurés

Auteur (s): Felix Pappe

Publié à l’origine sur Vers l’IA.

Introduction

Dans le passé, l’extraction d’informations spécifiques de documents ou d’images utilisant des méthodes traditionnelles aurait pu devenir rapidement lourde et frustrante, surtout lorsque les résultats finaux s’éloignent de ce que vous vouliez. Les raisons de cela peuvent être diverses, allant des dispositions de documents trop complexes aux fichiers mal formatés, ou une avalanche d’éléments visuels, que les machines ont du mal à interpréter.

Cependant, les modèles de langue compatible Vision (VLMS) sont venus à la rescousse. Au cours des derniers mois et années, ces modèles ont acquis des capacités toujours plus grandes, des descriptions d’images approximatives à l’extraction de texte détaillée. Notamment, l’extraction d’informations textuelles complexes à partir d’images a connu des progrès étonnants. Cela permet une extraction rapide des connaissances à partir de divers types de documents sans systèmes cassants basés sur des règles qui se cassent dès que la structure des documents change – et sans la formation spécialisée à forte intensité de temps, de données et de coût des modèles personnalisés.

Cependant, il y a un défaut: les VLM, comme leurs homologues en texte uniquement, ont tendance à produire une sortie verbale autour des informations que vous souhaitez réellement. Phrases telles que « Bien sûr, voici les informations que vous avez demandées » ou « Ce sont les informations extraites sur XYZ » entoure généralement le contenu essentiel.

Vous pouvez utiliser des expressions régulières ainsi que l’ingénierie rapide avancée pour contraindre le VLM à la sortie uniquement des informations demandées. Cependant, la fabrication de l’invite parfaite et le regex correspondant pour une tâche donnée sont difficiles et nécessitent beaucoup d’essais et d’erreurs. Dans ce billet de blog, je voudrais introduire une approche plus simple: combiner les riches capacités de VLLMS avec la validation stricte offerte par les classes pyndantes pour extraire exactement les informations souhaitées pour votre pipeline de traitement de documents.

Description du problème de la publication

L’exemple de cet article de blog décrit une situation que chaque emploi Le demandeur a probablement connu plusieurs fois. J’en suis sûr.
Après avoir soigneusement et soigneusement créé votre CV, en pensant à chaque mot et peut-être même à chaque lettre, vous téléchargez le fichier sur un portail d’emploi. Mais après avoir réussi à télécharger le fichier, y compris toutes les informations demandées, il vous est demandé à nouveau de remplir les mêmes détails dans les formulaires HTML standard en copiant et en collant les informations de votre CV dans les champs corrects.
Certaines entreprises tentent de faire automatiquement ces champs en fonction des informations extraites de votre CV, mais les résultats sont souvent loin d’être précis ou complets.

Dans le code suivant, je combine Pixtral, Langchain et Pydontic pour fournir une solution simple.
Le code extrait le prénom, le nom de famille, le numéro de téléphone, le courrier électronique et l’anniversaire du CV s’ils existent. Cela permet de garder l’exemple simple et se concentre sur les aspects techniques.
Le code peut être facilement adapté pour d’autres cas d’utilisation ou étendus pour extraire toutes les informations requises d’un CV.

Plongeons donc dans le code.

Procédure pas à pas de code

Importation de bibliothèques requises

Dans la première étape, les bibliothèques requises sont importées, notamment:

• os, pathlibet typing Pour les modules Python standard fournissant l’accès au système de fichiers et les annotations de type
• base64 Pour coder les données d’image binaires sous forme de texte
• dontenv pour charger des variables d’environnement à partir d’un .env déposer os.environ
• pydantic pour définir un schéma pour le structuré LLM sortir
• ChatMistralAI de l’intégration Mistral de Langchain comme la vision comparée LLM interface
• PIL pour ouvrir et redimensionner les images

import os
import base64
from pathlib import Path
from typing import Optional
from dotenv import load_dotenv
from pydantic import BaseModel, Field
from langchain_mistralai.chat_models import ChatMistralAI
from langchain_core.messages import HumanMessage
from PIL import Image

Variables d’environnement de chargement

Par la suite, les variables d’environnement sont chargées en utilisant load_dotenv()et le MISTRAL_API_KEY est récupéré.

load_dotenv()
MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
if not MISTRAL_API_KEY:
raise ValueError("MISTRAL_API_KEY not set in environment")

Définition du schéma de sortie avec pydance

Suite à cela, le schéma de sortie est défini à l’aide de pyndantique. Pydontic est une bibliothèque Python pour l’analyse de données et la validation basée sur des conseils de type Python. À la base, Pydantic BaseModel offre diverses fonctionnalités utiles, telles que la déclaration de types de données (par exemple str, int, List(str)modèles imbriqués, etc.) et la contrainte automatique des données entrantes dans les types requis si possible (par exemple, la conversion "102" dans 102).
De plus, il valide si les données entrantes correspondent au schéma prédéfini et soulèvent une erreur si ce n’est pas le cas. Grâce à ces schémas clairement définis, les données peuvent être rapidement sérialisées en d’autres formats tels que JSON. De même, Pydontic permet également la création de champs de documents avec des métadonnées que des outils tels que les LLM peuvent inspecter et utiliser.
Le bloc de code suivant définit la structure de la sortie attendue à l’aide de pydontic. Ce sont les points de données que le modèle doit extraire de l’image CV.

class BasicCV(BaseModel):
first_name: Optional(str) = Field(None, description="first name")
last_name: Optional(str) = Field(None, description="last name")
phone: Optional(str) = Field(None, description="Telephone number")
email: Optional(str) = Field(None, description="Email address")
birthday: Optional(str) = Field(None, description="Date of birth (e.g., YYYY-MM-DD)")

Convertir des images en base64

Par la suite, la première fonction est définie pour le script. La fonction encode_image_to_base64() Fait exactement ce que son nom suggère. Il charge une image et le convertit en une chaîne Base64, qui est transmise dans le VLM plus tard.

De plus, un facteur d’échelle a été intégré. Bien qu’aucune information supplémentaire ne soit obtenue en augmentant simplement la hauteur et la largeur, selon mon expérience, les résultats ont tendance à s’améliorer, en particulier dans les situations où la résolution originale de l’image est faible.

def encode_image_to_base64(image_path: Path, upscale_factor: float = 1.0) -> str:
with Image.open(image_path) as img:
if upscale_factor != 1.0:
new_size = (int(img.width * upscale_factor), int(img.height * upscale_factor))
img = img.resize(new_size, Image.LANCZOS)
from io import BytesIO
buffer = BytesIO()
img.save(buffer, format="PNG")
image_bytes = buffer.getvalue()
return base64.b64encode(image_bytes).decode()

Traitement du CV avec un modèle de langue de vision

Passons maintenant à la fonction principale de ce script. Le process_cv() La fonction commence par initialiser l’interface Mistral à l’aide d’une clé API générée précédemment. Ce modèle est ensuite enveloppé en utilisant le .with_structured_output(BasicCV) Fonction, dans laquelle le modèle pydatique défini ci-dessus est passé comme entrée. Si vous utilisez un VLM différent, assurez-vous qu’il prend en charge la sortie structurée, comme tous les VLM ne le font pas.

Ensuite, l’image d’entrée est convertie en une chaîne Base64 (B64), qui est ensuite transformée en un identifiant de ressource uniforme (URI) en fixant une chaîne de métadonnées devant la chaîne B64.

Ensuite, une simple invite de système est définie, ce qui laisse la place à l’amélioration des tâches d’extraction plus complexes mais fonctionne parfaitement pour ce scénario.

Enfin, l’uri et l’invite du système sont combinés dans un langchain HumanMessagequi est transmis au VLM structuré. Le modèle renvoie ensuite les informations demandées au format pydatique précédemment défini.

def process_cv(
image_path: Path,
api_key: Optional(str) = None
) -> BasicCV:
llm = ChatMistralAI(
model="pixtral-12b-latest",
mistral_api_key=api_key or MISTRAL_API_KEY,
)
structured_llm = llm.with_structured_output(BasicCV)
image_b64 = encode_image_to_base64(image_path)
data_uri = f"data:image/png;base64,{image_b64}"
system_text = (
"Extract only the following fields from this CV: first name, last name, "
"telephone number, email address, and birthday. Return JSON matching the schema."
)
message = HumanMessage(
content=(
{"type": "text", "text": system_text},
{"type": "image_url", "image_url": data_uri},
)
)
result: BasicCV = structured_llm.invoke((message))
return result

Exécuter le script

Cette fonction est exécutée par le principal, où le chemin est défini et les informations finales sont imprimées.

if __name__ == "__main__":
image_file = Path("cv-test.png")
cv_data = process_cv(image_file)
print(f"First Name: {cv_data.first_name}")
print(f"Last Name: {cv_data.last_name}")
print(f"Phone: {cv_data.phone}")
print(f"Email: {cv_data.email}")
print(f"Birthday: {cv_data.birthday}")

Conclusion

Ce simple script Python ne fournit qu’une première impression de la puissance des VLMS et flexibles. En combinaison avec Pyndantic et avec le support du puissant cadre de Langchain, les VLM peuvent être transformés en une solution significative pour de nombreux flux de travail de traitement de documents, tels que le traitement des applications ou la manipulation des factures.

Quelle expérience avez-vous eue avec des modèles de langue de grande envergure Vision?
Avez-vous d’autres champs à l’esprit où un tel flux de travail pourrait être bénéfique?

Source

felix-pappe.medium.com/subscribe 🔔
www.linkedin.com/in/felix-pappe 🔗
https://felixpappe.de🌐

Publié via Vers l’IA