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

Optymalizacja dokładności OCR

Lekcja 8 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Jakość wejścia determinuje jakość wyjścia
  2. Rozdzielczość i wstępne przetwarzanie
  3. Dostosowanie konfiguracji do typu dokumentu
  4. Przetwarzanie dużych wolumenów
  5. Weryfikacja przed wykorzystaniem
  6. Podsumowanie operacyjne
  7. Kluczowe wnioski

Aktualizacja z 2 listopada 2026 r. — 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), który jest ogólnie dostępny 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. Dodatek z 3 listopada 2026 r.: Lokalny plik PDF jest przesyłany w formacie base64 jako {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; typ document_base64 ze starszych przykładów nie istnieje ani w dokumentacji, ani w SDK mistralai, a takie przykłady zakończyłyby się niepowodzeniem. Źródła: OCR Processor · Document QnA.

Jakość wejścia determinuje jakość wyjścia

Zespół Mistral wyraził to dosadnie podczas webinarium poświęconego Document AI: „śmieci na wejściu, śmieci na wyjściu“. Niezależnie od mocy modelu, nie odzyska on informacji, których skan nie zarejestrował. Gdy projekt ekstrakcji danych nie spełnia oczekiwań, winowajcą jest prawie zawsze etap poprzedzający wywołanie API – wyblakła kserokopia, ponownie zeskanowany faks lub zdjęcie wykonane pod kątem w słabo oświetlonym magazynie. Ta lekcja omawia mechanizmy, które realnie wpływają na dokładność.

Rozdzielczość i wstępne przetwarzanie

Pierwszym dźwignią jest rozdzielczość skanowania. Cele zależą od zawartości dokumentu:

  • Dokumenty drukowane: minimum 200 DPI, zalecane 300 DPI
  • Pismo ręczne: minimum 300 DPI
  • Złożone tabele: zalecane 300 DPI
  • Dokumenty historyczne: 400 DPI lub więcej

Poniżej tych wartości cienkie linie znikają i żadne przetwarzanie programowe ich nie przywróci. Wyższe wartości głównie zwiększają rozmiar pliku. Jeśli kontrolujesz łańcuch skanowania, prawidłowa konfiguracja skanera zaoszczędzi Ci znacznie więcej kłopotów niż jakikolwiek trik programistyczny.

Gdy dokument dociera już w formie cyfrowej, wstępne przetwarzanie obrazu może nieco poprawić sytuację. Poniższa funkcja łączy cztery klasyczne operacje – konwersję do skali szarości, poprawę kontrastu, wyostrzenie i binaryzację – zanim zwróci obraz zakodowany w base64, gotowy do wywołania OCR:

from PIL import Image, ImageEnhance, ImageFilter
import io
import base64

def pre_process_image(image_path: str) -> str:
    """Wstępnie przetwarza obraz, aby poprawić ekstrakcję OCR."""
    img = Image.open(image_path)

    # 1. Konwersja do skali szarości
    img = img.convert("L")

    # 2. Zwiększenie kontrastu
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(1.5)

    # 3. Zwiększenie ostrości
    img = img.filter(ImageFilter.SHARPEN)

    # 4. Binaryzacja (progowanie)
    img = img.point(lambda x: 0 if x < 128 else 255, "1")

    # Konwersja do base64
    buffer = io.BytesIO()
    img.save(buffer, format="PNG")
    return base64.b64encode(buffer.getvalue()).decode("utf-8")

Przetestuj to przetwarzanie na próbce przed zastosowaniem go do całej partii. Binaryzacja jest szczególnie brutalna: na już ostrym dokumencie nic nie wnosi, a na dokumencie wykonanym ołówkiem może całkowicie usunąć tekst.

Orientacja to kolejna korekta, której nie wolno zaniedbywać. Skany często docierają obrócone o 90 lub 180 stopni, a informacje o orientacji są zwykle przechowywane w metadanych EXIF obrazu:

from PIL import Image

def correct_orientation(image_path: str) -> Image.Image:
    """Koryguje orientację zeskanowanego obrazu na podstawie metadanych EXIF."""
    img = Image.open(image_path)

    # Użycie danych EXIF do korekcji orientacji
    try:
        exif = img._getexif()
        if exif:
            orientation = exif.get(274)  # Tag orientacji EXIF
            rotations = {3: 180, 6: 270, 8: 90}
            if orientation in rotations:
                img = img.rotate(rotations[orientation], expand=True)
    except (AttributeError, KeyError):
        pass

    return img

Szeroki blok try jest tutaj uzasadniony: wiele obrazów nie posiada danych EXIF, a brak danych o orientacji nie powinien przerywać przetwarzania wsadowego.

Dostosowanie konfiguracji do typu dokumentu

W przypadku typowych dokumentów drukowanych – faktur, umów, raportów – optymalna konfiguracja sprowadza się do wyraźnego żądania ekstrakcji tabel, zamiast polegania na ustawieniach domyślnych:

# Optymalna konfiguracja dla dokumentów drukowanych
ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": f"data:application/pdf;base64,{document_base64}"
    },
    table_format="markdown"  # Jawna ekstrakcja tabel
)

Pismo ręczne wymaga większej dbałości na etapie wstępnym. Skanuj w rozdzielczości minimum 300 DPI, zwiększ kontrast między atramentem a papierem, ale pomiń agresywną binaryzację z poprzedniego skryptu: usuwa ona cienkie kreski długopisu i stracisz więcej informacji, niż zyskasz. Sam model radzi sobie dobrze z pismem ręcznym, w tym z tekstem wielojęzycznym, co nie było oczywiste w poprzednich generacjach OCR.

Są też mocno zdegradowane skany – archiwa, pogniecione dokumenty, kopie z kopii. Strategia ulega zmianie: zacznij od redukcji szumu za pomocą filtra medianowego przed zwiększeniem kontrastu, a następnie zwiększ jasność, jeśli całość pozostaje zbyt ciemna.

from PIL import Image, ImageFilter, ImageEnhance

def improve_scan(path: str) -> Image.Image:
    """Poprawia jakość skanu niskiej jakości."""
    img = Image.open(path)

    # Redukcja szumu
    img = img.filter(ImageFilter.MedianFilter(size=3))

    # Zwiększenie kontrastu
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(2.0)

    # Zwiększenie jasności, jeśli zbyt ciemno
    enhancer = ImageEnhance.Brightness(img)
    img = enhancer.enhance(1.2)

    return img

Kolejność ma znaczenie: zwiększenie kontrastu przed usunięciem szumu jedynie wzmocni plamy tak samo mocno, jak litery.

Przetwarzanie dużych wolumenów

Gdy liczba plików przekracza kilka sztuk, potrzebne jest przetwarzanie wsadowe z obsługą błędów dla każdego pliku z osobna. Przy bardzo dużych wolumenach Mistral oferuje usługę Batch Inference; poniższy skrypt pokazuje podstawową logikę dla folderu z plikami PDF, gdzie każda awaria jest logowana w wynikach zamiast przerywać pętlę:

import os
import json
from pathlib import Path
from mistralai.client import Mistral

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

def process_folder(folder: str) -> dict:
    """Przetwarza wszystkie pliki PDF w folderze."""
    results = {}
    path = Path(folder)

    for file in path.glob("*.pdf"):
        print(f"Przetwarzanie {file.name}...")

        with open(file, "rb") as f:
            import base64
            doc_b64 = base64.b64encode(f.read()).decode("utf-8")

        try:
            response = client.ocr.process(
                model="mistral-ocr-latest",
                document={
                    "type": "document_url",
                    "document_url": f"data:application/pdf;base64,{doc_b64}"
                },
                table_format="markdown"
            )

            results[file.name] = {
                "pages": len(response.pages),
                "content": "\n\n".join(
                    p.markdown for p in response.pages
                )
            }
        except Exception as e:
            results[file.name] = {"error": str(e)}

    return results

Ten słownik wyników daje Ci na koniec przetwarzania dokładną listę plików do ponownej próby. Przy partii liczącej kilkaset dokumentów to różnica między ponownym uruchomieniem trzech plików a zaczynaniem wszystkiego od zera.

Weryfikacja przed wykorzystaniem

Ekstrakcja, która powiodła się technicznie, może okazać się nieudana w praktyce: pusta strona zwrócona dla nieczytelnego skanu lub powódź bezsensownych znaków na zaszumionym obrazie. Kilka prostych heurystyk wystarczy, aby uruchomić automatyczny alert.

def verify_quality(markdown: str) -> dict:
    """Weryfikuje jakość ekstrakcji OCR."""
    indicators = {
        "length": len(markdown),
        "words": len(markdown.split()),
        "empty_lines_ratio": markdown.count("\n\n") / max(len(markdown), 1),
        "special_chars_ratio": sum(
            1 for c in markdown if not c.isalnum() and c not in " \n\t.,;:!?-"
        ) / max(len(markdown), 1),
    }

    # Alerty
    if indicators["words"] < 10:
        indicators["alert"] = "Wyekstrahowano bardzo mało tekstu"
    elif indicators["special_chars_ratio"] > 0.3:
        indicators["alert"] = "Wysoki udział znaków specjalnych"

    return indicators

Oba progi są orientacyjne i muszą zostać skalibrowane do Twojego korpusu: dziesięć słów na stronie umowy sygnalizuje problem, ale już nie w przypadku listu przewozowego zawierającego tylko piętnaście słów.

Podsumowanie operacyjne

Zapamiętaj łańcuch w jego logicznej kolejności. Skanuj w rozdzielczości minimum 300 DPI dla każdego nietrywialnego dokumentu i zwiększ kontrast przed wysłaniem, jeśli dokument jest wyblakły. Skoryguj kąt obrotu skanów. Zawsze preferuj natywny plik PDF od skanu, gdy jest dostępny: jego jakość jest strukturalnie lepsza. Jawnie określaj table_format="markdown" lub "html", gdy involved są tabele. Przetwarzaj wsadowo i równolegluj wywołania przy dużych wolumenach. I systematycznie waliduj jakość ekstrakcji przed wprowadzeniem jej do systemu informacyjnego – złe dane kosztują więcej niż brakujące dane.

Kluczowe wnioski

  • Jakość dokumentu źródłowego jest głównym czynnikiem wpływającym na dokładność
  • Wstępne przetwarzanie obrazu (kontrast, ostrość, binaryzacja) poprawia wyniki
  • Dostosuj podejście do typu dokumentu (drukowany, ręczny, zdegradowany)
  • Używaj przetwarzania wsadowego dla dużych wolumenów
  • Zawsze waliduj jakość ekstrakcji przed użyciem