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

Extraction de tableaux et de structures

Lektion 6 av 16 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  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. Viktiga punkter

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 avec 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 pipe standard, produisant une sortie lisible telle quelle et facile à analyser :

| Product | Quantity | Unit Price | 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 le formatage avancé que Markdown ne peut exprimer :

<table>
  <thead>
    <tr>
      <th>Product</th>
      <th>Quantity</th>
      <th>Unit Price</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 hors 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 un pipe, 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 ; la conversion de « €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 largement justifié pour les rapports financiers ou les tableaux réglementaires.

Viktiga punkter

  • 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 le formatage avancé
  • 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