Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Extraction de tableaux et de structures

Lekcija 6 od 16 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Les tableaux : le point faible historique de l’OCR
  2. Le paramètre table_format
  3. Récupérer les tableaux sous forme de données
  4. Passer à pandas pour l’analyse
  5. Quand les tableaux se compliquent
  6. Cljučne ugotovitve

Mis à jour le 2 novembre 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) a été retiré le 30 septembre 2026. Utilise OCR 4.1 (mistral-ocr-4-1), disponible depuis le 31 août au même tarif, ou l’alias mistral-ocr-latest qui le cible depuis le 16 juillet. OCR 4.1 ajoute des scores de confiance au niveau des blocs.

Les tableaux : le point faible historique de l’OCR

Demande à Tesseract d’extraire le tableau récapitulatif d’un rapport financier, et tu obtiendras une suite de lignes où les valeurs de la colonne « Total » se mélangent à celles de la colonne « Quantité », sans aucun lien pour les rattacher à leurs lignes d’origine. Le problème ne vient pas de la reconnaissance des caractères, qui fonctionne bien, mais d’une absence totale de conscience de la structure tabulaire. Les solutions traditionnelles lisent de gauche à droite, de haut en bas, perdant au passage les relations entre colonnes et lignes.

OCR 4 aborde la page différemment : il la voit. Cette compréhension visuelle lui permet de restituer un tableau en tant que tel, et non comme du texte aplati.

Le paramètre table_format

Tu contrôles le rendu des tableaux via un seul paramètre passé à l’appel OCR :

import os
from mistralai.client import Mistral

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

# Format Markdown (recommandé pour la plupart des cas)
ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": "https://example.com/financial-report.pdf"
    },
    table_format="markdown"
)

Trois valeurs sont possibles, et ce choix n’est pas cosmétique : il détermine ce que tu pourras faire du résultat en aval.

Avec null, la valeur par défaut, les tableaux sont intégrés au flux Markdown sans formatage tabulaire spécifique. Ce réglage convient lorsque tu ne traites pas de documents tabulaires et que tu souhaites simplement indexer du texte.

Avec "markdown", chaque tableau est rendu au format standard avec des barres verticales, produisant une sortie lisible telle quelle et facile à analyser :

| Produit | Quantité | Prix unitaire | Total |
|---------|----------|---------------|-------|
| Widget A | 100 | 12,50 € | 1 250 € |
| Widget B | 50 | 25,00 € | 1 250 € |
| **Total** | **150** | | **2 500 €** |

Avec "html", le tableau est rendu en HTML complet, préservant les fusions de cellules et la mise en forme avancée que Markdown ne peut exprimer :

<table>
  <thead>
    <tr>
      <th>Produit</th>
      <th>Quantité</th>
      <th>Prix unitaire</th>
      <th>Total</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Widget A</td>
      <td>100</td>
      <td>12,50 €</td>
      <td>1 250 €</td>
    </tr>
  </tbody>
</table>

En pratique, Markdown couvre la plupart des besoins : indexation RAG, recherche ou affichage dans un éditeur. Passe à HTML dès que tes tableaux incluent des cellules fusionnées ou que le résultat doit être intégré dans une page web. Garde null uniquement lorsque les tableaux n’ont pas d’importance dans ton flux de travail, par exemple pour un rapport narratif ou une correspondance.

Récupérer les tableaux sous forme de données

Un tableau Markdown reste du texte. Pour le transformer en données manipulables, tu dois le repérer dans le flux et le découper. La fonction ci-dessous parcourt les lignes, identifie celles appartenant à un tableau, ignore la ligne de séparation et ferme le tableau courant dès qu’une ligne normale apparaît :

import os
import re
import json
from mistralai.client import Mistral

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

def extract_markdown_tables(markdown: str) -> list[list[list[str]]]:
    """Extrait les tableaux Markdown et les convertit en listes."""
    tables = []
    lines = markdown.split("\n")
    current_table = []
    in_table = False

    for line in lines:
        if "|" in line and line.strip().startswith("|"):
            # Ignorer la ligne de séparation (|---|---|)
            if re.match(r"^\|[\s\-:|]+\|$", line.strip()):
                continue
            cells = [
                c.strip() for c in line.strip().strip("|").split("|")
            ]
            current_table.append(cells)
            in_table = True
        else:
            if in_table and current_table:
                tables.append(current_table)
                current_table = []
            in_table = False

    if current_table:
        tables.append(current_table)

    return tables


# Extraction OCR avec tableaux Markdown
ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": "https://example.com/invoice.pdf"
    },
    table_format="markdown"
)

# Parcourir les pages et extraire les tableaux
for page in ocr_response.pages:
    tables = extract_markdown_tables(page.markdown)
    for i, table in enumerate(tables):
        print(f"Page {page.index + 1}, Tableau {i + 1}:")
        print(json.dumps(table, indent=2, ensure_ascii=False))

La vérification finale en dehors de la boucle n’est pas décorative : sans elle, un tableau situé à la fin d’une page — cas fréquent pour un récapitulatif de facture — ne serait jamais ajouté à la liste, car aucune ligne normale ne viendrait le fermer.

Passer à pandas pour l’analyse

Une liste de listes suffit pour l’export, pas pour le calcul. La conversion en DataFrame implique de promouvoir la première ligne en en-têtes :

import pandas as pd

def tables_to_dataframes(markdown: str) -> list[pd.DataFrame]:
    """Convertit les tableaux Markdown en DataFrames pandas."""
    tables = extract_markdown_tables(markdown)
    dataframes = []

    for table in tables:
        if len(table) < 2:
            continue
        headers = table[0]
        data = table[1:]
        df = pd.DataFrame(data, columns=headers)
        dataframes.append(df)

    return dataframes

# Utilisation
for page in ocr_response.pages:
    dfs = tables_to_dataframes(page.markdown)
    for df in dfs:
        print(df.to_string())
        print()

Le test len(table) < 2 filtre les faux positifs : une ligne isolée contenant une barre verticale, située dans un bloc de code ou une adresse, ne produira pas un DataFrame cassé et vide. Garde à l’esprit que les valeurs restent des chaînes de caractères ; convertir « 1 250 € » en nombre t’incombe toujours.

Quand les tableaux se compliquent

Les cellules fusionnées, les en-têtes à deux niveaux ou les mises en page irrégulières repoussent Markdown au-delà de ses limites expressives. Bascule alors vers HTML et laisse BeautifulSoup et pandas gérer l’analyse :

from bs4 import BeautifulSoup
import pandas as pd

ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": "https://example.com/complex-report.pdf"
    },
    table_format="html"
)

for page in ocr_response.pages:
    soup = BeautifulSoup(page.markdown, "html.parser")
    tables = soup.find_all("table")

    for table in tables:
        df = pd.read_html(str(table))[0]
        print(df)

Cette approche t’évite d’écrire un analyseur : pd.read_html gère les attributs rowspan et colspan que ton découpage manuel manquerait. Le coût est une dépendance supplémentaire et une sortie légèrement plus verbeuse — un compromis qui vaut largement le coup pour les rapports financiers ou les tableaux réglementaires.

Cljučne ugotovitve

  • Le paramètre table_format contrôle le rendu des tableaux (null, markdown, html)
  • Le format Markdown convient à la plupart des cas d’usage
  • Le format HTML préserve les cellules fusionnées et la mise en forme avancée
  • Les tableaux extraits peuvent être convertis en DataFrames pandas pour analyse
  • OCR 4 reconstruit fidèlement la structure tabulaire, même sur des mises en page complexes