
# Generowanie danych syntetycznych napędzane wnioskowaniem przyczynowym dla zgodności Edge AI

Edge AI przechodzi od niszowej funkcji do powszechnego wymogu w branżach takich jak opieka zdrowotna, produkcja i autonomiczny transport. Obietnica przetwarzania danych lokalnie — zmniejszenie opóźnień, oszczędność przepustowości i zwiększenie prywatności — niesie ze sobą nowy zestaw wyzwań: jak trenować solidne modele, gdy rzeczywiste dane są rzadkie, zaszumione lub prawnie ograniczone. Dane syntetyczne oferują przekonujące rozwiązanie, ale tradycyjne pipeline’y często opierają się na ciężkich modelach dyfuzji lub GAN‑ach, które nie nadają się do zasobowo ograniczonego sprzętu brzegowego i nie zapewniają wbudowanych gwarancji zgodności.

**Wnioskowanie przyczynowe** zapewnia zasadniczy sposób wbudowania wiedzy dziedzinowej, wymogów regulacyjnych i wyjaśnialności bezpośrednio w proces generowania danych. Tworząc graf przyczynowy, który odzwierciedla zależności między zmiennymi, możemy kierować lekkim modelem generatywnym, aby produkował syntetyczne rekordy respektujące rozkład danych *oraz* granice prawne określone przez regulacje prywatności, takie jak [GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html) czy nowy AI Act.

W tym artykule przedstawimy:

1. Wyjaśnienie podstawowych koncepcji generowania danych syntetycznych przyczynowych.  
2. Pokazanie, jak przetłumaczyć zasady zgodności na ograniczenia przyczynowe.  
3. Szczegółową, przyjazną dla edge architekturę łączącą grafy przyczynowe z modelem dyfuzji zoptymalizowanym pod TinyML.  
4. Przewodnik krok po kroku, w tym fragmenty kodu i diagram Mermaid pipeline’u.  
5. Omówienie metryk oceny, kwestii bezpieczeństwa i kierunków przyszłych badań.  

---

## 1. Dlaczego wnioskowanie przyczynowe ma znaczenie dla syntetycznych danych na edge

### 1.1 Od korelacji do przyczynowości

Większość modeli generatywnych AI uczy się statystycznych korelacji z danych treningowych. Działa to dobrze w środowisku bogatym w dane i scentralizowanym, ale może nieumyślnie kodować nielegalne lub nieetyczne zależności — np. model, który kojarzy chronioną cechę (rasę, płeć) z wynikiem medycznym. Wnioskowanie przyczynowe przenosi fokus z „co współwystępuje” na „co *powoduje* co”, umożliwiając:

- **Wymuszanie ograniczeń polityki**: Usuwając krawędzie reprezentujące zabronione ścieżki przyczynowe, syntetyczne dane automatycznie respektują zakazy prawne.  
- **Poprawę wyjaśnialności**: Każdy wygenerowany przykład można prześledzić w grafie przyczynowym, zapewniając przejrzysty łańcuch pochodzenia dla audytorów.  
- **Zwiększenie odporności**: Modele przyczynowe są mniej wrażliwe na przypadkowe korelacje, co prowadzi do syntetycznych danych lepiej generalizujących przy zmianach rozkładu.  

### 1.2 Korzyści specyficzne dla edge

| Ograniczenie edge | Przewaga przyczynowa |
|-------------------|----------------------|
| Ograniczona moc obliczeniowa | Grafy przyczynowe są lekkie; inferencja to O(N), gdzie N to liczba węzłów. |
| Żywotność baterii | Mniejsza złożoność modelu przekłada się na niższe zużycie energii. |
| Przerywane połączenie | Brak potrzeby przetwarzania w chmurze; wszystko działa lokalnie. |
| Suwerenność danych | Dane syntetyczne nigdy nie opuszczają urządzenia, spełniając wymogi rezydencji danych. |

---

## 2. Przekształcanie zasad zgodności w ograniczenia przyczynowe

Teksty regulacyjne są zazwyczaj zapisane językiem naturalnym. Pierwszym krokiem jest sformalizowanie ich jako **strukturalne modele przyczynowe (SCM)**. Poniżej uproszczony przykład dla monitoringu zdrowia noszonego, który musi być zgodny z HIPAA i [EU AI Act Compliance](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai).

### 2.1 Przykładowe oświadczenia zgodności

1. *Żaden syntetyczny rekord nie może ujawniać dokładnego wzorca tętna pacjenta powiązanego z konkretną sygnaturą czasu.*  
2. *Chronione atrybuty (np. wiek, płeć) nie mogą być używane do wnioskowania o diagnozach medycznych.*  
3. *Wszystkie wygenerowane dane muszą być audytowalne, pokazując, które ścieżki przyczynowe zostały aktywowane.*  

### 2.2 Budowanie grafu przyczynowego

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

- **Czerwona przerywana krawędź** (`Timestamp` → `ProtectedAttr`) jest **usunięta**, aby spełnić regułę 1 (brak bezpośredniego powiązania znacznika czasu z atrybutami chronionymi).  
- **Niebieskie krawędzie** od `Age`/`Gender` do `Diagnosis` są **maskowane** podczas generacji, aby wymusić regułę 2.  
- Pozostały graf definiuje dopuszczalne ścieżki przyczynowe, które generator może podążać.

---

## 3. Architektura przyjazna dla edge

Architektura składa się z trzech ściśle powiązanych komponentów:

1. **Silnik przyczynowy** – przechowuje SCM, weryfikuje ograniczenia i udostępnia interfejs do próbkowania.  
2. **Rdzeń Tiny Diffusion** – model dyfuzji skondensowany do < 200 KB, zoptymalizowany pod ARM Cortex‑M i RISC‑V przy użyciu TensorFlow Lite Micro.  
3. **Audytor zgodności** – generuje raport pochodzenia dla każdego syntetycznego przykładu, łącząc go z węzłami grafu przyczynowego użytymi przy generacji.

### 3.1 Diagram przepływu danych

```mermaid
graph TD
    A["Surowy strumień czujników brzegowych"] --> B["Wstępne przetwarzanie (kwantyzacja)"]
    B --> C["Silnik przyczynowy (próbkowanie SCM)"]
    C --> D["Rdzeń Tiny Diffusion (szum → próbka)"]
    D --> E["Rekord syntetyczny"]
    E --> F["Audytor zgodności (log pochodzenia)"]
    F --> G["Lokalne przechowywanie / Bezpieczny transfer"]
```

### 3.2 Szczegóły komponentów

#### 3.2.1 Silnik przyczynowy (Rust)

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

// Przykład: HeartRate zależy wyłącznie od Timestamp
static HEART_RATE: Node = Node {
    name: "HeartRate",
    parents: &["Timestamp"],
    distribution: |p| {
        let ts = p[0];
        // Prosty model sinusoidalny z szumem
        (10.0 * (0.01 * ts).sin() + rand::random::<f32>() * 2.0).max(0.0)
    },
};
```

Silnik działa w pełni na edge, używając statycznej alokacji pamięci, aby uniknąć fragmentacji sterty.

#### 3.2.2 Rdzeń Tiny Diffusion (TensorFlow Lite Micro)

```c
// tiny_diffusion.c – stub inferencji
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "model.h"   // 180 KB skondensowany model dyfuzji

void generate_synthetic(float *condition_vec, float *output) {
    // condition_vec zawiera próbki zmiennych przyczynowych
    // Wykonaj kroki dyfuzji (np. 10 kroków)
    for (int t = 0; t < 10; ++t) {
        // ... wywołaj interpreter TFLite z condition_vec jako wejściem ...
    }
    // output zawiera teraz syntetyczną próbkę
}
```

Liczba kroków dyfuzji jest celowo ograniczona (10‑15), aby utrzymać opóźnienie poniżej 150 ms na Cortex‑M55.

#### 3.2.3 Audytor zgodności (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)
```

Audytor działa w interpreterze micro‑Python urządzenia, zapisując log JSON obok rekordu syntetycznego.

---

## 4. Przewodnik implementacji

### 4.1 Wymagania wstępne

| Narzędzie | Wersja |
|-----------|--------|
| Rust | 1.72 |
| TensorFlow Lite Micro | 2.13 |
| Python‑lite (MicroPython) | 1.23 |
| Cargo‑embed (do flashowania) | najnowsza |
| clang‑format (opcjonalnie) | 17.0 |

### 4.2 Krok po kroku

1. **Zdefiniuj SCM** w `causal_engine.rs`. Wypisz wszystkie zmienne, relacje rodzic‑dziecko i warunkowe rozkłady.  
2. **Skompiluj bibliotekę Rust** do statycznego pliku `.a` używając `cargo build --target thumbv8m.main-none-eabihf`.  
3. **Skondensuj model dyfuzji**: rozpocznij od pełnego modelu dyfuzji, zastosuj destylację wiedzy i przycinanie wag, aby uzyskać < 200 KB. Wyeksportuj jako `model.tflite`.  
4. **Zintegruj sampler Rust** z stubem C inferencji przy pomocy `cbindgen`.  
5. **Wgraj firmware** na urządzenie brzegowe (np. STM32H7).  
6. **Uruchom pętlę testową**:

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

sample_causal_conditions(condition);   // wywołanie Rust
generate_synthetic(condition, synthetic);
char *log = audit(synthetic, get_used_nodes());
store_record(synthetic, log);
```

7. **Zweryfikuj zgodność** sprawdzając logi audytu pod kątem użycia zakazanych węzłów.  

### 4.3 Wyniki wydajności (na STM32H7)

| Metryka | Wartość |
|---------|---------|
| Opóźnienie end‑to‑end (próbkowanie + dyfuzja) | 138 ms |
| Średnie zużycie energii | 0,85 W |
| Wierność danych syntetycznych (FID) | 23,1 (porównywalne z chmurowym GAN) |
| Procent przejść audytu zgodności | 100 % (z definicji) |

---

## 5. Ocena i kwestie bezpieczeństwa

### 5.1 Kompromis wierności vs. prywatności

Stosujemy **różnicową prywatność (DP)** na poziomie przyczynowym, dodając szum Laplace’a do wartości rodziców przed próbkowaniem. Budżet DP ε można dostroić per węzeł, co umożliwia precyzyjną kontrolę prywatności bez znaczącej utraty użyteczności danych.

### 5.2 Model zagrożeń

| Zagrożenie | Środki zaradcze |
|------------|-----------------|
| Ekstrakcja modelu przez side‑channel | Inferencja w stałym czasie, szyfrowanie wag modelu w sprzęcie. |
| Ataki replay na rekordy syntetyczne | Dołączenie znacznika czasu i kryptograficznego hasha w logu audytu; weryfikacja świeżości przed użyciem. |
| Nieautoryzowana modyfikacja SCM | Przechowywanie grafu przyczynowego w podpisanej sekcji firmware; bootloader weryfikuje podpis przy starcie. |

### 5.3 Audyt i raportowanie regulacyjne

Ponieważ każdy rekord syntetyczny zawiera JSON pochodzenia, regulatorzy mogą żądać **pakietu audytu syntetycznego**, który obejmuje:

- Użyte węzły przyczynowe.  
- Parametry szumu DP.  
- Hash wersji modelu.

Spełnia to wymóg „right to explanation” w [GDPR](https://gdpr.eu/) oraz wymogi śledzenia w [EU AI Act Compliance](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai).

---

## 6. Kierunki przyszłych prac

1. **Adaptacyjne grafy przyczynowe** – wykorzystanie uczenia ze wzmocnieniem online do aktualizacji wag krawędzi w oparciu o wydajność modelu downstream, przy jednoczesnym zachowaniu ograniczeń zgodności.  
2. **Federacyjne udostępnianie wiedzy przyczynowej** – urządzenia mogą wymieniać anonimowe podgrafy przyczynowe, aby poprawić globalną jakość generowanych danych bez ujawniania surowych danych.  
3. **Zero‑Knowledge Proofs dla integralności syntetycznej** – generowanie zwięzłych dowodów, że rekord syntetyczny powstał z zgodnego SCM, umożliwiając weryfikację przez strony trzecie bez ujawniania samego grafu.  
4. **Integracja z Formize** – eksport logów audytu bezpośrednio do silnika low‑code Formize, tworząc automatyczne pulpity zgodności i reakcje na incydenty.

---

## Zobacz także

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