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

Reconnaissance optique de caractères et transcription de texte dans les images

Lektion 8 av 12 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Lire du texte dans des images
  2. OCR simple : lire le texte visible
  3. Extraire le texte d’une facture
  4. Transcrire des captures d’écran
  5. Lire des tickets de caisse et reçus
  6. Traitement de documents par lots
  7. Améliorer la précision de l’OCR
  8. API Vision contre Document AI
  9. Viktiga punkter

Lire du texte dans des images

La reconnaissance optique de caractères (OCR) constitue l’un des cas d’usage les plus courants de l’API Vision. Grâce aux modèles multimodaux de Mistral, tu peux extraire du texte depuis des photos, des captures d’écran, des documents numérisés, des factures ou des tickets de caisse sans installer de bibliothèque OCR dédiée : ni Tesseract, ni modèles de langage spécifiques, ni pipeline de prétraitement.

L’avantage ne se limite pas à réduire les dépendances. L’OCR classique renvoie des caractères ; un modèle multimodal comprend ce qu’il lit et peut, lors du même appel, distinguer un numéro de facture d’un numéro de bon de commande. Cette leçon présente des cas d’usage fréquents et des techniques qui améliorent concrètement la précision.

OCR simple : lire le texte visible

L’approche la plus directe tient en une seule consigne, à condition qu’elle soit sans ambiguïté :

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Transcribe exactly all visible text in this image. Do not comment, do not summarize--return only the text as it appears."},
                {"type": "image_url", "image_url": "https://exemple.com/document-scanne.jpg"}
            ]
        }
    ]
)

print(response.choices[0].message.content)

Le mot-clé est « exactement ». Sans cette instruction, le modèle a tendance à paraphraser ou résumer le contenu, car c’est ce que fait spontanément un assistant utile : ici, tu demandes l’inverse d’un service, une restitution littérale.

Extraire le texte d’une facture

Les factures contiennent des informations structurées — émetteur, destinataire, montants, dates — que le modèle peut identifier par leur rôle, et non seulement par leur position. C’est précisément l’avantage face à l’OCR à zones fixes, qui échoue dès que le fournisseur modifie la mise en page :

prompt_facture = """Analyze this invoice and extract the following information:
- Issuer (name, address, SIRET if visible)
- Recipient (name, address)
- Invoice number
- Issue date
- Due date
- Billing lines (description, quantity, unit price, total)
- Subtotal excluding tax
- VAT (rate and amount)
- Total including tax

Return the result as structured JSON."""

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "You are a certified accountant. Extract billing data with precision. Return only valid JSON."
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": prompt_facture},
                {"type": "image_url", "image_url": data_uri_facture}
            ]
        }
    ]
)

Transcrire des captures d’écran

Un autre besoin fréquent consiste à récupérer le contenu d’une interface ou d’un terminal partagé sous forme de capture d’écran, typiquement dans un ticket de support. Ici, la mise en forme fait partie de l’information : une trace de terminal dont l’indentation est perdue devient inutilisable.

import base64

def encoder_image(chemin):
    with open(chemin, "rb") as f:
        b64 = base64.standard_b64encode(f.read()).decode("utf-8")
    return f"data:image/png;base64,{b64}"

# Transcrire une capture d'écran de terminal
response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Transcribe the terminal output visible in this screenshot. Preserve formatting and indentation."
                },
                {"type": "image_url", "image_url": encoder_image("captures/terminal.png")}
            ]
        }
    ]
)

Lire des tickets de caisse et reçus

Les reçus thermiques représentent le cas le plus difficile : impression pâle, papier froissé, encre qui s’efface. La technique décisive consiste à autoriser explicitement le modèle à déclarer forfait sur un élément ; sinon, il comblera les lacunes avec des valeurs plausibles.

prompt_recu = """Read this cash register ticket and extract:
1. Store name
2. Date and time
3. List of items (name, price)
4. Subtotal
5. Payment method
6. Total amount

If an item is illegible, indicate [illegible].
Return the result as JSON."""

response = client.chat.complete(
    model="mistral-large-latest",  # Large pour une meilleure lecture
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": prompt_recu},
                {"type": "image_url", "image_url": encoder_image("recu-supermarche.jpg")}
            ]
        }
    ]
)

Un [illegible] dans le résultat vaut infiniment mieux qu’un montant inventé : le premier déclenche une vérification humaine, le second passe inaperçu jusqu’à la réconciliation comptable. Pour ces documents dégradés, utilise Mistral Large 3 : la différence de précision avec Small est significative sur un texte flou ou partiellement lisible.

Traitement de documents par lots

Le passage à l’échelle suit le schéma déjà vu : une fonction unitaire paramétrée par le modèle, puis une boucle sur le dossier.

import json
from pathlib import Path

def ocr_document(chemin_image, modele="mistral-small-latest"):
    """Performs OCR on a document and returns the text."""
    response = client.chat.complete(
        model=modele,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": "Transcribe the entire text of this document. Preserve formatting (headings, paragraphs, lists)."
                    },
                    {"type": "image_url", "image_url": encoder_image(chemin_image)}
                ]
            }
        ]
    )
    return response.choices[0].message.content

# Traiter un dossier
dossier = Path("documents_scannes/")
resultats = {}

for fichier in sorted(dossier.glob("*.jpg")):
    print(f"OCR of {fichier.name}...")
    resultats[fichier.name] = ocr_document(fichier)

# Sauvegarder
with open("transcriptions.json", "w", encoding="utf-8") as f:
    json.dump(resultats, f, ensure_ascii=False, indent=2)

print(f"{len(resultats)} documents transcribed.")

Le paramètre modele dans la signature n’est pas cosmétique : il te permet de relancer uniquement les documents douteux avec Large sans réécrire la fonction.

Améliorer la précision de l’OCR

Deux leviers agissent en amont du modèle. Le premier est le prétraitement de l’image : un scan gris et peu contrasté devient lisible après conversion en niveaux de gris, rehaussement du contraste et accentuation des contours.

from PIL import Image, ImageEnhance, ImageFilter

def pretraiter_pour_ocr(chemin):
    """Improves an image for OCR: contrast, sharpness, grayscale."""
    img = Image.open(chemin)

    # Convert to grayscale
    img = img.convert("L")

    # Increase contrast
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(2.0)

    # Increase sharpness
    img = img.filter(ImageFilter.SHARPEN)

    return img

Le facteur 2,0 fonctionne pour un scan délavé ; poussé trop haut, il crée des artefacts qui dégradent la lecture. Teste sur trois documents représentatifs avant de figer la valeur.

Le second levier est la spécialisation de la consigne selon le type de document. Un formulaire appelle « Lis chaque champ et sa valeur correspondante », une lettre « Transcris le corps de la lettre en conservant les paragraphes », un tableau « Extrait les données du tableau au format Markdown ». Trois formulations, trois structures de sortie : classe tes documents avant de les transcrire, et la qualité gagne un cran.

API Vision contre Document AI

Pour l’OCR avancé et l’analyse de documents, Mistral propose également Document AI (OCR 4), un service spécialisé. Le tableau suivant délimite la frontière entre les deux.

CritèreAPI VisionDocument AI (OCR 4)
OCR simpleSuffisantSurdimensionné
Documents complexesLimitéOptimisé
Tableaux imbriquésApproximatifPrécis
PDF multipagesNon pris en chargePris en charge
Mise en page complexeBasiqueAvancée

La ligne de partage décisive concerne les PDF multipages : l’API Vision traite des images, pas des documents paginés. Dès que ta source est un PDF de plusieurs dizaines de pages, la question ne se pose plus. Nous aborderons Document AI dans la leçon 12 (Prochaines étapes).

Viktiga punkter

  • L’API Vision effectue une OCR adéquate pour les cas simples (factures, captures d’écran, tickets de caisse)
  • Utilise le mot « exactement » dans ta consigne pour éviter la paraphrase
  • Mistral Large 3 est nettement supérieur à Small pour les documents de mauvaise qualité
  • Le prétraitement d’image (contraste, niveaux de gris) améliore les résultats
  • Pour l’OCR avancé et les PDF multipages, envisage Document AI (OCR 4) de Mistral