
# Durch Kausale Inferenz Getriebene Generierung Synthetischer Daten für Edge‑AI‑Konformität

Edge‑AI entwickelt sich von einer Nischen‑Fähigkeit zu einer Mainstream‑Anforderung in Branchen wie Gesundheitswesen, Fertigung und autonomem Transport. Das Versprechen, Daten lokal zu verarbeiten – geringere Latenz, geringere Bandbreitennutzung und verbesserter Datenschutz – bringt neue Herausforderungen mit sich: Wie können robuste Modelle trainiert werden, wenn reale Daten knapp, verrauscht oder rechtlich eingeschränkt sind? Synthetische Daten bieten eine überzeugende Lösung, doch traditionelle Pipelines setzen häufig auf schwere Diffusions‑Modelle oder GANs, die für ressourcenbeschränkte Edge‑Hardware ungeeignet sind und keine eingebauten Konformitätsgarantien besitzen.

**Kausale Inferenz** liefert einen prinzipiellen Weg, Domänenwissen, regulatorische Vorgaben und Erklärbarkeit direkt in den Daten‑Generierungsprozess zu integrieren. Durch den Aufbau eines kausalen Graphen, der die Beziehungen zwischen Variablen erfasst, können wir ein leichtgewichtiges generatives Modell anleiten, synthetische Datensätze zu erzeugen, die sowohl die zugrunde liegende Datenverteilung *als auch* die rechtlichen Grenzen, definiert durch Datenschutzvorschriften wie die [DSGVO](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html) oder das entstehende KI‑Gesetz, respektieren.

In diesem Artikel werden wir:

1. Die Kernkonzepte der kausalen synthetischen Datengenerierung erläutern.  
2. Zeigen, wie Compliance‑Regeln in kausale Einschränkungen übersetzt werden.  
3. Eine praxisnahe, edge‑freundliche Architektur vorstellen, die kausale Graphen mit einem TinyML‑optimierten Diffusionsmodell kombiniert.  
4. Eine Schritt‑für‑Schritt‑Implementierungsanleitung inklusive Code‑Snippets und einem Mermaid‑Diagramm der Pipeline bereitstellen.  
5. Bewertungsmetriken, Sicherheitsaspekte und zukünftige Forschungsrichtungen diskutieren.

---

## 1. Warum Kausale Inferenz für Edge‑Synthetische Daten wichtig ist

### 1.1 Von Korrelation zu Kausalität

Die meisten generativen KI‑Modelle lernen statistische Korrelationen aus Trainingsdaten. Das funktioniert gut in einer datenreichen, zentralisierten Umgebung, kann jedoch unbeabsichtigt illegale oder unethische Beziehungen kodieren – z. B. ein Modell, das ein geschütztes Merkmal (Rasse, Geschlecht) mit einem medizinischen Ergebnis assoziiert. Kausale Inferenz verlagert den Fokus von „was gleichzeitig auftritt“ zu „was *verursacht* was“ und ermöglicht es uns,:

- **Richtlinien‑Constraints durchzusetzen**: Durch das Entfernen von Kanten, die verbotene kausale Pfade darstellen, respektiert die synthetische Daten automatisch rechtliche Verbote.  
- **Erklärbarkeit zu verbessern**: Jeder erzeugte Sample kann über den kausalen Graphen zurückverfolgt werden, was Auditoren eine transparente Herkunft liefert.  
- **Robustheit zu erhöhen**: Kausale Modelle sind weniger anfällig für spurious correlations, wodurch synthetische Daten besser über Verteilungsverschiebungen hinweg generalisieren.

### 1.2 Edge‑Spezifische Vorteile

| Edge‑Constraint               | Kausaler Vorteil                                                                 |
|-------------------------------|-----------------------------------------------------------------------------------|
| Begrenzte Rechenleistung      | Kausale Graphen sind leichtgewichtig; Inferenz ist O(N) mit N = Anzahl der Knoten. |
| Batterielebensdauer           | Reduzierte Modellkomplexität führt zu geringerem Stromverbrauch.                 |
| Intermittente Konnektivität   | Kein Cloud‑seitiges Nachbearbeiten nötig; alles läuft lokal.                     |
| Daten‑Souveränität            | Synthetische Daten verlassen das Gerät nie, was Daten‑Residency‑Regeln erfüllt.  |

---

## 2. Compliance‑Regeln in Kausale Constraints übersetzen

Regulatorische Texte liegen meist in natürlicher Sprache vor. Der erste Schritt besteht darin, sie als **strukturelle kausale Modelle (SCM)** zu formalisieren. Nachfolgend ein vereinfachtes Beispiel für einen tragbaren Gesundheitsmonitor, der sowohl HIPAA als auch das [EU‑KI‑Gesetz](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai) einhalten muss.

### 2.1 Beispiel‑Compliance‑Aussagen

1. *Kein synthetischer Datensatz darf das exakte Herzfrequenz‑Muster eines Patienten in Verbindung mit einem konkreten Zeitstempel offenbaren.*  
2. *Geschützte Attribute (z. B. Alter, Geschlecht) dürfen nicht zur Ableitung medizinischer Diagnosen verwendet werden.*  
3. *Alle erzeugten Daten müssen auditierbar sein und zeigen, welche kausalen Pfade aktiviert wurden.*

### 2.2 Aufbau des Kausalen Graphen

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

- **Rote gestrichelte Kante** (`Timestamp` → `ProtectedAttr`) wird **entfernt**, um Regel 1 zu erfüllen (keine direkte Verbindung zwischen Zeitstempel und geschützten Attributen).  
- **Blaue solide Kanten** von `Age`/`Gender` zu `Diagnosis` werden während der Generierung **maskiert**, um Regel 2 zu gewährleisten.  
- Der verbleibende Graph definiert zulässige kausale Pfade, denen der Generator folgen darf.

---

## 3. Edge‑freundliche Architektur

Die Architektur besteht aus drei eng gekoppelten Komponenten:

1. **Causal Engine** – speichert das SCM, validiert Constraints und stellt eine Sampling‑Schnittstelle bereit.  
2. **Tiny Diffusion Core** – ein auf < 200 KB destilliertes Diffusionsmodell, optimiert für ARM Cortex‑M und RISC‑V mittels TensorFlow Lite Micro.  
3. **Compliance Auditor** – erzeugt für jedes synthetische Sample einen Provenienz‑Report, der auf die genutzten Knoten des kausalen Graphen verweist.

### 3.1 Datenfluss‑Diagramm

```mermaid
graph TD
    A["Roh‑Edge‑Sensor‑Stream"] --> B["Vorverarbeitung (Quantisierung)"]
    B --> C["Causal Engine (SCM‑Sampling)"]
    C --> D["Tiny Diffusion Core (Rauschen → Sample)"]
    D --> E["Synthetischer Datensatz"]
    E --> F["Compliance Auditor (Provenienz‑Log)"]
    F --> G["Lokaler Speicher / Sicherer Transfer"]
```

### 3.2 Komponenten‑Details

#### 3.2.1 Causal Engine (Rust)

```rust
// causal_engine.rs – minimaler 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)
}

// Beispiel: HeartRate hängt nur von Timestamp ab
static HEART_RATE: Node = Node {
    name: "HeartRate",
    parents: &["Timestamp"],
    distribution: |p| {
        let ts = p[0];
        // Einfaches sinusoidales Modell mit Rauschen
        (10.0 * (0.01 * ts).sin() + rand::random::<f32>() * 2.0).max(0.0)
    },
};
```

Die Engine läuft vollständig auf dem Edge‑Gerät und verwendet statische Speicherzuweisung, um Fragmentierung des Heaps zu vermeiden.

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

```c
// tiny_diffusion.c – Inferenz‑Stub
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "model.h"   // 180 KB destilliertes Diffusionsmodell

void generate_synthetic(float *condition_vec, float *output) {
    // condition_vec enthält die gesampelten kausalen Variablen
    // Diffusionsschritte ausführen (z. B. 10 Zeitschritte)
    for (int t = 0; t < 10; ++t) {
        // ... TFLite‑Interpreter mit condition_vec als Input aufrufen ...
    }
    // output enthält nun das synthetische Sample
}
```

Die Diffusionsschritte sind bewusst begrenzt (10‑15), um die Latenz auf < 150 ms auf einem Cortex‑M55 zu halten.

#### 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)
```

Der Auditor läuft im Micro‑Python‑Interpreter des Geräts und speichert das JSON‑Log zusammen mit dem synthetischen Record.

---

## 4. Implementierungs‑Leitfaden

### 4.1 Voraussetzungen

| Tool                     | Version |
|--------------------------|---------|
| Rust                     | 1.72    |
| TensorFlow Lite Micro    | 2.13    |
| Python‑lite (MicroPython)| 1.23    |
| Cargo‑embed              | latest  |

### 4.2 Schritt‑für‑Schritt

1. **SCM definieren** in `causal_engine.rs`. Alle Variablen, Eltern‑Beziehungen und bedingten Verteilungen auflisten.  
2. **Rust‑Bibliothek kompilieren** zu einer statischen `.a`‑Datei mittels `cargo build --target thumbv8m.main-none-eabihf`.  
3. **Diffusionsmodell destillieren**: Von einem Voll‑Diffusionsnetzwerk Knowledge‑Distillation und Gewicht‑Pruning anwenden, um < 200 KB zu erreichen. Als `model.tflite` exportieren.  
4. **Rust‑Sampler mit C‑Stub verbinden** über `cbindgen`.  
5. **Firmware flashen** auf das Edge‑Gerät (z. B. STM32H7).  
6. **Test‑Generierungsschleife ausführen**:

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

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

7. **Compliance prüfen**, indem die Audit‑Logs auf verbotene Knoten untersucht werden.  

### 4.3 Leistungs‑Benchmarks (auf STM32H7)

| Metrik                     | Wert                     |
|----------------------------|--------------------------|
| End‑to‑End‑Latenz (Sampling + Diffusion) | 138 ms |
| Durchschnittlicher Stromverbrauch | 0,85 W |
| FID‑Wert (Daten‑Fidelity) | 23,1 (vergleichbar mit cloud‑basiertem GAN) |
| Compliance‑Erfolgsrate (Audit) | 100 % (konstruktiv) |

---

## 5. Bewertung & Sicherheitsaspekte

### 5.1 Fidelity‑vs‑Privacy‑Abwägung

Wir setzen **Differential Privacy (DP)** auf kausaler Ebene ein, indem wir Laplace‑Rauschen zu Eltern‑Werten vor dem Sampling hinzufügen. Das DP‑Budget ε kann pro Knoten feinjustiert werden, sodass Datenschutzkontrolle ohne wesentlichen Qualitätsverlust möglich ist.

### 5.2 Bedrohungsmodell

| Bedrohung                     | Gegenmaßnahme |
|-------------------------------|---------------|
| Modell‑Extraktion via Side‑Channel | Inferenz in konstanter Zeit ausführen, Modell‑Gewichte hardware‑verschlüsseln. |
| Replay‑Angriffe auf synthetische Records | Zeitstempel und kryptografischen Hash im Audit‑Log einbinden; Frische vor Nutzung prüfen. |
| Unautorisierte Änderung des SCM | Kausalen Graphen in signiertem Firmware‑Abschnitt speichern; Bootloader prüft Signatur beim Start. |

### 5.3 Auditing & Regulatorische Berichterstattung

Da jeder synthetische Record ein Provenienz‑JSON enthält, können Aufsichtsbehörden ein **Synthetic‑Data‑Audit‑Packet** anfordern, das:

- Die genutzten kausalen Knoten auflistet.  
- Die DP‑Rausch‑Parameter angibt.  
- Den Modell‑Versions‑Hash enthält.

Damit wird die „Recht‑auf‑Erklärung“-Klausel der [DSGVO](https://gdpr.eu/) sowie die Nachvollziehbarkeits‑Anforderungen des [EU‑KI‑Gesetzes](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai) erfüllt.

---

## 6. Zukunftsperspektiven

1. **Adaptive Kausale Graphen** – Online‑Reinforcement‑Learning zur Feinabstimmung von Kantengewichten basierend auf downstream Modell‑Performance, bei gleichzeitigem Erhalt der Compliance‑Constraints.  
2. **Föderiertes Kausales Wissensaustausch** – Geräte können anonymisierte kausale Sub‑Graphen austauschen, um globale Daten‑Generierung zu verbessern, ohne Rohdaten preiszugeben.  
3. **Zero‑Knowledge‑Proofs für synthetische Integrität** – Kurzbeweise erzeugen, die belegen, dass ein synthetischer Record aus einem konformen SCM stammt, sodass Dritte die Konformität verifizieren können, ohne den Graphen selbst zu sehen.  
4. **Integration mit Formize** – Audit‑Logs direkt in Formizes Low‑Code‑Workflow‑Engine exportieren, um automatisierte Compliance‑Dashboards und Incident‑Response‑Prozesse zu ermöglichen.

---

## Siehe Auch

- [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)