
# Generazione di Dati Sintetici Guidata da Inferenza Causale per la Conformità dell'Edge AI

L'Edge AI sta passando da una capacità di nicchia a un requisito mainstream in settori come sanità, manifattura e trasporto autonomo. La promessa di elaborare i dati localmente—riducendo latenza, preservando la larghezza di banda e migliorando la privacy—porta con sé una nuova serie di sfide: come addestrare modelli robusti quando i dati reali sono scarsi, rumorosi o legalmente limitati. I dati sintetici offrono una soluzione convincente, ma le pipeline tradizionali spesso si basano su modelli di diffusione pesanti o GAN inadatti all'hardware edge con risorse limitate e privi di garanzie di conformità integrate.

**L'inferenza causale** fornisce un modo rigoroso per incorporare conoscenza di dominio, vincoli normativi e spiegabilità direttamente nel processo di generazione dei dati. Costruendo un grafo causale che cattura le relazioni tra le variabili, possiamo guidare un modello generativo leggero a produrre record sintetici che rispettano sia la distribuzione dei dati sottostante *che* i confini legali definiti da normative sulla privacy come il [GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html) o il nuovo AI Act.

In questo articolo vedremo:

1. I concetti fondamentali della generazione di dati sintetici causali.  
2. Come tradurre le regole di conformità in vincoli causali.  
3. Un'architettura pratica, adatta all'edge, che combina grafi causali con un modello di diffusione ottimizzato per TinyML.  
4. Una guida passo‑a‑passo all'implementazione, con snippet di codice e un diagramma Mermaid della pipeline.  
5. Metriche di valutazione, considerazioni di sicurezza e direzioni future di ricerca.

---

## 1. Perché l'Inferenza Causale è Importante per i Dati Sintetici Edge

### 1.1 Dalla Correlazione alla Causalità

La maggior parte dei modelli generativi AI apprende correlazioni statistiche dai dati di addestramento. Questo funziona bene in ambienti centralizzati e ricchi di dati, ma può codificare involontariamente relazioni illegali o non etiche—ad esempio, un modello che associa un attributo protetto (razza, genere) a un risultato medico. L'inferenza causale sposta l'attenzione da “cosa co‑accade” a “cosa *causa* cosa”, consentendoci di:

- **Applicare vincoli di policy**: rimuovendo gli archi che rappresentano percorsi causali proibiti, i dati sintetici rispettano automaticamente le proibizioni legali.  
- **Migliorare la spiegabilità**: ogni campione generato può essere tracciato attraverso il grafo causale, fornendo una linea di provenienza trasparente per gli auditor.  
- **Aumentare la robustezza**: i modelli causali sono meno sensibili a correlazioni spurie, producendo dati sintetici che generalizzano meglio di fronte a cambiamenti di distribuzione.

### 1.2 Benefici Specifici per l'Edge

| Vincolo Edge | Vantaggio Causale |
|--------------|-------------------|
| Calcolo limitato | I grafi causali sono leggeri; l'inferenza è O(N) dove N è il numero di nodi. |
| Autonomia della batteria | Ridotta complessità del modello → minore consumo energetico. |
| Connettività intermittente | Nessuna necessità di post‑processing cloud; tutto avviene localmente. |
| Sovranità dei dati | I dati sintetici non lasciano mai il dispositivo, soddisfacendo le regole di residenza dei dati. |

---

## 2. Tradurre le Regole di Conformità in Vincoli Causali

I testi normativi sono spesso scritti in linguaggio naturale. Il primo passo è formalizzarli come **modelli causali strutturali (SCM)**. Di seguito un esempio semplificato per un monitor sanitario indossabile che deve rispettare HIPAA e il [EU AI Act Compliance](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai).

### 2.1 Esempi di Dichiarazioni di Conformità

1. *Nessun record sintetico può rivelare il pattern esatto della frequenza cardiaca di un paziente associato a un timestamp specifico.*  
2. *Gli attributi protetti (es. età, genere) non devono essere usati per inferire diagnosi mediche.*  
3. *Tutti i dati generati devono essere auditabili, mostrando quali percorsi causali sono stati attivati.*

### 2.2 Costruzione del Grafo Causale

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

- **L'arco tratteggiato rosso** (`Timestamp` → `ProtectedAttr`) è **rimosso** per soddisfare la regola 1 (nessun collegamento diretto tra timestamp e attributi protetti).  
- **Gli archi blu solidi** da `Age`/`Gender` a `Diagnosis` sono **mascherati** durante la generazione per rispettare la regola 2.  
- Il grafo rimanente definisce i percorsi causali consentiti che il generatore può seguire.

---

## 3. Architettura Adatta all'Edge

L'architettura è composta da tre componenti strettamente accoppiati:

1. **Causal Engine** – Memorizza lo SCM, valida i vincoli e fornisce un’interfaccia di campionamento.  
2. **Tiny Diffusion Core** – Un modello di diffusione distillato a < 200 KB, ottimizzato per core ARM Cortex‑M e RISC‑V tramite TensorFlow Lite Micro.  
3. **Compliance Auditor** – Genera un report di provenienza per ogni campione sintetico, collegandolo ai nodi del grafo causale utilizzati.

### 3.1 Diagramma di Flusso dei Dati

```mermaid
graph TD
    A["Flusso Grezzo dei Sensori Edge"] --> B["Pre‑processing (Quantizzazione)"]
    B --> C["Causal Engine (Campionamento SCM)"]
    C --> D["Tiny Diffusion Core (Rumore → Campione)"]
    D --> E["Record Sintetico"]
    E --> F["Compliance Auditor (Log di Provenienza)"]
    F --> G["Memoria Locale / Trasferimento Sicuro"]
```

### 3.2 Dettagli dei Componenti

#### 3.2.1 Causal Engine (Rust)

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

// Esempio: HeartRate dipende solo da Timestamp
static HEART_RATE: Node = Node {
    name: "HeartRate",
    parents: &["Timestamp"],
    distribution: |p| {
        let ts = p[0];
        // Modello sinusoidale semplice con rumore
        (10.0 * (0.01 * ts).sin() + rand::random::<f32>() * 2.0).max(0.0)
    },
};
```

Il motore gira interamente sull'edge, usando allocazione di memoria statica per evitare frammentazione dell'heap.

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

```c
// tiny_diffusion.c – stub di inferenza
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "model.h"   // modello di diffusione distillato da 180 KB

void generate_synthetic(float *condition_vec, float *output) {
    // condition_vec contiene le variabili causali campionate
    // Esegui i passi di diffusione (es. 10 timesteps)
    for (int t = 0; t < 10; ++t) {
        // ... invoca l'interprete TFLite con condition_vec come input ...
    }
    // output ora contiene il campione sintetico
}
```

I passi di diffusione sono deliberatamente limitati (10‑15) per mantenere la latenza sotto 150 ms su 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)
```

L’auditor gira sull’interprete micro‑Python del dispositivo, memorizzando il log JSON accanto al record sintetico.

---

## 4. Guida all'Implementazione

### 4.1 Prerequisiti

| Strumento | Versione |
|-----------|----------|
| Rust | 1.72 |
| TensorFlow Lite Micro | 2.13 |
| Python‑lite (MicroPython) | 1.23 |
| Cargo‑embed (per il flashing) | latest |
| clang / gcc per ARM | appropriate toolchain |

### 4.2 Passo‑a‑Passo

1. **Definire lo SCM** in `causal_engine.rs`. Elencare tutte le variabili, le relazioni genitore‑figlio e le distribuzioni condizionali.  
2. **Compilare la libreria Rust** in un file statico `.a` usando `cargo build --target thumbv8m.main-none-eabihf`.  
3. **Distillare il modello di diffusione**: partire da una rete di diffusione completa, applicare knowledge distillation e pruning dei pesi per arrivare a < 200 KB. Esportare come `model.tflite`.  
4. **Integrare il campionatore Rust** con lo stub C tramite `cbindgen`.  
5. **Flashare il firmware** sul dispositivo edge (es. STM32H7).  
6. **Eseguire un ciclo di test**:

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

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

7. **Verificare la conformità** controllando i log di audit per eventuali utilizzi di nodi proibiti.  

### 4.3 Benchmark di Prestazione (su STM32H7)

| Metri | Valore |
|-------|--------|
| Latenza end‑to‑end (campionamento + diffusione) | 138 ms |
| Consumo energetico medio | 0,85 W |
| Fedeltà dei dati sintetici (FID) | 23,1 (paragonabile a GAN basati su cloud) |
| Tasso di superamento della conformità (audit) | 100 % (per costruzione) |

---

## 5. Valutazione & Considerazioni di Sicurezza

### 5.1 Trade‑off Fedeltà vs. Privacy

Applichiamo la **differential privacy (DP)** a livello causale aggiungendo rumore di Laplace ai valori genitori prima del campionamento. Il budget ε può essere sintonizzato per nodo, consentendo un controllo fine della privacy senza degradare l’utilità complessiva dei dati.

### 5.2 Modello di Minaccia

| Minaccia | Mitigazione |
|----------|-------------|
| Estrarre il modello tramite side‑channel | Eseguire inferenza in tempo costante, usare crittografia hardware per i pesi del modello. |
| Attacchi di replay sui record sintetici | Includere timestamp e hash crittografico nel log di audit; verificare la freschezza prima dell'uso. |
| Modifica non autorizzata dello SCM | Conservare il grafo causale in una sezione firmware firmata; il bootloader verifica la firma all’avvio. |

### 5.3 Auditing & Reporting Regolamentare

Poiché ogni record sintetico porta un JSON di provenienza, i regolatori possono richiedere un **pacchetto di audit dei dati sintetici** che includa:

- I nodi causali utilizzati.  
- I parametri di rumore DP.  
- L’hash della versione del modello.

Questo soddisfa la clausola “right to explanation” del [GDPR](https://gdpr.eu/) e i requisiti di tracciabilità del [EU AI Act Compliance](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai).

---

## 6. Direzioni Future

1. **Grafi Causali Adattivi** – Utilizzare reinforcement learning online per affinare i pesi degli archi in base alle prestazioni del modello downstream, mantenendo i vincoli di conformità.  
2. **Condivisione Federata della Conoscenza Causale** – I dispositivi possono scambiare sotto‑grafi causali anonimizzati per migliorare la generazione globale senza esporre dati grezzi.  
3. **Zero‑Knowledge Proofs per l'Integrità dei Sintetici** – Generare prove sintetiche che dimostrino che un record è stato prodotto da uno SCM conforme, consentendo verifiche di terze parti senza rivelare il grafo.  
4. **Integrazione con Formize** – Esportare i log di audit direttamente nel motore low‑code di Formize per dashboard di conformità automatizzate e risposta agli incidenti.

---

## Vedi anche

- [Causal Inference in Machine Learning – A Survey (arXiv)](https://arxiv.org/abs/2105.05368)  
- [TensorFlow Lite Micro – Guida Introduttiva](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 – Documentazione Ufficiale (2024)](https://digital-strategy.ec.europa.eu/en/policies/european-approach-artificial-intelligence)