# 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