Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Extractie van tabellen en structuur

Les 6 van 16 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Tabellen: de historische zwakke plek van OCR
  2. De parameter table_format
  3. Tabellen als gegevens ophalen
  4. Overstappen naar pandas voor analyse
  5. Wanneer tabellen complex worden
  6. Belangrijkste punten

Bijgewerkt op 2 november 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) is op 30 september 2026 buiten gebruik gesteld. Gebruik OCR 4.1 (mistral-ocr-4-1), algemeen beschikbaar sinds 31 augustus tegen dezelfde prijs, of het alias mistral-ocr-latest, dat sinds 16 juli hiernaar verwijst. OCR 4.1 voegt betrouwbaarheidsscores toe op blokniveau.

Tabellen: de historische zwakke plek van OCR

Vraag Tesseract om de samenvattende tabel uit een financieel rapport te halen, en u krijgt een reeks regels waarin waarden uit de kolom “Totaal” vermengd raken met die uit de kolom “Aantal”, zonder enige aanwijzing die ze terugkoppelt aan hun oorspronkelijke rijen. Het probleem ligt niet bij de tekenherkenning, die prima werkt; het is het totale gebrek aan bewustzijn van de tabelstructuur. Traditionele oplossingen lezen van links naar rechts, van boven naar beneden, en verliezen onderweg de relaties tussen kolommen en rijen.

OCR 4 benadert de pagina anders: het ziet de pagina. Dit visuele begrip stelt het in staat om een tabel als tabel te herstellen, niet als platte tekst.

De parameter table_format

U stuurt de weergave van tabellen aan met één enkele parameter die u meegeeft aan de OCR-aanroep:

import os
from mistralai.client import Mistral

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

# Markdown-indeling (aanbevolen voor de meeste gevallen)
ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": "https://example.com/financial-report.pdf"
    },
    table_format="markdown"
)

Er zijn drie mogelijke waarden, en de keuze is niet louter cosmetisch: deze bepaalt wat u downstream met het resultaat kunt doen.

Met null, de standaardwaarde, worden tabellen geïntegreerd in de Markdown-stroom zonder specifieke tabelopmaak. Deze instelling werkt wanneer u geen tabulair document verwerkt en gewoon tekst wilt indexeren.

Met "markdown" wordt elke tabel weergegeven in het standaard pipe-formaat, wat resulteert in uitvoer die direct leesbaar en eenvoudig te parseren is:

| Product | Aantal | Eenheidsprijs | Totaal |
|---------|----------|------------|-------|
| Widget A | 100 | €12,50 | €1.250 |
| Widget B | 50 | €25,00 | €1.250 |
| **Totaal** | **150** | | **€2.500** |

Met "html" wordt de tabel weergegeven als volledige HTML, waarbij cel samenvoegingen en geavanceerde opmaak behouden blijven die Markdown niet kan uitdrukken:

<table>
  <thead>
    <tr>
      <th>Product</th>
      <th>Aantal</th>
      <th>Eenheidsprijs</th>
      <th>Totaal</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Widget A</td>
      <td>100</td>
      <td>€12,50</td>
      <td>€1.250</td>
    </tr>
  </tbody>
</table>

In de praktijk dekt Markdown de meeste behoeften: RAG-indexering, zoeken of weergave in een editor. Schakel over op HTML zodra uw tabellen samengevoegde cellen bevatten of het resultaat in een webpagina moet worden ingesloten. Houd null alleen aan wanneer tabellen in uw workflow niet relevant zijn, bijvoorbeeld bij een narratief rapport of correspondentie.

Tabellen als gegevens ophalen

Een Markdown-tabel is nog steeds tekst. Om deze om te zetten in manipuleerbare gegevens, moet u deze in de stroom lokaliseren en opsplitsen. De onderstaande functie loopt door de regels heen, identificeert die welke tot een tabel behoren, negeert de scheidingsregel en sluit de huidige tabel zodra er een gewone regel verschijnt:

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]]]:
    """Extraheert Markdown-tabellen en zet ze om in lijsten."""
    tables = []
    lines = markdown.split("\n")
    current_table = []
    in_table = False

    for line in lines:
        if "|" in line and line.strip().startswith("|"):
            # Negeer scheidingsregel (|---|---|)
            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


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

# Itereer door pagina's en extraheer tabellen
for page in ocr_response.pages:
    tables = extract_markdown_tables(page.markdown)
    for i, table in enumerate(tables):
        print(f"Pagina {page.index + 1}, Tabel {i + 1}:")
        print(json.dumps(table, indent=2, ensure_ascii=False))

De laatste controle buiten de lus is niet louter decoratief: zonder deze zou een tabel aan het einde van een pagina—een veelvoorkomend geval bij een factuuroverzicht—nooit aan de lijst worden toegevoegd, aangezien er geen gewone regel langskomt om deze af te sluiten.

Overstappen naar pandas voor analyse

Een lijst van lijsten volstaat voor export, niet voor berekening. Converteer naar een DataFrame om de eerste rij naar kopteksten te promoveren:

import pandas as pd

def tables_to_dataframes(markdown: str) -> list[pd.DataFrame]:
    """Zet Markdown-tabellen om in pandas DataFrames."""
    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

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

De test len(table) < 2 filtert false positives eruit: een geïsoleerde regel met een pipe-teken, binnen een codeblok of een adres, levert geen kapot of leeg DataFrame op. Houd er rekening mee dat waarden strings blijven; het omzetten van “€1.250” naar een getal is nog steeds aan u.

Wanneer tabellen complex worden

Samengevoegde cellen, koppen op twee niveaus of onregelmatige lay-outs duwen Markdown voorbij zijn expressieve limieten. Schakel dan over op HTML en laat BeautifulSoup en pandas de analyse afhandelen:

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)

Deze aanpak bespaart u het schrijven van een parser: pd.read_html handelt attributen rowspan en colspan af die uw handmatige splitsing zou missen. De kosten zijn een extra afhankelijkheid en iets uitgebreidere uitvoer—een afweging die de moeite waard is voor financiële rapporten of regulatoire tabellen.

Belangrijkste punten

  • De parameter table_format stuurt de tabelweergave aan (null, markdown, html)
  • Markdown-indeling is geschikt voor de meeste use cases
  • HTML-indeling behoudt samengevoegde cellen en geavanceerde opmaak
  • Geëxtraheerde tabellen kunnen worden omgezet in pandas DataFrames voor analyse
  • OCR 4 reconstrueert tabulaire structuren getrouw, zelfs bij complexe lay-outs