Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Extraire des données structurées à partir d'images

Lektion 9 av 12 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Transforme les images en données exploitables
  2. Le mode JSON de l’API
  3. Extraire un tableau depuis une image
  4. Formulaires et documents administratifs
  5. Extraire les données d’une étiquette produit
  6. Pipeline d’extraction avec validation
  7. Conversion en CSV ou DataFrame
  8. Viktiga punkter

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écaution particulière : 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 illustré dans les exemples ci-dessous.

Extraire un tableau depuis une image

Les tableaux photographiés ou les captures d’écran constituent un cas d’usage fréquent, 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 nutritionnel 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 » fasse référence à 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.

Viktiga punkter

  • 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