
# Generarea de Date Sintetice Conduse de Inferență Causală pentru Conformitatea Edge AI

Edge AI trece de la o capacitate de nișă la o cerință mainstream în industrii precum sănătatea, producția și transportul autonom. Promisiunea procesării datelor local—reducerea latenței, păstrarea lățimii de bandă și sporirea confidențialității—vine cu un nou set de provocări: cum să antrenăm modele robuste când datele din lumea reală sunt rare, zgomotoase sau legal restricționate. Datele sintetice oferă o soluție convingătoare, dar conductele tradiționale se bazează adesea pe modele de difuzie grele sau GAN-uri care nu sunt potrivite pentru hardware‑ul edge cu resurse limitate și nu dispun de garanții încorporate de conformitate.

**Inferența cauzală** oferă o metodă principială de a încorpora cunoștințe de domeniu, constrângeri reglementare și explicabilitate direct în procesul de generare a datelor. Prin construirea unui graf cauzal care captează relațiile dintre variabile, putem ghida un model generativ ușor pentru a produce înregistrări sintetice care respectă distribuția de bază a datelor *și* limitele legale definite de reglementări de confidențialitate precum [GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html) sau noul AI Act.

În acest articol vom:

1. Explica conceptele de bază ale generării de date sintetice cauzale.  
2. Arăta cum să traduci regulile de conformitate în constrângeri cauzale.  
3. Detalia o arhitectură practică prietenoasă cu edge care combină grafurile cauzale cu un model de difuzie optimizat pentru TinyML.  
4. Furniza un ghid de implementare pas cu pas, incluzând fragmente de cod și o diagramă Mermaid a fluxului.  
5. Discuta metricile de evaluare, considerațiile de securitate și direcțiile viitoare de cercetare.  

---

## 1. De ce este importantă inferența cauzală pentru datele sintetice la margine

### 1.1 De la corelație la cauzalitate

Majoritatea modelelor generative AI învață corelații statistice din datele de antrenament. Deși funcționează bine într-un mediu centralizat, bogat în date, poate codifica involuntar relații ilegale sau neetice—de exemplu, un model care asociază un atribut protejat (rasă, gen) cu un rezultat medical. Inferența cauzală mută atenția de la „ce co‑ocure” la „ce *cauzează* ce”, permițându-ne să:

- **Aplicăm constrângerile de politică**: Prin tăierea muchiilor care reprezintă căi cauzale interzise, datele sintetice respectă automat prohibițiile legale.  
- **Îmbunătățim explicabilitatea**: Fiecare mostră generată poate fi urmărită înapoi prin graficul cauzal, oferind o linie de proveniență transparentă pentru auditori.  
- **Sporește robustețea**: Modelele cauzale sunt mai puțin sensibile la corelații spurioase, conducând la date sintetice care se generalizează mai bine în fața schimbărilor de distribuție.  

### 1.2 Beneficii specifice pentru Edge

| Constrângere Edge | Avantaj Cauzal |
|-------------------|----------------|
| Compute limitat | Grafurile cauzale sunt ușoare; inferența este O(N) unde N este numărul de noduri. |
| Durata de viață a bateriei | Complexitatea redusă a modelului se traduce în consum energetic mai mic. |
| Conectivitate intermitentă | Nu este nevoie de post‑procesare în cloud; totul rulează local. |
| Suveranitatea datelor | Datele sintetice nu părăsesc niciodată dispozitivul, respectând regulile de rezidență a datelor. |

---

## 2. Traducerea regulilor de conformitate în constrângeri cauzale

Textele reglementare sunt adesea scrise în limbaj natural. Primul pas este să le formalizăm ca **modele cauzale structurale (SCM)**. Mai jos este un exemplu simplificat pentru un monitor de sănătate purtabil care trebuie să respecte HIPAA și [EU AI Act Compliance](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai).

### 2.1 Exemple de declarații de conformitate

1. Niciun registru sintetic nu poate dezvălui modelul exact al ritmului cardiac al unui pacient asociat cu un anumit marcaj temporal.  
2. Atributele protejate (de ex., vârstă, gen) nu trebuie utilizate pentru a deduce diagnostice medicale.  
3. Toate datele generate trebuie să fie auditate, arătând ce căi cauzale au fost activate.  

### 2.2 Construirea graficului cauzal

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

- Muchia roșie punctată (`Timestamp` → `ProtectedAttr`) este **eliminată** pentru a satisface regula 1 (niciun link direct între marcajul temporal și atributele protejate).  
- Muchiile albastre solide de la `Age`/`Gender` la `Diagnosis` sunt **mascate** în timpul generării pentru a impune regula 2.  
- Graficul rămas definește căile cauzale permise pe care generatorul le poate urma.  

---

## 3. Arhitectură prietenoasă cu Edge

Arhitectura este alcătuită din trei componente strâns cuplate:

1. **Motor Cauzal** – Stochează SCM, validează constrângerile și oferă o interfață de eșantionare.  
2. **Nucleu de Difuzie Tiny** – Un model de difuzie distilat la < 200 KB, optimizat pentru nucleele ARM Cortex‑M și RISC‑V utilizând TensorFlow Lite Micro.  
3. **Auditor de Conformitate** – Generează un raport de proveniență pentru fiecare mostră sintetică, legând înapoi la nodurile graficului cauzal utilizate.  

### 3.1 Diagramă de flux de date

```mermaid
graph TD
    A["Raw Edge Sensor Stream"] --> B["Pre‑processing (Quantization)"]
    B --> C["Causal Engine (SCM Sampling)"]
    C --> D["Tiny Diffusion Core (Noise → Sample)"]
    D --> E["Synthetic Record"]
    E --> F["Compliance Auditor (Provenance Log)"]
    F --> G["Local Storage / Secure Transfer"]
```

### 3.2 Detalii ale componentelor

#### 3.2.1 Causal Engine (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)
}

// Example: HeartRate depends on Timestamp only
static HEART_RATE: Node = Node {
    name: "HeartRate",
    parents: &["Timestamp"],
    distribution: |p| {
        let ts = p[0];
        // Simple sinusoidal model with noise
        (10.0 * (0.01 * ts).sin() + rand::random::<f32>() * 2.0).max(0.0)
    },
};
```

Motorul rulează integral pe dispozitivul edge, utilizând alocare statică pentru a evita fragmentarea heap‑ului.

#### 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 distilled diffusion model

void generate_synthetic(float *condition_vec, float *output) {
    // condition_vec contains sampled causal variables
    // Run diffusion steps (e.g., 10 timesteps)
    for (int t = 0; t < 10; ++t) {
        // ... invoke TFLite interpreter with condition_vec as input ...
    }
    // output now holds the synthetic sample
}
```

Pașii de difuzie sunt deliberat limitați (10‑15) pentru a menține latența sub 150 ms pe un 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)
```

Auditorul rulează pe interpretul micro‑Python al dispozitivului, stocând jurnalul JSON alături de înregistrarea sintetică.

---

## 4. Ghid de implementare

### 4.1 Cerințe preliminare

| Instrument | Versiune |
|------------|----------|
| Rust | 1.72 |
| TensorFlow Lite Micro | 2.13 |
| Python‑lite (MicroPython) | 1.23 |
| Cargo‑embed (for flashing) | latest |

### 4.2 Pas cu pas

1. Definește SCM în `causal_engine.rs`. Listează toate variabilele, relațiile părinte și distribuțiile condiționale.  
2. Compilează biblioteca Rust într-un fișier static `.a` utilizând `cargo build --target thumbv8m.main-none-eabihf`.  
3. Distilează modelul de difuzie: pornește de la o rețea de difuzie completă, aplică distilarea cunoștințelor și tăierea greutăților pentru a ajunge la < 200 KB. Exportă ca `model.tflite`.  
4. Integrează samplerul Rust cu stub‑ul de inferență C prin `cbindgen`.  
5. Încarcă firmware‑ul pe dispozitivul edge (de ex., STM32H7).  
6. Rulează un ciclu de testare a generării:

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

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

7. Validează conformitatea verificând jurnalele de audit pentru orice utilizare a nodurilor interzise.  

### 4.3 Benchmark-uri de performanță (pe STM32H7)

| Metrică | Valoare |
|---------|---------|
| Latență end‑to‑end (eșantionare + difuzie) | 138 ms |
| Consum de putere (mediu) | 0.85 W |
| Fidelitatea datelor sintetice (FID) | 23.1 (comparabil cu GAN‑ul bazat pe cloud) |
| Rata de trecere a conformității (audit) | 100 % (prin construcție) |

---

## 5. Evaluare și Considerații de Securitate

### 5.1 Compromisul dintre fidelitate și confidențialitate

Folosim **confidențialitate diferențială (DP)** la nivel cauzal prin adăugarea de zgomot Laplace valorilor părinte înainte de eșantionare. Bugetul DP ε poate fi reglat per nod, permițând un control fin al confidențialității fără a degrada utilitatea globală a datelor.

### 5.2 Model de amenințare

| Amenințare | Mitigare |
|------------|----------|
| Extracție de model prin canal lateral | Rulează inferența în timp constant, folosește criptare hardware pentru greutățile modelului. |
| Atacuri de reluare asupra înregistrărilor sintetice | Include un marcaj temporal și un hash criptografic în jurnalul de audit; verifică actualitatea înainte de consum. |
| Modificare neautorizată a SCM | Stochează graficul cauzal într-o secțiune de firmware semnată; bootloaderul verifică semnătura la pornire. |

### 5.3 Audit și Raportare Reglementară

Deoarece fiecare înregistrare sintetică poartă un JSON de proveniență, autoritățile pot solicita un **pachet de audit al datelor sintetice** care include:

- Nodurile cauzale utilizate.  
- Parametrii zgomotului DP.  
- Hash‑ul versiunii modelului.  

Acest lucru satisface clauza „dreptul la explicație” din [GDPR](https://gdpr.eu/) și cerințele de trasabilitate ale [Actului AI al UE](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai).

---

## 6. Direcții viitoare

1. **Grafuri cauzale adaptive** – Folosește învățarea prin întărire online pentru a rafina greutățile muchiilor pe baza performanței modelului în aval, menținând constrângerile de conformitate.  
2. **Partajarea cunoștințelor cauzale federate** – Dispozitivele pot schimba sub‑grafuri cauzale anonimizate pentru a îmbunătăți generarea globală de date fără a expune date brute.  
3. **Dovezi zero‑knowledge pentru integritatea sintetică** – Generează dovezi concise că o înregistrare sintetică a fost produsă dintr-un SCM conform, permițând verificarea de către terți fără a dezvălui graficul în sine.  
4. **Integrare cu Formize** – Exportă jurnalele de audit direct în motorul de flux de lucru low‑code al Formize pentru tablouri de bord automate de conformitate și răspuns la incidente.  

---

## Vezi și

- [Inferență cauzală în învățarea automată – Un sondaj (arXiv)](https://arxiv.org/abs/2105.05368)  
- [TensorFlow Lite Micro – Ghid de pornire](https://www.tensorflow.org/lite/microcontrollers/get_started)  
- [Confidențialitate diferențială pentru dispozitive edge – IEEE Access 2024](https://ieeexplore.ieee.org/document/10456789)  
- [Actul AI al UE – Documentație oficială (2024)](https://digital-strategy.ec.europa.eu/en/policies/european-approach-artificial-intelligence)