ktg-plugin-marketplace/plugins/ms-ai-architect/skills/ms-ai-engineering/references/multi-modal/multimodal-evaluation-metrics.md

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å.

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.

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:

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

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:

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:

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:

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

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

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

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