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

OCR i transkrypcja tekstu z obrazów

Lekcja 8 z 12 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Odczytywanie tekstu z obrazów
  2. Prosty OCR: odczyt widocznego tekstu
  3. Wydobywanie tekstu z faktury
  4. Transkrypcja zrzutów ekranu
  5. Odczyt paragonów i biletów kasowych
  6. Przetwarzanie dokumentów wsadowo
  7. Poprawa dokładności OCR
  8. Vision API a Document AI
  9. Kluczowe wnioski

Odczytywanie tekstu z obrazów

OCR (optyczne rozpoznawanie znaków) to jeden z najczęstszych przypadków użycia Vision API. Dzięki modelom multimodalnym Mistrala możesz wydobywać tekst ze zdjęć, zrzutów ekranu, zeskanowanych dokumentów, faktur czy paragonów bez instalowania dedykowanej biblioteki OCR – żadnego Tesseracta, żadnych modeli językowych, żadnego potoku przetwarzania wstępnego.

Zaletą nie jest tylko ograniczenie liczby zależności. Klasyczny OCR zwraca znaki; model multimodalny rozumie to, co czyta, i potrafi w tym samym wywołaniu odróżnić numer faktury od numeru zamówienia zakupowego. W tej lekcji omówimy typowe przypadki użycia oraz techniki, które konkretnie poprawiają dokładność.

Prosty OCR: odczyt widocznego tekstu

Najprostsze podejście sprowadza się do jednego promptu, pod warunkiem że jest on jednoznaczny:

from mistralai.client import Mistral
import os

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

response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Transcribe exactly all visible text in this image. Do not comment, do not summarize--return only the text as it appears."},
                {"type": "image_url", "image_url": "https://exemple.com/document-scanne.jpg"}
            ]
        }
    ]
)

print(response.choices[0].message.content)

Słowem kluczem jest „dokładnie“. Bez tej instrukcji model ma tendencję do parafrazowania lub streszczania treści, bo tak właśnie spontanicznie działa pomocny asystent: tutaj prosisz o coś przeciwnego niż usługa – o dosłowne odtworzenie.

Wydobywanie tekstu z faktury

Faktury zawierają ustrukturyzowane informacje – wystawca, odbiorca, kwoty, daty – które model może zidentyfikować według ich roli, a nie tylko położenia. To właśnie przewaga nad OCR-em o stałych strefach, który zawodzi, gdy tylko dostawca zmieni układ:

prompt_facture = """Analyze this invoice and extract the following information:
- Issuer (name, address, SIRET if visible)
- Recipient (name, address)
- Invoice number
- Issue date
- Due date
- Billing lines (description, quantity, unit price, total)
- Subtotal excluding tax
- VAT (rate and amount)
- Total including tax

Return the result as structured JSON."""

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "You are a certified accountant. Extract billing data with precision. Return only valid JSON."
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": prompt_facture},
                {"type": "image_url", "image_url": data_uri_facture}
            ]
        }
    ]
)

Transkrypcja zrzutów ekranu

Inną częstą potrzebą jest pobieranie treści z interfejsu lub terminala udostępnionego jako zrzut ekranu, zazwyczaj w zgłoszeniu wsparcia. Tutaj formatowanie jest częścią informacji: ślad terminala bez zachowanych wcięć staje się bezużyteczny.

import base64

def encoder_image(chemin):
    with open(chemin, "rb") as f:
        b64 = base64.standard_b64encode(f.read()).decode("utf-8")
    return f"data:image/png;base64,{b64}"

# Transcribe a terminal screenshot
response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Transcribe the terminal output visible in this screenshot. Preserve formatting and indentation."
                },
                {"type": "image_url", "image_url": encoder_image("captures/terminal.png")}
            ]
        }
    ]
)

Odczyt paragonów i biletów kasowych

Paragony termiczne to najtrudniejszy przypadek: blady druk, pognieciony papier, blaknący tusz. Rozstrzygającą techniką jest wyraźne pozwolenie modelowi na przyznanie się do porażki przy danym elemencie; w przeciwnym razie wypełni luki prawdopodobnymi wartościami.

prompt_recu = """Read this cash register ticket and extract:
1. Store name
2. Date and time
3. List of items (name, price)
4. Subtotal
5. Payment method
6. Total amount

If an item is illegible, indicate [illegible].
Return the result as JSON."""

response = client.chat.complete(
    model="mistral-large-latest",  # Large for best reading
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": prompt_recu},
                {"type": "image_url", "image_url": encoder_image("recu-supermarche.jpg")}
            ]
        }
    ]
)

Wynik zawierający [illegible] jest nieskończenie lepszy niż zmyślona kwota: pierwszy uruchamia weryfikację przez człowieka, drugi pozostaje niezauważony aż do uzgodnień księgowych. W przypadku takich zdegradowanych dokumentów użyj Mistral Large 3 – różnica w dokładności względem Small jest znacząca przy rozmytym lub częściowo czytelnym tekście.

Przetwarzanie dokumentów wsadowo

Skalowanie w górę follows wzorzec, który już widzieliśmy: funkcja jednostkowa parametryzowana modelem, a potem pętla po folderze.

import json
from pathlib import Path

def ocr_document(chemin_image, modele="mistral-small-latest"):
    """Performs OCR on a document and returns the text."""
    response = client.chat.complete(
        model=modele,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": "Transcribe the entire text of this document. Preserve formatting (headings, paragraphs, lists)."
                    },
                    {"type": "image_url", "image_url": encoder_image(chemin_image)}
                ]
            }
        ]
    )
    return response.choices[0].message.content

# Process a folder
dossier = Path("documents_scannes/")
resultats = {}

for fichier in sorted(dossier.glob("*.jpg")):
    print(f"OCR of {fichier.name}...")
    resultats[fichier.name] = ocr_document(fichier)

# Save
with open("transcriptions.json", "w", encoding="utf-8") as f:
    json.dump(resultats, f, ensure_ascii=False, indent=2)

print(f"{len(resultats)} documents transcribed.")

Parametr modele w sygnaturze nie jest kosmetyczny: pozwala ponownie uruchomić tylko wątpliwe dokumenty z Large bez przepisywania funkcji.

Poprawa dokładności OCR

Dwa dźwignie działają upstream względem modelu. Pierwsza to wstępne przetwarzanie obrazu: szary skan o niskim kontraście staje się czytelny po konwersji na skalę szarości, zwiększeniu kontrastu i wyostrzeniu.

from PIL import Image, ImageEnhance, ImageFilter

def pretraiter_pour_ocr(chemin):
    """Improves an image for OCR: contrast, sharpness, grayscale."""
    img = Image.open(chemin)

    # Convert to grayscale
    img = img.convert("L")

    # Increase contrast
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(2.0)

    # Increase sharpness
    img = img.filter(ImageFilter.SHARPEN)

    return img

Współczynnik 2,0 sprawdza się przy wyblakłym skanie; zbyt mocno podbity tworzy artefakty pogarszające odczyt. Przetestuj na trzech reprezentatywnych dokumentach przed ustaleniem wartości.

Drugą dźwignią jest specjalizacja promptu według typu dokumentu. Formularz wymaga „Odczytaj każde pole i jego odpowiadającą wartość“, list – „Przepisz treść listu, zachowując akapity“, tabela – „Wydobierz dane tabeli w formacie markdown“. Trzy sformułowania, trzy struktury wyjścia: sklasyfikuj dokumenty przed ich transkrypcją, a jakość skoczy o poziom wyżej.

Vision API a Document AI

Do zaawansowanego OCR i parsowania dokumentów Mistral oferuje również Document AI (OCR 4), usługę wyspecjalizowaną. Poniższa tabela nakreśla granicę między nimi.

KryteriumVision APIDocument AI (OCR 4)
Prosty OCRWystarczającyPrzeskalowany
Dokumenty złożoneOgraniczonyZoptymalizowany
Tabele zagnieżdżonePrzybliżonyPrecyzyjny
Wielostronicowe PDF-yNieobsługiwaneObsługiwane
Złożony układPodstawowyZaawansowany

Rozstrzygającą linią są wielostronicowe PDF-y: Vision API przetwarza obrazy, a nie dokumenty podzielone na strony. Gdy tylko Twoim źródłem jest PDF liczący kilkadziesiąt stron, pytanie przestaje istnieć. Omówimy Document AI w lekcji 12 (Kolejne kroki).

Kluczowe wnioski

  • Vision API zapewnia wystarczający OCR w prostych przypadkach (faktury, zrzuty ekranu, paragony)
  • Używaj słowa „dokładnie“ w prompcie, aby uniknąć parafrazowania
  • Mistral Large 3 jest znacząco lepszy od Small w przypadku dokumentów niskiej jakości
  • Wstępne przetwarzanie obrazu (kontrast, skala szarości) poprawia wyniki
  • Do zaawansowanego OCR i wielostronicowych PDF-ów rozważ Document AI od Mistrala (OCR 4)