Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

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

Lekce 8 z 12 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Lire du texte dans des images
  2. OCR simple : lire le texte visible
  3. Extraire du texte d’une facture
  4. Transcrire des captures d’écran
  5. Lire les tickets de caisse et reçus
  6. Traitement de documents en lot
  7. Améliorer la précision de l’OCR
  8. API Vision contre Document AI
  9. Klíčové poznatky

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 à partir de photos, de captures d’écran, de documents numérisés, de factures ou de 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 couvre les cas d’usage fréquents et les techniques qui améliorent concrètement la précision.

OCR simple : lire le texte visible

L’approche la plus directe tient en une seule invite, à 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 serviable : ici, tu demandes l’inverse d’un service, une restitution littérale.

Extraire du 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 par rapport à 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 les 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 par 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 en lot

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.

from PIL import Image, ImageEnhance, ImageFilter

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

    # Convertir en niveaux de gris
    img = img.convert("L")

    # Augmenter le contraste
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(2.0)

    # Augmenter la netteté
    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 l’invite 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 démarcation 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).

Klíčové poznatky

  • L’API Vision effectue une OCR adéquate pour les cas simples (factures, captures d’écran, reçus)
  • Utilise le mot « exactement » dans ton invite pour éviter la paraphrase
  • Mistral Large 3 est nettement meilleur que 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