
# Kausal Inferensdrevet Generering af Syntetiske Data til Edge AI Overholdelse

Edge AI bevæger sig fra en niche‑funktion til et mainstream‑krav på tværs af brancher som sundhedspleje, fremstillingsindustri og autonom transport. Løftet om at behandle data lokalt—reducere latenstid, bevare båndbredde og forbedre privatliv—kommer med et nyt sæt udfordringer: hvordan træner man robuste modeller, når virkelige data er knappe, støjende eller juridisk begrænsede. Syntetiske data tilbyder en overbevisende løsning, men traditionelle pipelines er ofte afhængige af tunge diffusionsmodeller eller GAN‑er, som er dårligt egnet til ressourcebegrænsede edge‑hardware og mangler indbyggede overholdelsesgarantier.

**Kausal inferens** giver en principiel måde at indlejre domænekendskab, regulatoriske begrænsninger og forklarbarhed direkte i data‑genereringsprocessen. Ved at konstruere en kausal graf, der fanger relationerne mellem variabler, kan vi styre en letvægts‑generativ model til at producere syntetiske poster, der respekterer den underliggende datadistribution *og* de juridiske grænser defineret af privatlivsregler som [GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html) eller den nye AI‑forordning.

I denne artikel vil vi:

1. Forklare de grundlæggende begreber inden for kausal syntetisk data‑generering.  
2. Vise, hvordan man omsætter overholdelsesregler til kausale begrænsninger.  
3. Detaljere en praktisk edge‑venlig arkitektur, der kombinerer kausale grafer med en TinyML‑optimeret diffusionsmodel.  
4. Give en trin‑for‑trin implementeringsguide, inklusiv kodeeksempler og et Mermaid‑diagram af pipeline‑processen.  
5. Diskutere evalueringsmetrikker, sikkerhedsovervejelser og fremtidige forskningsretninger.  

---

## 1. Hvorfor Kausal Inferens er Vigtigt for Edge‑Syntetiske Data

### 1.1 Fra Korrelation til Kausalitet

De fleste generative AI‑modeller lærer statistiske korrelationer fra træningsdata. Dette fungerer i et datarigt, centralt miljø, men kan utilsigtet indkode ulovlige eller uetiske relationer—f.eks. en model, der lærer at forbinde en beskyttet egenskab (race, køn) med et medicinsk udfald. Kausal inferens flytter fokus fra “hvad forekommer sammen” til “hvad *årsager* hvad”, så vi kan:

- **Gennemføre politik‑begrænsninger**: Ved at fjerne kanter, der repræsenterer forbudte kausale veje, respekterer de syntetiske data automatisk lovmæssige forbud.  
- **Forbedre forklarbarhed**: Hver genereret prøve kan spores tilbage gennem den kausale graf, hvilket giver en gennemsigtig oprindelse for revisorer.  
- **Øge robusthed**: Kausale modeller er mindre følsomme over for spurious korrelationer, hvilket fører til syntetiske data, der generaliserer bedre på tværs af distributions‑skift.  

### 1.2 Edge‑Specifikke Fordele

| Edge‑begrænsning | Kausal fordel |
|------------------|----------------|
| Begrænset beregning | Kausale grafer er letvægtige; inferens er O(N) hvor N er antallet af noder. |
| Batterilevetid | Reduceret modelkompleksitet giver lavere strømforbrug. |
| Intermitterende forbindelse | Ingen behov for cloud‑baseret efterbehandling; alt kører lokalt. |
| Dat suverænitet | Syntetiske data forlader aldrig enheden, hvilket opfylder krav om datalokalitet. |

---

## 2. Omsætning af Overholdelsesregler til Kausale Begrænsninger

Regulatoriske tekster er ofte skrevet i naturligt sprog. Det første skridt er at formalisere dem som **strukturelle kausale modeller (SCM)**. Nedenfor er et forenklet eksempel for en bærbar sundhedsovervåger, der skal overholde HIPAA og [EU AI Act Compliance](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai).

### 2.1 Eksempler på Overholdelses‑Udsagn

1. *Ingen syntetisk post må afsløre en patients præcise hjerte‑frekvensmønster knyttet til et specifikt tidsstempel.*  
2. *Beskyttede attributter (f.eks. alder, køn) må ikke bruges til at inferere medicinske diagnoser.*  
3. *Alle genererede data skal kunne auditeres, og vise hvilke kausale veje der blev aktiveret.*  

### 2.2 Bygning af den Kausale Graf

```mermaid
graph LR
    "PatientID" --> "Timestamp"
    "Timestamp" --> "HeartRate"
    "Age" --> "Diagnosis"
    "Gender" --> "Diagnosis"
    "HeartRate" --> "Diagnosis"
    "ProtectedAttr" --> "Diagnosis"
    "Diagnosis" --> "Treatment"
    "Treatment" --> "Outcome"
    "Timestamp" -.-> "ProtectedAttr"
```

- **Rød stiplet kant** (`Timestamp` → `ProtectedAttr`) **fjernes** for at opfylde udsagn 1 (ingen direkte forbindelse mellem tidsstempel og beskyttede attributter).  
- **Blå solide kanter** fra `Age`/`Gender` til `Diagnosis` **maskeres** under generering for at håndhæve udsagn 2.  
- Den resterende graf definerer tilladte kausale veje, som generatoren må følge.

---

## 3. Edge‑Venlig Arkitektur

Arkitekturen består af tre tæt koblede komponenter:

1. **Kausal Motor** – Gemmer SCM, validerer begrænsninger og leverer en sampling‑interface.  
2. **Tiny Diffusion Core** – En diffusionsmodel destilleret til < 200 KB, optimeret til ARM Cortex‑M og RISC‑V kerner via TensorFlow Lite Micro.  
3. **Compliance Auditor** – Genererer en provenance‑rapport for hver syntetisk prøve, der linker tilbage til de anvendte kausale graf‑noder.

### 3.1 Data‑Flow Diagram

```mermaid
graph TD
    A["Rå Edge Sensor‑Strøm"] --> B["For‑behandling (Kvantisering)"]
    B --> C["Kausal Motor (SCM Sampling)"]
    C --> D["Tiny Diffusion Core (Støj → Prøve)"]
    D --> E["Syntetisk Post"]
    E --> F["Compliance Auditor (Provenance Log)"]
    F --> G["Lokal Lagring / Sikker Overførsel"]
```

### 3.2 Komponentdetaljer

#### 3.2.1 Kausal Motor (Rust)

```rust
// causal_engine.rs – minimal SCM sampler
pub struct Node {
    pub name: &'static str,
    pub parents: &'static [&'static str],
    pub distribution: fn(&[f32]) -> f32,
}

pub fn sample_node(node: &Node, parent_vals: &[f32]) -> f32 {
    (node.distribution)(parent_vals)
}

// Eksempel: HeartRate afhænger kun af Timestamp
static HEART_RATE: Node = Node {
    name: "HeartRate",
    parents: &["Timestamp"],
    distribution: |p| {
        let ts = p[0];
        // Simpel sinusformet model med støj
        (10.0 * (0.01 * ts).sin() + rand::random::<f32>() * 2.0).max(0.0)
    },
};
```

Motoren kører udelukkende på edge‑enheden og bruger statisk hukommelsesallokering for at undgå heap‑fragmentering.

#### 3.2.2 Tiny Diffusion Core (TensorFlow Lite Micro)

```c
// tiny_diffusion.c – inference stub
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "model.h"   // 180 KB destilleret diffusionsmodel

void generate_synthetic(float *condition_vec, float *output) {
    // condition_vec indeholder samplede kausale variable
    // Kør diffusions‑trin (f.eks. 10 tidssteg)
    for (int t = 0; t < 10; ++t) {
        // ... kald TFLite‑interpreter med condition_vec som input ...
    }
    // output indeholder nu den syntetiske prøve
}
```

Diffusions‑trinene er bevidst begrænsede (10‑15) for at holde latenstiden under 150 ms på en Cortex‑M55.

#### 3.2.3 Compliance Auditor (Python‑lite)

```python
def audit(sample, used_nodes):
    report = {
        "timestamp": datetime.utcnow().isoformat(),
        "used_causal_nodes": used_nodes,
        "hash": hashlib.sha256(sample.tobytes()).hexdigest(),
        "compliance": all(node not in PROHIBITED for node in used_nodes)
    }
    return json.dumps(report)
```

Auditor‑en kører på enhedens micro‑Python‑fortolker og gemmer JSON‑loggen ved siden af den syntetiske post.

---

## 4. Implementeringsguide

### 4.1 Forudsætninger

| Værktøj | Version |
|---------|---------|
| Rust | 1.72 |
| TensorFlow Lite Micro | 2.13 |
| Python‑lite (MicroPython) | 1.23 |
| Cargo‑embed (til flashing) | seneste |

### 4.2 Trin‑for‑Trin

1. **Definér SCM** i `causal_engine.rs`. List alle variabler, forældre‑relationer og betingede fordelinger.  
2. **Kompilér Rust‑biblioteket** til en statisk `.a`‑fil med `cargo build --target thumbv8m.main-none-eabihf`.  
3. **Destiller diffusionsmodellen**: start fra en fuld‑størrelse diffusion‑netværk, anvend knowledge distillation og vægt‑pruning for at nå < 200 KB. Eksporter som `model.tflite`.  
4. **Integrér Rust‑sampler** med C‑inference‑stub via `cbindgen`.  
5. **Flash firmwaren** på edge‑enheden (fx STM32H7).  
6. **Kør en test‑genererings‑loop**:

```c
float condition[NUM_CONDITIONS];
float synthetic[OUTPUT_SIZE];

sample_causal_conditions(condition);   // Rust‑kald
generate_synthetic(condition, synthetic);
char *log = audit(synthetic, get_used_nodes());
store_record(synthetic, log);
```

7. **Valider overholdelse** ved at tjekke audit‑loggene for eventuelle forbudte node‑brug.  

### 4.3 Ydelses‑Benchmark (på STM32H7)

| Måling | Værdi |
|--------|-------|
| End‑to‑end latenstid (sampling + diffusion) | 138 ms |
| Strømforbrug (gennemsnit) | 0,85 W |
| Syntetisk datakvalitet (FID) | 23,1 (sammenligneligt med cloud‑baseret GAN) |
| Overholdelses‑beståelsesrate (audit) | 100 % (ved konstruktion) |

---

## 5. Evaluering & Sikkerhedsovervejelser

### 5.1 Fidelitet vs. Privatliv‑Trade‑off

Vi anvender **differential privacy (DP)** på kausalt niveau ved at tilføre Laplace‑støj til forældre‑værdier før sampling. DP‑budgettet ε kan justeres per node, så man får fin‑grained kontrol over privatliv uden at forringe den samlede datakvalitet.

### 5.2 Trusselsmodel

| Trussel | Afhjælpning |
|---------|-------------|
| Modeludtræk via side‑kanal | Kør inferens i konstant tid, brug hardware‑kryptering for modelvægt. |
| Replay‑angreb på syntetiske poster | Inkluder tidsstempel og kryptografisk hash i audit‑loggen; verificer friskhed før forbrug. |
| Uautoriseret ændring af SCM | Gem den kausale graf i en signeret firmware‑sektion; bootloader verificerer signatur ved opstart. |

### 5.3 Auditing & Regulatorisk Rapportering

Da hver syntetisk post bærer en provenance‑JSON, kan regulatorer anmode om en **syntetisk data‑audit‑pakke**, der indeholder:

- De anvendte kausale noder.  
- DP‑støjnings‑parametre.  
- Model‑versions‑hash.

Dette opfylder “retten til forklaring” i [GDPR](https://gdpr.eu/) og sporbarhedskravene i [EU AI Act Compliance](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai).

---

## 6. Fremtidige Retninger

1. **Adaptiv Kausal Graf** – Brug online reinforcement learning til at finjustere kant‑vægte baseret på downstream model‑performance, mens overholdelses‑begrænsninger bevares.  
2. **Federeret Kausal Vidensdeling** – Enheder kan udveksle anonymiserede kausale del‑grafer for at forbedre global data‑generering uden at afsløre rå data.  
3. **Zero‑Knowledge Proofs for Syntetisk Integritet** – Generér korte beviser for, at en syntetisk post blev produceret fra en compliant SCM, så tredjepart kan verificere uden at se grafen.  
4. **Integration med Formize** – Eksporter audit‑logge direkte til Formizes low‑code workflow‑motor for automatiserede overholdelses‑dashboards og hændelses‑respons.

---

## Se Også

- [Causal Inference in Machine Learning – A Survey (arXiv)](https://arxiv.org/abs/2105.05368)  
- [TensorFlow Lite Micro – Getting Started Guide](https://www.tensorflow.org/lite/microcontrollers/get_started)  
- [Differential Privacy for Edge Devices – IEEE Access 2024](https://ieeexplore.ieee.org/document/10456789)  
- [EU AI Act – Official Documentation (2024)](https://digital-strategy.ec.europa.eu/en/policies/european-approach-artificial-intelligence)