Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Optimering af OCR-nøjagtighed

Lektion 8 af 16 Opdateret 3. november 2026 Udvikler
På denne side
  1. Inputkvalitet bestemmer outputkvalitet
  2. Opløsning og forbehandling
  3. Tilpasning af konfiguration til dokumenttype
  4. Behandling af volumener
  5. Verificér før udnyttelse
  6. Operationelt overblik
  7. Vigtige pointer

Opdatering 2. november 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) blev udfaset den 30. september 2026. Brug OCR 4.1 (mistral-ocr-4-1), som har været generelt tilgængelig siden 31. august til samme pris, eller aliasset mistral-ocr-latest, som har peget på det siden 16. juli. OCR 4.1 tilføjer konfidensscorer på blokniveau. Tillæg 3. november 2026: En lokal PDF transmitteres i base64 som {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; typen document_base64 fra ældre eksempler findes hverken i dokumentationen eller i mistralai SDK’et, og disse eksempler ville have fejlet. Kilder: OCR Processor · Document QnA.

Inputkvalitet bestemmer outputkvalitet

Mistral-teamet var klare i mælet under deres webinar om Document AI: det er „garbage in, garbage out”. Uanset hvor kraftfuld modellen er, kan den ikke gendanne oplysninger, som scanningen undlod at fange. Når et udtræksprojekt underpræsterer, er synderen næsten altid placeret før API’et – en falmet fotokopi, en gen-indscannet fax eller et foto taget på skrå i et dårligt oplyst lager. Denne lektion dækker de håndtag, der faktisk påvirker nøjagtigheden.

Opløsning og forbehandling

Det første håndtag er scanningsopløsningen. Målene afhænger af, hvad dokumentet indeholder:

  • Trykte dokumenter: Minimum 200 DPI, anbefalet 300 DPI
  • Håndskrift: Minimum 300 DPI
  • Komplekse tabeller: Anbefalet 300 DPI
  • Historiske dokumenter: 400 DPI eller højere

Under disse værdier forsvinder fine linjer, og ingen softwarebehandling kan bringe dem tilbage. At gå højere op øger mest blot filstørrelsen. Hvis du styrer scanningskæden, vil en korrekt opsætning af scanneren spare dig for langt flere problemer end ethvert kodningstrick.

Når dokumentet ankommer allerede digitaliseret, kan billedforbehandling vinde noget terræn tilbage. Funktionen nedenfor kæder fire klassiske operationer sammen – konvertering til gråtoner, kontrastforbedring, skærpning og binarisering – før billedet returneres kodet i base64, klar til OCR-kaldet:

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

def pre_process_image(image_path: str) -> str:
    """Forbehandler et billede for at forbedre OCR-udtrækning."""
    img = Image.open(image_path)

    # 1. Konverter til gråtoner
    img = img.convert("L")

    # 2. Øg kontrasten
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(1.5)

    # 3. Øg skærpningen
    img = img.filter(ImageFilter.SHARPEN)

    # 4. Binarisering (tærskelværdi)
    img = img.point(lambda x: 0 if x < 128 else 255, "1")

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

Test denne behandling på en stikprøve, før du anvender den på en hel batch. Binarisering er især brutal: på et allerede skarpt dokument tilføjer den intet, og på et blyantsdokument kan den slette teksten fuldstændigt.

Orientering er den anden korrektion, du ikke bør negligere. Scanninger ankommer ofte roteret 90 eller 180 grader, og orienteringsinformationen er normalt gemt i billedets EXIF-metadata:

from PIL import Image

def correct_orientation(image_path: str) -> Image.Image:
    """Korrigerer orienteringen af et scannet billede via EXIF-metadata."""
    img = Image.open(image_path)

    # Brug EXIF-data til at korrigere orientering
    try:
        exif = img._getexif()
        if exif:
            orientation = exif.get(274)  # EXIF-orienteringstag
            rotations = {3: 180, 6: 270, 8: 90}
            if orientation in rotations:
                img = img.rotate(rotations[orientation], expand=True)
    except (AttributeError, KeyError):
        pass

    return img

Den brede try-blok er berettiget her: mange billeder har ingen EXIF-data, og manglende orienteringsdata bør ikke afbryde batch-behandlingen.

Tilpasning af konfiguration til dokumenttype

For almindelige trykte dokumenter – fakturaer, kontrakter, rapporter – koger den optimale konfiguration ned til eksplicit at anmode om tabeludtrækning i stedet for at stole på standardindstillinger:

# Optimal konfiguration for trykte dokumenter
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"  # Eksplicit tabeludtrækning
)

Håndskrift kræver mere omhu upstream. Scan ved mindst 300 DPI, øg kontrasten mellem blæk og papir, men spring den aggressive binarisering fra det tidligere script over: den sletter fine kuglepennestrøg, og du vil miste flere oplysninger, end du vinder. Modellen selv håndterer håndskrift godt, inklusive flersproget tekst, hvilket ikke var en selvfølge med tidligere OCR-generationer.

Så er der stærkt nedbrudte scanninger – arkiver, krøllede dokumenter, kopier af kopier. Strategien ændrer sig: start med at reducere støj med et medianfilter, før du booster kontrasten, og øg derefter lysstyrken, hvis det hele stadig er for mørkt.

from PIL import Image, ImageFilter, ImageEnhance

def improve_scan(path: str) -> Image.Image:
    """Forbedrer en scannning af lav kvalitet."""
    img = Image.open(path)

    # Støjreduktion
    img = img.filter(ImageFilter.MedianFilter(size=3))

    # Øg kontrasten
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(2.0)

    # Øg lysstyrken hvis for mørk
    enhancer = ImageEnhance.Brightness(img)
    img = enhancer.enhance(1.2)

    return img

Rækkefølgen betyder noget: at booste kontrasten før fjernelse af støj styrker blot pletterne lige så meget som bogstaverne.

Behandling af volumener

Når antallet af filer overstiger en håndfuld, får du brug for batch-behandling med fejlhåndtering pr. fil. Til meget store volumener tilbyder Mistral Batch Inference-tjenesten; følgende script viser den grundlæggende logik for en mappe med PDF’er, hvor hver fejl logges i resultaterne i stedet for at bryde løkken:

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:
    """Behandler alle PDF'er i en mappe."""
    results = {}
    path = Path(folder)

    for file in path.glob("*.pdf"):
        print(f"Processing {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

Denne results-ordbog giver dig ved slutningen af behandlingen den nøjagtige liste over filer, der skal genkøres. På en batch på flere hundrede dokumenter er det forskellen mellem at genkøre tre filer og starte helt forfra.

Verificér før udnyttelse

En udtrækning, der lykkedes teknisk, kan have fejlet i praksis: en tom side returneret for en ulæselig scanning eller en flodbølge af garbage-tegn på et støjende billede. Nogle få simple heuristikker er nok til at udløse en automatisk alarm.

def verify_quality(markdown: str) -> dict:
    """Verificerer kvaliteten af en OCR-udtrækning."""
    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),
    }

    # Advarsler
    if indicators["words"] < 10:
        indicators["alert"] = "Meget lidt tekst udtrukket"
    elif indicators["special_chars_ratio"] > 0.3:
        indicators["alert"] = "Høj ratio af specialtegn"

    return indicators

De to tærskelværdier er vejledende og skal kalibreres til dit korpus: ti ord på en kontraktside signalerer et problem, men ikke på en følgeseddel, der kun indeholder femten.

Operationelt overblik

Husk kæden i sin logiske rækkefølge. Scan ved mindst 300 DPI for ethvert ikke-trivielt dokument, og øg kontrasten før afsendelse, hvis dokumentet er falmet. Korrektur roteringsvinklen på scanninger. Foretræk altid den native PDF frem for en scanning, når det er muligt: dens kvalitet er strukturelt overlegen. Angiv eksplicit table_format="markdown" eller "html", når tabeller er involveret. Behandle i batches og parallelisér kald for store volumener. Og valider systematisk udtrækningskvaliteten, før du fodrer den ind i dit informationssystem – dårlige data koster mere end manglende data.

Vigtige pointer

  • Kildedokumentets kvalitet er den primære faktor for nøjagtighed
  • Billedforbehandling (kontrast, skærpning, binarisering) forbedrer resultaterne
  • Tilpas din tilgang til dokumenttypen (trykt, håndskrevet, nedbrudt)
  • Brug batch-behandling til store volumener
  • Valider altid udtrækningskvaliteten før brug