Salt la conținutul principal
Română— Alege o limbă
Meniu

Extragerea tabelelor și a structurii

Lecția 6 din 16 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Tabelele: punctul slab istoric al OCR
  2. Parametrul table_format
  3. Recuperarea tabelelor ca date
  4. Trecerea la pandas pentru analiză
  5. Când tabelele devin complicate
  6. Puncte cheie

Actualizat pe 2 noiembrie 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) a fost retras la 30 septembrie 2026. Utilizați OCR 4.1 (mistral-ocr-4-1), disponibil din 31 august la același preț, sau aliasul mistral-ocr-latest, care indică spre acesta începând cu 16 iulie. OCR 4.1 adaugă scoruri de încredere la nivel de bloc.

Tabelele: punctul slab istoric al OCR

Cereți-i lui Tesseract să extragă tabelul sintetic dintr-un raport financiar și veți obține un șir de linii în care valorile din coloana „Total“ se amestecă cu cele din coloana „Cantitate“, fără nicio indicație care să le lege de rândurile originale. Problema nu este recunoașterea caracterelor, care funcționează corect, ci lipsa totală de conștientizare a structurii tabulare. Soluțiile tradiționale citesc de la stânga la dreapta, de sus în jos, pierzând pe drum relațiile dintre coloane și rânduri.

OCR 4 abordează pagina diferit: o vede. Această înțelegere vizuală îi permite să restituie un tabel ca atare, nu ca text aplatizat.

Parametrul table_format

Controlați randarea tabelelor printr-un singur parametru transmis apelului OCR:

import os
from mistralai.client import Mistral

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

# Format Markdown (recomandat pentru majoritatea cazurilor)
ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": "https://example.com/financial-report.pdf"
    },
    table_format="markdown"
)

Sunt posibile trei valori, iar alegerea nu este cosmetică: aceasta determină ce puteți face ulterior cu rezultatul.

Cu null, valoarea implicită, tabelele sunt integrate în fluxul Markdown fără o formatare tabulară specifică. Această setare funcționează atunci când nu procesați documente tabulare și doriți doar text pentru indexare.

Cu "markdown", fiecare tabel este randat în format standard cu bare verticale, producând un output lizibil ca atare și ușor de analizat:

| Produs | Cantitate | Preț unitar | Total |
|---------|----------|------------|-------|
| Widget A | 100 | €12,50 | €1.250 |
| Widget B | 50 | €25,00 | €1.250 |
| **Total** | **150** | | **€2.500** |

Cu "html", tabelul este randat ca HTML complet, păstrând fuzionările de celule și formatarea avansată pe care Markdown nu le poate exprima:

<table>
  <thead>
    <tr>
      <th>Produs</th>
      <th>Cantitate</th>
      <th>Preț unitar</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>

În practică, Markdown acoperă majoritatea nevoilor: indexare RAG, căutare sau afișare într-un editor. Treceți la HTML imediat ce tabelele includ celule fuzionate sau rezultatul trebuie încorporat într-o pagină web. Păstrați null doar atunci când tabelele nu contează în fluxul dumneavoastră de lucru – de exemplu, un raport narativ sau corespondență.

Recuperarea tabelelor ca date

Un tabel Markdown rămâne text. Pentru a-l transforma în date manipulabile, trebuie să îl identificați în flux și să îl descompuneți. Funcția de mai jos parcurge liniile, le identifică pe cele care aparțin unui tabel, ignoră linia separator și închide tabelul curent imediat ce apare o linie obișnuită:

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]]]:
    """Extrage tabelele Markdown și le convertește în liste."""
    tables = []
    lines = markdown.split("\n")
    current_table = []
    in_table = False

    for line in lines:
        if "|" in line and line.strip().startswith("|"):
            # Ignoră linia separator (|---|---|)
            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


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

# Iterează prin pagini și extrage tabelele
for page in ocr_response.pages:
    tables = extract_markdown_tables(page.markdown)
    for i, table in enumerate(tables):
        print(f"Pagina {page.index + 1}, Tabelul {i + 1}:")
        print(json.dumps(table, indent=2, ensure_ascii=False))

Verificarea finală din afara buclei nu este decorativă: fără ea, un tabel aflat la sfârșitul unei pagini – un caz frecvent pentru un sumar de factură – nu ar fi niciodată adăugat la listă, deoarece nicio linie obișnuită nu intervine pentru a-l închide.

Trecerea la pandas pentru analiză

O listă de liste este suficientă pentru export, nu pentru calcul. Conversia într-un DataFrame implică promovarea primului rând ca antet:

import pandas as pd

def tables_to_dataframes(markdown: str) -> list[pd.DataFrame]:
    """Convertește tabelele Markdown în DataFrame-uri 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

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

Testul len(table) < 2 filtrează falsurile pozitive: o linie izolată care conține o bară verticală, într-un bloc de cod sau într-o adresă, nu va produce un DataFrame rupt și gol. Rețineți că valorile rămân șiruri de caractere; conversia „€1.250“ într-un număr vă revine dumneavoastră.

Când tabelele devin complicate

Celulele fuzionate, anteturile pe două niveluri sau layout-urile neregulate împing Markdown dincolo de limitele sale expresive. Treceți atunci la HTML și lăsați BeautifulSoup și pandas să gestioneze analiza:

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)

Această abordare vă scutește de scrierea unui parser: pd.read_html gestionează atributele rowspan și colspan pe care divizarea manuală le-ar rata. Costul este o dependență suplimentară și un output ușor mai verbose – un compromis care merită pentru rapoarte financiare sau tabele de reglementare.

Puncte cheie

  • Parametrul table_format controlează randarea tabelelor (null, markdown, html)
  • Formatul Markdown se potrivește majorității cazurilor de utilizare
  • Formatul HTML păstrează celulele fuzionate și formatarea avansată
  • Tabelele extrase pot fi convertite în DataFrame-uri pandas pentru analiză
  • OCR 4 reconstruiește fidel structura tabulară, chiar și pe layout-uri complexe