1. Koti
  2. blogi
  3. HE Synteettinen Data Reuna

Homomorfinen salaus mahdollistaa synteettisen datan generoinnin reunalla

Homomorfinen salaus mahdollistaa synteettisen datan generoinnin reunalla

Johdanto

Reunalaitteet — älykamerat, puettavat laitteet, teollisuuden anturit — keräävät massiivisia määriä henkilökohtaisia tai omistusoikeudellisia tietoja. Perinteiset putket siirtävät nämä raakadatat pilveen puhdistamista, augmentointia tai synteettisen datan generointia varten, mikä altistaa tiedot sieppaukselle, sääntelyrikkomuksille ja viiveille.

Homomorfinen salaus (HE) tarjoaa houkuttelevan vaihtoehdon: se mahdollistaa laskennan suoraan salatulla datalla, säilyttäen luottamuksellisuuden samalla kun monimutkaiset analytiikat ovat mahdollisia. Yhdistämällä HE laitteella tapahtuvaan synteettisen datan generaattoriin syntyy yksityisyyttä suojaava synteettinen dataputki, joka ei koskaan paljasta alkuperäistä kuormaa, ei edes laskentamoottorille.

Tässä artikkelissa:

  1. Selitämme HE:n keskeiset käsitteet, jotka ovat olennaisia synteettisen datan generoinnissa.
  2. Kuvaamme kokonaisvaltaisen reunaarkkitehtuurin, jossa HE integroidaan nykyaikaisiin diffuusioon perustuvien generaattoreihin.
  3. Keskustelemme suorituskykykompromisseista, laitteistokiihdytyksestä ja kustannustehokkaista käyttöönotto­strategioista.
  4. Tarjoamme käytännön Python‑prototyypin, jossa hyödynnetään Microsoft SEAL -kirjastoa ja kevyttä diffuusio­mallia.
  5. Korostamme turvallisuusparhaita käytäntöjä ja sääntelyn vaikutuksia (GDPR, HIPAA, CCPA).

Keskeinen opetus: Salaamalla raakatietojen mittaukset ennen kuin ne lähtevät laitteesta ja suorittamalla synteettisen datan generointi kokonaan salatussa tilassa organisaatiot voivat saavuttaa nollatietämättömän datan synteesin — reunalaitteisto ei koskaan näe raakadataa, ja alavirran kuluttajat saavat vain synteettisiä, yksityisyyttä turvaavia tietueita.


1. Miksi homomorfinen salaus synteettiseen dataan?

HaastePerinteinen lähestymistapaHE‑pohjainen synteettinen generointi
Datan paljastuminenRaakadata siirretään pilveen tai keskitettyyn palvelimeenData pysyy salattuna päästä‑päähän
Sääntelyn noudattaminenVaatii laajaa suostumushallintaa ja auditointejaSalaus täyttää “datan‑käytössä”‑suojausvaatimuksen
ViivePilvipalveluun ja takaisin kuluu sekunteja‑minuuttejaLaitteella tapahtuva laskenta poistaa verkko‑viiveen
LuottamusVaatii luottamusta kolmannen osapuolen prosessointiympäristöönNollatietämätön todistus: prosessorilla ei ole pääsyä selkokieleen

HE tukee lisäystä ja kertolaskua salatuille teksteille, mahdollistaen lineaarialgebran, matriisitoiminnot ja jopa epälineaariset approksimaatiot, joita nykyaikaiset generatiiviset mallit vaativat. Vaikka täysi homomorfinen salaus (FHE) pystyy arvioimaan mielivaltaisia piirejä, jossain määrin homomorfinen salaus (SHE) riittää usein diffuusioon perustuville generaattoreille, kunhan käytetään älykkäitä approksimaatioita.


2. Arkkitehtuurin blueprint

Alla on korkean tason Mermaid‑kaavio, joka havainnollistaa datavirtaa.

  flowchart LR
    A["Reuna‑anturi"] --> B["HE‑kooderi"]
    B --> C["Salattu kuorma"]
    C --> D["HE‑pohjainen diffuusio‑moottori"]
    D --> E["Salattu synteettinen näyte"]
    E --> F["HE‑dekooderi (valinnainen)"]
    F --> G["Synteettisen datan kuluttaja"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px

Komponentit:

  1. HE‑kooderi — Muuttaa raakatietovektorit salatuksi tekstiksi käyttäen laitteessa säilytettävää julkista avainta.
  2. Salattu kuorma — Sarjoitettu salaus, joka voidaan siirtää (tai pitää paikallisesti) prosessointia varten.
  3. HE‑pohjainen diffuusio‑moottori — Kevyt diffuusio­malli, jonka aritmeettiset ytimet on uudelleenkirjoitettu toimimaan salauksessa (lisäys, skalaarikertolasku ja polynominen approksimaatio epälineaarisille funktioille).
  4. Salattu synteettinen näyte — Tuloste pysyy salattuna; valinnaisesti HE‑dekooderi voidaan suorittaa luotetussa eristetyssä ympäristössä, jotta saadaan selkokielinen synteettinen data.
  5. Synteettisen datan kuluttaja — Alavirran AI‑palvelut (esim. mallin koulutus, analytiikka), jotka vastaanottavat vain synteettisiä, yksityisyyttä suojaavia tietueita.

3. Kryptografiset perusteet

3.1 Ring‑Learning With Errors (RLWE)

Useimmat nykyaikaiset HE‑järjestelmät (BFV, CKKS, BGV) perustuvat RLWE‑ongelmaan. Synteettiseen dataan suositellaan CKKS‑kaavaa, koska se tukee likimääräistä aritmetiikkaa reaaliluvuilla — luonnollinen valinta diffuusio­malleille, jotka käsittelevät liukuluku‑tensoreita.

Keskeiset parametrit:

ParametriTyypillinen arvoVaikutus
Polynomimodulin aste (N)2^14 (16384)Määrittää salauksen koon ja turvallisuustason
Skaalauskerroin (Δ)2^40Hallitsee liukuluku‑approksimaation tarkkuutta
Salauksen moduli (q)2^180Vaikuttaa melubudjettiin ja laskentasyvyyteen

3.2 Melun hallinta

Jokainen homomorfinen operaatio lisää melua salaukseen. Diffuusio‑askeleet sisältävät useita kertolaskuja; siksi on tärkeää relinearisointi ja reskaalaus jokaisen askeleen jälkeen melun pitämiseksi hallinnassa. Bootstrapping‑menetelmää tarvitaan vain harvoin, esimerkiksi kun melubudjetti uhkaa ylittyä syvissä diffuusio‑putkissa (≤ 10 askelta).


4. Diffuusio‑mallin uudelleensuunnittelu salatussa tilassa

4.1 Perinteinen diffuusio lyhyesti

Diffuusio­malli denoisaa latenttia muuttujaa (x_t) iteratiivisesti käyttäen opittua pistetoimintaa (\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 ]

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

4.2 Salattu approksimaatiostrategia

  1. Lineaariset operaatiot — Suoraan tuettu CKKS‑kaavassa (lisäys, skalaarikertolasku).
  2. Epälineaarinen aktivointi — Korvataan pienellä polynomilla (esim. Chebyshev‑approksimaatio), joka jäljittelee neuroverkon ulostuloa.
  3. Satunnaisen melun injektointi — Luodaan melu ulkopuolisessa (selkokielisessä) tilassa, salataan ja lisätään homomorfisesti.

Salattu päivitys näyttää tältä:

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

missä (c_1, c_2) ovat (\alpha_t):stä johdetut skaalausvakioita.

4.3 Mallin koon optimointi

  • Parametrien pakkaus: Käytä tietämyksen destillaatiota pienentääksesi opettajamallin 1‑2 MB‑opiskelijamalliin, joka sopii polynomiseen budjettiin.
  • Kvanttaus: 8‑bittinen kvanttaus pienentää salauksen kokoa ja nopeuttaa homomorfista kertolaskua.

5. Prototyyppi‑toteutus

Alla on minimaalinen Python‑prototyyppi, joka havainnollistaa salattua diffuusiota yksinkertaisella 2‑dimensiolla datalla. Se käyttää Microsoft SEAL ‑kirjastoa (seal-python) ja yksinkertaista polynomista pistetoimintaa.

# python
import seal
import numpy as np

# -------------------- HE‑asetukset --------------------
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)   # Esimerkkisensorin mittaus
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Polynominen pistetoiminto (aste 3) --------------------
def poly_score(ct):
    # Approksimoi pieni neuroverkko: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Esimerkkikertoimet
    # 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)

    # Yhdenmukaistetaan skaalaus (kaikki ciphertextit jakavat nyt saman skaalauskerroin)

    # Lineaarinen yhdistelmä
    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

# -------------------- Yksi diffuusio‑askel --------------------
def diffusion_step(ct, t):
    # Yksinkertaiset vakioarvot demonstraatiota varten
    c1 = 0.9
    c2 = 0.1

    # Skaalataan vakioarvot plain‑teksteiksi
    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

    # Lasketaan pistetoiminto
    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)

    # Yhdistetään
    evaluator.add(term1, term2, term1)
    return term1

# Suoritetaan 5 salattua diffuusio‑askelta
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Valinnainen purku synteettiseen näytteeseen
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Synteettinen (purettu) näyte:", synthetic)

Huom: Koodin sisäiset kommentit on jätetty alkuperäiseen englantiin, jotta koodi pysyy toiminnallisena. Tekstisisältö on käännetty.


6. Suorituskyky & laitteistokiihdytys

AlustaKeskimääräinen latenssi per diffuusio‑askel (ms)Muistin käyttö (MB)Huomautuksia
ARM Cortex‑A78 (8 GB RAM)420120Perus, ilman kiihdytystä
NVIDIA Jetson Orin (GPU)85150GPU‑ytimet NTT‑kiihdytykseen
Intel Xeon AVX‑51260130Vektorisoitu NTT ja rinnakkainen relinearisointi
Google Edge TPU (kustomoitu HE‑kirjasto)38110Kokeellinen, hyödyntää TPU‑matriisitoimintoja polynomien arvioinnissa

Käytännön vinkkejä tuotantoon

  1. Paketoi useita näytteitä yhteen salaukseen käyttäen paketoitua koodausta; CKKS voi salata jopa N/2 slottia kerrallaan.
  2. Laiska reskaalaus: lykkää reskaalaus useiden kertolaskujen jälkeen, jotta vältetään turhat modulus‑vaihdot.
  3. Hyödynnä FPGA‑pohjaisia NTT‑kiihdyttimiä äärimmäisen vähävirtaisten reunalaitteiden (esim. Xilinx Zynq) kanssa.

7. Turvallisuus‑ ja sääntely‑tarkistuslista

  • Avaimenhallinta: Julkiset avaimet tallennetaan laitteeseen; salaiset avaimet säilytetään suojatussa eristetyssä ympäristössä tai HSM‑laitteessa. Avain­kierto suositellaan 90 päivän välein.
  • Nollatietämättömät todistukset: Luo tiivis todiste siitä, että synteettinen näyte on johdettu kelvollisesta diffuusio‑prosessista paljastamatta taustadataa.
  • Audit‑loki: Kirjaa salattujen operaatioiden hash‑arvot (esim. SHA‑256 ciphertext‑tunniste) muuttumattomaan kirjanpitoon (blockchain) sääntelyn tarkastuksia varten.
  • GDPR/CCPA: Koska raakaa henkilötietoa ei koskaan poisteta laitteesta selkokielisenä, putki täyttää “datan‑käytössä”‑suojausvaatimuksen, mikä helpottaa DPIA‑prosesseja.
  • HIPAA: Salattu PHI‑data käsitellään HE:n alla, mikä luokitellaan de‑identifioiduksi “asiantuntijamäärityksen” perusteella, edellyttäen että salausavain on tiukasti hallinnassa.

8. Todellisia käyttötapauksia

  1. Älykkäät terveydenhuollon puettavat laitteet — Synteettiset syke‑mallit mallin koulutukseen ilman potilaan vitaleja paljastamatta.
  2. Teollinen IoT — Synteettiset värähtely‑signaalit ennakoivaan kunnossapitoon, kun omistusoikeudelliset kone‑tiedot pysyvät salattuina.
  3. Autonomiset ajoneuvot — Synteettiset LIDAR‑pistepilvet jatkuvaan mallin hienosäätöön ilman, että raaka‑sensoridata jaetaan.

9. Tulevaisuuden suuntaviivat

  • Hybridinen HE‑MPC: Yhdistä homomorfinen salaus ja turvallinen moniosapuolinen laskenta (MPC) mahdollistamaan yhteistyöpohjainen synteettinen data useiden reunalaitteiden välillä.
  • Dynaamiset polynomiverkot: Hyödynnä Neural Architecture Search (NAS)‑menetelmää automaattisesti löytämään matalan asteen polynomisia approksimaatioita, jotka tasapainottavat tarkkuuden ja homomorfisen kustannuksen.
  • Kvanttisuojaus‑HE: Tutki lattice‑pohjaisia skeemoja, jotka kestävät post‑kvantti‑uhkia, varmistaen pitkän aikavälin sääntelyn noudattamisen kriittisissä infrastruktuureissa.

Katso myös

Torstai, 5. marraskuuta 2026
Valitse kieli