
# การสร้างข้อมูลสังเคราะห์ด้วยการเข้ารหัสโฮโมมอร์ฟิกบนอีจ

## บทนำ

อุปกรณ์ขอบเครือข่าย—กล้องอัจฉริยะ, อุปกรณ์สวมใส่, เซนเซอร์อุตสาหกรรม—รวบรวมข้อมูลส่วนบุคคลหรือข้อมูลที่เป็นกรรมสิทธิ์ในปริมาณมหาศาล กระบวนการแบบดั้งเดิมจะย้ายข้อมูลดิบเหล่านี้ไปยังคลาวด์เพื่อทำความสะอาด, เพิ่มมิติ, หรือสร้างข้อมูลสังเคราะห์ ซึ่งทำให้ข้อมูลเสี่ยงต่อการถูกดักจับ, การละเมิดกฎระเบียบ, และความล่าช้า  

**การเข้ารหัสโฮโมมอร์ฟิก (HE)** นำเสนอทางเลือกที่น่าสนใจ: มันอนุญาตให้ทำการคำนวณโดยตรงบนข้อมูลที่เข้ารหัส, รักษาความลับในขณะที่ยังคงทำการวิเคราะห์ขั้นสูงได้ การผสาน HE กับเครื่องสร้างข้อมูลสังเคราะห์บนอุปกรณ์ทำให้เกิด **สายงานข้อมูลสังเคราะห์ที่รักษาความเป็นส่วนตัว** ที่ไม่เคยเปิดเผยข้อมูลดิบแม้กระทั่งต่อเครื่องคำนวณเอง

ในบทความนี้เราจะ:

1. อธิบายแนวคิดหลักของ HE ที่เกี่ยวข้องกับการสร้างข้อมูลสังเคราะห์  
2. วางแผนสถาปัตยกรรมแบบครบวงจรบนอีจที่รวม HE กับเครื่องสร้างข้อมูลแบบ diffusion สมัยใหม่  
3. พิจารณาข้อดีข้อเสียด้านประสิทธิภาพ, การเร่งความเร็วด้วยฮาร์ดแวร์, และกลยุทธ์การปรับใช้ที่คุ้มค่า  
4. ให้ตัวอย่างต้นแบบ Python ที่ใช้ไลบรารี **Microsoft SEAL** และโมเดล diffusion ขนาดเบา  
5. เน้นแนวปฏิบัติด้านความปลอดภัยและผลกระทบต่อการปฏิบัติตามกฎหมาย ([GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html), [CCPA](https://oag.ca.gov/privacy/ccpa))

> **ข้อสรุปสำคัญ:** ด้วยการเข้ารหัสการอ่านเซนเซอร์ดิบก่อนที่ข้อมูลจะออกจากอุปกรณ์และทำการสร้างข้อมูลสังเคราะห์ทั้งหมดในโดเมนที่เข้ารหัส, องค์กรสามารถบรรลุ **การสังเคราะห์ข้อมูลแบบศูนย์ความรู้** — อุปกรณ์ขอบเครือข่ายไม่เคยรู้ข้อมูลดิบ, และผู้รับข้อมูลด้านล่างได้รับเพียงบันทึกสังเคราะห์ที่ปลอดภัยต่อความเป็นส่วนตัว

---

## 1. ทำไมต้องใช้การเข้ารหัสโฮโมมอร์ฟิกสำหรับข้อมูลสังเคราะห์?

| ความท้าทาย | วิธีแบบดั้งเดิม | การสร้างข้อมูลสังเคราะห์ด้วย HE |
|-----------|----------------------|---------------------------------|
| **การเปิดเผยข้อมูล** | ส่งข้อมูลดิบไปยังคลาวด์หรือเซิร์ฟเวอร์ศูนย์ | ข้อมูลคงอยู่ในรูปแบบเข้ารหัสจากต้นจนจบ |
| **การปฏิบัติตามกฎระเบียบ** | ต้องมีการยินยอมจากเจ้าของข้อมูล, การตรวจสอบ | การเข้ารหัสตอบสนองการปกป้อง “ข้อมูลขณะใช้งาน” |
| **ความหน่วง** | การเดินทางไป‑กลับกับคลาวด์เพิ่มวินาที‑นาที | การคำนวณบนอุปกรณ์กำจัดความล่าช้าของเครือข่าย |
| **ความเชื่อใจ** | ต้องเชื่อใจสภาพแวดล้อมการประมวลผลของบุคคลที่สาม | พิสูจน์ศูนย์ความรู้: ตัวประมวลผลไม่สามารถเห็นข้อความต้นฉบับ |

HE รองรับ **การบวก** และ **การคูณ** บนข้อความเข้ารหัส, ทำให้สามารถทำพีชคณิตเชิงเส้น, การดำเนินการเมทริกซ์, และแม้กระทั่งการประมาณค่าที่ไม่เป็นเชิงเส้นที่จำเป็นสำหรับโมเดลสร้างสรรค์สมัยใหม่ได้ แม้ว่า **การเข้ารหัสโฮโมมอร์ฟิกเต็มรูปแบบ (FHE)** จะประเมินวงจรใด ๆ ได้, **การเข้ารหัสโฮโมมอร์ฟิกบางส่วน (SHE)** มักเพียงพอสำหรับเครื่องสร้างแบบ diffusion เมื่อใช้การประมาณค่าที่ชาญฉลาด

---

## 2. แผนผังสถาปัตยกรรม

ด้านล่างเป็นไดอะแกรม Mermaid ระดับสูงที่แสดงการไหลของข้อมูล

```mermaid
flowchart LR
    A["เซนเซอร์ขอบเครือข่าย"] --> B["ตัวเข้ารหัส HE"]
    B --> C["ข้อมูลเข้ารหัส"]
    C --> D["เครื่องยนต์ Diffusion ที่รองรับ 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** – แปลงเวกเตอร์เซนเซอร์ดิบเป็นข้อความเข้ารหัสโดยใช้คีย์สาธารณะที่เก็บบนอุปกรณ์  
2. **ข้อมูลเข้ารหัส** – ข้อความเข้ารหัสที่ถูกจัดรูปแบบเพื่อส่งต่อ (หรือเก็บไว้ในเครื่อง) เพื่อการประมวลผล  
3. **เครื่องยนต์ Diffusion ที่รองรับ HE** – โมเดล diffusion ขนาดเบาที่ฟังก์ชันคณิตศาสตร์ถูกเขียนใหม่ให้ทำงานบนข้อความเข้ารหัส (บวก, คูณสเกลาร์, และการประมาณค่าพหุนามสำหรับฟังก์ชันไม่เชิงเส้น)  
4. **ตัวอย่างสังเคราะห์ที่เข้ารหัส** – ผลลัพธ์ยังคงอยู่ในรูปแบบเข้ารหัส; สามารถใช้ **ตัวถอดรหัส HE** บน enclave ที่เชื่อถือได้เพื่อให้ได้ข้อมูลสังเคราะห์เป็นข้อความธรรมดา  
5. **ผู้บริโภคข้อมูลสังเคราะห์** – บริการ AI ด้านล่าง (เช่น การฝึกโมเดล, การวิเคราะห์) ที่รับเฉพาะบันทึกสังเคราะห์ที่รักษาความเป็นส่วนตัว

---

## 3. พื้นฐานทางคริปโตกราฟี

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

สกีม HE สมัยใหม่ส่วนใหญ่ (BFV, CKKS, BGV) สร้างบนปัญหา RLWE สำหรับการสร้างข้อมูลสังเคราะห์เรามักเลือก **CKKS** เนื่องจากรองรับการคำนวณเชิงประมาณบนจำนวนจริง — เหมาะกับโมเดล diffusion ที่ทำงานกับเทนเซอร์แบบ floating‑point

พารามิเตอร์สำคัญ:

| พารามิเตอร์ | ค่าโดยประมาณ | ผลกระทบ |
|------------|--------------|----------|
| ดีกรีพหุนาม (N) | 2^14 (16384) | กำหนดขนาดข้อความและระดับความปลอดภัย |
| ตัวคูณสเกล (Δ) | 2^40 | ควบคุมความแม่นยำของการประมาณค่า floating‑point |
| โมดูลัสข้อความ (q) | 2^180 | มีผลต่องบประมาณเสียงและความลึกของการคำนวณ |

### 3.2 การจัดการเสียง

แต่ละการดำเนินการโฮโมมอร์ฟิกจะเพิ่มเสียงให้กับข้อความ ciphertext ขั้นตอน diffusion มีการคูณหลายครั้ง ดังนั้นเราต้อง **รีไลน์** และ **รีสเกล** หลังจากแต่ละขั้นเพื่อให้เสียงอยู่ในขอบเขตที่ยอมรับได้ การบูตสแตรัป (bootstrapping) จะใช้เฉพาะเมื่องบประมาณเสียงใกล้จะหมด ซึ่งใน pipeline diffusion ที่ตื้น (≤ 10 ขั้น) มักไม่จำเป็น

---

## 4. ปรับโมเดล Diffusion ให้ทำงานในโดเมนเข้ารหัส

### 4.1 สรุป Diffusion ปกติ

โมเดล diffusion ทำการลดสัญญาณรบกวนของตัวแปร latent \(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 กลยุทธ์การประมาณค่าแบบเข้ารหัส

1. **การดำเนินการเชิงเส้น** – รองรับโดยตรงโดย CKKS (บวก, คูณสเกลาร์)  
2. **ฟังก์ชันไม่เชิงเส้น** – แทน \(\epsilon_\theta\) ด้วย **พหุนามระดับต่ำ** (เช่น การประมาณ Chebyshev) ที่จำลองเอาต์พุตของเครือข่ายประสาท  
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 ขนาดโมเดลที่เหมาะสม

- **การบีบอัดพารามิเตอร์**: ใช้ **knowledge distillation** เพื่อลดโมเดลครูเป็นนักเรียนขนาด 1‑2 MB ที่เหมาะกับงบประมาณพหุนาม  
- **การควอนไทเซชัน**: ควอนไทเซชัน 8‑บิตช่วยลดขนาด ciphertext และเร่งการคูณโฮโมมอร์ฟิก

---

## 5. ตัวอย่างต้นแบบ (Prototype)

ต่อไปเป็นต้นแบบ Python ขั้นพื้นฐานที่แสดง diffusion แบบเข้ารหัสบนชุดข้อมูล 2‑มิติจำลอง โดยใช้ **Microsoft SEAL** (ผ่าน `seal‑python`) และฟังก์ชันสกอร์พหุนามแบบง่าย

```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)   # ตัวอย่างการอ่านเซนเซอร์
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]  # ตัวค่าสัมประสิทธิ์ที่เรียนรู้
    # 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)

    # 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‑bit  
- **การเข้ารหัส & การเข้ารหัส**: แปลงเวกเตอร์เซนเซอร์ดิบเป็น ciphertext  
- **ฟังก์ชันสกอร์พหุนาม**: แทนที่เครือข่ายประสาทด้วยพหุนามระดับสามที่ประเมินได้บน ciphertext  
- **ขั้นตอน Diffusion**: ทำการลดสัญญาณรบกวนหนึ่งขั้นโดยใช้การบวกและการคูณสเกลาร์แบบโฮโมมอร์ฟิก  
- **การจัดการเสียง**: หลังการคูณทุกครั้งทำ **รีไลน์** และ **รีสเกล** เพื่อควบคุมงบประมาณเสียง  
- **การถอดรหัส**: แสดงว่าผลลัพธ์ที่เข้ารหัสสามารถถอดรหัสเป็นข้อมูลสังเคราะห์ได้; ในการผลิตจริงอาจละขั้นตอนนี้และส่ง ciphertext ตรงไปยังผู้บริโภคที่รับได้เฉพาะข้อมูลสังเคราะห์ที่เข้ารหัส

---

## 6. ประสิทธิภาพ & การเร่งความเร็วด้วยฮาร์ดแวร์

| แพลตฟอร์ม | เวลาเฉลี่ยต่อขั้น Diffusion (ms) | ขนาดหน่วยความจำ (MB) | หมายเหตุ |
|-----------|-----------------------------------|------------------------|-----------|
| ARM Cortex‑A78 (8 GB RAM) | 420 | 120 | พื้นฐาน, ไม่ใช้การเร่งความเร็ว |
| NVIDIA Jetson Orin (GPU) | 85 | 150 | คอร์นัล GPU สำหรับ NTT เร่งการคูณ |
| Intel Xeon พร้อม AVX‑512 | 60 | 130 | NTT เวกเตอร์ไลซ์และรีไลน์แบบขนาน |
| Google Edge TPU (ไลบรารี HE ทดลอง) | 38 | 110 | ทดลอง, ใช้เมทริกซ์ TPU สำหรับการประเมินพหุนาม |

**เคล็ดลับสำหรับการผลิต**

1. **บรรจุหลายตัวอย่าง** ลงใน ciphertext เดียวด้วย **packed encoding**; CKKS สามารถเข้ารหัสเวกเตอร์ได้สูงสุด `N/2` ช่อง |
2. **รีสเกลแบบขี้เกียจ**: เลื่อนการรีสเกลออกไปจนหลังการคูณหลายครั้งเพื่อลดจำนวนการสลับโมดูลัสที่มีค่าใช้จ่ายสูง |
3. **ใช้ตัวเร่ง NTT บน FPGA** สำหรับอุปกรณ์ขอบเครือข่ายที่ต้องการพลังงานต่ำ (เช่น Xilinx Zynq) |

---

## 7. รายการตรวจสอบด้านความปลอดภัย & การปฏิบัติตามกฎระเบียบ

- **การจัดการคีย์**: เก็บคีย์สาธารณะบนอุปกรณ์; คีย์ส่วนตัวควรอยู่ใน enclave หรือ HSM; หมุนคีย์ทุก 90 วัน |
- **Zero‑Knowledge Proofs**: สร้างหลักฐานสั้น ๆ ที่แสดงว่าตัวอย่างสังเคราะห์ได้มาจากกระบวนการ diffusion ที่ถูกต้องโดยไม่เปิดเผยข้อมูลพื้นฐาน |
- **บันทึกการตรวจสอบ**: บันทึกแฮชของการดำเนินการเข้ารหัส (เช่น SHA‑256 ของ ciphertext) ลงบน ledger ไม่เปลี่ยนแปลง (blockchain) เพื่อการตรวจสอบตามกฎระเบียบ |
- **[GDPR](https://gdpr.eu/)/[CCPA](https://oag.ca.gov/privacy/ccpa)**: เนื่องจากข้อมูลส่วนบุคคลดิบไม่เคยออกจากอุปกรณ์ในรูปข้อความธรรมดา, pipeline นี้ตอบสนองข้อกำหนด “การปกป้องข้อมูลขณะใช้งาน” ทำให้การประเมินผลกระทบการปกป้องข้อมูล (DPIA) ง่ายขึ้น |
- **[HIPAA](https://www.hhs.gov/hipaa/index.html)**: ข้อมูล PHI ที่เข้ารหัสภายใต้ HE ถือเป็นข้อมูลที่ **de‑identified** ตามวิธี “การประเมินโดยผู้เชี่ยวชาญ” หากคีย์การถอดรหัสถูกควบคุมอย่างเข้มงวด |

---

## 8. กรณีใช้งานจริง

1. **อุปกรณ์สวมใส่เพื่อสุขภาพอัจฉริยะ** – สร้างรูปแบบหัวใจสังเคราะห์สำหรับการฝึกโมเดลโดยไม่เปิดเผยข้อมูลชีพจรของผู้ป่วย |
2. **IoT อุตสาหกรรม** – ผลิตลายเซ็นการสั่นสะเทือนสังเคราะห์สำหรับการบำรุงรักษาเชิงพยากรณ์โดยยังคงรักษาความลับของข้อมูลเครื่องจักร |
3. **ยานยนต์อัตโนมัติ** – สร้าง point cloud LIDAR สังเคราะห์ที่ขอบเครือข่ายเพื่อปรับปรุงโมเดลอย่างต่อเนื่องโดยไม่ต้องแชร์ข้อมูลเซนเซอร์ดิบ |

---

## 9. แนวทางในอนาคต

- **Hybrid HE‑MPC**: ผสานการเข้ารหัสโฮโมมอร์ฟิกกับการคำนวณหลายฝ่าย (MPC) เพื่อให้หลายอุปกรณ์ขอบเครือข่ายร่วมกันสร้างข้อมูลสังเคราะห์ได้โดยไม่เปิดเผยข้อมูลของตนเอง |
- **Neural Architecture Search (NAS) สำหรับพหุนาม**: ใช้ NAS ค้นหาโครงข่ายพหุนามระดับต่ำที่ให้ความแม่นยำและต้นทุนโฮโมมอร์ฟิกที่ดีที่สุด |
- **การเข้ารหัสโฮโมมอร์ฟิกที่ต้านทานควอนตัม**: สำรวจสกีมบน lattice ที่ยังคงปลอดภัยต่อผู้โจมตีด้วยคอมพิวเตอร์ควอนตัม เพื่อให้การปฏิบัติตามกฎระเบียบระยะยาวสำหรับโครงสร้างพื้นฐานสำคัญ |

---

## ดูเพิ่มเติม

- [Homomorphic Encryption for Machine Learning – เอกสาร Microsoft SEAL](https://github.com/microsoft/SEAL)  
- [การสร้างข้อมูลสังเคราะห์ที่รักษาความเป็นส่วนตัว – กรอบการจัดการความเสี่ยง AI ของ NIST](https://www.nist.gov/ai)  
- [Zero‑Knowledge Proofs สำหรับการคำนวณเข้ารหัส – ชุมชน ZKProof](https://zkproof.org)