ms-ai-architect/skills/ms-ai-engineering/references/mlops-genaiops/responsible-ai-mlops-integration.md

# Responsible AI Integration in MLOps

**Category:** MLOps & GenAIOps
**Last updated:** 2026-06-19
**Confidence:** 95% (basert på offisiell Microsoft-dokumentasjon og Azure Machine Learning-referanser)
**Type:** reference
**Source:** https://learn.microsoft.com/azure/machine-learning/concept-responsible-ai-dashboard
**Status:** Established Practice

---

## Innhold

- [Introduksjon](#introduksjon)
- [Kjernekomponenter](#kjernekomponenter)
- [Arkitekturmønstre](#arkitekturmønstre)
- [Beslutningsveiledning](#beslutningsveiledning)
- [Integrasjon med Microsoft-stakken](#integrasjon-med-microsoft-stakken)
- [Offentlig sektor (Norge)](#offentlig-sektor-norge)
- [Kostnad og lisensiering](#kostnad-og-lisensiering)
- [For arkitekten (Cosmo)](#for-arkitekten-cosmo)
- [Kilder og verifisering](#kilder-og-verifisering)

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

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

```yaml
# 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:**

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

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

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

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

---

### Microsoft 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. **Foundry/Agent Framework-evaluering**: Evaluere generative modeller med Microsoft Foundry-evaluatorer og custom metrics. Merk: **Prompt Flow avvikles 2027-04-20** — migrer evaluerings-/orkestreringslogikk til **Microsoft Agent Framework (MAF)**
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.