Przejdź do głównej treści
Polski— Wybierz język
Menu

Ekstrakcja tabel i struktury

Lekcja 6 z 16 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Tabele: historyczna słabość OCR
  2. Parametr table_format
  3. Pobieranie tabel jako danych
  4. Przejście do pandas w celu analizy
  5. Gdy tabele stają się skomplikowane
  6. Kluczowe wnioski

Zaktualizowano 2 listopada 2026 — OCR. Model OCR 4.0 (mistral-ocr-4-0) został wycofany 30 września 2026 r. Używaj OCR 4.1 (mistral-ocr-4-1), dostępnego ogólnie od 31 sierpnia w tej samej cenie, lub aliasu mistral-ocr-latest, który wskazuje na niego od 16 lipca. OCR 4.1 dodaje wyniki pewności (confidence scores) na poziomie bloków.

Tabele: historyczna słabość OCR

Poproś Tesseract o wyodrębnienie tabeli podsumowującej z raportu finansowego, a otrzymasz ciąg linii, w którym wartości z kolumny „Suma“ mieszają się z wartościami z kolumny „Ilość“, bez żadnej wskazówki łączącej je z oryginalnymi wierszami. Problem nie leży w rozpoznawaniu znaków, które działa poprawnie, lecz w całkowitym braku świadomości struktury tabelarycznej. Tradycyjne rozwiązania czytają od lewej do prawej, od góry do dołu, gubiąc po drodze relacje między kolumnami i wierszami.

OCR 4 podchodzi do strony inaczej: ją widzi. To zrozumienie wizualne pozwala przywrócić tabelę jako tabelę, a nie jako spłaszczony tekst.

Parametr table_format

Sterujesz renderowaniem tabel za pomocą jednego parametru przekazywanego do wywołania OCR:

import os
from mistralai.client import Mistral

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

# Format Markdown (zalecany w większości przypadków)
ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": "https://example.com/financial-report.pdf"
    },
    table_format="markdown"
)

Możliwe są trzy wartości, a wybór nie jest kwestią kosmetyczną: decyduje o tym, co możesz zrobić z wynikiem w dalszym etapie przetwarzania.

Przy wartości null (domyślnej) tabele są integrowane z przepływem Markdown bez specyficznego formatowania tabelarycznego. To ustawienie sprawdza się, gdy nie przetwarzasz dokumentów tabelarycznych i potrzebujesz jedynie tekstu do indeksowania.

Przy wartości "markdown" każda tabela jest renderowana w standardowym formacie z pipe’ami, co daje wynik czytelny od razu i łatwy do parsowania:

| Produkt | Ilość | Cena jednostkowa | Suma |
|---------|----------|------------|-------|
| Widget A | 100 | 12,50 € | 1 250 € |
| Widget B | 50 | 25,00 € | 1 250 € |
| **Suma** | **150** | | **2 500 €** |

Przy wartości "html" tabela jest renderowana jako pełny kod HTML, zachowując scalenia komórek i zaawansowane formatowanie, którego Markdown nie potrafi wyrazić:

<table>
  <thead>
    <tr>
      <th>Produkt</th>
      <th>Ilość</th>
      <th>Cena jednostkowa</th>
      <th>Suma</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Widget A</td>
      <td>100</td>
      <td>12,50 €</td>
      <td>1 250 €</td>
    </tr>
  </tbody>
</table>

W praktyce Markdown pokrywa większość potrzeb: indeksowanie RAG, wyszukiwanie czy wyświetlanie w edytorze. Przełącz się na HTML, gdy tylko Twoje tabele zawierają scalone komórki lub wynik musi zostać osadzony na stronie internetowej. Pozostaw null tylko wtedy, gdy tabele nie mają znaczenia w Twoim przepływie pracy – np. w raporcie narracyjnym lub korespondencji.

Pobieranie tabel jako danych

Tabela w Markdown to nadal tekst. Aby przekształcić ją w dane możliwe do manipulacji, musisz wykryć ją w strumieniu i rozdzielić. Poniższa funkcja przechodzi przez linie, identyfikuje te należące do tabeli, ignoruje linię separatora i zamyka bieżącą tabelę natychmiast, gdy pojawi się zwykła linia:

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]]]:
    """Wyodrębnia tabele Markdown i konwertuje je na listy."""
    tables = []
    lines = markdown.split("\n")
    current_table = []
    in_table = False

    for line in lines:
        if "|" in line and line.strip().startswith("|"):
            # Ignoruj linię separatora (|---|---|)
            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


# Ekstrakcja OCR z tabelami w formacie Markdown
ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": "https://example.com/invoice.pdf"
    },
    table_format="markdown"
)

# Iteracja przez strony i ekstrakcja tabel
for page in ocr_response.pages:
    tables = extract_markdown_tables(page.markdown)
    for i, table in enumerate(tables):
        print(f"Strona {page.index + 1}, Tabela {i + 1}:")
        print(json.dumps(table, indent=2, ensure_ascii=False))

Ostatnie sprawdzenie poza pętlą nie jest ozdobnikiem: bez niego tabela znajdująca się na końcu strony – częsty przypadek w podsumowaniu faktury – nigdy nie zostałaby dodana do listy, ponieważ nie pojawiłaby się żadna zwykła linia, która by ją zamknęła.

Przejście do pandas w celu analizy

Lista list wystarcza do eksportu, ale nie do obliczeń. Konwersja do DataFrame oznacza promowanie pierwszego wiersza do nagłówków:

import pandas as pd

def tables_to_dataframes(markdown: str) -> list[pd.DataFrame]:
    """Konwertuje tabele Markdown na DataFrame biblioteki 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

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

Test len(table) < 2 filtruje fałszywe trafienia: pojedyncza linia zawierająca pipe, znajdująca się w bloku kodu lub adresie, nie utworzy uszkodzonego, pustego DataFrame. Pamiętaj, że wartości pozostają stringami; konwersja „1 250 €“ na liczbę nadal należy do Ciebie.

Gdy tabele stają się skomplikowane

Scalone komórki, nagłówki dwupoziomowe lub nieregularne układy wypychają Markdown poza granice jego możliwości ekspresyjnych. Przełącz się wtedy na HTML i pozwól bibliotece BeautifulSoup oraz pandas zająć się analizą:

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)

To podejście избавia Cię od pisania parsera: pd.read_html obsługuje atrybuty rowspan i colspan, które Twoje ręczne dzielenie by przeoczyło. Kosztem jest dodatkowa zależność i nieco bardziej rozwlekły wynik – to kompromis wart poniesienia w przypadku raportów finansowych lub tabel regulacyjnych.

Kluczowe wnioski

  • Parametr table_format kontroluje renderowanie tabel (null, markdown, html)
  • Format Markdown odpowiada większości przypadków użycia
  • Format HTML zachowuje scalone komórki i zaawansowane formatowanie
  • Wyodrębnione tabele można konwertować na DataFrame biblioteki pandas w celu analizy
  • OCR 4 wiernie odtwarza strukturę tabelaryczną, nawet w przypadku złożonych układów