# Computer Vision and LLM Integration

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

---

## 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, Azure AI 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), veginfrastruktur (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 | Azure AI 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:

```python
# Treningsdata format (JSONL)
training_example = {
    "messages": [
        {
            "role": "system",
            "content": "Du er ein ekspert på analyse av norske vegskilt."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Identifiser og klassifiser skiltet i biletet."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "data:image/jpeg;base64,<base64_encoded_image>"
                    }
                }
            ]
        },
        {
            "role": "assistant",
            "content": "Skiltet er eit fartsgrenseskilt som viser 80 km/t. "
                       "Type: Forbudsskilt (skilt 362). Tilstand: God."
        }
    ]
}
```

**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:

```python
# 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

```python
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

```python
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:

```python
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:

```python
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

```python
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

- **Vegvesenet**: Analyse av vegdekkeskade 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 Cosmo

- **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 Vegvesenet sin inspeksjonsinfrastruktur 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
