ms-ai-architect/skills/ms-ai-engineering/references/multi-modal/ocr-pipeline-architecture.md

OCR Pipelines and Text Extraction Architecture

Last updated: 2026-02 Status: GA Category: Multi-Modal AI Type: reference

---

Innhold

• Introduksjon
• Kjernekomponentar
• Image Preprocessing og Quality Assessment
• OCR Engine Selection og Configuration
• Text Normalization og Correction
• Integration with Document Understanding
• Norsk offentleg sektor
• Beslutningsrammeverk
• For arkitekten

Introduksjon

Optical Character Recognition (OCR) er ein grunnleggjande kapabilitet for digitalisering av offentleg forvaltning. Microsoft tilbyr to hovudtenester for OCR: Azure AI Document Intelligence (tidlegare Form Recognizer) som er optimalisert for dokument med høg oppløysing, og Azure AI Vision Image Analysis (Read API) som er optimalisert for generelle bilete som skiltar, plakatar og scena-tekst.

Document Intelligence opererer på høgare oppløysing enn Vision Read og støttar utvinning av både trykt og handskriven tekst frå PDF-dokument, skanna bilete, Microsoft Office-filer (Word, Excel, PowerPoint) og HTML. Tenesta inkluderer paragrafdeteksjon, tabellgjenkjenning, figurar, utvalgsmerke og språkdeteksjon. Read-modellen er OCR-motoren som ligg under alle andre Document Intelligence-modellar (Layout, Invoice, Receipt, ID Document, osv.).

For norsk offentleg sektor er robust OCR kritisk for digitalisering av arkiv, automatisering av saksbehandling, uttrekk av data frå skjema og faktura, og tilgjengeleggjering av historiske dokument. Azure Document Intelligence v4.0 (GA) tilbyr Batch API for store volum, searchable PDF-output, og add-on capabilities som høgoppløyseleg OCR, språkdeteksjon og query fields.

---

Kjernekomponentar

Komponent	Formål	Teknologi
Document Intelligence Read	Dokument-optimalisert OCR med paragrafar	Azure AI Document Intelligence v4.0
Document Intelligence Layout	Strukturert uttrekk (tabellar, figurar)	Azure AI Document Intelligence v4.0
Vision Read API	Generell scene-tekst OCR	Azure AI Vision 4.0
Prebuilt Models	Feltuttrekk frå faktura, kvittering, ID	Azure AI Document Intelligence
Custom Models	Trenable modellar for eigne dokumenttypar	Azure AI Document Intelligence
Document Classifier	Automatisk dokumentklassifisering og splitting	Azure AI Document Intelligence
Content Understanding	Generativ AI-basert dokumentforståing	Microsoft Foundry (preview)
Batch API	Volumbasert asynkron prosessering	Azure AI Document Intelligence v4.0

---

Image Preprocessing og Quality Assessment

Bildekvalitetskrav

Parameter	Document Intelligence	Vision Read
Format	PDF, JPEG, PNG, BMP, TIFF, HEIF, DOCX, XLSX, PPTX, HTML	JPEG, PNG, GIF, BMP, WEBP, ICO, TIFF, MPO
Maks filstorleik	500 MB (Standard), 4 MB (Free)	20 MB
Maks dimensjonar	10 000 x 10 000 px (standard)	16 000 x 16 000 px
Min dimensjonar	50 x 50 px	50 x 50 px
Maks sider	2000 sider per dokument	N/A (enkeltbilete)

Preprocessing-pipeline

from PIL import Image, ImageEnhance, ImageFilter
import io

def preprocess_for_ocr(image_path: str) -> bytes:
    """Optimaliser bilete for best OCR-resultat."""
    img = Image.open(image_path)

    # Steg 1: Konverter til gråskala om ikkje allereie
    if img.mode != 'L':
        img = img.convert('L')

    # Steg 2: Oppskaler låg-oppløyselege bilete
    min_dimension = 1024
    if min(img.size) < min_dimension:
        scale = min_dimension / min(img.size)
        new_size = (int(img.width * scale), int(img.height * scale))
        img = img.resize(new_size, Image.LANCZOS)

    # Steg 3: Kontrastforbetring
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(1.5)

    # Steg 4: Skarpheit
    img = img.filter(ImageFilter.SHARPEN)

    # Steg 5: Binarisering for svært dårlege skanningar
    # (valfritt — bruk berre for ekstremt dårlege bilete)
    # threshold = 128
    # img = img.point(lambda p: 255 if p > threshold else 0)

    buffer = io.BytesIO()
    img.save(buffer, format="PNG", dpi=(300, 300))
    return buffer.getvalue()

Kvalitetsmetrikkar

def assess_image_quality(image_path: str) -> dict:
    """Vurder bildekvalitet for OCR."""
    img = Image.open(image_path)

    quality = {
        "resolution": {
            "width": img.width,
            "height": img.height,
            "dpi_estimated": min(img.width, img.height) / 8.27,
            "sufficient": min(img.width, img.height) >= 500
        },
        "format": {
            "mode": img.mode,
            "format": img.format,
            "is_optimal": img.format in ["PNG", "TIFF"]
        },
        "recommendation": []
    }

    if quality["resolution"]["dpi_estimated"] < 150:
        quality["recommendation"].append(
            "Oppløysing er låg — bruk OCR_HIGH_RESOLUTION add-on"
        )
    if img.mode == "RGBA":
        quality["recommendation"].append(
            "Konverter frå RGBA til RGB for raskare prosessering"
        )

    return quality

---

OCR Engine Selection og Configuration

Hovudval: Document Intelligence vs Vision Read

Kriterium	Document Intelligence Read	Vision Read API
Brukscase	Dokument (PDF, skanningar, Office)	Scene-tekst (skiltar, plakatar)
Oppløysing	Høgare (doc-optimalisert)	Standard
Handskrift	Ja — premium	Ja — grunnleggjande
Tabellar	Ja (Layout-modell)	Nei
Strukturert output	Paragrafar, seksjonar, figurar	Liner og ord
Fleirspråkleg	300+ språk/lokalar	100+ språk
Batch	Ja (Batch API)	Nei (synkron)
Output til PDF	Searchable PDF	Nei

Document Intelligence Read — Python SDK

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import (
    AnalyzeResult,
    AnalyzeDocumentRequest,
    DocumentAnalysisFeature
)

client = DocumentIntelligenceClient(
    endpoint=os.environ["DI_ENDPOINT"],
    credential=AzureKeyCredential(os.environ["DI_KEY"])
)

# Analyser dokument med high-resolution OCR
with open("scanned_document.pdf", "rb") as f:
    poller = client.begin_analyze_document(
        "prebuilt-read",
        body=f,
        features=[DocumentAnalysisFeature.OCR_HIGH_RESOLUTION]
    )

result: AnalyzeResult = poller.result()

# Utvinne språkdeteksjon
if result.languages:
    for lang in result.languages:
        print(f"Språk: {lang.locale} "
              f"(confidence: {lang.confidence:.2f})")

# Utvinne handskrift-stil
if result.styles:
    for style in result.styles:
        if style.is_handwritten:
            text = ",".join([
                result.content[s.offset:s.offset + s.length]
                for s in style.spans
            ])
            print(f"Handskriven tekst: {text}")

# Utvinne paragrafar
for para in result.paragraphs:
    print(f"[{para.role}] {para.content}")

# Utvinne sider, liner og ord
for page in result.pages:
    print(f"--- Side {page.page_number} ---")
    print(f"Dimensjonar: {page.width}x{page.height} {page.unit}")
    for line in page.lines:
        print(f"  Linje: {line.content}")
        for word in page.words:
            if word.confidence < 0.7:
                print(f"    [LAV CONFIDENCE] {word.content}: "
                      f"{word.confidence:.2f}")

Layout-modellen for strukturert uttrekk

# Layout gir tabellar, figurar og seksjonar i tillegg til OCR
poller = client.begin_analyze_document(
    "prebuilt-layout",
    AnalyzeDocumentRequest(url_source=document_url)
)
result = poller.result()

# Tabellar
for table_idx, table in enumerate(result.tables):
    print(f"Tabell {table_idx}: "
          f"{table.row_count} rader x {table.column_count} kolonnar")
    for cell in table.cells:
        print(f"  [{cell.row_index}][{cell.column_index}]: "
              f"{cell.content}")

# Figurar (med bounding regions)
if result.figures:
    for fig in result.figures:
        print(f"Figur: {fig.caption.content if fig.caption else 'Utan caption'}")

---

Text Normalization og Correction

Post-OCR normalisering

import re
from typing import Optional

def normalize_ocr_text(raw_text: str,
                       locale: str = "nb-NO") -> str:
    """Normaliser OCR-tekst for norsk kontekst."""

    text = raw_text

    # Fiks vanlege OCR-feil i norsk tekst
    ocr_corrections = {
        r'\b0\b(?=[a-zA-Z])': 'O',      # 0 → O framfor bokstavar
        r'(?<=[a-zA-Z])\b0\b': 'o',      # 0 → o etter bokstavar
        r'l(?=[0-9])': '1',               # l → 1 framfor tal
        r'(?<=[0-9])O': '0',             # O → 0 etter tal
        r'æ\s': 'æ',                      # Fjern spacing i æøå
        r'ø\s': 'ø',
        r'å\s': 'å',
    }

    for pattern, replacement in ocr_corrections.items():
        text = re.sub(pattern, replacement, text)

    # Normaliser personnummer-format
    text = re.sub(
        r'(\d{6})\s*(\d{5})',
        r'\1 \2',
        text
    )

    # Normaliser organisasjonsnummer
    text = re.sub(
        r'(\d{3})\s*(\d{3})\s*(\d{3})',
        r'\1 \2 \3',
        text
    )

    # Fjern OCR-artifact (stray pikslar som vert tolka som teikn)
    text = re.sub(r'[^\w\s.,;:!?()@\-/\\æøåÆØÅ€£$%&#+*]', '', text)

    return text.strip()


def extract_structured_fields(ocr_result: AnalyzeResult) -> dict:
    """Utvinne strukturerte felt frå OCR-resultat."""
    fields = {}

    for para in ocr_result.paragraphs:
        content = para.content.strip()

        # Detekter datoar
        date_match = re.search(
            r'(\d{1,2})[./-](\d{1,2})[./-](\d{2,4})',
            content
        )
        if date_match:
            fields.setdefault("dates", []).append(date_match.group())

        # Detekter beløp (NOK)
        amount_match = re.search(
            r'kr\.?\s*([\d\s]+[,.]?\d*)',
            content, re.IGNORECASE
        )
        if amount_match:
            fields.setdefault("amounts", []).append(
                amount_match.group(1).strip()
            )

    return fields

---

Integration with Document Understanding

End-to-end OCR Pipeline

Innkommande dokument (PDF/bilete)
    → Steg 1: Kvalitetsvurdering (preprocessing)
    → Steg 2: Dokumentklassifisering (Custom Classifier)
    → Steg 3: OCR + Strukturert uttrekk
        → Faktura → prebuilt-invoice
        → Kvittering → prebuilt-receipt
        → ID-dokument → prebuilt-idDocument
        → Generelt → prebuilt-layout + query fields
    → Steg 4: Post-processing (normalisering, validering)
    → Steg 5: Integrasjon (Cosmos DB, AI Search, Power Automate)

Query Fields for fleksibelt feltuttrekk

# Utvinne spesifikke felt utan modelltrening
poller = client.begin_analyze_document(
    "prebuilt-layout",
    AnalyzeDocumentRequest(url_source=doc_url),
    features=[DocumentAnalysisFeature.QUERY_FIELDS],
    query_fields=["Saksnummer", "Vedtaksdato", "Klagerist",
                   "Ansvarlig saksbehandler"]
)
result = poller.result()

for doc in result.documents:
    for field_name, field_value in doc.fields.items():
        print(f"{field_name}: {field_value.get('valueString')}")

Searchable PDF Output

from azure.ai.documentintelligence.models import AnalyzeOutputOption

# Konverter skanna PDF til søkbar PDF
with open("scanned.pdf", "rb") as f:
    poller = client.begin_analyze_document(
        "prebuilt-read",
        body=f,
        output=[AnalyzeOutputOption.PDF]
    )

result = poller.result()
operation_id = poller.details["operation_id"]

# Last ned searchable PDF
response = client.get_analyze_result_pdf(
    model_id=result.model_id,
    result_id=operation_id
)

with open("searchable_output.pdf", "wb") as writer:
    writer.writelines(response)

Azure AI Search Integration

{
  "@odata.type": "#Microsoft.Skills.Vision.OcrSkill",
  "context": "/document/normalized_images/*",
  "detectOrientation": true,
  "inputs": [
    {"name": "image", "source": "/document/normalized_images/*"}
  ],
  "outputs": [
    {"name": "text", "targetName": "ocrText"},
    {"name": "layoutText", "targetName": "ocrLayoutText"}
  ]
}

Kombiner med Text Merge skill for å slå saman OCR-tekst med dokumenttekst:

{
  "@odata.type": "#Microsoft.Skills.Text.MergeSkill",
  "context": "/document",
  "inputs": [
    {"name": "text", "source": "/document/content"},
    {"name": "itemsToInsert", "source": "/document/normalized_images/*/ocrText"}
  ],
  "outputs": [
    {"name": "mergedText", "targetName": "merged_content"}
  ]
}

---

Norsk offentleg sektor

Bruksområde

• Arkivdigitalisering: OCR av historiske dokument og protokollar
• Saksbehandling: Automatisk uttrekk frå innkomne dokument
• Fakturaprosessering: Prebuilt invoice model for leverandørfaktura
• ID-verifisering: Prebuilt ID document model for pass og førarkort
• Byggesak: Uttrekk av informasjon frå teikningar og plankartet

Språkstøtte for norsk

• Document Intelligence: Norsk bokmål (nb) og nynorsk (nn) støtta
• Handskriftgjenkjenning: Støttar norske teikn (æ, ø, å)
• High-resolution OCR: Forbetrar resultat for gamle, dårlege skanningar

GDPR og personvern

• Document Intelligence er stateless — ingen lagring etter analyse
• For PDF med personnummer: Sladding etter OCR-uttrekk
• Batch API-resultat lagrast i Microsoft-managed container eller eigen Azure Storage
• Anbefaling: Bruk customer-managed key for kryptering av mellomlagring

---

Beslutningsrammeverk

Scenario	Anbefaling	Grunngjeving
PDF-dokumentanalyse	Document Intelligence Read/Layout	Beste OCR for dokument
Skiltar og scene-tekst	Vision Read API	Optimalisert for generelle bilete
Faktura/kvittering	Document Intelligence prebuilt	Ferdig modell med feltuttrekk
Eigendefinerte skjema	Custom Model + query fields	Fleksibelt utan full modelltrening
Store volum (10K+ dokument)	Batch API	Asynkron, kostnadseffektiv
Historiske dokument (dårleg kvalitet)	OCR_HIGH_RESOLUTION add-on	Høgare oppløysing for betre resultat
Søkbar PDF frå skanning	Read + AnalyzeOutputOption.PDF	Innebygd searchable PDF
RAG-pipeline	AI Search + OCR Skill + Text Merge	End-to-end indeksering

---

For arkitekten

• Azure AI Document Intelligence v4.0 er standard for dokument-OCR — høgare oppløysing enn Vision Read, støttar PDF/Office/HTML, og inkluderer paragrafdeteksjon, tabellar og handskrift med confidence scores per ord.
• Prebuilt-modellar eliminerer behovet for trening — invoice, receipt, ID document og layout dekkjer dei vanlegaste scenarioa i offentleg forvaltning, med query fields for fleksibelt feltuttrekk utan modelltrening.
• Batch API er essensielt for volum-digitalisering — asynkron prosessering av tusenvis av dokument med resultat i Azure Blob Storage, eigna for arkivdigitaliseringsprosjekt.
• Searchable PDF er ein game-changer for arkiv — konverter skanna dokument til søkbare PDF-ar med innebygd tekst-layer, direkte brukbare i saksbehandlingssystem og arkivløysingar.
• OCR_HIGH_RESOLUTION add-on er kritisk for dårlege skanningar — aktiverer høgare oppløysing for historiske dokument, handskrivne notat og låg-kvalitets-kopiar som er vanlege i offentlege arkiv.