Spring til hovedindhold
Dansk— Vælg et sprog
Menu

OCR: Tekstuddrag

Lektion 6 af 12 Opdateret 30. juli 2026 Begynder
På denne side
  1. Læs tekst i billeder
  2. Klassisk OCR vs. multimodal OCR
  3. Grundlæggende udtrækning
  4. Struktureret dokumentudtrækning
  5. Udtrækning af visitkort
  6. Behandling af skærmbilleder
  7. Batch-behandling af dokumenter
  8. Begrænsninger ved Grok OCR
  9. Vigtige pointer

Læs tekst i billeder

OCR (Optical Character Recognition) er et af de mest kraftfulde anvendelsestilfælde for Grok Vision. I modsætning til traditionelle værktøjer, der kun udtrækker tegn, forstår Grok konteksten af teksten i billedet, dens layout og dens betydning.

Klassisk OCR vs. multimodal OCR

Traditionelle OCR-værktøjer (Tesseract, Google Vision OCR, AWS Textract) er fremragende til rå tegnudtrækning. Grok tilføjer en ekstra dimension: Det forstår, hvad teksten betyder inden for billedets kontekst.

Når du eksempelvis behandler en scannet faktura, udtrækker et klassisk OCR-værktøj alle tegn. Grok kan også:

  • Identificere felter (fakturanummer, dato, samlet beløb)
  • Strukturere data i et brugbart format
  • Korrigere OCR-fejl ved hjælp af kontekst
  • Fortolke tabeller og komplekse layouts

Grundlæggende udtrækning

Til simpel udtrækning af synlig tekst:

response = client.responses.create(
    model="grok-4.5",
    input=[
        {
            "type": "input_image",
            "image_url": url_document,
            "detail": "high"  # Essential for OCR
        },
        {
            "type": "input_text",
            "text": "Extract all visible text in this image. Preserve the layout as much as possible."
        }
    ],
    store=False
)

Parameteren detail: "high" er afgørende for OCR. I low-tilstand kan modellen overse fin tekst eller fejlæse visse tegn.

Struktureret dokumentudtrækning

Til professionelle dokumenter bør du anmode om struktureret udtrækning:

def extraire_facture(image_url):
    prompt = """This image is an invoice. Extract the following
information in JSON:
- "invoice_number": the invoice number
- "date": the issue date
- "issuer": name and address of the issuer
- "recipient": name and address of the recipient
- "lines": table with columns [description, quantity, unit_price, total]
- "subtotal": amount excluding tax
- "vat": VAT amount
- "total_incl_tax": amount including tax

If a field is not visible, indicate null."""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_image", "image_url": image_url, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Udtrækning af visitkort

def extraire_carte_visite(image_url):
    prompt = """Extract the information from this business card in JSON:
- "name": full name
- "title": job title/position
- "company": company name
- "email": email address
- "phone": phone number(s)
- "address": postal address
- "website": website URL
- "social_media": links to social media profiles"""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_image", "image_url": image_url, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Behandling af skærmbilleder

Skærmbilleder er et fremragende anvendelsestilfælde, da de ofte indeholder tekst i komplekse layouts (menuer, sidebjælker, popups):

def analyser_screenshot(image_url):
    prompt = """Analyze this screenshot and identify:
1. The application or website displayed
2. The visible page or section
3. The main interface elements (buttons, menus, forms)
4. Any important text displayed
5. Any error messages or notifications"""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_image", "image_url": image_url, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Batch-behandling af dokumenter

For at behandle store mængder dokumenter skal du kombinere Grok OCR med en behandlingspipeline:

import json

async def pipeline_ocr(documents):
    resultats = []

    for doc in documents:
        # 1. Validate the image
        if not valider_image(doc["chemin"]):
            resultats.append({"fichier": doc["chemin"], "erreur": "Invalid image"})
            continue

        # 2. Encode to base64
        image_url = encoder_base64(doc["chemin"])

        # 3. Extract with Grok
        response = client.responses.create(
            model="grok-4.5",
            input=[
                {"type": "input_image", "image_url": image_url, "detail": "high"},
                {"type": "input_text", "text": doc["prompt"]}
            ],
            store=False
        )

        # 4. Parse the result
        try:
            data = json.loads(response.output_text)
            resultats.append({"fichier": doc["chemin"], "data": data})
        except json.JSONDecodeError:
            resultats.append({"fichier": doc["chemin"], "texte_brut": response.output_text})

    return resultats

Begrænsninger ved Grok OCR

  • Håndskrevet tekst: Genkendelse fungerer godt for læselig skrift, men kan fejle ved kursiv eller ulæselig håndskrift.
  • Ikke-latinske sprog: Nøjagtigheden varierer afhængigt af sproget og den anvendte skrifttype.
  • Billeder i lav kvalitet: Scanninger med lav opløsning eller slørede fotos forringer resultaterne.
  • Meget lille tekst: Selv i high-tilstand kan tekst, der er mindre end 8 pixels i højden, blive fejlæst.

Vigtige pointer

  • Brug altid detail: "high" til OCR-opgaver.
  • Anmod om struktureret udtrækning (JSON) for automatisk at kunne bruge dataene.
  • Grok går videre end rå OCR: Det forstår kontekst og layout.
  • Brug store: false til følsomme dokumenter (fakturaer, visitkort).
  • Valider og forbehandl billeder for at maksimere udtrækningskvaliteten.