
# ჰომომორფური დაშიფვრის მხარდაჭერით სინთეზური მონაცემების გენერაცია კიდეზე

## შესავალი

კიდე‑მოწყობილობები — ჭკვიანი კამერები, სამაგრებული მოწყობილობები, სამრეწველო სენსორები — აგროვებენ მასიური ნაკადებს პერსონალურ ან პროპრაიეტარულ მონაცემებს. ტრადიციული პაიპლინები გადაგზავნიან ამ ნედლივ მონაცემებს ღრუბელში გასუფთავებისთვის, აუმჯობესებისთვის ან სინთეზური მონაცემების გენერაციისთვის, რაც აჩვენებს ისინი ინტერსეფციას, რეგულაციურ დარღვევებს და ლატენციის საფასურებს.

**ჰომომორფური დაშიფვრა (HE)** სთავაზობს მიმზიდველი ალტერნატივას: იგი აძლიერებს გამოთვლას პირდაპირ დაშიფრულ მონაცემებზე, შენარჩუნებს კონფიდენციალურობას, თუმცა მაინც იძლევა სიფრთხილე‑მაღალ ანალიტიკას. HE‑ის შერწყმა მოწყობილობაზე სინთეზური მონაცემის გენერატორებთან ქმნის **კონფიდენციალურ‑შენარჩუნებული სინთეზური მონაცემის პაიპლინს**, რომელიც არასოდეს აჩვენებს ორიგინალურ პელოდს, მაშინაც კი, როდესაც გამოთვლის იინჟინერი თვითონ.

ამ სტატიაში ჩვენ:

1. ახსნათ HE‑ის ძირითადი კონცეფციები, რომლებიც დაკავშირებულია სინთეზური მონაცემების გენერაციასთან.  
2. აღწეროთ სრულყოფილი კიდე არქიტექტურა, რომელიც ინტეგრირებულია HE‑ით თანამედროვე დიფუზიის‑მოდელებთან.  
3. განიხილოთ შესრულების კომპრომისები, აპარატურული აჩქარება და ღირებულების ეფექტური განაწილება.  
4. პრაკტიკული Python პროტოტიპის მიწოდება, რომელიც იყენებს **Microsoft SEAL** ბიბლიოთეკას და მსუბუქ დიფუზიის მოდელს.  
5. გამოკვეთოთ უსაფრთხოების საუკეთესო პრაქტიკები და შესაბამისობის გავლენა ([GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html), [CCPA](https://oag.ca.gov/privacy/ccpa)).

> **მთავარი დასკვნა:** ნედლი სენსორის წაკითხვები დაშიფრულად, სანამ ისინი დატოვებენ მოწყობილობას, და სინთეზური მონაცემის გენერაცია სრულად დაშიფრულ დომენში, ორგანიზაციებს შეუძლიათ მიაღწიონ **ნულ‑ცნობურ მონაცემის სინთეზას** — კიდე‑მოწყობილობა არასოდეს იცის ნედლი მონაცემები, ხოლო ქვედა მომხმარებლები იღებენ მხოლოდ სინთეზურ, კონფიდენციალურ ჩანაწერებს.

## 1. რატომ ჰომომორფური დაშიფვრა სინთეზური მონაცემებისთვის?

| გამოწვევა | ტრადიციული მიდგომა | HE‑მხარდაჭერილი სინთეზური გენერაცია |
|-----------|----------------------|---------------------------------|
| **მონაცემების გამჟღავნება** | ნედლი მონაცემები გადაეგზავნება ღრუბელში ან ცენტრალურ სერვერზე | მონაცემები დარჩება დაშიფრულად ბოლომდე |
| **რეგულაციური შესაბამისობა** | საჭიროია ფართო თანხმობა, აუდიტები | დაშიფვრა აკმაყოფილებს “მონაცემების‑გამოყენების” დაცვის მოთხოვნებს |
| **ლატენცია** | ღრუბელში დაბრუნება დამატებით წამებს‑წუთებს | მოწყობილობაზე შესრულება იშლის ქსელის დაყოვნებას |
| **ნდობა** | საჭიროა ნდობა მესამე მხარის პროცესის გარემოში | ნულ‑ცნობითი დამადასტურებელი: პროცესორს არ შეუძლია ნახოს ღია ტექსტი |

HE‑ი მხარს უჭერს **დამატებას** და **გამრავლებას** ციფრულ ტექსტებზე, რაც აძლიერებს ხაზურ ალგებრს, მატრიცის ოპერაციებს, და нават არ‑ლინერურ aproximaციებს, რომლებიც საჭიროებია თანამედროვე გენერაციული მოდელებისთვის. სრულად ჰომომორძურ დაშიფვრას (FHE) შეუძლია შეფასება ნებისმიერი ციკლის, თუმცა **ნაწილობრივ ჰომომორძურ დაშიფვრას (SHE)** ხშირად საკმარისია დიფუზიის‑მოდელებისთვის, როდესაც კომბინირებულია ჭკვიანი aproximaციებით.

## 2. არქიტექტურული სქემა

ქვემოთ მოცემულია მაღალი‑დონეის Mermaid დიაგრამა, რომელიც აჩვენებს მონაცემთა ნაკადს.

```mermaid
flowchart LR
    A["Edge Sensor"] --> B["HE Encoder"]
    B --> C["Encrypted Payload"]
    C --> D["HE‑Enabled Diffusion Engine"]
    D --> E["Encrypted Synthetic Sample"]
    E --> F["HE Decoder (optional)"]
    F --> G["Synthetic Data Consumer"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
```

**კომპონენტები:**

1. **HE ენკოდერი** – გარდაქმნის ნედლივ სენსორურ ვექტორებს ციფრულ ტექსტში, იყენებს მოწყობილობაზე შენახულ საზოგადო გასაღებს.  
2. **დაშიფრული პელოდი** – სერიალიზებული ციფრულ ტექსტი, რომელიც გადაეგზავნება (ან ადგილობრივად ინახება) დამუშავებისთვის.  
3. **HE‑მხარდაჭერილი დიფუზიის ძრავა** – მსუბუქი დიფუზიის მოდელი, რომლის არითმეტიკული ბირთვებიც გადაწერილია მუშაობისთვის ციფრულ ტექსტებზე (დამატება, სკალარული გამრავლება და პოლინომური aproximaციები არ‑ლინერალურ ფუნქციებზე).  
4. **დაშიფრული სინთეზური ნიმუში** – გამოსავალი დარჩება დაშიფრულად; სურვილისამებრ, **HE დეკოდერი** შეიძლება გამოყენებული იყოს ნდობით ენკლავზე, რათა მიიღოთ ღია ტექსტის სინთეზური მონაცემები.  
5. **სინთეზური მონაცემების მომხმარებელი** – ქვედა AI სერვისები (მაგ., მოდელის ტრენინგი, ანალიტიკა), რომლებიც იღებენ მხოლოდ სინთეზურ, კონფიდენციალურ ჩანაწერებს.

## 3. კრიპტოგრაფიული საფუძვლები

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

მრავალჯერ თანამედროვე HE სქემები (BFV, CKKS, BGV) აგებულია RLWE‑ის პრობლემაზე. სინთეზური მონაცემების გენერაციისთვის, ჩვეულებრივ, ვიყენებთ **CKKS**, რადგან იგი მხარს უჭერს დაახლოებით ალგებრს რეალურ რიცხვებზე — ბუნებრივად შეესაბამება დიფუზიის მოდელებს, რომლებიც მუშაობენ ფლოტ‑პოინტ ტენსორებზე.

**მნიშვნელოვანი პარამეტრები**

| პარამეტრი | ტიპიკური მნიშვნელობა | ტოლება |
|-----------|----------------------|--------|
| პოლინომის მოდულუსის დიგრესი (N) | 2^14 (16384) | განსაზღვრავს ციფრულ ტექსტის ზომას & უსაფრთხოების დონეს |
| მასშტაბის ფაქტორი (Δ) | 2^40 | აკონტროლებს ფლოტ‑პოინტ aproximaციის სიზუსტეს |
| ციფრულ ტექსტის მოდულუსი (q) | 2^180 | გავლენას ახდენს შაბლონის ბიუჯეტზე და გამრავლების სიღრმეზე |

### 3.2 შაბლონის მართვა

ყოველი ჰომომორძური ოპერაცია აძლიერებს შაბლონს. დიფუზიის ნაბიჯები მოიცავს მრავალ გამრავლებას; ამიტომ აუცილებელია **რელინერიზაცია** და **რესკეილინგი** თითოეულ ნაბიჯზე, რათა შაბლონი დარჩეს კონტროლში. არქიტექტურაში **ბუტსტრაპინგი** გამოიყენება მხოლოდ მაშინ, როდესაც შაბლონის ბიუჯეტი საფრთხის ქვეშაა, რაც ირჩევა ნაკლები დიფუზიის ნაბიჯებისთვის (≤ 10).

## 4. დიფუზიის გადამუშავება დაშიფრულ დომენში

### 4.1 სტანდარტული დიფუზიის მიმოხილვა

დიფუზიის მოდელი იტერატიულად აუმჯობესებს ლათინურ ცვლადს \(x_t\) გამოყენებით სწავლის ფუნქციის \(\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 დაშიფრულ aproximaციის სტრატეგია

1. **ლინერური ოპერაციები** – პირდაპირ მხარდაჭერილია CKKS‑ის მიერ (დამატება, სკალარული გამრავლება).  
2. **არ‑ლინერური აქტივაცია** – შეცვალეთ \(\epsilon_\theta\) **დაბალი‑დიგრესი პოლინომით** (მაგ., Chebyshev aproximaცია), რომელიც ა� Approximate‑ებს ნეირონული ქსელის გამომავალი.  
3. **შემთხვევითი შაბლონის შეყვანა** – შექმენით შაბლონი გარეთ, დაშიფრეთ იგი, და დაამატეთ ჰომომორძურად.

შედეგური დაშიფრული განახლება ხდება:

\[
\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 მოდელის ზომის გათვალისწინება

- **პარამეტრების შეკუმშვა**: გამოიყენეთ **ცოდნის დისტილაცია**, რათა მასწავლებლის მოდელი შემცირდეს 1‑2 მბ-ის სტუდენტად, რომელიც შეესაბამება პოლინომურ aproximaციის ბიუჯეტს.  
- **ქვანტიზაცია**: 8‑ბიტის ქვანტიზაცია შემცირებს ციფრულ ტექსტის ზომას და აჩქარებს ჰომომორძურ გამრავლებას.

## 5. პროტოტიპის განხორციელება

ქვემოთ მოცემულია მინიმალური Python პროტოტიპი, რომელიც აჩვენებს დაშიფრულ დიფუზიას სინთეზურ 2‑D მონაცემებზე. იგი იყენებს **Microsoft SEAL** ბიბლიოთეკას (`seal-python`) და ცალკეულ პოლინომურ score‑ფუნქციას.

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

**პროექტის განმარტება**

- **გასაღებების გენერაცია**: CKKS‑ის 16384‑დიგრესი, რომელიც იძლევა ~128‑ბიტ უსაფრთხოების დონეს.  
- **ეკოდირება & დაშიფვრა**: ნედლი სენსორის ვექტორი ეკოდირდება და დაშიფრებულია.  
- **პოლინომური Score**: ნეირონული ქსელის შეცვლა კუბურ პოლინომით, რომელიც შეიძლება შეფასდეს ჰომომორძურად.  
- **დიფუზიის ნაბიჯი**: ერთ-ერთი დენოიზაციის იტერაცია, რომელიც იყენებს ჰომომორძურ დამატებასა და გამრავლებას.  
- **შაბლონის მართვა**: თითოეულ გამრავლებაზე **რელინერიზაცია** და **რესკეილინგი** ხდება, რათა noise‑ის ბიუჯეტი კონტროლში დარჩეს.  
- **დეკოდირება**: აჩვენებს, რომ საბოლოო ციფრულ ტექსტს შეიძლება დეკოდიროთ სინთეზურ ნიმუშად; პროდუქციაში ეს შეიძლება მოხდეს მხოლოდ ნდობით ენკლავში ან არ მოხდეს, თუ downstream‑მომხმარებლები მიიღებენ დაშიფრულ მონაცემებს.

## 6. შესრულება & აპარატურული აჩქარება

| პლატფორმა | საშუალო ლატენცია თითოეულ დიფუზიის ნაბიჯზე (მს) | მეხსიერების დატვირთვა (მბ) | შენიშვნები |
|-----------|--------------------------------------|-----------------------|-----------|
| ARM Cortex‑A78 (8 GB RAM) | 420 | 120 | საბაზისო, აჩქარება არ არის |
| NVIDIA Jetson Orin (GPU) | 85 | 150 | GPU‑ის NTT kernels აჩქარებს გამრავლებებს |
| Intel Xeon with AVX‑512 | 60 | 130 | ვექტორიზებული NTT და პარალელური რელინერიზაცია |
| Google Edge TPU (custom HE lib) | 38 | 110 | ექსპერიმენტული, იყენებს TPU მატრიცის ოპერაციებს პოლინომურ aproximaციაზე |

**პროდუქციის რჩევები**

1. **ბაჩის დაშიფვრა**: ერთდროულად დაშიფრეთ რამდენიმე ნიმუში, იყენეთ **packed encoding**; CKKS‑ის შეუძლია დაშიფროს ვექტორები, რომელთა სიგრძე არ აღემატება `N/2` სლოტს.  
2. **ლაზიური რესკეილინგის გამოყენება**: გადადეთ რესკეილინგი რამდენიმე გამრავლებაზე, რათა შემციროთ მოდული‑სვიჩის ღირებულება.  
3. **FPGA‑ზე NTT აჩქარება**: გამოიყენეთ Xilinx Zynq‑ის NTT‑accelerator‑ები, რომ მიიღოთ ულტრა‑დაბალი ენერგიის მოწყობილობები.

## 7. უსაფრთხოების & შესაბამისობის სია

- **გასაღებების მართვა**: საზოგადო გასაღებები შეინახეთ მოწყობილობაზე; საიდუმლო გასაღებები უსაფრთხო ენკლავში ან HSM-ში. გასაღებების გადატრიალება ყოველ 90 დღეში.  
- **ნულ‑ცნობითი დამადასტურებლები**: შექმენით მოკლე დამადასტურებელი, რომ სინთეზური ნიმუში მიღებულია სწორი დიფუზიის პროცესიდან, არამარტო ძირითადი მონაცემები არ გამოვლინდება.  
- **აუდიტის ტრეკი**: ლოგირეთ დაშიფრულ ოპერაციების ჰეშები (მაგ., SHA‑256 ციფრულ ტექსტის) არამოქმედებადი ლეჯერში (ბლოკჩეინი) რეგულაციური აუდიტებისთვის.  
- **[GDPR](https://gdpr.eu/)**: რადგან ნედლი პერსონალური მონაცემები არასოდეს გადის მოწყობილობაზე ღია ფორმით, პაიპლინი აკმაყოფილებს “მონაცემების‑გამოყენების” დაცვის მოთხოვნებს, რაც გამარტივებს Data Protection Impact Assessments (DPIA).  
- **[HIPAA](https://www.hhs.gov/hipaa/index.html)**: დაშიფრულ PHI‑ის დამუშავება ითვლება “დეუნიფრებული” მონაცემებით, თუ დაშიფვრის გასაღებები მკაცრად კონტროლირებულია, რაც აკმაყოფილებს ექსპერტის დადგენის მეთოდს.  
- **[CCPA](https://oag.ca.gov/privacy/ccpa)**: მომხმარებლებს შეუძლიათ მოთხოვნათ, რომ მათი მონაცემები არ იყოს გამჟღავნებული, რაც ჰომომორძურ დაშიფვრით ავტომატურად შესრულდება.

## 8. რეალური სამყარო გამოყენების შემთხვევები

1. **ჭკვიანი სამედიცინო სამაგრებული** – შექმენით სინთეზური გულის ციკლის შაბლონები მოდელის ტრენინგისთვის, არამარტო პაციენტის ცოცხალი მონაცემები არ გამოვლინდება.  
2. **სამრეწველო IoT** – წარმოადგინეთ სინთეზური ვიბრაციის სიგნალები პროგნოზირებადი შენარჩუნებისთვის, ხოლო პროპრაიეტარული მანქანის მონაცემები დარჩება დაშიფრულად.  
3. **ავტონომიური ტრანსპორტი** – შექმენით სინთეზური LIDAR პუნქტული ღრუბლები კიდეზე, მოდელის მუდმივი გაუმჯობესებისთვის, არამარტო ნედლი სენსორების ნაკადები არ გაუზიაროთ.

## 9. მომავალის მიმართულებები

- **ჰიბრიდული HE‑MPC**: ჰომომორძური დაშიფვრის კომბინაცია უსაფრთხო მრავალმხრივი გამოთვლით, რათა შესაძლებლობა ჰქონდეს თანამშრომლობით სინთეზური მონაცემების გენერაცია მრავალ კიდე‑ნოდზე.  
- **დინამიკური პოლინომური ქსელები**: გამოიყენეთ **ნეირონული არქიტექტურის ძიება (NAS)**, რათა ავტომატურად აღმოჩნდეს დაბალი დიგრესი პოლინომური aproximaციები, რომლებიც ბალანსირებს სიზუსტეს და ჰომომორძურ ღირებულებას.  
- **ქვანტუმის‑განმცივებელი HE**: განისწავლეთ ლატიცის‑მდებარეობის სქემები, რომლებიც უსაფრთხოა პოსტ‑ქვანტუმის დამპყრებლების წინააღმდეგ, რაც უზრუნველყოფს გრძელვადიან შესაბამისობას კრიტიკული ინფრასტრუქტურაზე.

## იხილეთ ასევე

- [ჰომომორძური დაშიფვრა მანქანურ სწავლას – Microsoft SEAL დოკუმენტაცია](https://github.com/microsoft/SEAL)  
- [კონფიდენციალურობის‑შენარჩუნებული სინთეზური მონაცემების გენერაცია – NIST AI რისკის მართვის ჩარჩო](https://www.nist.gov/ai)  
- [ნულ‑ცნობითი დამადასტურებლები დაშიფრულ გამოთვლებისთვის – ZKProof საზოგადოება](https://zkproof.org)