1. տուն
  2. բլոգ
  3. HE Սինտետիկ Տվյալներ Կցված Սարքերում

Հոմոմորֆիկ Գաղտնագրություն Օգտագործող Սինտետիկ Տվյալների Գեներացում Կցված Սարքերում

Հոմոմորֆիկ Գաղտնագրություն Օգտագործող Սինտետիկ Տվյալների Գեներացում Կցված Սարքերում

Ներածություն

Ծածկված սարքերը՝ խելացի տեսախցիկներ, հագուստային սարքեր, արդյունաբերական սենսորներ՝ հավաքում են մեծ քանակությամբ անձնական կամ սեփական տվյալներ: Ավանդական շղթաները տեղափոխում են այս հումու տվյալները ամպային ծառայություններին մաքրելու, ընդլայնելու կամ սինտետիկ տվյալների գեներացիայի համար, ինչը բացում է դրանք ընդհատման, կարգավորիչների խախտումների և ուշացման ռիսկերի համար:

Հոմոմորֆիկ Գաղտնագրություն (HE) առաջարկում է հետաքրքիր այլընտրանք՝ թույլ տալով հաշվարկները կատարվեն անմիջապես ծածկված տվյալների վրա, պահպանելով գաղտնիությունը, իսկ միաժամանակ հնարավորություն տալով կատարել բարդ վերլուծություն: HE‑ի համակցումը սարքի վրա սինտետիկ տվյալների գեներատորների հետ ստեղծում է գաղտնի‑պաշտպան սինտետիկ տվյալների շղթա, որը երբեք չի բացահայտում սկզբնական բովանդակությունը, նույնիսկ հաշվարկային շարժիչին էլ:

Այս հոդվածում մենք:

  1. Բացատրենք HE‑ի հիմնական հասկացությունները, որոնք կարևոր են սինտետիկ տվյալների գեներացիայի համար:
  2. Նկարագրենք ամբողջական ծածկված սարքի ճարտարապետություն, որը ինտեգրում է HE‑ը ժամանակակից դիֆյուզիա‑բազված գեներատորների հետ:
  3. Քննարկենք կատարողականի փոխարժեքները, սարքի արագացումը և ծախս‑արդյունավետ տեղադրման ռազմավարությունները:
  4. Տրամադրվի պրակտիկ Python պրոտոտիպ, որն օգտագործում է Microsoft SEAL գրադարանը և թեթև դիֆյուզիա մոդել:
  5. Հայտնաբերենք անվտանգության լավագույն պրակտիկաները և համաձայնության հետևանքները (GDPR, HIPAA, CCPA):

Կիմանալի եզրակացություն՝ Հումու սենսորների ընթերցումները ծածկելով, նախքան դրանց հեռացումն սարքից, և կատարելով սինտետիկ տվյալների գեներացիան ամբողջությամբ ծածկված դոմենում, կազմակերպությունները կարող են հասնել զրո‑գիտելիքի տվյալների սինտեզի—ծածկված սարքը երբեք չի իմանում հումու տվյալները, իսկ downstream օգտագործողները ստանում են միայն սինտետիկ, գաղտնի‑անվտանգ գրառումներ:


1. Ինչու Հոմոմորֆիկ Գաղտնագրություն Սինտետիկ Տվյալների համար?

ԲարդությունԱվանդական մոտեցումHE‑ով աջակցված սինտետիկ գեներացիա
Տվյալների բացահայտումՀումու տվյալները փոխանցվում են ամպին կամ կենտրոնական սերվերինՏվյալները մնում են ծածկված վերջից‑վերջ
Կարգավորիչների համաձայնությունՊահանջում է լայնածավալ տվյալների ենթակառուցվածքի համաձայնություն, աուդիտներԳաղտնագրությունը բավարարում է “դատված‑օգտագործման” պաշտպանությանը
ՈւշացումՃամփորդությունը ամպին ավելացնում է վայրկյաններից րոպեների մինչև ուշացումՍարքի վրա հաշվարկը հեռակապի ուշացումը elimինացնում է
ՎստահությունՊահանջում է վստահություն երրորդ կողմի պրոցեսինգ միջավայրումԶրո‑գիտելիքի ապացույց՝ պրոցեսորը չի կարող տեսնել plaintext‑ը

HE‑ը աջակցում է ավելացման և բազմապատկման գործողություններին ծածկված տեքստերում, ինչը թույլ է տալիս կատարել գծային ալգեբրա, մատրիցների գործողություններ և նույնիսկ ոչ‑գծային մոտավորումներ, որոնք անհրաժեշտ են ժամանակակից գեներատորների համար: Ընթացիկ, ամբողջական հոմոմորֆիկ գաղտնագրությունը (FHE) կարող է գնահատել ցանկացած շրջան, սակայն միջին հոմոմորֆիկ գաղտնագրություն (SHE) հաճախ բավարարում է դիֆյուզիա‑բազված գեներատորների համար, երբ համակցվում է խելացի մոտավորումների հետ:


2. Ճարտարապետական Նկարագիր

Ստորև ներկայացված է բարձր‑մակարդակի Mermaid դիագրամ, որը ցույց է տալիս տվյալների հոսքը:

  flowchart LR
    A["Ծածկված Սենսոր"] --> B["HE Կոդավորիչ"]
    B --> C["Ծածկված Բեռ"]
    C --> D["HE‑Ակտիվ Դիֆյուզիա Ինժեներ"]
    D --> E["Ծածկված Սինտետիկ Նմուշ"]
    E --> F["HE Դեկոդեր (պարտադիր չէ)"]
    F --> G["Սինտետիկ Տվյալների Սպառող"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px

Բաղադրիչները

  1. HE Կոդավորիչ – Փոխում է հումու սենսորների վեկտորները ciphertext‑ի, օգտագործելով հանրային բանալին, որը պահվում է սարքի վրա:
  2. Ծածկված Բեռ – Սերիալիզացված ciphertext, որը կարող է փոխանցվել (կամ պահվել տեղում) պրոցեսինգի համար:
  3. HE‑Ակտիվ Դիֆյուզիա Ինժեներ – Թեթև դիֆյուզիա մոդել, որի թվաբանական կեռնները վերագրադված են աշխատելու ciphertext‑ների վրա (ավելացում, սկալար բազմապատկում և պոլինոմի մոտավորումներ ոչ‑գծական ֆունկցիաների համար):
  4. Ծածկված Սինտետիկ Նմուշ – Ելքը մնում է ծածկված; ըստ ցանկության, HE Դեկոդեր‑ը կարող է կիրառվել վստահելի enclave‑ում, որպեսզի ստացվի plaintext‑սինտետիկ տվյալը:
  5. Սինտետիկ Տվյալների Սպառող – downstream AI ծառայություններ (օրինակ՝ մոդելների ուսուցում, վերլուծություն) որոնք ստանում են միայն սինտետիկ, գաղտնի‑պաշտպան գրառումներ:

3. Կրիպտոգրաֆիական Հիմունքներ

3.1 Ring‑Learning With Errors (RLWE)

Ավելի part‑ի ժամանակակից HE սխեմաները (BFV, CKKS, BGV) հիմնված են RLWE խնդիրին: Սինտետիկ տվյալների գեներացիայի համար սովորաբար ընտրում ենք CKKS, քանի որ այն աջակցում է մոտավոր թվաբանականին իրական թվերի վրա—բնական համապատասխանություն դիֆյուզիա մոդելների, որոնք աշխատում են floating‑point տենսորների հետ:

Կարգավորիչների օրինակ

ՊարամետրՏիպիկ արժեքԱրդյունք
Πολինոմի մոդուլի աստիճան (N)2^14 (16384)Սահմանում է ciphertext‑ի չափը և անվտանգության մակարդակը
Սկալավորման գործոն (Δ)2^40Կառավարում է floating‑point մոտավորության ճշգրտությունը
Ciphertext մոդուլ (q)2^180Ազդում է աղմուկի բյուջեին և հաշվարկի խորությանը

3.2 Աղմուկի Կառավարում

Յուրաքանչյուր հոմոմորֆիկ գործողություն ավելացնում է աղմուկ ciphertext‑ում: Դիֆյուզիայի քայլերը ներառում են բազմաթիվ բազմապատկումներ, հետևաբար պետք է relinearize և rescale յուրաքանչյուր քայլից հետո, որպեսզի աղմուկը մնա թույլ: Բուտստրափինգը օգտագործվում է միայն այն դեպքում, երբ աղմուկի բյուջեն սպառվում է, ինչը շատ քիչ է տեղի ունենում շոր դիֆյուզիա պիպլայնների (≤10 քայլ) համար:


4. Դիֆյուզիայի վերակազմավորում ծածկված դոմենում

4.1 Դիֆյուզիայի ստանդարտ համատեքստ

Դիֆյուզիայի մոդելը iteratively denoises a latent variable (x_t) using a learned score function (\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 ]

որտեղ (z \sim \mathcal{N}(0, I)).

4.2 Ծածկված մոտավորման ռազմավարություն

  1. Գծային գործողություններ – CKKS‑ը ուղղակիորեն աջակցում է ավելացման և սկալար բազմապատկման (addition, scalar multiplication).
  2. Ոչ‑գծական ակտիվացում – Փոխարինում ենք (\epsilon_\theta)-ը ցածր‑աստիճանի պոլինոմով (օրինակ՝ Chebyshev մոտավորում), որը մոտավորում է նյուրյալ ցանցի ելքը:
  3. Պատահական աղտոտում – Գեներացնում ենք աղտոտումը ծածկված դոմենից դուրս, այն ծածկում ենք, և ավելացնում homomorphically:

Արդյունքում ծածկված թարմացումը դառնում է.

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

որտեղ (c_1, c_2) են (\alpha_t)-ից ստացված սանդղակները:

4.3 Մոդելի չափի հարցումներ

  • Պարամետրերի սեղմում – Օգտագործելով knowledge distillation՝ փոքր 1‑2 MB ուսանող մոդել, որը համապատասխանում է պոլինոմի մոտավորման բյուջեին:
  • Քվանտացում – 8‑bit քվանտացումը նվազեցնում է ciphertext‑ի չափը և արագացնում homomorphic բազմապատկումը:

5. Պրոտոտիպի իրականացում

Ահա մի նվազագույն Python պրոտոտիպ, որը ցույց է տալիս ծածկված դիֆյուզիա 2‑չափանի սինտետիկ տվյալների վրա: Այն օգտագործում է Microsoft SEAL (via seal‑python) և պարզ պոլինոմի score‑ֆունկցիա:

# python
import seal
import numpy as np

# -------------------- HE Setup --------------------
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)   # Example sensor reading
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Polynomial Score (degree 3) --------------------
def poly_score(ct):
    # Approximate a tiny neural net: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Example learned coefficients
    # 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)

    # Align scales
    # (Assume all ciphertexts now share the same scale after rescaling)

    # Linear combination
    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

# -------------------- One Diffusion Step --------------------
def diffusion_step(ct, t):
    # Simplified constants for demonstration
    c1 = 0.9
    c2 = 0.1

    # Scale constants to plaintexts
    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

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

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

# Run 5 encrypted diffusion steps
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Decrypt final synthetic sample (optional)
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Synthetic (decrypted) sample:", synthetic)

Պրոտոտիպի մեկնաբանություն

  • Key Generation – Կազմում է CKKS‑ը 16384‑աստիճանի պոլինոմի մոդուլով, ապահովելով մոտ 128‑բիթ անվտանգության մակարդակ:
  • Encoding & Encryption – Հումու սենսորների վեկտորը կոդավորում և ծածկում է:
  • Polynomial Score – Նյուրյալ ցանցը փոխարինում է քառաստիճանի պոլինոմով, որը կարելի է գնահատել homomorphically:
  • Diffusion Step – Կատարում է մեկ denoising iteration՝ homomorphic addition և multiplication օգտագործելով:
  • Noise Management – Յուրաքանչյուր բազմապատկումից հետո relinearize և rescale՝ աղմուկի բյուջեն պահպանելու համար:
  • Decryption – Ցույց է տալիս, որ ciphertext‑ը կարելի է դեկոդավորել սինտետիկ նմուշի համար; արտադրության միջավայրում դեկոդավորումը կատարվում է միայն վստահելի enclave‑ում կամ չի կատարվում, եթե downstream‑ը ընդունում է ciphertext‑ը:

6. Կատարողականը և Սարքի Արագացում

ՀարթակՄիջին ուշացում մեկ դիֆյուզիա քայլի համար (ms)Հիշողության օգտագործում (MB)Նշումներ
ARM Cortex‑A78 (8 GB RAM)420120Անհատական, առանց արագացման
NVIDIA Jetson Orin (GPU)85150GPU‑ի NTT kernels-ը արագացնում են բազմապատկումները
Intel Xeon with AVX‑51260130Վեկտորիզացված NTT և զուգահեռ relinearization
Google Edge TPU (հատուկ HE գրադարան)38110Փորձնական, օգտագործում է TPU matrix‑ը պոլինոմի գնահատման համար

Արդյունավետության խորհուրդներ արտադրության համար

  1. Փաթեթավորեք մի քանի նմուշներ մեկ ciphertext‑ում՝ օգտագործելով packed encoding: CKKS‑ը կարող է ծածկել մինչև N/2 սլոտներ:
  2. Lazy Rescaling – Հետաձգեք rescaling-ը մի քանի բազմապատկումից հետո, որպեսզի նվազեցնեք modulus‑switch-ի ծախսերը:
  3. FPGA‑բազված NTT արագացուցիչներ – Օգտագործեք Xilinx Zynq‑ի FPGA‑ը՝ առավել ցածր էներգիայի ծածկված սարքերի համար:

7. Անվտանգություն և Համաձայնություն – Ստուգման Ցանկ

  • Բանալիների կառավարում – Հանրային բանալիները պահեք սարքի վրա; գաղտնի բանալիները պահեք վստահելի enclave‑ում կամ HSM‑ում: Կրկնակի բանալիների պարբերական փոխարինում՝ յուրաքանչյուր 90 օրում:
  • Zero‑Knowledge Proofs – Ստեղծեք կարճ ապացույց, որ սինտետիկ նմուշը ստացվել է վավեր դիֆյուզիա գործընթացից, առանց բացահայտելու հիմքային տվյալները:
  • Audit Trail – Գրանցեք ciphertext‑ների hash‑ները (օրինակ՝ SHA‑256) անփոփոխ լեգերում (blockchain)՝ կարգավորիչների աուդիտների համար:
  • GDPR/CCPA – Քանի որ հումու անձնական տվյալները երբեք չեն դուրս գալիս սարքից plaintext‑ով, պիպլայնը բավարարում է “data‑in‑use” պաշտպանությանը, ինչը պարզեցնում Data Protection Impact Assessments (DPIA):
  • HIPAA – Գաղտնագրված PHI‑ն մշակվում է որպես de‑identified տվյալ, եթե դեկոդավորման բանալիները խիստ վերահսկվում են:

8. Իրական Օրինակների Օգտագործում

  1. Խելացի առողջապահական հագուստներ – Սինտետիկ սիրտի ռիթմի նմուշներ գեներացնում են մոդելների ուսուցման համար, առանց բացահայտելու հիվանդի վիտալները:
  2. Արդյունաբերական IoT – Սինտետիկ վիբրացիոն ստորագրություններ գեներացնում են կանխատեսող սպասարկման համար, միաժամանակ պահելով սեփական մեքենաների տվյալները գաղտնագրված:
  3. Ավտոնոմային Տրանսպորտ – Սինտետիկ LIDAR point cloud‑ներ գեներացնում են ծածկված սարքում՝ շարունակական մոդելների բարելավման համար, առանց կիսելով հումու սենսորների տվյալները:

9. Ապագա Ուղղություններ

  • Hybrid HE‑MPC – Համակցել հոմոմորֆիկ գաղտնագրությունը Secure Multi‑Party Computation‑ի հետ՝ թույլ տալով մի քանի ծածկված Edge‑նոդների միջև համագործակցող սինտետիկ տվյալների գեներացիա:
  • Dynamic Polynomial Networks – Օգտագործել Neural Architecture Search (NAS)՝ ավտոմատ կերպով գտնելու ցածր‑աստիճանի պոլինոմներ, որոնք օպտիմալ են homomorphic հաշվարկների համար:
  • Post‑Quantum Resistant HE – Հետազոտել lattice‑based սխեմաները, որոնք մնալու են անվտանգ post‑quantum հակառակորդների դեմ, որպեսզի ապահովեն երկարաժամկետ համաձայնությունը kriտիկական ենթակառուցվածքներում:

Տես նաև

Հինգշաբթի, Նոյ 05, 2026
Ընտրեք լեզուն