Extraction de tableaux et de structures
Na tej strani
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’aliasmistral-ocr-latestqui 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_formatcontrô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