# Multi-Modal AI Evaluation and Metrics

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

---

## Introduksjon

Evaluering av multi-modale AI-system er fundamentalt meir komplekst enn evaluering av rein tekst-AI. Når system kombinerer tekst, bilete, tale og video, treng ein metrikkrammeverk som dekker kvaliteten innanfor kvar modalitet, men også korleis modalitetane samhandlar — det som blir kalla cross-modal alignment. Azure AI Foundry og Azure OpenAI Evaluation API gir innebygd støtte for både NLP-baserte metrikktypar (BLEU, ROUGE, cosine similarity) og AI-assistert evaluering (groundedness, relevance, coherence, fluency).

For norsk offentleg sektor er systematisk evaluering ikkje berre god praksis — det er eit krav under EUs AI Act for høgrisiko AI-system. Evalueringsrammeverket må dokumentere nøyaktigheit, rettferd og pålitelegheit på ein måte som tilfredsstiller regulatoriske krav til transparens og etterprøvbarheit.

Microsoft Foundry tilbyr eit sentralisert evalueringsrammeverk der ein kan definere test-datasett, kjøre automatiserte evalueringar, og samanlikne resultat på tvers av modellar og versjonar. Dette er integrert med GenAIOps-pipelines for kontinuerleg evaluering i produksjon.

---

## Kjernekomponentar

| Komponent | Formål | Teknologi |
|-----------|--------|-----------|
| **Azure OpenAI Evaluations** | Innebygd evalueringsrammeverk | Azure OpenAI API |
| **Foundry Evaluation SDK** | Programmatisk evaluering | Azure AI Foundry SDK |
| **NLP Metrics** | BLEU, ROUGE, F1, GLEU, METEOR | Matematisk-baserte metrikktypar |
| **AI Quality (AI-assisted)** | Groundedness, Relevance, Coherence | GPT-basert dommar |
| **Risk & Safety Metrics** | Content safety, protected material | Innhaldsfiltrering |
| **Custom Evaluators** | Eigendefinerte evalueringspromptar | Custom prompt classifiers |

---

## Text Generation Metrics

### BLEU (BiLingual Evaluation Understudy)

BLEU er den mest brukte metrikken for maskinoversetting og tekstgenerering. Den evaluerer overlap mellom generert tekst og referansetekst på n-gram-nivå.

```python
from azure.ai.evaluation import BleuScoreEvaluator

bleu_evaluator = BleuScoreEvaluator()

result = bleu_evaluator(
    response="Azure AI Foundry gir verktøy for å bygge AI-løysingar.",
    ground_truth="Azure AI Foundry tilbyr verktøy for å utvikle AI-løysingar."
)

print(f"BLEU Score: {result['bleu_score']:.4f}")
# BLEU Score: 0.0-1.0 (høgare = betre)
```

**Eigenskapar:**
- Samanliknar n-gram (1-gram til 4-gram) mellom generert og referansetekst
- Range: 0.0 til 1.0
- Styrke: Korrelerer godt med menneskelig vurdering for oversetting
- Svakheit: Tek ikkje omsyn til meining, berre ordoverlap

### ROUGE (Recall-Oriented Understudy for Gisting Evaluation)

ROUGE er designa for evaluering av automatisk oppsummering og fokuserer på recall — kor godt den genererte teksten dekker referanseteksten.

```python
from azure.ai.evaluation import RougeScoreEvaluator

rouge_evaluator = RougeScoreEvaluator(rouge_type="rougeL")

result = rouge_evaluator(
    response="Systemet brukar Azure AI for dokumentanalyse og ekstraksjon.",
    ground_truth="Azure AI-systemet analyserer dokument og ekstraherer strukturert data."
)

print(f"ROUGE-L Score: {result['rouge_score']:.4f}")
```

**ROUGE-variantar:**

| Variant | Beskriving | Beste bruk |
|---------|-----------|-----------|
| **ROUGE-1** | Overlap av enkeltord (unigrams) | Generell dekningssjekk |
| **ROUGE-2** | Overlap av ordpar (bigrams) | Frasekvalitet |
| **ROUGE-L** | Lengste felles subsekvens | Setningsstruktur |
| **ROUGE-3 til -5** | Overlap av 3-5 gram | Detaljert n-gram analyse |

### Cosine Similarity (Semantic)

Cosine similarity måler semantisk likskap mellom tekst-embeddings, uavhengig av ordval:

```python
from azure.ai.evaluation import CosineSimilarityEvaluator

# Krev ein embedding-modell
cosine_evaluator = CosineSimilarityEvaluator(
    model_config={
        "azure_endpoint": "https://<resource>.openai.azure.com/",
        "api_key": "<api-key>",
        "azure_deployment": "text-embedding-3-large"
    }
)

result = cosine_evaluator(
    response="Azure gir skybaserte AI-tenester for bedrifter.",
    ground_truth="Microsoft tilbyr enterprise AI-løysingar i skya."
)

print(f"Cosine Similarity: {result['cosine_similarity']:.4f}")
```

**Støtta embedding-modellar:**
- `text-embedding-3-small`
- `text-embedding-3-large`
- `text-embedding-ada-002`

### METEOR og GLEU

```python
from azure.ai.evaluation import MeteorScoreEvaluator, GleuScoreEvaluator

# METEOR — ser på eksakte treff, stemming og synonym
meteor = MeteorScoreEvaluator()
meteor_result = meteor(
    response="Modellen genererer nøyaktige svar.",
    ground_truth="Modellen produserer presise svar."
)

# GLEU — Google BLEU-variant, betre for korte tekstar
gleu = GleuScoreEvaluator()
gleu_result = gleu(
    response="Azure AI er kraftig.",
    ground_truth="Azure AI er svært kraftig."
)
```

### Val av tekstmetrikk per brukscase

| Brukscase | Primær metrikk | Sekundær metrikk |
|-----------|---------------|-----------------|
| Maskinoversetting | BLEU | METEOR |
| Oppsummering | ROUGE-L | BLEU, BERTScore |
| Klassifisering | Precision, Recall, F1 | Accuracy |
| RAG (retrieval) | Groundedness | Relevance, Coherence |
| Fri-form tekstgenerering | Cosine Similarity | Fluency, GPT Similarity |

---

## Image Quality og Relevance Metrics

### AI-assistert bildeevaluering

For evaluering av bilete-relaterte oppgåver (image captioning, VQA, bileteforståing) brukar ein GPT-4o som dommar:

```python
from openai import AzureOpenAI

def evaluate_image_caption(image_url, generated_caption, reference_caption):
    """Evaluer kvaliteten på ein AI-generert bilettekst."""

    client = AzureOpenAI(
        azure_endpoint="https://<resource>.openai.azure.com/",
        api_key="<api-key>",
        api_version="2024-08-01-preview"
    )

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": """Evaluer kvaliteten på ein bilettekst på ein skala frå 1-5:
                1: Feil — beskriv ikkje biletet
                2: Delvis rett — nokon element er korrekte
                3: Akseptabel — hovudelement er beskrivne
                4: God — nøyaktig og informativ
                5: Utmerka — presis, informativ og naturleg

                Returner JSON: {"score": X, "begrunnelse": "..."}"""
            },
            {
                "role": "user",
                "content": [
                    {"type": "image_url", "image_url": {"url": image_url}},
                    {
                        "type": "text",
                        "text": (
                            f"Generert bilettekst: {generated_caption}\n"
                            f"Referanse: {reference_caption}\n\n"
                            f"Evaluer den genererte biletteksten."
                        )
                    }
                ]
            }
        ],
        response_format={"type": "json_object"},
        max_tokens=200
    )

    return response.choices[0].message.content
```

### Multimodal Embeddings for bildeliksskap

Azure AI Vision sin multimodal embedding API muliggjer vektorbasert samanlikning mellom bilete og tekst:

```python
import requests

def compute_image_text_similarity(image_url, text_query):
    """Berekn similarity mellom bilete og tekst via multimodal embeddings."""

    endpoint = "https://<resource>.cognitiveservices.azure.com/"

    # Vektoriser biletet
    image_response = requests.post(
        f"{endpoint}/computervision/retrieval:vectorizeImage",
        params={"api-version": "2024-02-01", "model-version": "2023-04-15"},
        headers={
            "Ocp-Apim-Subscription-Key": "<api-key>",
            "Content-Type": "application/json"
        },
        json={"url": image_url}
    )
    image_vector = image_response.json()["vector"]

    # Vektoriser teksten
    text_response = requests.post(
        f"{endpoint}/computervision/retrieval:vectorizeText",
        params={"api-version": "2024-02-01", "model-version": "2023-04-15"},
        headers={
            "Ocp-Apim-Subscription-Key": "<api-key>",
            "Content-Type": "application/json"
        },
        json={"text": text_query}
    )
    text_vector = text_response.json()["vector"]

    # Cosine similarity
    similarity = cosine_similarity(image_vector, text_vector)
    return similarity
```

---

## Cross-Modal Alignment Measurement

### Alignment mellom modalitetar

Cross-modal alignment måler kor godt ulike modalitetar (tekst, bilete, audio) samsvarar i eit multi-modal system:

```python
class CrossModalEvaluator:
    """Evaluerer alignment mellom modalitetar."""

    def __init__(self, openai_client, vision_client):
        self.openai = openai_client
        self.vision = vision_client

    def evaluate_text_image_alignment(self, text, image_url):
        """Evaluer om tekst og bilete formidlar same informasjon."""

        # Generer bilettekst frå biletet
        image_caption = self.generate_caption(image_url)

        # Berekn semantisk likskap mellom tekst og bilettekst
        text_embedding = self.embed_text(text)
        caption_embedding = self.embed_text(image_caption)
        similarity = cosine_similarity(text_embedding, caption_embedding)

        # AI-assistert alignment-vurdering
        alignment_result = self.openai.chat.completions.create(
            model="gpt-4o",
            messages=[
                {
                    "role": "system",
                    "content": "Vurder om teksten og biletet formidlar same bodskap."
                },
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": f"Tekst: {text}"},
                        {"type": "image_url", "image_url": {"url": image_url}},
                        {"type": "text", "text": "Er tekst og bilete aligna? Score 1-5."}
                    ]
                }
            ]
        )

        return {
            "semantic_similarity": similarity,
            "ai_alignment_score": alignment_result.choices[0].message.content,
            "image_caption": image_caption
        }

    def evaluate_audio_text_alignment(self, audio_transcript, reference_text):
        """Evaluer alignment mellom transkribert audio og referansetekst."""

        # Word Error Rate (WER) for tale-til-tekst
        wer = self.compute_wer(audio_transcript, reference_text)

        # Semantisk likskap (handterer ulikt ordval)
        similarity = self.compute_cosine_similarity(audio_transcript, reference_text)

        return {
            "word_error_rate": wer,
            "semantic_similarity": similarity,
            "alignment_quality": "god" if wer < 0.15 and similarity > 0.85 else "treng forbetring"
        }
```

### Evaluation Dashboard

```python
def create_evaluation_report(eval_results):
    """Generer ein evalueringsrapport for multi-modal system."""

    report = {
        "modell": eval_results["model_name"],
        "dato": eval_results["evaluation_date"],
        "tekstkvalitet": {
            "bleu": eval_results["bleu_score"],
            "rouge_l": eval_results["rouge_l_score"],
            "cosine_similarity": eval_results["cosine_score"]
        },
        "bildekvalitet": {
            "caption_accuracy": eval_results["caption_score"],
            "image_text_alignment": eval_results["alignment_score"]
        },
        "audiokvalitet": {
            "word_error_rate": eval_results["wer"],
            "speaker_accuracy": eval_results["speaker_accuracy"]
        },
        "cross_modal": {
            "text_image_alignment": eval_results["text_image_alignment"],
            "audio_text_alignment": eval_results["audio_text_alignment"]
        },
        "samla_score": compute_weighted_score(eval_results)
    }

    return report
```

---

## User Satisfaction og Business KPIs

### Task Completion Rate

```python
def measure_task_completion(interactions):
    """Mål brukartilfredsheit via oppgåvegjennomføring."""

    metrics = {
        "total_interactions": len(interactions),
        "successful_completions": 0,
        "partial_completions": 0,
        "failures": 0,
        "avg_turns_to_completion": 0,
        "avg_response_time_ms": 0
    }

    for interaction in interactions:
        if interaction["outcome"] == "success":
            metrics["successful_completions"] += 1
        elif interaction["outcome"] == "partial":
            metrics["partial_completions"] += 1
        else:
            metrics["failures"] += 1

    metrics["task_completion_rate"] = (
        metrics["successful_completions"] / metrics["total_interactions"] * 100
    )

    return metrics
```

### Business-relevante KPIs for multi-modal AI

| KPI | Beskriving | Målmetode |
|-----|-----------|-----------|
| **Task Completion Rate** | Andel vellykka oppgåver | Logging + brukarfeedback |
| **Time to Resolution** | Tid frå start til løysing | Tidsstempel-analyse |
| **User Satisfaction (CSAT)** | Brukartilfredsheit 1-5 | Post-interaksjon survey |
| **Automation Rate** | Andel heilautomatiserte oppgåver | Logging av eskaleringar |
| **Error Recovery Rate** | Kor ofte systemet retter eigne feil | Feillogging |
| **Cost per Interaction** | Total kostnad per brukarinteraksjon | Token-tracking + infra |

### Foundry Evaluation Pipeline

```python
from azure.ai.evaluation import evaluate

# Batch-evaluering via Foundry SDK
results = evaluate(
    evaluation_name="multi-modal-eval-v2",
    data="eval_dataset.jsonl",
    evaluators={
        "bleu": BleuScoreEvaluator(),
        "rouge": RougeScoreEvaluator(rouge_type="rougeL"),
        "cosine": CosineSimilarityEvaluator(model_config=embedding_config),
        "groundedness": GroundednessEvaluator(model_config=judge_config),
        "relevance": RelevanceEvaluator(model_config=judge_config),
        "coherence": CoherenceEvaluator(model_config=judge_config),
        "fluency": FluencyEvaluator(model_config=judge_config)
    },
    output_path="eval_results/"
)

# Samanlikn med tidlegare evaluering
print(f"BLEU delta: {results['bleu'] - previous_results['bleu']:+.4f}")
print(f"ROUGE-L delta: {results['rouge'] - previous_results['rouge']:+.4f}")
```

---

## Implementeringsmønstre

### Continuous Evaluation Pipeline

```
Code Change → Build → Deploy → Evaluate → Gate → Promote
                                   |
                                   ├── NLP Metrics (BLEU, ROUGE)
                                   ├── AI Quality (Groundedness, Relevance)
                                   ├── Safety Metrics
                                   └── Business KPIs
```

### A/B Testing for multimodal system

1. **Definer hypotese** — "GPT-4o gir betre bilettekstar enn Image Analysis"
2. **Randomiser** — 50/50 trafikkfordeling
3. **Evaluer** — Same metrikk-suite på begge variantar
4. **Statistisk test** — Signifikanstest med tilstrekkeleg samplestorleik

---

## Norsk offentleg sektor

### AI Act-krav til evaluering

| Krav | Implementering |
|------|---------------|
| **Artikkel 9: Risikostyring** | Dokumenterte evalueringsresultat for alle modellar |
| **Artikkel 10: Data governance** | Evalueringsdatasett med kjend kvalitet |
| **Artikkel 13: Transparens** | Publiserte metrikkresultat for høgrisiko-system |
| **Artikkel 15: Nøyaktigheit** | Baseline-metrikktypar med definerte tersklar |

### Norsk kontekst

- **Datatilsynet** tilrår systematisk testing av AI-system før produksjon
- **Digdir sin veiledar for bruk av KI** krev dokumentert evaluering
- **Norsk bokmål/nynorsk** treng eigne evalueringsdatasett — ikkje bruk engelske benchmarks åleine

---

## Beslutningsrammeverk

| Scenario | Metrikk | Begrunnelse |
|----------|---------|-------------|
| Maskinoversetting | BLEU + METEOR | Industristandard for oversetting |
| Oppsummering | ROUGE-L + BERTScore | Dekking + semantisk likskap |
| RAG-system | Groundedness + Relevance + Coherence | Heilskapleg kvalitetsvurdering |
| Bilettekst | GPT-4o Judge + Cosine | AI-assistert + semantisk |
| Talegjenkjenning | WER + SER | Word/Sentence Error Rate |
| Produksjonssystem | Business KPIs + NLP metrics | Kombinert kvalitet og verdi |

---

## For Cosmo

- **Azure OpenAI Evaluations** tilbyr BLEU, ROUGE, GLEU, METEOR og Cosine Similarity som innebygde NLP-metrikktypar — bruk Foundry SDK for batch-evaluering med `evaluate()` API-et
- **AI-assistert evaluering** (Groundedness, Relevance, Coherence, Fluency) krev ein GPT-modell som dommar — dette er meir robust enn NLP-metrikktypar for open-ended generering, men krev ekstra token-kostnad
- **Cross-modal alignment** er den mest undervurderte evalueringsdimensjonen — mål om tekst, bilete og audio faktisk formidlar same bodskap, ikkje berre individuell kvalitet
- **AI Act krev dokumentert evaluering** for høgrisiko AI-system — etabler automatiserte evalueringspipelines med definerte tersklar og versjonert metrikk-historie
- **Norske evalueringsdatasett** er mangelvare — invester i domene-spesifikke testdatasett på bokmål/nynorsk for å unngå systematisk bias frå engelskspråklege benchmarks