OCR : extraction de texte

Lire le texte dans les images

L’OCR (Optical Character Recognition) est l’un des cas d’usage les plus puissants de la vision Grok. Contrairement aux outils OCR traditionnels qui se contentent d’extraire des caractères, Grok comprend le contexte du texte dans l’image, sa mise en page et sa signification.

OCR classique vs OCR multimodal

Les outils OCR traditionnels (Tesseract, Google Vision OCR, AWS Textract) excellent dans l’extraction brute de caractères. Grok apporte une dimension supplémentaire : il comprend ce que le texte signifie dans le contexte de l’image.

Par exemple, face à une facture scannée, un OCR classique extraira tous les caractères. Grok peut en plus :

• Identifier les champs (numéro de facture, date, montant total)
• Structurer les données dans un format exploitable
• Corriger les erreurs d’OCR grâce au contexte
• Interpréter les tableaux et les mises en page complexes

Extraction basique

Pour une extraction simple du texte visible :

response = client.responses.create(
    model="grok-4",
    input=[
        {
            "type": "input_image",
            "image_url": url_document,
            "detail": "high"  # Important pour l'OCR
        },
        {
            "type": "input_text",
            "text": "Extrais tout le texte visible dans cette image. Conserve la mise en page autant que possible."
        }
    ],
    store=False
)

Le paramètre detail: "high" est essentiel pour l’OCR. En mode low, le modèle peut manquer du texte fin ou mal lire certains caractères.

Extraction structurée de documents

Pour les documents professionnels, demandez une extraction structurée :

def extraire_facture(image_url):
    prompt = """Cette image est une facture. Extrais les informations
suivantes en JSON :
- "numero_facture": le numéro de facture
- "date": la date d'émission
- "emetteur": nom et adresse de l'émetteur
- "destinataire": nom et adresse du destinataire
- "lignes": tableau avec colonnes [description, quantite, prix_unitaire, total]
- "sous_total": montant HT
- "tva": montant de la TVA
- "total_ttc": montant TTC

Si un champ n'est pas visible, indique null."""

    response = client.responses.create(
        model="grok-4",
        input=[
            {"type": "input_image", "image_url": image_url, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Extraction de cartes de visite

def extraire_carte_visite(image_url):
    prompt = """Extrais les informations de cette carte de visite en JSON :
- "nom": nom complet
- "titre": titre/fonction
- "entreprise": nom de l'entreprise
- "email": adresse email
- "telephone": numéro(s) de téléphone
- "adresse": adresse postale
- "site_web": URL du site web
- "reseaux_sociaux": liens vers les réseaux sociaux"""

    response = client.responses.create(
        model="grok-4",
        input=[
            {"type": "input_image", "image_url": image_url, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Traitement de captures d’écran

Les captures d’écran sont un excellent cas d’usage car elles contiennent souvent du texte dans des mises en page complexes (menus, barres latérales, popups) :

def analyser_screenshot(image_url):
    prompt = """Analyse cette capture d'écran et identifie :
1. L'application ou le site web affiché
2. La page ou section visible
3. Les éléments d'interface principaux (boutons, menus, formulaires)
4. Tout texte important affiché
5. Les éventuels messages d'erreur ou notifications"""

    response = client.responses.create(
        model="grok-4",
        input=[
            {"type": "input_image", "image_url": image_url, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Traitement par lots de documents

Pour traiter un volume important de documents, combinez l’OCR Grok avec un pipeline de traitement :

import json

async def pipeline_ocr(documents):
    resultats = []

    for doc in documents:
        # 1. Valider l'image
        if not valider_image(doc["chemin"]):
            resultats.append({"fichier": doc["chemin"], "erreur": "Image invalide"})
            continue

        # 2. Encoder en base64
        image_url = encoder_base64(doc["chemin"])

        # 3. Extraire avec Grok
        response = client.responses.create(
            model="grok-4",
            input=[
                {"type": "input_image", "image_url": image_url, "detail": "high"},
                {"type": "input_text", "text": doc["prompt"]}
            ],
            store=False
        )

        # 4. Parser le résultat
        try:
            data = json.loads(response.output_text)
            resultats.append({"fichier": doc["chemin"], "data": data})
        except json.JSONDecodeError:
            resultats.append({"fichier": doc["chemin"], "texte_brut": response.output_text})

    return resultats

Limites de l’OCR Grok

• Texte manuscrit : la reconnaissance est correcte pour une écriture lisible, mais peut échouer sur des écritures cursives ou illisibles
• Langues non latines : la précision varie selon la langue et la police utilisée
• Images de faible qualité : les scans basse résolution ou les photos floues dégradent les résultats
• Texte très petit : même en mode high, le texte de moins de 8 pixels de haut peut être mal lu

Points clés à retenir

• Utilisez toujours detail: "high" pour les tâches d’OCR
• Demandez une extraction structurée (JSON) pour exploiter les données automatiquement
• Grok va au-delà de l’OCR brut : il comprend le contexte et la mise en page
• Utilisez store: false pour les documents sensibles (factures, cartes de visite)
• Validez et prétraitez les images pour maximiser la qualité d’extraction