# OCR Pipelines and Text Extraction Architecture **Last updated:** 2026-02 **Status:** GA **Category:** Multi-Modal AI --- ## 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 | Azure AI 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 ```python 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 ```python 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 ```python 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 ```python # 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 ```python 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 ```python # 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 ```python 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 ```json { "@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: ```json { "@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 Cosmo - **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.