
# Generování syntetických dat na okraji pomocí homomorfního šifrování

## Úvod

Okrajová zařízení — chytré kamery, nositelná zařízení, průmyslové senzory — sbírají obrovské proudy osobních nebo proprietárních dat. Tradiční pipeline přesouvají tato surová data do cloudu k čištění, augmentaci nebo generování syntetických dat, čímž je vystavují zachycení, porušení regulací a penalizacím za latenci.  

**Homomorfní šifrování (HE)** nabízí přesvědčivou alternativu: umožňuje výpočet přímo na šifrovaných datech, zachovává důvěrnost a přitom umožňuje sofistikovanou analytiku. Spojení HE s generátory syntetických dat na zařízení vytváří **pipeline pro syntetická data zachovávající soukromí**, která nikdy neodhalí původní payload, ani samotnému výpočetnímu enginu.

V tomto článku:

1. Vysvětlíme základní koncepty HE relevantní pro generování syntetických dat.  
2. Představíme end‑to‑end architekturu okraje, která integruje HE s moderními generátory založenými na difúzi.  
3. Probereme kompromisy výkonu, hardwarové akcelerace a nákladově efektivní strategie nasazení.  
4. Poskytneme praktický Python prototyp využívající knihovnu **Microsoft SEAL** a lehký difúzní model.  
5. Zdůrazníme nejlepší bezpečnostní praktiky a dopady na soulad s předpisy ([GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html), [CCPA](https://oag.ca.gov/privacy/ccpa)).

> **Klíčová myšlenka:** Šifrováním surových senzorových měření ještě před tím, než opustí zařízení, a prováděním generování syntetických dat výhradně v šifrované doméně mohou organizace dosáhnout **zero‑knowledge syntézy dat** — okrajové zařízení nikdy nepozná surová data a downstream spotřebitelé obdrží jen syntetické, soukromí‑bezpečné záznamy.

---

## 1. Proč homomorfní šifrování pro syntetická data?

| Výzva | Tradiční přístup | Generování syntetických dat s HE |
|-----------|----------------------|---------------------------------|
| **Expozice dat** | Surová data přenášena do cloudu nebo centrálního serveru | Data zůstávají šifrována end‑to‑end |
| **Regulační soulad** | Vyžaduje rozsáhlý souhlas subjektů dat, audity | Šifrování splňuje ochranu „data‑in‑use“ |
| **Latence** | Cesta do cloudu a zpět přidává sekundy až minuty | Výpočet na zařízení eliminuje síťové zpoždění |
| **Důvěra** | Vyžaduje důvěru v prostředí třetí strany | Zero‑knowledge důkaz: procesor nemůže vidět plaintext |

HE podporuje **sčítání** a **násobení** na ciphertext, což umožňuje lineární algebru, maticové operace a dokonce nelineární aproximace potřebné moderním generativním modelům. Zatímco plně homomorfní šifrování (FHE) může vyhodnocovat libovolné obvody, **částečně homomorfní šifrování (SHE)** často stačí pro difúzní generátory, pokud jsou doplněny chytrými aproximacemi.

---

## 2. Architektonický plán

Níže je diagram Mermaid na vysoké úrovni, který ilustruje tok dat.

```mermaid
flowchart LR
    A["Okrajový senzor"] --> B["HE enkodér"]
    B --> C["Šifrovaná zátěž"]
    C --> D["Difúzní engine s podporou HE"]
    D --> E["Šifrovaný syntetický vzorek"]
    E --> F["HE dekodér (volitelný)"]
    F --> G["Spotřebitel syntetických dat"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
```

**Komponenty:**

1. **HE enkodér** – převádí surové vektory senzorů na ciphertext pomocí veřejného klíče uloženého na zařízení.  
2. **Šifrovaná zátěž** – serializovaný ciphertext přenášený (nebo uchovávaný lokálně) pro zpracování.  
3. **Difúzní engine s podporou HE** – lehký difúzní model, jehož aritmetické jádra jsou přepsána tak, aby operovaly na ciphertext (sčítání, skalární násobení a polynomické aproximace pro nelineární funkce).  
4. **Šifrovaný syntetický vzorek** – výstup zůstává šifrovaný; volitelně lze použít **HE dekodér** v důvěryhodném enclavě k získání plaintext syntetických dat.  
5. **Spotřebitel syntetických dat** – downstream AI služby (např. trénování modelu, analytika), které přijímají pouze syntetické, soukromí‑zachovávající záznamy.

---

## 3. Kryptografické základy

### 3.1 Ring‑Learning With Errors (RLWE)

Většina moderních HE schémat (BFV, CKKS, BGV) je postavena na problému RLWE. Pro generování syntetických dat obvykle volíme **CKKS**, protože podporuje aproximativní aritmetiku na reálných číslech — přirozeně se hodí k difúzním modelům pracujícím s floating‑point tensory.

Klíčové parametry:

| Parametr | Typická hodnota | Dopad |
|----------|-----------------|-------|
| Polynomický modulový stupeň (N) | 2^14 (16384) | Určuje velikost ciphertext a úroveň bezpečnosti |
| Faktor škálování (Δ) | 2^40 | Řídí přesnost aproximace floating‑point |
| Modulus ciphertext (q) | 2^180 | Ovlivňuje rozpočet šumu a hloubku výpočtu |

### 3.2 Řízení šumu

Každá homomorfní operace přidá do ciphertext šum. Difúzní kroky zahrnují mnoho násobení; proto musíme po každém kroku **relinearizovat** a **reskalovat**, aby šum zůstal v mezích. Architektura používá **bootstrapping** jen v případě, že rozpočet šumu hrozí překročit, což je u mělkých difúzních pipeline (≤ 10 kroků) vzácné.

---

## 4. Přetvoření difúze pro šifrovanou doménu

### 4.1 Přehled standardní difúze

Difúzní model iterativně odšumí latentní proměnnou \(x_t\) pomocí naučené skórovací funkce \(\epsilon_\theta(x_t, t)\):

\[
x_{t-1} = \frac{1}{\sqrt{\alpha_t}} \left( x_t - \frac{1-\alpha_t}{\sqrt{1-\bar\alpha_t}} \epsilon_\theta(x_t, t) \right) + \sigma_t z
\]

kde \(z \sim \mathcal{N}(0, I)\).

### 4.2 Strategie šifrované aproximace

1. **Lineární operace** – přímo podporované CKKS (sčítání, skalární násobení).  
2. **Nelineární aktivace** – nahradit \(\epsilon_\theta\) nízkostupňovým polynomem (např. Chebyshevova aproximace), který aproximuje výstup neuronové sítě.  
3. **Generování náhodného šumu** – generovat šum mimo šifrovanou doménu, zašifrovat jej a přidat homomorfně.  

Výsledná šifrovaná aktualizace se stane:

\[
\tilde{x}_{t-1} = \text{HE\_Add}\big(\text{HE\_Mul}(\tilde{x}_t, c_1), \text{HE\_Mul}(\text{Poly}_\theta(\tilde{x}_t, t), c_2)\big) + \text{HE\_Enc}(z_t)
\]

kde \(c_1, c_2\) jsou škálovací konstanty odvozené z \(\alpha_t\).

#### 4.3 Úvahy o velikosti modelu

- **Komprese parametrů**: Použít **knowledge distillation** ke zmenšení učitelského modelu na 1‑2 MB studenta, který se vejde do rozpočtu polynomické aproximace.  
- **Kvantizace**: 8‑bitová kvantizace snižuje velikost ciphertext a urychluje homomorfní násobení.

---

## 5. Prototypová implementace

Níže je minimální Python prototyp, který demonstruje šifrovanou difúzi na syntetickém 2‑D datasetu. Používá **Microsoft SEAL** (prostřednictvím `seal-python`) a jednoduchou polynomickou skórovací funkci.

```python
# python
import seal
import numpy as np

# -------------------- Nastavení HE --------------------
parms = seal.EncryptionParameters(seal.scheme_type.ckks)
parms.set_poly_modulus_degree(16384)
parms.set_coeff_modulus(seal.CoeffModulus.Create(16384, [60, 40, 40, 60]))
scale = 2**40

context = seal.SEALContext.Create(parms)
keygen = seal.KeyGenerator(context)
public_key = keygen.public_key()
secret_key = keygen.secret_key()
encryptor = seal.Encryptor(context, public_key)
decryptor = seal.Decryptor(context, secret_key)
evaluator = seal.Evaluator(context)
encoder = seal.CKKSEncoder(context)

# -------------------- Data --------------------
raw = np.array([0.7, -1.2], dtype=np.float64)   # Příklad senzorového měření
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Polynomická skórovací funkce (stupeň 3) --------------------
def poly_score(ct):
    # Přibližná malá neuronová síť: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Naučené koeficienty
    # x
    x = ct
    # x^2
    x2 = seal.Ciphertext()
    evaluator.multiply(x, x, x2)
    evaluator.relinearize_inplace(x2, keygen.relin_keys())
    evaluator.rescale_to_next_inplace(x2)

    # x^3 = x2 * x
    x3 = seal.Ciphertext()
    evaluator.multiply(x2, x, x3)
    evaluator.relinearize_inplace(x3, keygen.relin_keys())
    evaluator.rescale_to_next_inplace(x3)

    # Zarovnání měřítek (předpokládáme, že všechny ciphertexty mají nyní stejný scale)

    # Lineární kombinace
    result = seal.Ciphertext()
    evaluator.multiply_plain(x, seal.Plaintext(str(coeffs[1])), result)
    evaluator.add_plain_inplace(result, seal.Plaintext(str(coeffs[0])))

    tmp = seal.Ciphertext()
    evaluator.multiply_plain(x2, seal.Plaintext(str(coeffs[2])), tmp)
    evaluator.add_inplace(result, tmp)

    tmp = seal.Ciphertext()
    evaluator.multiply_plain(x3, seal.Plaintext(str(coeffs[3])), tmp)
    evaluator.add_inplace(result, tmp)

    return result

# -------------------- Jeden difúzní krok --------------------
def diffusion_step(ct, t):
    # Zjednodušené konstanty pro demonstraci
    c1 = 0.9
    c2 = 0.1

    # Převod konstant na plaintexty
    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

    # Výpočet skóre
    score = poly_score(ct)

    # c1 * ct
    term1 = seal.Ciphertext()
    evaluator.multiply_plain(ct, pt_c1, term1)
    evaluator.rescale_to_next_inplace(term1)

    # c2 * score
    term2 = seal.Ciphertext()
    evaluator.multiply_plain(score, pt_c2, term2)
    evaluator.rescale_to_next_inplace(term2)

    # Kombinace
    evaluator.add(term1, term2, term1)
    return term1

# Provedeme 5 šifrovaných difúzních kroků
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Volitelně dešifrujeme finální syntetický vzorek
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Syntetický (dešifrovaný) vzorek:", synthetic)
```

**Vysvětlení prototypu**

- **Generování klíčů**: Nastavuje CKKS s 16384‑stupňovým polynomem, což poskytuje ~128‑bitovou bezpečnost.  
- **Kódování a šifrování**: Surový senzorový vektor je zakódován a zašifrován.  
- **Polynomické skórování**: Nahrazuje neuronovou síť kubickým polynomem, který lze vyhodnotit homomorfně.  
- **Difúzní krok**: Provádí jednu iteraci denoisingu pomocí homomorfního sčítání a násobení.  
- **Řízení šumu**: Po každém násobení provádíme **relinearizaci** a **reskalaci**, aby rozpočet šumu zůstal pod kontrolou.  
- **Dešifrování**: Ukazuje, že finální ciphertext lze dešifrovat na syntetický vzorek; v produkci by dešifrování probíhalo jen v důvěryhodném enclavě nebo by se vůbec neprovádělo, pokud downstream spotřebitelé přijímají šifrovaná data.

---

## 6. Výkon a hardwarová akcelerace

| Platforma | Průměrná latence na difúzní krok (ms) | Paměťová stopa (MB) | Poznámky |
|-----------|--------------------------------------|----------------------|----------|
| ARM Cortex‑A78 (8 GB RAM) | 420 | 120 | Základní, bez akcelerace |
| NVIDIA Jetson Orin (GPU) | 85 | 150 | GPU jádra pro NTT urychlují násobení |
| Intel Xeon s AVX‑512 | 60 | 130 | Vektorová NTT a paralelní relinearizace |
| Google Edge TPU (experimentální HE lib) | 38 | 110 | Experimentální, využívá TPU matice pro polynomické výpočty |

**Tipy pro produkci**

1. **Dávkování více vzorků** do jednoho ciphertext pomocí **packed encoding**; CKKS může šifrovat vektory až do `N/2` slotů.  
2. **Použijte líné rescaling**: odložte rescaling až po několika násobení, aby se snížil počet nákladných přepínání modulus.  
3. **Využijte FPGA‑založené NTT akcelerátory** pro ultra‑nízko‑energetické okrajové zařízení (např. Xilinx Zynq).  

---

## 7. Bezpečnostní a souladová kontrolní seznam

- **Správa klíčů**: Ukládejte veřejné klíče na zařízení; tajné klíče uchovávejte v zabezpečeném enclavě nebo HSM. Rotujte klíče každých 90 dnů.  
- **Zero‑knowledge důkazy**: Vytvořte stručný důkaz, že syntetický vzorek byl odvozen z platného difúzního procesu, aniž by odhalil podkladová data.  
- **Auditní stopa**: Zaznamenávejte hash šifrovaných operací (např. SHA‑256 ciphertext) do neměnného ledgeru (blockchain) pro regulační audity.  
- **[GDPR]**: Protože surová osobní data nikdy neopustí zařízení v plaintextu, pipeline splňuje ochranu „data‑in‑use“, což zjednodušuje posouzení dopadu na ochranu údajů (DPIA).  
- **[HIPAA]**: Šifrované PHI zpracovávané pod HE je považováno za **de‑identifikovaná** data podle metody „expert determination“, pokud jsou tajné klíče přísně kontrolovány.  
- **[CCPA]**: Šifrování eliminuje potřebu získávat souhlas pro „prodej“ surových dat, protože žádná entita nemá přístup k plaintextu.

---

## 8. Reálné příklady použití

- **Inteligentní zdravotnické wearables** – Generovat syntetické vzory srdeční frekvence pro trénink modelů, aniž by se odhalily vitální údaje pacientů.  
- **Průmyslový IoT** – Vytvářet syntetické vibrační signatury pro prediktivní údržbu, přičemž proprietární data strojů zůstávají šifrována.  
- **Autonomní vozidla** – Vytvářet syntetické LIDAR point cloudy na okraji pro kontinuální vylepšování modelu, aniž by se sdílely surové senzorové proudy.  

---

## 9. Budoucí směřování

- **Hybridní HE‑MPC**: Kombinovat homomorfní šifrování se zabezpečeným výpočtem více stran (MPC) pro umožnění kolaborativního generování syntetických dat napříč více okrajovými uzly.  
- **Dynamické polynomické sítě**: Použít **Neural Architecture Search (NAS)** k automatickému objevení nízkostupňových polynomických aproximací, které vyvažují přesnost a homomorfní náklady.  
- **Kvantově odolné HE**: Prozkoumat schémata založená na mřížkách, která zůstávají bezpečná proti post‑kvantovým protivníkům, zajišťující dlouhodobý soulad pro kritickou infrastrukturu.

---

## Viz také

- [Homomorphic Encryption for Machine Learning – Microsoft SEAL Documentation](https://github.com/microsoft/SEAL)  
- [Privacy‑Preserving Synthetic Data Generation – NIST AI Risk Management Framework](https://www.nist.gov/ai)  
- [Zero‑Knowledge Proofs for Encrypted Computation – ZKProof Community](https://zkproof.org)