ktg-plugin-marketplace/plugins/ms-ai-architect/skills/ms-ai-engineering/references/mlops-genaiops/responsible-ai-mlops-integration.md

Responsible AI Integration in MLOps

Kategori: MLOps & GenAIOps Sist oppdatert: 2026-04 Confidence: 95% (basert på offisiell Microsoft-dokumentasjon og Azure Machine Learning-referanser)

---

Introduksjon

Responsible AI (RAI) i MLOps-kontekst handler om å integrere ansvarlig AI-praksis systematisk gjennom hele modellens livssyklus — fra utvikling og trening til deployment, overvåking og vedlikehold. Mens tradisjonell MLOps fokuserer på repeaterbarhet, automatisering og pålitelighet, legger RAI-integrasjon til dimensjoner som rettferdighet (fairness), forklarbarhet (interpretability), bias-deteksjon, åpenhet (transparency) og compliance.

Azure Machine Learning tilbyr et omfattende rammeverk for RAI-integrasjon via Responsible AI dashboard, Responsible AI scorecard, og dedikerte komponenter som kan bygges direkte inn i CI/CD-pipelines. Dette sikrer at modeller ikke bare er teknisk robuste, men også etisk forsvarlige og regulatorisk compliant.

Hvorfor dette er kritisk for MLOps:

• Model governance: Sporer rettferdighet, bias og forklarbarhet gjennom hele modellens levetid
• Auditability: Dokumenterer modellbeslutninger for compliance og regulatoriske krav
• Stakeholder trust: Gir ikke-tekniske interessenter innsikt i modellens oppførsel
• Risk mitigation: Identifiserer og reduserer fairness-issues og feilmønstre før produksjon

---

Kjernekomponenter

1. Responsible AI Dashboard

Formål: En samlet, tilpassbar plattform som integrerer flere RAI-verktøy i én grensesnitt, designet for model debugging og ansvarlig beslutningstaking.

Komponenter i dashbordet:

Komponent	Funksjon	Bruksområde
Error Analysis	Identifiserer hvordan feil er distribuert i datasettet	Oppdage systematiske feil i spesifikke subgrupper
Model Fairness	Vurderer modellens ytelse på tvers av sensitive grupper	Sjekke om modellen behandler ulike grupper likt
Model Interpretability	Forklarer hvordan modellen tar beslutninger (global/lokal)	Forstå hvilke features som driver prediksjoner
Data Analysis	Utforsker datasettet for skjevheter og representasjon	Identifisere over-/underrepresentasjon i treningsdata
Counterfactual What-If	Viser minimale endringer som gir annen prediksjon	Hjelpe brukere forstå hva som må endres for annet utfall
Causal Inference	Estimerer kausale effekter av treatment-features	Skille korrelasjon fra kausalitet i beslutninger

Integrasjon i MLOps: Dashbordet genereres som del av en Azure ML pipeline job ved hjelp av komponentene fra Azure ML-registeret. Dette gjør RAI-vurdering til en automatisert del av CI/CD-flyten.

Confidence note: 🟢 Høy (basert på microsoft_azureml_rai_tabular_insight_constructor og relaterte komponenter)

---

2. Responsible AI Scorecard (Public Preview)

(Verified MCP 2026-04) — RAI Scorecard er i public preview. Bruker Azure SDK v2 og CLI v2.

Formål: Et PDF-dokument som oppsummerer RAI-innsikter fra dashbordet, designet for å dele med ikke-tekniske stakeholders, compliance-team og auditører.

Innhold:

• Model summary med performance metrics og target values
• Data characteristics (distribusjon, representasjon)
• Fairness assessment på tvers av sensitive grupper
• Top important features (global interpretability)
• Error cohort analysis (hvor modellen feiler)
• Causal insights (hvis relevant)

Bruk i governance-workflow:

1. Data scientist genererer scorecard etter modelltrening
2. Product manager/risk officer vurderer om modellen møter rettferdighets- og ytelseskrav
3. Scorecard arkiveres som del av model registry for audit trail
4. Godkjenning fra stakeholders før deployment til produksjon

Confidence note: 🟢 Høy (basert på Azure ML Responsible AI Scorecard-dokumentasjon)

---

3. RAI Components for Pipelines

Azure Machine Learning tilbyr RAI-komponenter som kan kjøres i pipeline jobs for automatisert RAI-vurdering:

Komponent	Komponent-navn	Funksjon
Constructor	microsoft_azureml_rai_tabular_insight_constructor	Oppretter RAI dashboard-objektet
Explanation	microsoft_azureml_rai_tabular_explanation	Genererer model interpretability insights
Error Analysis	microsoft_azureml_rai_tabular_erroranalysis	Analyserer feilmønstre i kohorter
Causal Analysis	microsoft_azureml_rai_tabular_causal	Utfører kausal inferens på treatment features
Counterfactual	microsoft_azureml_rai_tabular_counterfactual	Genererer counterfactual examples
Gather	microsoft_azureml_rai_tabular_insight_gather	Samler alle insights til dashboard

Pipeline-eksempel (Python SDK):

from azure.ai.ml import MLClient, Input
from azure.ai.ml.entities import Pipeline
from azure.identity import DefaultAzureCredential

ml_client_registry = MLClient(
    credential=DefaultAzureCredential(),
    registry_name="azureml"
)

# Last komponenter
rai_constructor = ml_client_registry.components.get(
    name="microsoft_azureml_rai_tabular_insight_constructor",
    label="latest"
)
rai_explanation = ml_client_registry.components.get(
    name="microsoft_azureml_rai_tabular_explanation",
    label="latest"
)
rai_erroranalysis = ml_client_registry.components.get(
    name="microsoft_azureml_rai_tabular_erroranalysis",
    label="latest"
)
rai_gather = ml_client_registry.components.get(
    name="microsoft_azureml_rai_tabular_insight_gather",
    label="latest"
)

# Definer pipeline
@pipeline
def rai_pipeline(train_data, test_data, model_input, target_column):
    # Opprett RAI dashboard
    create_rai_job = rai_constructor(
        title="Production Model RAI Assessment",
        task_type="classification",
        model_input=model_input,
        train_dataset=train_data,
        test_dataset=test_data,
        target_column_name=target_column,
        categorical_column_names='["gender", "ethnicity", "income_bracket"]',
        maximum_rows_for_test_dataset=5000
    )

    # Generer explanations
    explain_job = rai_explanation(
        rai_insights_dashboard=create_rai_job.outputs.rai_insights_dashboard
    )

    # Kjør error analysis
    error_job = rai_erroranalysis(
        rai_insights_dashboard=create_rai_job.outputs.rai_insights_dashboard,
        filter_features='["gender", "income_bracket"]'
    )

    # Samle insights
    gather_job = rai_gather(
        constructor=create_rai_job.outputs.rai_insights_dashboard,
        insight_1=explain_job.outputs.explanation,
        insight_2=error_job.outputs.error_analysis
    )

    return {
        "dashboard": gather_job.outputs.dashboard,
        "scorecard": gather_job.outputs.scorecard
    }

Confidence note: 🟢 Høy (basert på kodeeksempler fra Microsoft Learn)

---

Arkitekturmønstre

1. RAI-Augmented MLOps Pipeline

Pattern: Integrere RAI-vurdering som kvalitetsgate i CI/CD-pipeline.

Workflow:

┌─────────────────────────────────────────────────────────────────┐
│  1. Data Preparation (DataOps)                                  │
│     └─ Data quality checks + bias detection i input data        │
└────────────────┬────────────────────────────────────────────────┘
                 │
┌────────────────▼────────────────────────────────────────────────┐
│  2. Model Training (MLOps)                                      │
│     └─ MLflow tracking + model registry                         │
└────────────────┬────────────────────────────────────────────────┘
                 │
┌────────────────▼────────────────────────────────────────────────┐
│  3. RAI Dashboard Generation (Automated)                        │
│     ├─ Error analysis                                           │
│     ├─ Fairness assessment                                      │
│     ├─ Interpretability                                         │
│     └─ Scorecard generering                                     │
└────────────────┬────────────────────────────────────────────────┘
                 │
┌────────────────▼────────────────────────────────────────────────┐
│  4. Quality Gate Check                                          │
│     └─ Sjekk om fairness/performance thresholds er møtt         │
│        (automatisk eller human-in-the-loop approval)            │
└────────────────┬────────────────────────────────────────────────┘
                 │
          ┌──────┴──────┐
          │             │
    [PASS]│             │[FAIL]
          ▼             ▼
   ┌──────────┐   ┌──────────────┐
   │ Deploy   │   │ Reject +     │
   │ to Prod  │   │ Retrain      │
   └──────────┘   └──────────────┘

Implementering i Azure DevOps/GitHub Actions:

# Azure Pipelines eksempel
stages:
  - stage: Train
    jobs:
      - job: TrainModel
        steps:
          - script: python train.py
          - task: AzureCLI@2
            inputs:
              scriptType: bash
              scriptLocation: inlineScript
              inlineScript: |
                az ml job create -f training-pipeline.yml

  - stage: RAI_Assessment
    dependsOn: Train
    jobs:
      - job: GenerateRAIDashboard
        steps:
          - task: AzureCLI@2
            inputs:
              scriptType: bash
              scriptLocation: inlineScript
              inlineScript: |
                az ml job create -f rai-pipeline.yml
          - script: python validate_rai_metrics.py
            displayName: "Check RAI Quality Gates"

  - stage: Deploy
    dependsOn: RAI_Assessment
    condition: succeeded()
    jobs:
      - job: DeployToProduction
        steps:
          - script: python deploy.py

Confidence note: 🟡 Moderat-høy (basert på generell MLOps-praksis + Azure ML RAI-komponenter)

---

2. Continuous RAI Monitoring i Produksjon

Pattern: Overvåke fairness og model drift i produksjon med Azure ML Data Collection.

Komponenter:

• Azure ML Data Collector: Samler inn inference-data fra deployed endpoints
• Model Monitoring: Tracker data drift, prediction drift, og feature attribution drift
• Fairness Metrics Tracking: Kontinuerlig evaluering av fairness-metrics på live data

Workflow:

Production Model Endpoint
    │
    ├─> Data Collection (via Azure ML Data Collector)
    │       └─> Lagres i Azure ML Dataset
    │
    ├─> Scheduled RAI Pipeline (daglig/ukentlig)
    │       ├─> Error analysis på nye data
    │       ├─> Fairness drift detection
    │       └─> Interpretability refresh
    │
    └─> Alerting & Actions
            ├─> Alert hvis fairness threshold brytes
            ├─> Trigger retraining pipeline
            └─> Notify stakeholders via Azure Event Grid

Implementering:

# Deploy model med data collection
from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    DataCollector
)

deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name="credit-model-endpoint",
    model=model,
    data_collector=DataCollector(
        collections={
            "model_inputs": {"enabled": True},
            "model_outputs": {"enabled": True}
        },
        sampling_rate=1.0
    )
)

# Schedule RAI monitoring pipeline
from azure.ai.ml.entities import JobSchedule, RecurrenceTrigger

schedule = JobSchedule(
    name="rai-monitoring-schedule",
    trigger=RecurrenceTrigger(frequency="week", interval=1),
    create_job=rai_monitoring_pipeline
)

ml_client.schedules.begin_create_or_update(schedule)

Confidence note: 🟢 Høy (basert på Azure ML monitoring-dokumentasjon)

---

3. Human-in-the-Loop RAI Approval

Pattern: Bruke Responsible AI Scorecard som beslutningsunderlag for deployment-godkjenning.

Workflow:

1. Automated RAI Assessment: Pipeline genererer dashboard + scorecard
2. Scorecard Distribution: PDF sendes til product manager/risk officer
3. Stakeholder Review: Ikke-tekniske stakeholders vurderer:
   • Møter modellen fairness-krav?
   • Er error rates akseptable?
   • Er sensitive grupper behandlet rettferdig?
4. Approval Gate: Manuell godkjenning i Azure DevOps/GitHub før deployment
5. Audit Trail: Scorecard arkiveres sammen med modell i registry

Azure DevOps eksempel:

- stage: Approval
  dependsOn: RAI_Assessment
  jobs:
    - deployment: ApprovalJob
      environment: 'production-approval'  # Krever manuell approval
      strategy:
        runOnce:
          deploy:
            steps:
              - download: current
                artifact: rai-scorecard
              - script: echo "Scorecard downloaded for review"

Confidence note: 🟢 Høy (standard DevOps approval pattern)

---

Beslutningsveiledning

Når bør RAI integreres i MLOps?

Scenario	RAI-kritiskhet	Anbefalte komponenter
Høy-risiko beslutninger (kreditt, rekruttering, helse)	🔴 Kritisk	Full RAI dashboard + scorecard + human approval
Regulerte sektorer (finans, helse, offentlig sektor)	🔴 Kritisk	Error analysis + fairness + causal inference
Customer-facing AI (anbefalingssystemer, chatbots)	🟡 Viktig	Interpretability + counterfactual + data analysis
Interne optimaliseringsmodeller (supply chain, ops)	🟢 Moderat	Error analysis + basic interpretability
Eksperimentelle/forskningsmodeller	🟢 Lavt	Valgfritt, kan utsettes til produksjon

---

Beslutningstre: Hvilke RAI-komponenter trengs?

Påvirker modellen menneskers liv direkte?
│
├─ JA → Bruker den sensitive attributes (kjønn, etnisitet, etc.)?
│       │
│       ├─ JA → FULLT RAI-dashboard
│       │       ├─ Error analysis
│       │       ├─ Fairness assessment
│       │       ├─ Interpretability
│       │       ├─ Counterfactual what-if
│       │       └─ Scorecard for approval
│       │
│       └─ NEI → Interpretability + Error analysis
│
└─ NEI → Er modellen i produksjon med mange brukere?
         │
         ├─ JA → Error analysis + Interpretability (monitoring)
         │
         └─ NEI → Valgfritt RAI-dashboard (best practice)

---

Quality Gates: Eksempel på fairness thresholds

# validate_rai_metrics.py
import json

def validate_rai_scorecard(scorecard_path: str) -> bool:
    """
    Validerer at modellen møter RAI-krav før deployment.
    """
    with open(scorecard_path, 'r') as f:
        metrics = json.load(f)

    # Fairness thresholds
    fairness_checks = {
        "accuracy_disparity": metrics["fairness"]["accuracy_disparity"] < 0.05,
        "precision_disparity": metrics["fairness"]["precision_disparity"] < 0.05,
        "false_positive_rate_disparity": metrics["fairness"]["fpr_disparity"] < 0.10
    }

    # Performance thresholds
    performance_checks = {
        "overall_accuracy": metrics["performance"]["accuracy"] > 0.85,
        "f1_score": metrics["performance"]["f1_score"] > 0.80
    }

    # Error distribution checks
    error_checks = {
        "max_cohort_error_rate": max(metrics["error_analysis"]["cohort_error_rates"]) < 0.25
    }

    all_checks = {**fairness_checks, **performance_checks, **error_checks}

    if all(all_checks.values()):
        print("✅ All RAI quality gates passed")
        return True
    else:
        print("❌ RAI quality gate failures:")
        for check, passed in all_checks.items():
            if not passed:
                print(f"  - {check}: FAILED")
        return False

if __name__ == "__main__":
    import sys
    success = validate_rai_scorecard("rai_scorecard.json")
    sys.exit(0 if success else 1)

Confidence note: 🟡 Moderat (eksempel-kode, må tilpasses faktiske metric-strukturer)

---

Integrasjon med Microsoft-stakken

Azure Machine Learning

Feature	RAI-funksjonalitet
Model Registry	Lagrer RAI dashboard + scorecard sammen med modell
MLflow Integration	Logger RAI metrics som MLflow metrics for versjonskontroll
Azure ML Pipelines	Kjører RAI-komponenter som del av training/evaluation pipeline
Managed Endpoints	Data collection for kontinuerlig RAI-monitoring
Event Grid	Trigger alerts ved RAI metric drift

---

Azure DevOps / GitHub Actions

Integration points:

1. Build Validation: Kjør RAI pipeline som del av PR-validering
2. Release Gates: Automatisk quality gate basert på RAI metrics
3. Approval Workflows: Distribuer scorecard til approvers via artifacts
4. Audit Logging: Lagre RAI scorecards i Azure Artifacts for compliance

GitHub Actions eksempel:

name: MLOps with RAI

on:
  push:
    branches: [main]

jobs:
  train-and-assess:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Train Model
        run: |
          az ml job create -f training-pipeline.yml

      - name: Generate RAI Dashboard
        run: |
          az ml job create -f rai-pipeline.yml

      - name: Download RAI Scorecard
        run: |
          az ml job download --name $RAI_JOB_NAME --output-name scorecard

      - name: Upload Scorecard as Artifact
        uses: actions/upload-artifact@v3
        with:
          name: rai-scorecard
          path: scorecard.pdf

      - name: Validate RAI Metrics
        run: python validate_rai_metrics.py

  deploy:
    needs: train-and-assess
    runs-on: ubuntu-latest
    environment: production  # Krever approval
    steps:
      - name: Deploy to Production
        run: python deploy.py

---

Azure AI Foundry / Copilot Studio

Scenario: RAI for generative AI-modeller (GenAIOps).

Utfordringer:

• Responsible AI dashboard støtter kun tabular structured data (regression/classification)
• Generative AI krever andre RAI-tilnærminger

Løsninger:

1. Content Safety: Bruk Azure AI Content Safety for toxicity/bias detection
2. Prompt Flow Evaluation: Evaluere generative models med custom metrics
3. Manual Review: Human-in-the-loop review av generated outputs

Confidence note: 🟡 Moderat (RAI for GenAI er et fremvoksende felt, mindre standardisert enn for discriminative models)

---

Offentlig sektor (Norge)

Regulatoriske krav

Regulering	RAI-relevans
EU AI Act	Krever transparens og forklarbarhet for høy-risiko AI-systemer
GDPR Art. 22	Rett til forklaring ved automatiserte beslutninger
Digitaliseringsdirektoratet: Etisk retningslinjer for AI	Krav om rettferdighet og ikke-diskriminering
Utredningsinstruksen	Krav om konsekvensutredning (inkl. RAI-vurdering)

---

RAI Scorecard i utredningsprosessen

Pattern: Bruke Responsible AI Scorecard som del av AI-konsekvensutredning.

Workflow:

1. Innledende vurdering: Vurdere om AI-systemet faller under høy-risiko kategori
2. RAI-integrasjon i utvikling: Bygg RAI-vurdering inn i MLOps fra dag 1
3. Scorecard-generering: Generer scorecard ved milestone-punkter
4. Utredningsdokumentasjon: Inkluder scorecard i utredningsrapporten
5. Offentlig høring: Del scorecard med berørte parter
6. Vedtak og deployment: Arkiver scorecard som del av beslutningsgrunnlag

---

DPIA (Data Protection Impact Assessment) + RAI

Integration pattern: Kombinere DPIA og RAI-vurdering.

DPIA-element	RAI-komponent	Dokumentasjon
Formål og proporsjonalitet	Model overview + performance	Vis at modellen oppfyller formålet uten overskudd av nøyaktighet
Nødvendighet og dataminimering	Data analysis	Dokumenter hvilke features som faktisk brukes
Individers rettigheter	Counterfactual what-if	Gi brukere innsikt i hva som påvirker beslutningen
Risiko for diskriminering	Fairness assessment	Kvantifiser disparities på sensitive grupper
Åpenhet og informasjon	Interpretability + scorecard	Forklar modellens beslutninger i ikke-tekniske termer

Confidence note: 🟢 Høy (basert på GDPR + Digdir-retningslinjer)

---

Kostnad og lisensiering

Azure Machine Learning Pricing for RAI

Ressurs	Kostnadsfaktor	Estimat (NOK/måned)
Compute for RAI pipeline	VM-tid (CPU/GPU)	5 000 - 20 000 (avhengig av dataset-størrelse)
Storage (RAI dashboards)	Blob storage	100 - 500
Model Registry	Inkludert i AML workspace	Ingen ekstrakostnad
Event Grid (alerts)	Per event	50 - 200
Data Collection (monitoring)	Ingress/egress	500 - 2 000

Total estimat: 6 000 - 23 000 NOK/måned for full RAI-integrasjon.

Kostnad-optimalisering:

• Kjør RAI-pipelines på lavere-kostnads compute (CPU istedenfor GPU)
• Begrens test dataset til 5000 rader (maks for RAI dashboard UI)
• Bruk scheduled pipelines (ukentlig) istedenfor real-time monitoring
• Arkiver gamle RAI dashboards til cool/archive storage

---

Lisensiering

Tool	Lisensmodell	Inkludert i
Responsible AI Dashboard	Open-source (basert på InterpretML, Fairlearn, ErrorAnalysis, DiCE)	Azure ML workspace
Azure ML Pipelines	PaaS-modell	Azure ML workspace (betaler for compute)
Azure DevOps	Per-user (Basic Plan: gratis for 5 brukere)	Separat fra Azure ML
GitHub Actions	Gratis for public repos, betalt for private	Separat fra Azure ML

Confidence note: 🟢 Høy (basert på Azure pricing + open-source lisensiering)

---

For arkitekten (Cosmo)

Når skal RAI integreres i MLOps?

Cosmo's rule of thumb:

"Hvis modellen tar beslutninger som kan påvirke enkeltpersoners liv, økonomi eller rettigheter — integrer RAI fra dag 1. Hvis modellen optimaliserer interne prosesser uten direkte menneskelig påvirkning, kan RAI utsettes til produksjon, men bør uansett implementeres før go-live."

---

Typiske arkitekturvalg

Scenario	Anbefalt arkitektur
Kredittscoring for bank	Full RAI dashboard + human approval gate + DPIA-integrasjon
Rekruttering AI i offentlig sektor	RAI pipeline + scorecard + fairness monitoring i produksjon
Anbefalingssystem for e-handel	Error analysis + interpretability + A/B testing med fairness metrics
Prediktivt vedlikehold (industri)	Interpretability for trust + error analysis for modellkvalitet

---

Vanlige fallgruver

1. "Vi legger til RAI etter deployment" ❌ Problem: Vanskelig å fikse bias/unfairness i produksjonsmodell ✅ Løsning: Bygg RAI-vurdering inn i training pipeline fra start

2. "RAI dashboard er for komplisert for stakeholders" ❌ Problem: Stakeholders får ikke innsikt i modellens oppførsel ✅ Løsning: Bruk Responsible AI Scorecard (PDF) for ikke-tekniske stakeholders

3. "Vi kan ikke kjøre RAI-pipeline på produksjonsdata pga. GDPR" ❌ Problem: Manglende monitoring av fairness i produksjon ✅ Løsning: Anonymiser data eller kjør RAI på syntetiske data som matcher produksjonsdistribusjon

4. "RAI-komponenter tar for lang tid å kjøre" ❌ Problem: Forsinker CI/CD-pipeline ✅ Løsning: Kjør RAI-vurdering parallelt eller som scheduled job (ikke blocking)

---

Spørsmål å stille klienten

1. Regulatorisk kontekst:

   • "Faller denne modellen under EU AI Act høy-risiko kategori?"
   • "Krever deres sektor spesifikke compliance-krav (finans, helse, offentlig)?"

2. Stakeholder-forventninger:

   • "Hvem trenger innsikt i modellens beslutninger? (risk officers, auditors, sluttbrukere?)"
   • "Hva er akseptabel fairness disparity for dere? (f.eks. <5% accuracy gap mellom grupper)"

3. Datasettet:

   • "Inneholder datasettet sensitive attributes (kjønn, etnisitet, alder)?"
   • "Er det kjente skjevheter i historisk data?"

4. Deployment-strategi:

   • "Skal RAI-vurdering være blocking for deployment, eller advisory?"
   • "Hvem godkjenner modell-deployment basert på RAI scorecard?"

---

Anbefalte ressurser for videre dybdelæring

• Microsoft Responsible AI Standard: https://query.prod.cms.rt.microsoft.com/cms/api/am/binary/RE5cmFl
• Azure ML RAI Dashboard docs: https://learn.microsoft.com/en-us/azure/machine-learning/concept-responsible-ai-dashboard
• Fairlearn (open-source): https://fairlearn.org/
• InterpretML: https://interpret.ml/
• EU AI Act compliance guide: https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai

---

Kilder og verifisering

Microsoft Learn (offisiell dokumentasjon):

1. Responsible AI Dashboard concept: https://learn.microsoft.com/en-us/azure/machine-learning/concept-responsible-ai-dashboard?view=azureml-api-2

2. MLOps and GenAIOps for AI workloads: https://learn.microsoft.com/en-us/azure/well-architected/ai/mlops-genaiops

3. Responsible AI Scorecard: https://learn.microsoft.com/en-us/azure/machine-learning/concept-responsible-ai-scorecard?view=azureml-api-2

4. Generate RAI insights with YAML and Python: https://learn.microsoft.com/en-us/azure/machine-learning/how-to-responsible-ai-insights-sdk-cli?view=azureml-api-2

5. Model monitoring and data collection: https://learn.microsoft.com/en-us/azure/machine-learning/concept-data-collection https://learn.microsoft.com/en-us/azure/machine-learning/concept-model-monitoring

6. Fairness in ML (Azure ML): https://learn.microsoft.com/en-us/azure/machine-learning/concept-fairness-ml?view=azureml-api-2

7. Azure DevOps for ML: https://learn.microsoft.com/en-us/azure/machine-learning/how-to-devops-machine-learning?view=azureml-api-2

Open-source tools (referert i Azure ML RAI):

8. Fairlearn: https://fairlearn.org/
9. InterpretML: https://interpret.ml/
10. Error Analysis: https://erroranalysis.ai/
11. DiCE (Counterfactuals): https://github.com/interpretml/DiCE
12. EconML (Causal Inference): https://github.com/microsoft/EconML

Regulatory references:

13. EU AI Act: https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai
14. GDPR Article 22: https://gdpr-info.eu/art-22-gdpr/
15. Digdir AI-retningslinjer: https://www.digdir.no/

MCP-calls brukt: 6 (microsoft_docs_search x 3, microsoft_docs_fetch x 2, microsoft_code_sample_search x 1) Kilder totalt: 15 Confidence: 95% (høy tillit til Microsoft-dokumentasjon, moderat for implementeringseksempler)

---

For Cosmo Skyberg:

Dette dokumentet gir deg en komplett arkitekturoversikt over RAI-integrasjon i MLOps. Nøkkelpunktene for deg som arkitekt er:

1. RAI er ikke "nice-to-have", det er governance-kritisk for modeller som påvirker mennesker
2. Azure ML tilbyr production-ready komponenter — du trenger ikke bygge egne RAI-verktøy
3. Integrer RAI-vurdering i CI/CD-pipeline som quality gate, ikke som etterpåklapp
4. Responsible AI Scorecard er din kommunikasjonskanal til ikke-tekniske stakeholders
5. Norsk offentlig sektor har spesifikke krav (DPIA + utredningsinstruksen) som RAI støtter direkte

Bruk dette dokumentet som referanse når du designer MLOps-arkitekturer hvor compliance og etikk er kritisk.