open/ms-ai-architect
1
0
Fork 0
Code Issues Releases 4 Activity

feat(ultraplan-local): v1.6.0 — /ultraresearch-local deep research command

Browse source 
Add /ultraresearch-local for structured research combining local codebase
analysis with external knowledge via parallel agent swarms. Produces research
briefs with triangulation, confidence ratings, and source quality assessment.

New command: /ultraresearch-local with modes --quick, --local, --external, --fg.
New agents: research-orchestrator (opus), docs-researcher, community-researcher,
security-researcher, contrarian-researcher, gemini-bridge (all sonnet).
New template: research-brief-template.md.

Integration: --research flag in /ultraplan-local accepts pre-built research
briefs (up to 3), enriches the interview and exploration phases. Planning
orchestrator cross-references brief findings during synthesis.

Design principle: Context Engineering — right information to right agent at
right time. Research briefs are structured artifacts in the pipeline:
ultraresearch → brief → ultraplan --research → plan → ultraexecute.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-04-08 08:58:35 +02:00
commit baa2d0220b
488 changed files with 213221 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

732
skills/ms-ai-engineering/references/mlops-genaiops/responsible-ai-mlops-integration.md Normal file
View file

@ -0,0 +1,732 @@
# Responsible AI Integration in MLOps
**Kategori:** MLOps & GenAIOps
**Sist oppdatert:** 2026-02-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
**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
```
---
### 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.