open/ms-ai-architect
1
0
Fork 0
Code Issues Releases 4 Activity
ms-ai-architect/skills/ms-ai-infrastructure/references/hybrid-edge/regulatory-compliance-edge-ai.md
Kjell Tore Guttormsen baa2d0220b feat(ultraplan-local): v1.6.0 — /ultraresearch-local deep research command 
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>
2026-04-08 08:58:35 +02:00

551 lines
22 KiB
Markdown
Raw Blame History

# Regulatory Compliance for Edge AI
**Last updated:** 2026-02
**Status:** GA
**Category:** Hybrid Cloud & Edge AI
---
## Introduksjon
AI-systemer deployed pa edge — pa lokale servere, gateways, enheter eller on-premises Kubernetes-klynger — ma oppfylle de samme regulatoriske kravene som skybaserte AI-systemer, men med tilleggsutfordringer knyttet til fysisk tilgangskontroll, distribuert logging, og vedlikehold av mange enheter. Norsk offentlig sektor opererer under et komplekst regulatorisk landskap: GDPR, EU AI Act, NSM Grunnprinsipper, Utredningsinstruksen, og sektorspesifikke krav.
For edge AI er utfordringen todelt: For det forste ma selve AI-systemet vaere compliant (ansvarlig AI, dataminimering, transparens). For det andre ma den distribuerte arkitekturen — med data og modeller pa mange fysiske lokasjoner — administreres slik at alle noder er oppdaterte, logget, og revisjonsvennlige. Manglende sentralisert kontroll gir okt risiko for konfigurasjonsavvik og compliance-brudd.
Microsoft tilbyr verktoy for a adressere dette: Azure Arc for sentralisert policy-haandheving, Microsoft Purview for dataklassifisering og -styring, Microsoft Defender for Cloud for sikkerhetsvurdering, og Compliance Manager for regulatorisk kartlegging. Disse verktoyene kan utvides til edge-miljoer gjennom Arc-integrasjon.
---
## Kjernekomponenter
| Komponent | Formal | Teknologi |
|-----------|--------|-----------|
| Azure Arc | Sentralisert policy-haandheving pa edge | Kubernetes/Server |
| Microsoft Purview | Dataklassifisering og -styring | Data governance |
| Compliance Manager | Regulatorisk kartlegging og kontroller | Assessment |
| Microsoft Defender for Cloud | Sikkerhetsvurdering | CSPM/CWPP |
| Azure Policy | Automatisert policy-haandheving | Policy engine |
| Azure Monitor | Sentralisert logging og overvaking | Observability |
| Microsoft Priva | Personvernkonsekvensvurdering | Privacy |
---
## Data Protection Impact Assessment (DPIA)
### Nar er DPIA pakrevd for edge AI?
Ifoolge GDPR Art. 35 er DPIA pakrevd nar databehandling sannsynligvis medforer hoey risiko for fysiske personers rettigheter. For edge AI gjelder dette sarlig:
| Trigger | Edge AI-eksempel | DPIA-krav |
|---------|-----------------|-----------|
| Automatiserte beslutninger | AI-basert triage pa sykehus | Pakrevd |
| Systematisk overvaking | Kamerabasert trafikkanalyse | Pakrevd |
| Sensitive data i stor skala | Helsedata-analyse pa lokale servere | Pakrevd |
| Ny teknologi | AI-modeller pa edge-enheter | Vurderes |
| Saerbare grupper | AI i barnevern/NAV | Pakrevd |
### DPIA-mal for edge AI-system
```markdown
## DPIA for Edge AI-system
### 1. Systembeskrivelse
- **Navn**: [System-navn]
- **Formal**: [Formal med AI-behandling]
- **Datatyper**: [Persondata som behandles]
- **Datasubjekter**: [Hvem gjelder det]
- **Edge-lokasjon**: [Hvor AI kjorer]
- **Modelltype**: [SLM/ONNX/Custom]
- **Dataminimering**: [Hvordan begrenses datainnsamling]
### 2. Nodvendighet og proporsjonalitet
- [ ] Er AI-behandling nodvendig for formalet?
- [ ] Kan formalet oppnas med mindre inngripende midler?
- [ ] Er datamengden begrenset til det nodvendige?
- [ ] Er lagringstid fastsatt og begrunnet?
### 3. Risikovurdering
| Risiko | Sannsynlighet | Konsekvens | Tiltak |
|--------|--------------|------------|--------|
| Data pa avveie fra edge-enhet | Medium | Hoey | Kryptering, fysisk sikring |
| Feilaktig AI-beslutning | Medium | Avhengig av kontekst | Menneskelig overstyring |
| Modell-bias | Lav-Medium | Hoey | Bias-testing, overvaking |
| Manglende logging | Lav | Hoey | Sentralisert audit via Arc |
| Uautorisert tilgang | Medium | Hoey | Tilgangskontroll, attestasjon |
### 4. Tiltak for a redusere risiko
- [ ] Kryptering av data pa edge-enhet (at rest, in transit, in use)
- [ ] Automatisert logging til sentralt system
- [ ] Menneskelig overstyring for kritiske beslutninger
- [ ] Regelmessig bias-evaluering av AI-modell
- [ ] Sletterutiner for persondata pa edge
- [ ] Fysisk sikring av edge-enheter
- [ ] Sentralisert policy-haandheving via Azure Arc
### 5. Konsultasjon
- [ ] Personvernombud konsultert
- [ ] Datatilsynet konsultert (om pakrevd)
- [ ] Beroorte parter informert
```
### Implementering av DPIA-kontroller
```python
# Automatisert DPIA-kontrollsjekk for edge AI
from dataclasses import dataclass
from typing import Optional
from datetime import datetime
@dataclass
class DPIAControl:
id: str
name: str
description: str
status: str # "implemented", "partial", "missing"
evidence: Optional[str] = None
last_verified: Optional[datetime] = None
class EdgeAIDPIAChecker:
def __init__(self):
self.controls = self._define_controls()
def _define_controls(self) -> list[DPIAControl]:
return [
DPIAControl(
id="DPIA-01",
name="Data minimering",
description="Kun nodvendige persondata samles inn pa edge",
status="missing"
),
DPIAControl(
id="DPIA-02",
name="Kryptering at rest",
description="All data pa edge-enhet er kryptert",
status="missing"
),
DPIAControl(
id="DPIA-03",
name="Kryptering in transit",
description="TLS 1.3 for all kommunikasjon",
status="missing"
),
DPIAControl(
id="DPIA-04",
name="Tilgangskontroll",
description="RBAC implementert pa edge-klynge",
status="missing"
),
DPIAControl(
id="DPIA-05",
name="Audit logging",
description="All AI-inferens og datatilgang logges",
status="missing"
),
DPIAControl(
id="DPIA-06",
name="Menneskelig overstyring",
description="AI-beslutninger kan overstyres av menneske",
status="missing"
),
DPIAControl(
id="DPIA-07",
name="Slettemekanisme",
description="Persondata kan slettes fra edge-enhet",
status="missing"
),
DPIAControl(
id="DPIA-08",
name="Bias-evaluering",
description="Modellen er testet for bias og diskriminering",
status="missing"
),
DPIAControl(
id="DPIA-09",
name="Transparens",
description="Bruker informeres om AI-behandling",
status="missing"
),
DPIAControl(
id="DPIA-10",
name="Policy-haandheving",
description="Azure Policy haandheves pa edge via Arc",
status="missing"
)
]
def assess(self) -> dict:
"""Vurder compliance-status"""
implemented = sum(1 for c in self.controls if c.status == "implemented")
total = len(self.controls)
return {
"score": f"{implemented}/{total}",
"percentage": f"{(implemented/total)*100:.0f}%",
"status": "COMPLIANT" if implemented == total else "NON_COMPLIANT",
"missing": [c.name for c in self.controls if c.status == "missing"],
"partial": [c.name for c in self.controls if c.status == "partial"]
}
```
---
## Risk Assessment Frameworks
### NSM Grunnprinsipper for edge AI
```python
# NSM Grunnprinsipper-basert risikovurdering for edge AI
class NSMRiskAssessment:
"""Risikovurdering basert pa NSMs grunnprinsipper for IKT-sikkerhet"""
CATEGORIES = {
"identifisere": [
"Kartlegge enheter, systemer og tjenester",
"Klassifisere informasjon og data",
"Identifisere saarbarheter",
"Vurdere risiko"
],
"beskytte": [
"Haandtere identiteter og tilganger",
"Beskytte data (kryptering)",
"Sikre plattformer og applikasjoner",
"Beskytte nettverk"
],
"oppdage": [
"Overvake sikkerhetstilstand",
"Logge og analysere hendelser",
"Oppdage uonsket aktivitet"
],
"haandtere": [
"Haandtere sikkerhetshendelser",
"Gjenopprette etter hendelser",
"Forbedre basert pa erfaring"
]
}
def assess_edge_ai_system(self, system_config: dict) -> dict:
"""Vurder et edge AI-system mot NSM Grunnprinsipper"""
results = {}
for category, principles in self.CATEGORIES.items():
category_results = []
for principle in principles:
score = self._evaluate_principle(principle, system_config)
category_results.append({
"principle": principle,
"score": score, # 1-5
"status": "OK" if score >= 3 else "MANGELFULL"
})
results[category] = {
"principles": category_results,
"avg_score": sum(r["score"] for r in category_results) / len(category_results)
}
overall = sum(r["avg_score"] for r in results.values()) / len(results)
return {
"categories": results,
"overall_score": round(overall, 1),
"overall_status": "AKSEPTABEL" if overall >= 3.0 else "UTILSTREKKELIG",
"recommendation": self._generate_recommendations(results)
}
```
### EU AI Act risikoklassifisering for edge AI
| Risikoniva | Eksempel edge AI | Krav | Konsekvens |
|------------|-----------------|------|------------|
| Uakseptabel | Sosial scoring pa edge | Forbudt | Kan ikke deployes |
| Hoey risiko | Biometrisk ID pa edge | Full compliance | DPIA + CE-merking + audit |
| Begrenset risiko | Chatbot pa klientenhet | Transparens | Bruker ma informeres |
| Minimal risiko | Spam-filter lokalt | Frivillig | Anbefalt god praksis |
---
## Audit Logging at Edge
### Sentralisert audit-logging arkitektur
```
┌─────────────┐ ┌──────────────┐ ┌───────────────┐
│ Edge Node 1 │ │ Edge Node 2 │ │ Edge Node N │
│ │ │ │ │ │
│ [AI-inferens]│ │ [AI-inferens] │ │ [AI-inferens] │
│ [Audit log] │ │ [Audit log] │ │ [Audit log] │
│ ↓ │ │ ↓ │ │ ↓ │
│ [OMS Agent] │ │ [OMS Agent] │ │ [OMS Agent] │
└──────┬──────┘ └──────┬───────┘ └──────┬────────┘
│ │ │
└───────────────────┼─────────────────────┘
↓
┌────────────────────────┐
│ Log Analytics │
│ Workspace │
│ (Norway East) │
│ │
│ ┌────────────────┐ │
│ │ KQL-queries │ │
│ │ for compliance │ │
│ └────────────────┘ │
└────────────┬───────────┘
↓
┌────────────────────────┐
│ Azure Sentinel / SIEM │
│ (Sikkerhetshendelser) │
└────────────────────────┘
```
### Implementering av edge audit logging
```python
# Strukturert audit logging for edge AI
import json
import logging
from datetime import datetime
from typing import Optional
class EdgeAIAuditLogger:
"""Audit logger for AI-inferens pa edge, kompatibel med Azure Monitor"""
def __init__(self, device_id: str, log_path: str):
self.device_id = device_id
self.logger = logging.getLogger("edge-ai-audit")
# Filbasert logging (lokal buffer)
handler = logging.FileHandler(log_path)
handler.setFormatter(logging.Formatter('%(message)s'))
self.logger.addHandler(handler)
self.logger.setLevel(logging.INFO)
def log_inference(self, model_name: str, model_version: str,
input_summary: str, output_summary: str,
confidence: float, latency_ms: float,
user_id: Optional[str] = None,
contains_pii: bool = False):
"""Logg AI-inferens for audit"""
audit_entry = {
"timestamp": datetime.utcnow().isoformat() + "Z",
"event_type": "AI_INFERENCE",
"device_id": self.device_id,
"model": {
"name": model_name,
"version": model_version
},
"inference": {
"input_summary": input_summary if not contains_pii else "[PII_REDACTED]",
"output_summary": output_summary,
"confidence": confidence,
"latency_ms": latency_ms
},
"context": {
"user_id": user_id,
"contains_pii": contains_pii,
"processing_location": "edge",
"data_residency": "Norway"
}
}
self.logger.info(json.dumps(audit_entry))
def log_data_access(self, data_type: str, purpose: str,
legal_basis: str, user_id: Optional[str] = None):
"""Logg datatilgang for GDPR Art. 30"""
audit_entry = {
"timestamp": datetime.utcnow().isoformat() + "Z",
"event_type": "DATA_ACCESS",
"device_id": self.device_id,
"data_access": {
"data_type": data_type,
"purpose": purpose,
"legal_basis": legal_basis,
"user_id": user_id
}
}
self.logger.info(json.dumps(audit_entry))
def log_model_update(self, old_version: str, new_version: str,
update_source: str, integrity_check: str):
"""Logg modell-oppdatering"""
audit_entry = {
"timestamp": datetime.utcnow().isoformat() + "Z",
"event_type": "MODEL_UPDATE",
"device_id": self.device_id,
"model_update": {
"old_version": old_version,
"new_version": new_version,
"source": update_source,
"integrity_verified": integrity_check == "valid"
}
}
self.logger.info(json.dumps(audit_entry))
```
### KQL-queries for compliance-rapportering
```kusto
// KQL: AI-inferens audit-rapport siste 30 dager
EdgeAIAudit_CL
| where TimeGenerated > ago(30d)
| where event_type_s == "AI_INFERENCE"
| summarize
TotalInferences = count(),
AvgConfidence = avg(inference_confidence_d),
AvgLatency = avg(inference_latency_ms_d),
PIIInferences = countif(context_contains_pii_b == true),
UniqueModels = dcount(model_name_s),
UniqueDevices = dcount(device_id_s)
by bin(TimeGenerated, 1d)
| order by TimeGenerated desc
// KQL: Sjekk at alle edge-noder har oppdatert modell
EdgeAIAudit_CL
| where event_type_s == "MODEL_UPDATE"
| summarize LastUpdate = max(TimeGenerated), CurrentVersion = arg_max(TimeGenerated, model_update_new_version_s)
by device_id_s
| extend DaysSinceUpdate = datetime_diff('day', now(), LastUpdate)
| where DaysSinceUpdate > 7
| project device_id_s, CurrentVersion, DaysSinceUpdate
| order by DaysSinceUpdate desc
// KQL: PII-tilgangsrapport for GDPR Art. 30
EdgeAIAudit_CL
| where event_type_s == "DATA_ACCESS"
| summarize
AccessCount = count(),
UniqueUsers = dcount(data_access_user_id_s),
Purposes = make_set(data_access_purpose_s)
by data_access_data_type_s, data_access_legal_basis_s
| order by AccessCount desc
```
---
## Transparency and Explainability
### Forklarbarhets-krav for edge AI
| Krav | Kilde | Implementering |
|------|-------|----------------|
| Rett til forklaring | GDPR Art. 22 | Modell-forklaringsrapporter |
| Transparens | EU AI Act | Brukerinformasjon om AI-bruk |
| Dokumentasjon | EU AI Act (hoey-risiko) | Teknisk dokumentasjon |
| Menneskelig tilsyn | EU AI Act | Override-mekanisme |
| Etterproovbarhet | Forvaltningsloven | Audit trail + begrunnelse |
### Implementering av forklarbarhet pa edge
```python
# SHAP-basert forklarbarhet for edge AI-modeller
import shap
import numpy as np
class EdgeAIExplainer:
"""Lettvekts forklarbarhet for edge-deployde modeller"""
def __init__(self, model, feature_names: list[str]):
self.model = model
self.feature_names = feature_names
# Bruk pre-beregnet bakgrunnsdata for effektivitet
self.explainer = None
def initialize_with_background(self, background_data: np.ndarray):
"""Initialiser forklarer med representativt datasett"""
# Bruk kun 100 eksempler for minneeffektivitet pa edge
sample = background_data[:100] if len(background_data) > 100 else background_data
self.explainer = shap.KernelExplainer(
self.model.predict,
sample,
link="logit"
)
def explain_prediction(self, input_data: np.ndarray) -> dict:
"""Generer forklaring for en enkelt prediksjon"""
if self.explainer is None:
return {"error": "Forklarer ikke initialisert"}
shap_values = self.explainer.shap_values(input_data, nsamples=50)
# Sorter features etter viktighet
feature_importance = []
for i, name in enumerate(self.feature_names):
importance = abs(float(shap_values[0][i]))
direction = "oker" if shap_values[0][i] > 0 else "reduserer"
feature_importance.append({
"feature": name,
"importance": importance,
"direction": direction,
"value": float(input_data[0][i])
})
feature_importance.sort(key=lambda x: x["importance"], reverse=True)
# Generer menneskelesbar forklaring
top_features = feature_importance[:3]
explanation = self._generate_norwegian_explanation(top_features)
return {
"prediction": self.model.predict(input_data)[0],
"feature_importance": feature_importance,
"explanation_no": explanation,
"model_type": type(self.model).__name__,
"explainability_method": "SHAP (KernelExplainer)"
}
def _generate_norwegian_explanation(self, top_features: list[dict]) -> str:
"""Generer forklaring pa norsk"""
parts = []
for f in top_features:
parts.append(
f"'{f['feature']}' (verdi: {f['value']:.2f}) "
f"{f['direction']} sannsynligheten"
)
return "Beslutningen er hovedsakelig basert pa: " + ", ".join(parts) + "."
```
---
## Norsk offentlig sektor
### Regulatorisk sjekkliste for edge AI
| Regulering | Krav | Edge AI-implementering |
|-----------|------|----------------------|
| GDPR Art. 5 | Dataminimering | Prosesser pa edge, send kun aggregert |
| GDPR Art. 22 | Automatiserte beslutninger | Menneskelig overstyring pakrevd |
| GDPR Art. 30 | Behandlingsprotokoll | Audit logging pa alle noder |
| GDPR Art. 32 | Tekniske tiltak | Kryptering, tilgangskontroll |
| GDPR Art. 35 | DPIA | Dokumentert vurdering |
| EU AI Act | Risikoklassifisering | Kategoriser edge AI-systemer |
| NSM Grunnprinsipper | IKT-sikkerhet | Policy-haandheving via Arc |
| Forvaltningsloven | Begrunnelse | Forklarbarhetsmekanisme |
| Offentleglova | Innsyn | Tilgjengelig dokumentasjon |
| Arkivlova | Bevaring | Langsiktig audit-lagring |
### Datatilsynets anbefalinger for AI
- Gjennomfoer DPIA for alle AI-systemer som prosesserer persondata
- Implementer privacy by design og privacy by default
- Sikre rett til forklaring ved automatiserte beslutninger
- Dokumenter rettslig grunnlag for AI-behandling
- Gjennomfoer jevnlige revisjoner av AI-systemets funksjon
---
## Beslutningsrammeverk
| Scenario | Anbefaling | Begrunnelse |
|----------|------------|-------------|
| Hoey-risiko AI (helse, justis) | Full DPIA + EU AI Act compliance + audit | Pakrevd, strengeste krav |
| Begrenset risiko (chatbot, hjelp) | Transparenserklaring + logging | Informasjonsplikt |
| Minimal risiko (spam, klassifisering) | God praksis + logging | Frivillig, men anbefalt |
| Multi-edge deployment | Azure Arc + Policy + sentralisert logging | Konsistent haandheving |
| Sensitive persondata | DPIA + kryptering + forklarbarhet | GDPR-krav |
| Offentlig forvaltning | Full compliance-stack + begrunnelse | Forvaltningsloven |
---
## For Cosmo
- **DPIA er pakrevd for de fleste edge AI-systemer** i offentlig sektor som prosesserer persondata — bruk den strukturerte malen og implementer automatiserte kontrollsjekker
- **Audit logging pa edge ma synkroniseres sentralt** — bruk Azure Monitor Agent (OMS) pa alle edge-noder og lagre logger i Log Analytics Workspace i Norway East med 7 ars retention
- **EU AI Act krever risikoklassifisering** — kategoriser edge AI-systemer tidlig i prosjektet og implementer kravene for riktig risikoniva for du deployer
- **Forklarbarhets er et lovkrav ved automatiserte beslutninger** — implementer lettvekts SHAP-basert forklarbarhet pa edge og generer norskspraklige forklaringer for brukere og saksbehandlere
- **Azure Arc + Policy er den eneste skalerbare maaten** a handheve compliance pa tvers av mange edge-noder — definer policies sentralt og la Arc sikre at alle noder er compliant
Reference in a new issue View git blame Copy permalink