Extraction de données structurées à partir d'images
Šiame puslapyje
Transforme les images en données exploitables
La leçon précédente se concentrait sur la transcription de texte ; celle-ci va plus loin en produisant des données structurées. Extraire des données structurées signifie transformer le contenu visuel d’une image — un tableau, un formulaire, une carte de visite ou une étiquette — en JSON, CSV ou tout autre format que ton code peut manipuler directement, sans relecture manuelle.
Les enjeux sont plus élevés. Une transcription approximative peut encore aider un lecteur humain, mais l’absence d’une seule clé dans une réponse JSON fera planter le programme qui la consomme. Cette leçon couvre les deux garanties que tu dois mettre en œuvre : le mode JSON de l’API pour la validité syntaxique, et la validation de schéma pour la conformité métier.
Le mode JSON de l’API
Mistral propose un paramètre response_format qui force le modèle à renvoyer du JSON valide. Sans cela, tu perdras du temps à nettoyer des réponses enveloppées dans des blocs Markdown ou précédées de phrases d’introduction polies.
from mistralai.client import Mistral
import os
import json
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
response = client.chat.complete(
model="mistral-large-latest",
response_format={"type": "json_object"},
messages=[
{
"role": "system",
"content": "Always return a valid JSON object with the data extracted from the image."
},
{
"role": "user",
"content": [
{
"type": "text",
"text": "Extract the following data from this business card as JSON: name, title, company, email, phone, address."
},
{"type": "image_url", "image_url": data_uri_carte}
]
}
]
)
# Le résultat est directement analysable
donnees = json.loads(response.choices[0].message.content)
print(json.dumps(donnees, indent=2, ensure_ascii=False))
L’appel json.loads s’exécute sans précautions particulières : response_format={"type": "json_object"} garantit une sortie JSON syntaxiquement valide. Cependant, cela ne garantit pas la présence de telles ou telles clés. C’est pourquoi tu dois décrire le format attendu dans le prompt lui-même, comme le montrent les exemples ci-dessous.
Extraire un tableau depuis une image
Les tableaux photographiés ou les captures d’écran constituent un cas d’usage courant, et c’est là qu’un schéma explicite rapporte le plus. Sans instructions claires, le modèle inventera sa propre structure, qui pourra différer à chaque appel.
prompt_tableau = """Extract the content of this table as JSON.
Expected format:
{
"columns": ["Column1", "Column2", ...],
"rows": [
{"Column1": "value", "Column2": "value"},
...
]
}
Read all visible rows. If a cell is empty, use null."""
response = client.chat.complete(
model="mistral-large-latest",
response_format={"type": "json_object"},
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": prompt_tableau},
{"type": "image_url", "image_url": encoder_image("captures/tableau-excel.png")}
]
}
]
)
donnees = json.loads(response.choices[0].message.content)
print(f"Columns: {donnees['columns']}")
print(f"Number of rows: {len(donnees['rows'])}")
L’instruction concernant les cellules vides est cruciale. Sans elle, le modèle pourrait décaler les valeurs pour combler les trous, faussant ainsi le tableau. L’affichage du nombre de lignes offre une vérification immédiate : si l’image montre douze lignes mais que le script en rapporte huit, l’extraction est incomplète.
Formulaires et documents administratifs
Les formulaires remplis introduisent deux défis : l’écriture manuscrite et les cases à cocher, qui n’ont pas de valeur textuelle. Ton schéma doit donc inclure des champs dédiés pour ces éléments.
prompt_formulaire = """Analyze this filled form and extract all fields and their values.
Expected JSON format:
{
"form_type": "...",
"fields": {
"field_name": "entered_value",
...
},
"checked_boxes": ["field1", "field2"],
"signature_present": true/false
}
If a field is empty or illegible, use null."""
response = client.chat.complete(
model="mistral-large-latest",
response_format={"type": "json_object"},
messages=[
{
"role": "system",
"content": "You are a precise form extractor. Return structured JSON."
},
{
"role": "user",
"content": [
{"type": "text", "text": prompt_formulaire},
{"type": "image_url", "image_url": encoder_image("formulaires/cerfa-12345.jpg")}
]
}
]
)
Extraire les données d’une étiquette produit
Les étiquettes alimentaires suivent une structure standard : un tableau d’informations nutritionnelles pour 100 g, une liste d’ingrédients et les allergènes. Tu peux définir le schéma jusqu’au nom de l’unité, évitant ainsi toute supposition ultérieure sur le fait que „12“ se réfère à des grammes ou à des kilocalories.
prompt_etiquette = """Extract the nutritional information from this label.
JSON format:
{
"product_name": "...",
"net_weight": "...",
"nutrition_per_100g": {
"energy_kcal": ...,
"fat_g": ...,
"saturated_fat_g": ...,
"carbohydrates_g": ...,
"sugars_g": ...,
"protein_g": ...,
"salt_g": ...
},
"ingredients": "...",
"allergens": ["..."]
}"""
response = client.chat.complete(
model="mistral-large-latest",
response_format={"type": "json_object"},
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": prompt_etiquette},
{"type": "image_url", "image_url": encoder_image("produits/etiquette.jpg")}
]
}
]
)
produit = json.loads(response.choices[0].message.content)
Pipeline d’extraction avec validation
En production, les garanties syntaxiques ne suffisent pas. Le modèle peut renvoyer un JSON parfaitement valide où email est absent, ou où phone contient un entier au lieu d’une chaîne. Pydantic transforme ces cas en exceptions explicites dès l’étape d’extraction, plutôt que trois étapes plus loin dans ton pipeline.
from pydantic import BaseModel, Field
from typing import Optional
import json
class BusinessCard(BaseModel):
last_name: str
first_name: str
title: Optional[str] = None
company: Optional[str] = None
email: Optional[str] = None
phone: Optional[str] = None
address: Optional[str] = None
website: Optional[str] = None
def extract_business_card(image_path):
"""Extract and validate business card data."""
response = client.chat.complete(
model="mistral-large-latest",
response_format={"type": "json_object"},
messages=[
{
"role": "system",
"content": "Extract data from this business card. Fields: last_name, first_name, title, company, email, phone, address, website. Return JSON."
},
{
"role": "user",
"content": [
{"type": "text", "text": "Extract information from this business card."},
{"type": "image_url", "image_url": encoder_image(image_path)}
]
}
]
)
# Analyse et validation avec Pydantic
raw_data = json.loads(response.choices[0].message.content)
card = BusinessCard(**raw_data)
return card
# Utilisation
card = extract_business_card("cartes/contact-dupont.jpg")
print(f"Contact: {card.first_name} {card.last_name} - {card.email}")
Note la distinction entre last_name: str et title: Optional[str] = None. Une carte sans nom est une extraction échouée ; une carte sans titre de poste est un cas normal. Tu traces cette ligne, et Pydantic la fait respecter.
Conversion en CSV ou DataFrame
L’étape finale consiste à alimenter ton pipeline de traitement de données. Le JSON produit ci-dessus se convertit directement :
import pandas as pd
# Depuis un tableau extrait
donnees = json.loads(response.choices[0].message.content)
# Créer un DataFrame pandas
df = pd.DataFrame(donnees["rows"])
print(df.to_string())
# Exporter en CSV
df.to_csv("export/tableau_extrait.csv", index=False, encoding="utf-8")
L’argument encoding="utf-8" lors de l’export est obligatoire dès que tes données contiennent des caractères accentués ou des symboles monétaires.
Svarbiausi punktai
- Le paramètre
response_format={"type": "json_object"}garantit une sortie JSON valide - Fournis toujours un schéma JSON attendu dans ton prompt pour guider l’extraction
- Utilise Pydantic pour valider les données extraites en production
- Les tableaux, formulaires, étiquettes et cartes de visite sont des cibles idéales
- Combine l’extraction avec pandas pour une intégration directe dans tes flux de données