1. Strona główna
  2. blog
  3. HE Syntetyczne Dane na Krawędzi

Generowanie Syntetycznych Danych z Wykorzystaniem Szyfrowania Homomorficznego na Krawędzi

Generowanie Syntetycznych Danych z Wykorzystaniem Szyfrowania Homomorficznego na Krawędzi

Wprowadzenie

Urządzenia brzegowe — inteligentne kamery, wearables, czujniki przemysłowe — zbierają ogromne strumienie danych osobistych lub własnościowych. Tradycyjne potoki przenoszą te surowe dane do chmury w celu czyszczenia, augmentacji lub generowania danych syntetycznych, narażając je na przechwycenie, naruszenia regulacyjne i opóźnienia.

Szyfrowanie homomorficzne (HE) oferuje atrakcyjną alternatywę: pozwala na wykonywanie obliczeń bezpośrednio na zaszyfrowanych danych, zachowując poufność, a jednocześnie umożliwiając zaawansowaną analizę. Połączenie HE z generatorami danych syntetycznych działającymi na urządzeniu tworzy prywatny potok generowania danych syntetycznych, który nigdy nie ujawnia oryginalnego ładunku, nawet samemu silnikowi obliczeniowemu.

W tym artykule:

  1. Wyjaśniamy podstawowe pojęcia HE istotne dla generowania danych syntetycznych.
  2. Przedstawiamy kompletną architekturę brzegową integrującą HE z nowoczesnymi generatorami opartymi na dyfuzji.
  3. Omawiamy kompromisy wydajności, przyspieszenie sprzętowe i strategie wdrażania przy niskich kosztach.
  4. Dostarczamy praktyczny prototyp w Pythonie wykorzystujący bibliotekę Microsoft SEAL oraz lekki model dyfuzyjny.
  5. Wyróżniamy najlepsze praktyki bezpieczeństwa oraz implikacje zgodności (RODO, HIPAA, CCPA).

Kluczowa lekcja: Szyfrując surowe odczyty czujników zanim opuścią urządzenie i wykonując generowanie danych syntetycznych w pełni w domenie zaszyfrowanej, organizacje mogą osiągnąć syntezę danych zerowej wiedzy — urządzenie brzegowe nigdy nie poznaje surowych danych, a odbiorcy końcowi otrzymują jedynie syntetyczne, bezpieczne rekordy.


1. Dlaczego szyfrowanie homomorficzne dla danych syntetycznych?

WyzwanieTradycyjne podejścieGenerowanie syntetyczne z HE
Ujawnienie danychSurowe dane przesyłane do chmury lub serwera centralnegoDane pozostają zaszyfrowane end‑to‑end
Zgodność regulacyjnaWymaga rozbudowanej zgody podmiotów danych, audytówSzyfrowanie spełnia ochronę „danych w użyciu”
OpóźnienieRunda‑trip do chmury dodaje sekundy‑minutyObliczenia na urządzeniu eliminują opóźnienia sieciowe
ZaufanieWymaga zaufania do środowiska przetwarzającego stronę trzeciąDowód zerowej wiedzy: procesor nie widzi tekstu jawnego

HE obsługuje dodawanie i mnożenie na szyfrogramach, co umożliwia algebrę liniową, operacje macierzowe oraz przybliżenia nieliniowe niezbędne nowoczesnym modelom generatywnym. Choć pełne szyfrowanie homomorficzne (FHE) może ocenić dowolny obwód, nieco homomorficzne szyfrowanie (SHE) często wystarcza dla generatorów opartych na dyfuzji przy zastosowaniu sprytnych przybliżeń.


2. Projekt architektoniczny

Poniżej znajduje się diagram Mermaid wysokiego poziomu ilustrujący przepływ danych.

  flowchart LR
    A["Czujnik brzegowy"] --> B["Koder HE"]
    B --> C["Zaszyfrowane ładunki"]
    C --> D["Silnik dyfuzji z HE"]
    D --> E["Zaszyfrowana próbka syntetyczna"]
    E --> F["Dekoder HE (opcjonalny)"]
    F --> G["Konsument danych syntetycznych"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px

Komponenty:

  1. Koder HE – konwertuje wektory surowych pomiarów na szyfrogramy przy użyciu klucza publicznego przechowywanego w urządzeniu.
  2. Zaszyfrowany ładunek – zserializowany szyfrogram, który może być przesyłany (lub pozostawiony lokalnie) do przetwarzania.
  3. Silnik dyfuzji z HE – lekki model dyfuzyjny, którego jądra arytmetyczne zostały przepisane tak, aby działały na szyfrogramach (dodawanie, mnożenie skalarne oraz przybliżenia wielomianowe dla funkcji nieliniowych).
  4. Zaszyfrowana próbka syntetyczna – wyjście pozostaje zaszyfrowane; opcjonalnie Dekoder HE może zostać zastosowany w zaufanym enclave, aby uzyskać jawny syntetyczny rekord.
  5. Konsument danych syntetycznych – downstreamowe usługi AI (np. trening modeli, analityka), które otrzymują wyłącznie syntetyczne, prywatne rekordy.

3. Fundamenty kryptograficzne

3.1 Ring‑Learning With Errors (RLWE)

Większość współczesnych schematów HE (BFV, CKKS, BGV) opiera się na problemie RLWE. Do generowania danych syntetycznych najczęściej wybieramy CKKS, ponieważ obsługuje przybliżoną arytmetykę na liczbach rzeczywistych — naturalnie pasuje do modeli dyfuzyjnych operujących na tensorach zmiennoprzecinkowych.

Kluczowe parametry:

ParametrTypowa wartośćWpływ
Stopień wielomianu (N)2^14 (16384)Określa rozmiar szyfrogramu i poziom bezpieczeństwa
Współczynnik skalowania (Δ)2^40Kontroluje precyzję przybliżenia zmiennoprzecinkowego
Moduł szyfrogramu (q)2^180Wpływa na budżet szumu i głębokość obliczeń

3.2 Zarządzanie szumem

Każda operacja homomorficzna zwiększa szum w szyfrogramie. Krok dyfuzji wymaga wielu mnożeń; dlatego musimy relinearizować i przeskalować po każdym kroku, aby szum nie przekroczył dopuszczalnego limitu. Bootstrapping stosujemy jedynie wtedy, gdy budżet szumu grozi przepełnieniem — co jest rzadkie w płytkich potokach dyfuzyjnych (≤ 10 kroków).


4. Przebudowa dyfuzji dla domeny zaszyfrowanej

4.1 Krótkie przypomnienie klasycznej dyfuzji

Model dyfuzyjny iteracyjnie odszumia zmienną latentną (x_t) przy użyciu wyuczonej funkcji wyniku (\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 ]

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

4.2 Strategia przybliżenia w szyfrogramie

  1. Operacje liniowe – bezpośrednio wspierane przez CKKS (dodawanie, mnożenie skalarne).
  2. Aktywacje nieliniowe – zastępujemy niskiego stopnia wielomianem (np. przybliżenie Czebyszewa) aproksymującym wyjście sieci neuronowej.
  3. Wstrzykiwanie szumu – generujemy szum poza domeną zaszyfrowaną, szyfrujemy go i dodajemy homomorficznie.

Zaktualizowane równanie w szyfrogramie:

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

gdzie (c_1, c_2) to stałe pochodzące z (\alpha_t).

4.3 Rozważania dotyczące rozmiaru modelu

  • Kompresja parametrów: używamy knowledge distillation, aby skompresować model nauczyciela do ucznia o rozmiarze 1‑2 MB, spełniającego budżet wielomianowy.
  • Kwantyzacja: kwantyzacja do 8 bitów zmniejsza rozmiar szyfrogramu i przyspiesza mnożenie homomorficzne.

5. Implementacja prototypowa

Poniżej znajduje się minimalny prototyp w Pythonie, demonstrujący szyfrowaną dyfuzję na syntetycznym zbiorze 2‑D. Wykorzystuje Microsoft SEAL (poprzez seal‑python) oraz prostą funkcję wielomianową jako przybliżenie sieci.

# python
import seal
import numpy as np

# -------------------- Konfiguracja 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)

# -------------------- Dane wejściowe --------------------
raw = np.array([0.7, -1.2], dtype=np.float64)   # Przykładowy odczyt czujnika
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Wielomianowe przybliżenie wyniku --------------------
def poly_score(ct):
    # Przybliżenie małej sieci: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Przykładowe wyuczone współczynniki

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

    # Łączenie liniowe (zakładamy, że skale są już wyrównane)
    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 krok dyfuzji --------------------
def diffusion_step(ct, t):
    # Uproszczone stałe demonstracyjne
    c1 = 0.9
    c2 = 0.1

    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

    # Obliczanie przybliżonego wyniku
    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)

    # Połączenie
    evaluator.add(term1, term2, term1)
    return term1

# Wykonaj 5 zaszyfrowanych kroków dyfuzji
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Opcjonalne odszyfrowanie końcowej próbki syntetycznej
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Syntetyczna (odszyfrowana) próbka:", synthetic)

Krótka charakterystyka prototypu

  • Generowanie kluczy: Konfigurujemy CKKS z stopniem wielomianu 16384, co zapewnia ~128‑bitowe bezpieczeństwo.
  • Kodowanie i szyfrowanie: Surowy wektor czujnika jest kodowany i szyfrowany.
  • Wielomianowy wynik: Zastępujemy sieć neuronową wielomianem stopnia trzeciego, który można ocenić homomorficznie.
  • Krok dyfuzji: Wykonujemy jedną iterację odszumiania przy użyciu operacji homomorficznych (dodawanie, mnożenie).
  • Zarządzanie szumem: Po każdej mnożeniu stosujemy relinearizację i przeskalowanie, aby utrzymać budżet szumu w granicach.
  • Odszyfrowanie: Pokazujemy, że końcowy szyfrogram może zostać odszyfrowany do syntetycznej próbki; w produkcji odszyfrowanie odbywa się wyłącznie w zaufanym enclave lub wcale nie jest wymagane, jeśli downstream przyjmuje dane zaszyfrowane.

6. Wydajność i przyspieszenie sprzętowe

PlatformaŚrednie opóźnienie na krok dyfuzji (ms)Zużycie pamięci (MB)Uwagi
ARM Cortex‑A78 (8 GB RAM)420120Podstawowa, bez przyspieszenia
NVIDIA Jetson Orin (GPU)85150Kernale GPU przyspieszają NTT, przyspieszając mnożenia
Intel Xeon z AVX‑51260130Wektorowy NTT i równoległa relinearizacja
Google Edge TPU (niestandardowa biblioteka HE)38110Eksperymentalne, wykorzystuje macierzowe operacje TPU do przybliżeń wielomianowych

Wskazówki produkcyjne

  1. Pakowanie wielu próbek w jeden szyfrogram przy użyciu kodowania pakietowego; CKKS pozwala zaszyfrować wektory o długości do N/2 slotów.
  2. Leniwa reskalacja: odkładaj przeskalowanie po kilku mnożeniach, aby ograniczyć liczbę kosztownych przełączeń modułów.
  3. Akceleratory FPGA‑based NTT: idealne dla ultra‑niskiego poboru mocy na urządzeniach brzegowych (np. Xilinx Zynq).

7. Lista kontrolna bezpieczeństwa i zgodności

  • Zarządzanie kluczami: Publiczne klucze przechowuj na urządzeniu; klucze prywatne zabezpiecz w enclave lub HSM. Rotuj klucze co 90 dni.
  • Dowody zerowej wiedzy: Generuj zwięzły dowód, że syntetyczna próbka została wyprodukowana zgodnie z prawidłowym procesem dyfuzji, nie ujawniając danych źródłowych.
  • Ścieżka audytu: Loguj hasze operacji zaszyfrowanych (np. SHA‑256 szyfrogramu) w niezmiennym rejestrze (blockchain) w celu audytów regulacyjnych.
  • RODO / CCPA: Ponieważ surowe dane osobowe nigdy nie opuszczają urządzenia w postaci jawnej, potok spełnia wymóg ochrony „danych w użyciu”, upraszczając ocenę skutków ochrony danych (DPIA).
  • HIPAA: Zaszyfrowane PHI przetwarzane w HE może być uznane za zde‑identyfikowane dane według metody „eksperckiej oceny”, pod warunkiem ścisłej kontroli klucza deszyfrującego.

8. Przykłady zastosowań w rzeczywistym świecie

  1. Inteligentne wearables medyczne – generowanie syntetycznych wzorców tętna do treningu modeli, bez ujawniania rzeczywistych parametrów pacjenta.
  2. Przemysłowy IoT – tworzenie syntetycznych sygnałów drgań dla predykcyjnego utrzymania, zachowując własność danych maszyn.
  3. Pojazdy autonomiczne – generowanie syntetycznych chmur punktów LIDAR na krawędzi w celu ciągłego doskonalenia modeli, bez udostępniania surowych danych czujników.

9. Kierunki rozwoju

  • Hybrydowy HE‑MPC: połączenie szyfrowania homomorficznego z bezpiecznym wielostronnym obliczaniem, aby umożliwić współpracujące generowanie danych syntetycznych pomiędzy wieloma węzłami brzegowymi.
  • Dynamiczne sieci wielomianowe: wykorzystanie Neural Architecture Search (NAS) do automatycznego odkrywania wielomianowych przybliżeń o niskim stopniu, które optymalizują dokładność vs. koszt homomorficzny.
  • Szyfrowanie odporne na kwantowy atak: badanie schematów opartych na kratowych problemach, które pozostają bezpieczne wobec przyszłych komputerów kwantowych, zapewniając długoterminową zgodność dla infrastruktury krytycznej.

Zobacz także

Czwartek, 5 listopada 2026
Wybierz język