ms-ai-architect/skills/ms-ai-engineering/references/multi-modal/cv-llm-integration.md

Computer Vision and LLM Integration

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

---

Innhold

• Introduksjon
• Kjernekomponentar
• Vision Encoder Selection og Fine-Tuning
• Prompt Injection for Visual Grounding
• Scene Understanding og Spatial Reasoning
• Few-Shot Learning med visuelle eksempel
• Implementeringsmønstre
• Norsk offentleg sektor
• Beslutningsrammeverk
• For arkitekten

Introduksjon

Integrasjonen av spesialiserte computer vision (CV) modellar med large language models (LLMs) representerer ein av dei viktigaste trendane i AI-arkitektur. I staden for å bruke GPT-4o sin innebygde vision direkte for alle oppgåver, kombinerer avanserte arkitekturar spesialiserte vision encoders med generative LLMs for å oppnå betre nøyaktigheit, lågare kostnad og meir kontrollerte resultat.

Azure-plattforma gir eit rikt økosystem for dette: Azure AI Vision for spesialisert bildeanalyse (OCR, objektdeteksjon, multimodal embeddings), Azure OpenAI for GPT-4o og GPT-4.1 sine vision-kapabilitetar, Microsoft Foundry for modellfinetuning og deployment, og Phi-4-multimodal-instruct som ein kostnadseffektiv open-source-modell for edge-scenario. Florence-2-modellen frå Microsoft er eit anna sterkt alternativ for spesialiserte vision-oppgåver.

For norsk offentleg sektor er denne integrasjonen relevant for byggesaksbehandling (analyse av arkitektteikningar), eigedomsforvaltning (skadevurdering frå bilete), helsevesen (medisinsk bildeanalyse), og kulturarv (digitalisering og klassifisering av museumsgjenstandar). Nøkkelen er å kombinere rette verktøy for rette oppgåver — bruk spesialiserte CV-modellar for presis ekstraksjon og LLMs for tolking og resonnering.

---

Kjernekomponentar

Komponent	Formål	Teknologi
Azure AI Vision	Spesialisert bildeanalyse og OCR	Image Analysis 4.0
GPT-4o / GPT-4.1 Vision	Multimodal LLM med bildeforståing	Azure OpenAI
Phi-4-multimodal	Open-source multimodal modell	Microsoft Foundry / Edge
Florence-2	Universell vision foundation model	Hugging Face / Azure ML
Multimodal Embeddings	Vektor-representasjon av bilete og tekst	Azure AI Vision v4.0
Custom Vision	Eigendefinert objektdeteksjon/klassifisering	Azure AI Custom Vision

---

Vision Encoder Selection og Fine-Tuning

Valet av vision encoder

Modell	Styrke	Svakheit	Bruksscenario
GPT-4o native vision	Generell forståing, resonnering	Kostnad, ingen spesialisering	Generell bildeforståing
Azure AI Vision 4.0	OCR, objektdeteksjon, embeddings	Ikkje generativ	Strukturert ekstraksjon
Florence-2	Universell, finetunable	Krev GPU for inferens	Spesialiserte oppgåver
Phi-4-multimodal	Liten, edge-kompatibel	Lågare kapasitet	Edge/IoT-scenario
Custom Vision	Høg nøyaktigheit for spesifikt domene	Krev treningsdata	Domene-spesifikk klassifisering

Vision Fine-Tuning av GPT-4o

GPT-4o støttar vision fine-tuning for å tilpasse modellen til spesifikke bildedomene:

# Treningsdata format (JSONL)
training_example = {
    "messages": [
        {
            "role": "system",
            "content": "Du er ein ekspert på identifisering av norske planteartar."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Identifiser og klassifiser planta i biletet."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "data:image/jpeg;base64,<base64_encoded_image>"
                    }
                }
            ]
        },
        {
            "role": "assistant",
            "content": "Planta er hundekjeks (Anthriscus sylvestris). "
                       "Familie: Skjermplantefamilien. Tilstand: Blomstrande."
        }
    ]
}

Krav for vision fine-tuning:

• Modell: gpt-4o versjon 2024-08-06 eller gpt-4.1 versjon 2025-04-14
• Maks 50 000 eksempel med bilete
• Maks 64 bilete per eksempel
• Maks 10 MB per bilete
• Format: JPEG, PNG, WEBP (RGB eller RGBA)
• Minimum 10 eksempel

Student-Teacher arkitektur

Phi-4-multimodal kan fintunast med labels frå GPT-4o i ein Student-Teacher-arkitektur:

# Teacher: GPT-4o genererer treningsdata
teacher_labels = generate_labels_with_gpt4o(images)

# Student: Phi-4-multimodal fintunast
from transformers import AutoModelForCausalLM, AutoProcessor
import torch

model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-4-multimodal-instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

processor = AutoProcessor.from_pretrained(
    "microsoft/Phi-4-multimodal-instruct"
)

# Fine-tuning med LoRA for effektivitet
from peft import LoraConfig, get_peft_model

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05
)

model = get_peft_model(model, lora_config)

---

Prompt Injection for Visual Grounding

Teknikkar for visuell grounding

Visual grounding er prosessen med å kople språklege referansar til spesifikke regionar i eit bilete. Gjennom prompt engineering kan ein styre korleis LLM-en tolkar og refererer til biletinnhald.

Strukturert prompting

def grounded_image_analysis(client, image_url, analysis_type):
    """Analyser bilete med strukturert grounding-prompt."""

    grounding_prompts = {
        "spatial": (
            "Analyser biletet systematisk:\n"
            "1. Kva er i SENTRUM av biletet?\n"
            "2. Kva er i BAKGRUNNEN?\n"
            "3. Kva er i FORGRUNNEN?\n"
            "4. Kva er til VENSTRE?\n"
            "5. Kva er til HØGRE?\n"
            "Beskriv relative storleikar og avstandar."
        ),
        "technical": (
            "Analyser det tekniske diagrammet:\n"
            "1. Identifiser alle komponentar (bounding box: oppe-venstre, nede-høgre)\n"
            "2. Beskriv koplingane mellom komponentar\n"
            "3. Les all tekst i diagrammet\n"
            "4. Identifiser dataflyt-retning"
        ),
        "document": (
            "Analyser dokumentet:\n"
            "1. Identifiser dokumenttype\n"
            "2. Les og strukturer all tekst\n"
            "3. Ekstraher tabellar i Markdown-format\n"
            "4. Identifiser signaturfelt og stempel\n"
            "5. Vurder dokumentet sin tilstand"
        )
    }

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": "Du er ein visuell analyseekspert. Ver presis om posisjonar."
            },
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": grounding_prompts[analysis_type]},
                    {"type": "image_url", "image_url": {"url": image_url, "detail": "high"}}
                ]
            }
        ],
        max_tokens=1500
    )

    return response.choices[0].message.content

Region-of-Interest Prompting

def analyze_image_region(client, image_url, region_description):
    """Fokuser analyse på ein spesifikk region av biletet."""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            f"Sjå nøye på {region_description} i biletet. "
                            f"Ignorer resten og fokuser berre på denne regionen. "
                            f"Beskriv detaljert kva du ser."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {"url": image_url, "detail": "high"}
                    }
                ]
            }
        ]
    )

    return response.choices[0].message.content

---

Scene Understanding og Spatial Reasoning

Romleg resonnering med GPT-4o

GPT-4o har evne til å forstå romlege relasjonar i bilete, men treng strukturert prompting for å utnytte dette fullt ut:

def spatial_reasoning_analysis(client, image_url):
    """Utfør romleg resonnering på eit bilete."""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "Du er ein ekspert på romleg resonnering og scene-forståing. "
                    "Beskriv 3D-relasjonar, avstandar, storleiksforhold og "
                    "romlege mønster. Bruk presise retningstermar."
                )
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Analyser det romlege oppsettet i dette biletet:\n"
                            "1. Objektplassering — kor er kvart objekt relativt til andre?\n"
                            "2. Djupne — kva er nært/fjernt?\n"
                            "3. Skala — relative storleikar mellom objekt\n"
                            "4. Symmetri — er det mønster i oppsettet?\n"
                            "5. Funksjonelle relasjonar — korleis heng tinga saman?"
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {"url": image_url, "detail": "high"}
                    }
                ]
            }
        ],
        max_tokens=1000
    )

    return response.choices[0].message.content

Scene Understanding Pipeline

Bilete
   |
   ├── Azure AI Vision (strukturert analyse)
   |   ├── Objektdeteksjon med bounding boxes
   |   ├── OCR med posisjonar
   |   └── Tags og kategoriar
   |
   ├── GPT-4o (semantisk analyse)
   |   ├── Scene-beskriving
   |   ├── Romleg resonnering
   |   └── Kontekstuell tolking
   |
   └── Fusion
       ├── Strukturerte data + semantisk forståing
       ├── Grounded captions (tekst knytt til regionar)
       └── Handlingsbar innsikt

---

Few-Shot Learning med visuelle eksempel

In-Context Visual Learning

GPT-4o støttar few-shot learning der ein viser eksempel med bilete:

def few_shot_visual_classification(client, target_image_url, examples):
    """Klassifiser bilete basert på visuelle eksempel."""

    messages = [
        {
            "role": "system",
            "content": (
                "Du klassifiserer bilete basert på eksempla du får. "
                "Lær mønsteret frå eksempla og bruk det på det nye biletet."
            )
        }
    ]

    # Legg til few-shot eksempel
    for example in examples:
        messages.append({
            "role": "user",
            "content": [
                {"type": "text", "text": "Klassifiser dette biletet:"},
                {"type": "image_url", "image_url": {"url": example["image_url"]}}
            ]
        })
        messages.append({
            "role": "assistant",
            "content": f"Klassifisering: {example['label']}\n"
                       f"Begrunnelse: {example['reasoning']}"
        })

    # Legg til målbilete
    messages.append({
        "role": "user",
        "content": [
            {"type": "text", "text": "Klassifiser dette nye biletet:"},
            {"type": "image_url", "image_url": {"url": target_image_url}}
        ]
    })

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        max_tokens=300
    )

    return response.choices[0].message.content

Token Cost Management for visuelle eksempel

def optimize_visual_tokens(images, detail_levels):
    """Optimaliser token-kostnad for visuelle eksempel."""

    # detail="low" — 85 tokens per bilete (uansett storleik)
    # detail="high" — 170 tokens per tile + 85 base tokens
    # detail="auto" — GPT vel automatisk

    optimized = []
    for img, detail in zip(images, detail_levels):
        content = {
            "type": "image_url",
            "image_url": {
                "url": img["url"],
                "detail": detail  # "low" for eksempel, "high" for target
            }
        }
        optimized.append(content)

    return optimized

# Bruk "low" detail for few-shot eksempel, "high" for analyse-target
# Sparar ~85% tokens på eksempelbilete

---

Implementeringsmønstre

Mønster 1: Cascade Pipeline

Bilete → Azure AI Vision (rask, billeg) → Filtrering → GPT-4o (dyr, presis)

Bruk Azure AI Vision for å filtrere og kategorisere bilete, og send berre relevante bilete til GPT-4o for djupare analyse. Reduserer GPT-4o-kostnad med 60-80%.

Mønster 2: Specialist Ensemble

Bilete → [OCR-spesialist, Objektdeteksjon, Sceneanalyse] → GPT-4o fusjon

Bruk spesialiserte modellar for kvar oppgåve og la GPT-4o syntetisere resultata.

Mønster 3: Edge + Cloud

Edge (Phi-4-multimodal) → Filtrering/Triagering → Cloud (GPT-4o) → Detaljert analyse

Bruk Phi-4 på edge for rask triagering, send berre komplekse tilfelle til cloud.

---

Norsk offentleg sektor

Bruksscenario

• Eigedomsforvaltar: Analyse av fasadeskade frå inspeksjonsbilete
• Kartverket: Klassifisering av satellittbilete og kartdata
• Kulturminnevern: Digital katalogisering av kulturminne
• Helsesektoren: Analyse av røntgen/MR med AI-assistanse (medisinsk produkt-regulering)

Regulatoriske omsyn

Aspekt	Krav
Medisinsk bruk	MDR (Medical Device Regulation) for diagnostiske AI
Personvern	GDPR for bilete som inneheld personar
Ansiktsgjenkjenning	Strengt regulert i Noreg — krev lovheimel
Vision fine-tuning	Azure filtrerer ut personar/ansikt frå treningsdata
Transparens	Dokumenter modellar og avgjerdsprosessar

---

Beslutningsrammeverk

Scenario	Anbefaling	Begrunnelse
Generell bildeforståing	GPT-4o native vision	Best generell kvalitet
Presis OCR og tabellekstraksjon	Azure AI Vision / Doc Intelligence	Spesialisert, lågare kostnad
Edge-inferens (offline)	Phi-4-multimodal + LoRA	Liten, rask, offline-kapabel
Domene-spesifikk klassifisering	Fine-tuned GPT-4o eller Custom Vision	Høg nøyaktigheit for spesifikt domene
Multimodal søk	Azure AI Vision embeddings	Vektorsøk på tvers av bilete/tekst
Kostnad-sensitiv bildeanalyse	Cascade: Vision → GPT-4o	60-80% reduksjon i GPT-4o-kall

---

For arkitekten

• Cascade-mønsteret (Azure AI Vision først, GPT-4o for komplekse tilfelle) reduserer kostnad med 60-80% — bruk Vision for filtrering/kategorisering og GPT-4o berre for det som krev resonnering
• Vision fine-tuning av GPT-4o (2024-08-06) gir domene-spesialisering — men Azure filtrerer automatisk ut bilete med personar/ansikt frå treningsdata, noko som avgrensar bruksområdet
• Phi-4-multimodal-instruct med Student-Teacher fine-tuning frå GPT-4o gir edge-kapabel vision AI — relevant for inspeksjon i felt og andre offline-scenario
• Few-shot visual learning med GPT-4o krev berre 3-5 eksempelbilete for ny klassifiseringsoppgåve — bruk detail: "low" på eksempel (85 tokens) og detail: "high" på target for å optimalisere kostnad
• Multimodal embeddings (Azure AI Vision v4.0) støttar 102 språk og muliggjer semantisk bildesøk — bruk for å bygge søkbare bildearkiv i offentleg sektor