Giới thiệu dự án

Mô hình Học máy Phân tán truyền thống đối mặt với những thách thức nghiêm trọng về chi phí truyền thông tập trung và vi phạm quyền riêng tư dữ liệu người dùng theo các khung pháp lý như GDPR, CCPA hay HIPAA. Thống kê từ Gartner chỉ ra rằng hơn 75% dữ liệu doanh nghiệp được tạo ra và xử lý ngoài trung tâm dữ liệu tập trung hoặc đám mây. Để giải quyết bài toán "đói dữ liệu" (data hungriness) mà vẫn bảo toàn tính ẩn danh, mô hình Học hợp tác (Federated Learning - FL) do Google giới thiệu năm 2016 đã tạo nên bước ngoặt bằng cơ chế huấn luyện phân tán: dữ liệu gốc được lưu giữ cục bộ tại thiết bị người dùng (client) và chỉ có các tham số mô hình hoặc gradient cập nhật được truyền về máy chủ trung tâm (Central Aggregator).

Tuy nhiên, chính cơ chế bảo vệ quyền riêng tư này lại trở thành điểm mù bảo mật. Máy chủ trung tâm không thể trực tiếp thanh tra dữ liệu huấn luyện cục bộ của các node tham gia, tạo điều kiện thuận lợi cho các cuộc tấn công đầu độc (Poisoning Attacks). Đồ án/khóa luận tốt nghiệp chuyên ngành An toàn Thông tin với đề tài "Tấn công đầu độc chống lại mô hình học máy Federated Learning" (Thực hiện bởi: Trần Nhật Tân - Trường Đại học Công nghệ Thông tin, ĐHQG-HCM; Cán bộ hướng dẫn: TS. Phạm Văn Hậu, ThS. Nguyễn Thanh Hòa) tập trung nghiên cứu, mô phỏng và thực nghiệm toàn diện các phương thức tấn công đầu độc dữ liệu (Data Poisoning Attacks) và đầu độc mô hình (Model Poisoning Attacks).

+-------------------------------------------------------------------------+
|                          Federated Learning System                      |
|                                                                         |
|  [ Benign Client 1 ] ----( Local Updates: Δw1 )----+                    |
|                                                    |                    |
|  [ Benign Client 2 ] ----( Local Updates: Δw2 )----+---> [ Aggregator ] |
|                                                    |      (FedAvg / G_t)|
|  [ Malicious Client] ---( Poisoned Updates: Δw_adv )+                   |
|    (ACGAN + Scale Factor γ)                                             |
+-------------------------------------------------------------------------+

Mục tiêu dự án

  1. Khảo sát toàn diện kiến trúc bảo mật, giao thức truyền thông và bề mặt tấn công của hệ thống Federated Learning (Cross-Device và Cross-Silo).
  2. Xây dựng môi trường thử nghiệm phân tán chuẩn công nghiệp sử dụng bộ công cụ PyTorch v1.8.0, PySyft v0.2.9 và PyGrid v0.3.0 trên hệ điều hành Ubuntu Server 18.04 LTS.
  3. Thực nghiệm phương pháp tấn công lật nhãn dữ liệu (Label-Flipping Attacks) với các tỉ lệ kẻ tấn công tham gia ($m%$) nhằm đo lường sự suy giảm độ chính xác của nhãn mục tiêu.
  4. Đề xuất mô hình cải tiến tấn công đầu độc sử dụng Mạng đối nghịch tạo sinh có bộ phân loại phụ (Auxiliary Classifier Generative Adversarial Network - ACGAN) kết hợp hệ số khuếch đại gradient (Scale Factor - $\gamma$) trong kịch bản tấn công đơn vòng (Single-Round Attack).
  5. Phân tích định lượng hiệu quả tấn công dựa trên các chỉ số: Global Model Accuracy ($G^{acc}$), Source Class Recall ($C_{src}^{recall}$), Poison Task Accuracy và Main Task Accuracy, làm cơ sở đề xuất giải pháp phòng thủ Byzantine-robust Aggregation.

Phạm vi và giới hạn nghiên cứu

  • Phạm vi: Tập trung vào kỹ thuật tấn công đầu độc có chủ đích (Targeted Poisoning) trên bài toán phân loại hình ảnh đa lớp sử dụng bộ dữ liệu chuẩn MNIST (chữ số viết tay) và Fashion-MNIST (phân loại trang phục).
  • Giới hạn: Kẻ tấn công đóng vai trò là các client hợp lệ trong quá trình FL (White-Box attack ở cấp độ client, Black-Box đối với Aggregator); không can thiệp trực tiếp vào mã nguồn của bộ tổng hợp Federated Averaging (FedAvg) trên Central Server.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Các nghiên cứu bảo mật FL trước đây chủ yếu tập trung vào tấn công suy luận (Inference Attacks) nhằm tái tạo dữ liệu riêng tư hoặc tấn công đầu độc dữ liệu cơ bản trong môi trường mô phỏng cục bộ (non-networked simulation), chưa phản ánh đúng độ trễ và cơ chế đồng bộ tham số thực tế.

Tiêu chí Centralized Machine Learning Distributed Learning (Parameter Server) Standard Federated Learning (FedAvg) Proposed ACGAN-Poisoning FL Testbed
Tính riêng tư dữ liệu Kém (Dữ liệu gom tập trung) Kém (Chia shard dữ liệu thô) Cao (Chỉ gửi model weight) Tận dụng lỗ hổng Aggregator mù dữ liệu
Bề mặt tấn công Trực tiếp trên Data Lake Trực tiếp trên Data Shards Poisoning qua Local Updates White-box Client + Generative Adversarial Synthesis
Độ phụ thuộc dữ liệu sẵn có Cần dataset đầy đủ Cần dataset đầy đủ Phụ thuộc dữ liệu của node Tự sinh dữ liệu qua ACGAN mà không cần data nạn nhân
Khả năng duy trì độc tính Tồn tại vĩnh viễn trong model Tồn tại vĩnh viễn Bị triệt tiêu bởi FedAvg Duy trì bền vững nhờ Scale Factor $\gamma$

Yêu cầu hệ thống theo mô hình MoSCoW

  • Must Have:
    • Triển khai thành công cụm Federated Learning phân tán đa máy ảo (Server - Client) qua WebSocket.
    • Cài đặt thuật toán lật nhãn LabelFlipping và cơ chế huấn luyện đối nghịch TrainGAN_FL.
    • Tích hợp công thức khuếch đại tham số độc hại $\Delta w_{adv} = \gamma \cdot (L_{t+1}^P - L_t^P)$.
  • Should Have:
    • Tự động hóa quá trình sinh mẫu đối kháng dựa trên Global Model $G_t$ tại mỗi epoch.
    • Trực quan hóa độ suy giảm Recall của lớp nguồn ($C_{src}$) so với các lớp độc lập ($C_{other}$).
  • Could Have:
    • Khả năng mở rộng đánh giá trên các cơ chế tổng hợp chịu lỗi Byzantine như Krum, Trimmed Mean, Median.
  • Won't Have (Giai đoạn này):
    • Thực thi tấn công backdoor chèn trigger vật lý phức tạp lên dữ liệu video thời gian thực.

Thiết kế kiến trúc hệ thống

graph TD
    subgraph Central Server Layer
        PS[PyGrid Server - Aggregator]
        GM[Global Model Weights G_t]
        FA[FedAvg Algorithm]
        PS <--> GM
        PS <--> FA
    end

    subgraph Benign Client Nodes
        BC1[Worker 1: PySyft + PyTorch]
        BC2[Worker 2: PySyft + PyTorch]
        D1[(Clean Data Shard 1)]
        D2[(Clean Data Shard 2)]
        BC1 --- D1
        BC2 --- D2
    end

    subgraph Adversarial Node Architecture
        ADV[Attacker Node: PyTorch]
        ACGAN[ACGAN Engine: Generator G + Discriminator D]
        LF[Label-Flipping Module]
        SF[Gradient Scaler: Factor gamma]
        ADV --> ACGAN
        ADV --> LF
        ADV --> SF
    end

    PS -- "Broadcast G_t" --> BC1
    PS -- "Broadcast G_t" --> BC2
    PS -- "Broadcast G_t" --> ADV

    BC1 -- "Clean Updates: Delta w1" --> PS
    BC2 -- "Clean Updates: Delta w2" --> PS
    ADV -- "Scaled Poisoned Updates: Delta w_adv" --> PS

Technology Stack chi tiết

  • Ngôn ngữ lập trình: Python v3.8.10
  • Framework Học sâu: PyTorch v1.8.0, Torchvision v0.9.0
  • Framework Federated Learning: PySyft v0.2.9 (OpenMined)
  • Nền tảng Quản trị & Điều phối: PyGrid v0.3.0 (Network, Domain, Worker)
  • Môi trường tính toán: CUDA v11.1, cuDNN v8.0.5, Ubuntu Server 18.04 LTS
  • Thư viện xử lý dữ liệu: NumPy v1.19.5, Pandas v1.2.4, Scikit-learn v0.24.2, Matplotlib v3.3.4

Implementation và kết quả

Chi tiết thuật toán và mã nguồn thực thi

Hệ thống triển khai 5 thuật toán lõi nhằm hiện thực hóa tấn công đầu độc từ cơ bản đến nâng cao:

1. Thuật toán lật nhãn dữ liệu (LabelFlipping)

Thuật toán xử lý tập huấn luyện cục bộ $D_{train}$ của kẻ tấn công bằng cách chuyển đổi nhãn nguồn $C_{src}$ thành nhãn đích $C_{target}$ trong khi giữ nguyên các thuộc tính không gian ảnh.

import torch
from torch.utils.data import Dataset

class PoisonedDataset(Dataset):
    """
    Kỹ thuật Label-Flipping: Thay thế toàn bộ nhãn thuộc Source Class (C_src) 
    sang Target Class (C_target) mà không làm biến dạng vector đặc trưng.
    """
    def __init__(self, original_dataset, source_class: int, target_class: int):
        self.data = []
        self.targets = []
        
        for img, label in original_dataset:
            if label == source_class:
                self.targets.append(target_class)
            else:
                self.targets.append(label)
            self.data.append(img)
            
        self.data = torch.stack(self.data)
        self.targets = torch.tensor(self.targets, dtype=torch.long)

    def __len__(self):
        return len(self.targets)

    def __getitem__(self, idx):
        return self.data[idx], self.targets[idx]

2. Thuật toán huấn luyện GAN trong Federated Learning (TrainGAN_FL) và Sinh dữ liệu (Data_Gen)

Trong trường hợp kẻ tấn công không sở hữu sẵn tập dữ liệu mục tiêu, mô hình ACGAN được triển khai để tận dụng Global Model $G_t$ làm bộ phân loại phụ (Auxiliary Classifier), phối hợp cùng Discriminator cục bộ $D$ để tối ưu Generator $G$:

$$\mathcal{L}{ACGAN} = \mathcal{L}{Source} (D) + \mathcal{L}_{Class} (G_t)$$

import torch
import torch.nn as nn

def train_acgan_in_fl_step(generator, discriminator, global_model, 
                           real_images, real_labels, latent_dim, 
                           optimizer_G, optimizer_D, device):
    batch_size = real_images.size(0)
    adversarial_loss = nn.BCELoss()
    auxiliary_loss = nn.CrossEntropyLoss()
    
    # Nhãn thực và giả định danh
    valid = torch.ones(batch_size, 1, device=device)
    fake = torch.zeros(batch_size, 1, device=device)
    
    # -----------------
    #  Huấn luyện Generator
    # -----------------
    optimizer_G.zero_grad()
    z = torch.randn(batch_size, latent_dim, device=device)
    gen_labels = torch.randint(0, 10, (batch_size,), device=device)
    gen_images = generator(z, gen_labels)
    
    # Đánh giá độ chân thực qua Discriminator và phân loại qua Global Model G_t
    validity = discriminator(gen_images)
    pred_label = global_model(gen_images)
    
    g_loss = 0.5 * (adversarial_loss(validity, valid) + auxiliary_loss(pred_label, gen_labels))
    g_loss.backward()
    optimizer_G.step()
    
    # ---------------------
    #  Huấn luyện Discriminator
    # ---------------------
    optimizer_D.zero_grad()
    real_validity = discriminator(real_images)
    fake_validity = discriminator(gen_images.detach())
    
    d_real_loss = adversarial_loss(real_validity, valid)
    d_fake_loss = adversarial_loss(fake_validity, fake)
    d_loss = 0.5 * (d_real_loss + d_fake_loss)
    d_loss.backward()
    optimizer_D.step()
    
    return g_loss.item(), d_loss.item()

3. Thuật toán khuếch đại Gradient (PoisonGAN với Scale Factor)

Tại vòng $t$, cập nhật độc hại của attacker $\Delta L_t^P$ được tính toán trên mô hình cục bộ đã tối ưu với dữ liệu giả mạo $D_{poisoned}$. Để triệt tiêu sự pha loãng của thuật toán FedAvg tại máy chủ:

$$w_{t+1} = w_t + \sum_{k=1}^K \frac{n_k}{n} \Delta w_k$$

Kẻ tấn công áp dụng hệ số tỉ lệ $\gamma \ge 1$:

$$\Delta w_{adv} = \gamma \cdot \Delta L_{t+1}^P = \gamma \cdot (L_{t+1}^P - L_t)$$

def compute_scaled_poisoned_update(local_model, global_model, scale_factor: float):
    """
    Tính toán vector gradient đầu độc và áp dụng Scale Factor gamma
    để chiếm quyền chi phối trong quá trình FedAvg Aggregation.
    """
    poisoned_update = {}
    with torch.no_grad():
        for (name, local_param), (_, global_param) in zip(
            local_model.named_parameters(), global_model.named_parameters()
        ):
            delta = local_param.data - global_param.data
            poisoned_update[name] = scale_factor * delta
    return poisoned_update

Kịch bản thực nghiệm và kết quả định lượng

Hệ thống được kiểm thử trên hai tập dữ liệu chuẩn:

  1. MNIST: 70.000 mẫu ảnh chữ số (60.000 train, 10.000 test), kích thước $28 \times 28 \times 1$.
  2. Fashion-MNIST: 60.000 mẫu ảnh thời trang (50.000 train, 10.000 test), 10 phân lớp độ phức tạp cao.
Cấu hình phần cứng:
- Server Node: Ubuntu Server 18.04 LTS, 8 vCPUs, 8GB RAM (PyGrid Aggregator)
- Worker Client Nodes: Ubuntu Server 18.04 LTS, 24 vCPUs, 32GB RAM (PySyft Node)
- Standalone GAN Station: 16 vCPUs, 32GB RAM, NVIDIA CUDA Accelerated

Kết quả tấn công lật nhãn với dữ liệu có sẵn (Phương pháp A)

Đánh giá tác động của tỉ lệ kẻ tấn công tham gia ($m% \in [10%, 50%]$) trên vòng hội tụ $T=200$ (Fashion-MNIST) và $T=100$ (MNIST). Cặp nhãn thực nghiệm: Fashion-MNIST ($C_{src}=4 \text{ [Coat]} \to C_{target}=6 \text{ [Shirt]}$) và MNIST ($C_{src}=6 \to C_{target}=0$).

Bộ dữ liệu Tỉ lệ Attacker ($m%$) Global Model Accuracy ($G^{acc}$) Source Class Recall ($C_{src}^{recall}$) Baseline Misclassification ($m_cnt$) Đánh giá độc tính
MNIST 0% (Baseline) 98.42% 97.80% 12 mẫu Mô hình chuẩn
MNIST 10% Attacker 97.65% 88.20% 118 mẫu Bắt đầu suy giảm
MNIST 30% Attacker 95.10% 34.50% 652 mẫu Suy giảm nghiêm trọng
MNIST 50% Attacker 92.30% 2.10% 978 mẫu Vô hiệu hóa hoàn toàn lớp 6
F-MNIST 0% (Baseline) 89.60% 88.40% 116 mẫu Mô hình chuẩn
F-MNIST 10% Attacker 88.90% 76.50% 235 mẫu Nhận diện sai tăng
F-MNIST 30% Attacker 86.20% 28.30% 716 mẫu Lẫn lộn Coat -> Shirt
F-MNIST 50% Attacker 83.10% 4.60% 954 mẫu Lớp 4 bị phá hủy hoàn toàn

Nhận xét chuyên sâu: Ngay cả khi $m = 50%$, độ chính xác toàn cục ($G^{acc}$) chỉ giảm nhẹ $6.12%$ trên MNIST và $6.50%$ trên Fashion-MNIST. Điều này cho thấy tính chất nguy hiểm cực cao của tấn công lật nhãn có chủ đích: hệ thống giám sát hiệu năng tổng thể khó phát hiện bất thường, trong khi chức năng phân loại của lớp mục tiêu đã bị tê liệt hoàn toàn ($C_{src}^{recall}$ rơi xuống mức xấp xỉ 2% - 4%).

Kết quả tấn công ACGAN kết hợp Scale Factor (Phương pháp B - Single-Round Attack)

Kẻ tấn công không có dữ liệu ban đầu, tự tổng hợp dữ liệu đối kháng qua Data_Gen và tiêm nhiễm mô hình chỉ trong 1 vòng duy nhất với các giá trị $\gamma \in [1.0, 10.0]$:

Chỉ số Scale Factor ($\gamma$) Poison Task Accuracy (Tỉ lệ tấn công thành công) Main Task Accuracy (Độ chính xác các nhãn khác) Mức độ duy trì sau 10 vòng tổng hợp
$\gamma = 1.0$ (Không scale) 18.2% 89.2% Bị triệt tiêu hoàn toàn sau 2 vòng
$\gamma = 3.0$ 54.6% 88.7% Duy trì trong 4 vòng
$\gamma = 5.0$ 82.4% 87.9% Duy trì trong 7 vòng
$\gamma = 8.0$ (Tối ưu) 94.8% 87.4% Duy trì ổn định qua 15 vòng
$\gamma = 10.0$ (Quá mức) 98.2% 74.1% Dễ bị bộ lọc bất thường (Anomaly Detection) chặn

Đổi mới và đóng góp

  1. Mô hình hóa tấn công đầu độc thực tế trên nền tảng mạng phân tán: Khác biệt hoàn toàn với các nghiên cứu trước đây (như Tolpegin et al., 2020) chỉ dừng lại ở các vòng lặp tính toán giả lập trên một tiến trình đơn, công trình này thiết lập hạ tầng thực thụ với PySyft và PyGrid qua giao thức WebSocket, kiểm chứng chính xác ảnh hưởng của độ trễ mạng và quá trình truyền serialization tensor.
  2. Kỹ thuật sinh dữ liệu đối kháng tự trị qua ACGAN: Đề xuất giải pháp khắc phục triệt để hạn chế thiếu dữ liệu của kẻ tấn công trong môi trường FL. Bằng cách trích xuất tri thức từ chính Global Model $G_t$ qua từng vòng để cập nhật Discriminator, kẻ tấn công có thể tạo ra hàng ngàn mẫu dữ liệu độc hại chuẩn phân phối mà không cần truy cập trái phép vào thiết bị của người dùng khác.
  3. Cơ chế tấn công đơn vòng hiệu quả cao (Single-Shot Poisoning): Kết hợp ACGAN với cơ chế Scale Factor $\gamma = 8.0$, cho phép đạt tỉ lệ tấn công thành công (Poison Task Accuracy) lên tới 94.8% chỉ trong một vòng gửi cập nhật duy nhất, giảm thiểu tối đa xác suất bị phát hiện bởi các thuật toán theo dõi lịch sử tham số.
Giải pháp so sánh Phương thức sinh dữ liệu Giao thức triển khai Tỉ lệ thành công Tính tàng hình (Stealthiness)
Tolpegin et al. (2020) Data có sẵn (Static) Local Simulation 88.0% (Sau nhiều vòng) Trung bình (Giảm $G^{acc}$ liên tục)
Zhang et al. (2020) GAN Standard GAN Toy Framework 79.5% (Cần data khởi tạo) Thấp (Mất cân bằng nhãn rõ rệt)
Đề xuất của Đồ án (PoisonGAN) ACGAN + Global $G_t$ PySyft + PyGrid Distributed 94.8% (Single-Round) Rất cao (Main Task giữ vững >87%)

Ứng dụng thực tế và triển khai

Kịch bản đe dọa trong đời sống thực tế

  • Bàn phím thông minh (Next-Word Prediction): Đầu độc mô hình gợi ý từ tự động (như Google Gboard) bằng cách chuyển hướng các từ khóa nhạy cảm sang các liên kết lừa đảo (phishing) hoặc nội dung độc hại mà không làm suy giảm tốc độ gõ phím chung của người dùng.
  • Hệ thống Y tế Liên kết (IoMT - Smart Healthcare): Trong kịch bản các bệnh viện cùng huấn luyện mô hình chẩn đoán u bướu từ ảnh X-quang, một node bị xâm nhập có thể sử dụng PoisonGAN để làm cho mô hình luôn chẩn đoán "Khối u ác tính loại A" thành "Lành tính", dẫn đến hậu quả nghiêm trọng trong điều trị lâm sàng.
  • Xe tự hành (Autonomous Vehicles): Đầu độc hệ thống nhận diện biển báo giao thông phân tán, khiến xe nhận định biển báo "Dừng lại" (Stop Sign) thành "Tốc độ tối đa 80km/h" khi xuất hiện một mẫu nhiễu đối kháng cụ thể.
+--------------------------------------------------------------------------+
|                     Quy trình Phòng thủ Khuyến nghị                      |
|                                                                          |
| 1. Client Weight Verification  --> 2. Robust Aggregation (Krum/Bulyan)   |
| 2. Norm Bounding (Clipping)    --> 4. Differential Privacy (DP-SGD Noise)|
+--------------------------------------------------------------------------+

Yêu cầu triển khai và giải pháp khắc phục

  • Phần cứng triển khai:
    • Aggregator Server: Tối thiểu 8 Core CPU, 16GB RAM, kết nối mạng băng thông rộng và địa chỉ IP tĩnh.
    • Client Node: Hỗ trợ môi trường Python 3.8+, bộ nhớ khả dụng tối thiểu 2GB RAM cho các mô hình phân loại chuẩn.
  • Chiến lược giảm thiểu rủi ro cho doanh nghiệp:
    • Thay thế thuật toán FedAvg bằng các bộ tổng hợp kháng lỗi Byzantine: Multi-Krum, Trimmed Mean, hoặc Coordinate-wise Median.
    • Áp dụng kỹ thuật Gradient Clipping (giới hạn chuẩn $L_2$ của vector cập nhật) nhằm vô hiệu hóa trực tiếp hệ số Scale Factor $\gamma$.
    • Bổ sung nhiễu Gauss thông qua Differential Privacy (DP-SGD) để phá vỡ cấu trúc gradient được tính toán tỉ mỉ từ mô hình ACGAN.

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Độ nhạy phân phối non-IID: Khi dữ liệu giữa các client có sự phân hóa quá sâu sắc (Heterogeneous non-IID data), khả năng hội tụ của bộ sinh ACGAN bị chậm lại đáng kể, đòi hỏi nhiều vòng huấn luyện hơn để đạt chất lượng ảnh giả mạo tối ưu.
  • Cơ chế Scale Factor tĩnh: Giá trị $\gamma$ hiện được thiết lập cố định qua cấu hình thực nghiệm; nếu đặt giá trị quá lớn ($\gamma > 10$), khoảng cách Euclidean giữa vector cập nhật của attacker và các benign client sẽ tăng vọt, dễ bị phát hiện bởi các bộ lọc bất thường cơ bản.

Hướng phát triển tiếp theo

  • Adaptive Dynamic Scaling: Phát triển thuật toán tự động ước lượng giá trị $\gamma$ tối ưu dựa trên biến thiên tham số của Global Model $G_t$ theo thời gian thực nhằm tối đa hóa độc tính mà không vượt qua ngưỡng phát hiện bất thường ($L_2\text{-norm threshold}$).
  • Nghiên cứu tấn công Backdoor Trigger tàng hình: Tích hợp trigger dạng watermark tần số cao vào mẫu sinh từ ACGAN để thực hiện tấn công cửa hậu không thể phân biệt bằng mắt thường.
  • Đánh giá trên các kiến trúc hiện đại: Mở rộng kiểm thử sang các mô hình Transformer phân tán (Federated Vision Transformers - ViT) và các tập dữ liệu phức tạp như CIFAR-100, ImageNet.

Đối tượng hưởng lợi

+-------------------------------------------------------------------------+
|                          Đối tượng hưởng lợi                            |
|                                                                         |
|  [ Sinh viên & Nghiên cứu sinh ] --> Giáo trình thực hành bảo mật FL    |
|  [ Kỹ sư Machine Learning ]     --> Framework kiểm thử độ bền mô hình   |
|  [ Doanh nghiệp triển khai AI ]  --> Bộ tiêu chuẩn phòng vệ Byzantine    |
+-------------------------------------------------------------------------+
  • Sinh viên & Nghiên cứu sinh ngành An toàn Thông tin / Khoa học Dữ liệu:
    • Tiếp cận tài liệu nghiên cứu chuyên sâu bằng tiếng Việt có đầy đủ mã nguồn, mô hình toán học và phương pháp luận thực nghiệm chuẩn mực.
    • Nắm vững kỹ thuật lập trình Federated Learning thực tế với PySyft và PyTorch thay vì chỉ dừng lại ở lý thuyết hàn lâm.
  • Kỹ sư Trí tuệ Nhân tạo & MLOps:
    • Nhận diện các lỗ hổng tiềm tàng trong đường ống huấn luyện phân tán (Decentralized MLOps Pipeline).
    • Tích hợp các bài kiểm thử độ bền (Stress Testing / Red Teaming) cho mô hình trước khi đóng gói triển khai thực tế.
  • Doanh nghiệp & Tổ chức Tài chính - Y tế:
    • Xây dựng lộ trình tuân thủ an toàn dữ liệu, hiểu rõ các mối đe dọa để đầu tư đúng mức vào các giải pháp phòng thủ tổng hợp tham số an toàn (Secure Multi-Party Computation & Robust Aggregation).

Câu hỏi thường gặp

1. Yêu cầu kỹ thuật tối thiểu để tái lập môi trường thực nghiệm của đồ án là gì?

Hệ thống yêu cầu máy chủ hoặc máy trạm chạy hệ điều hành Linux (khuyến nghị Ubuntu 18.04/20.04 LTS), cài đặt Python 3.8, PyTorch v1.8.0, PySyft v0.2.9, và tối thiểu 16GB RAM cùng 8 vCPUs. Nếu huấn luyện ACGAN trên tập dữ liệu kích thước lớn, khuyến nghị trang bị GPU hỗ trợ CUDA với tối thiểu 6GB VRAM.

2. Tại sao tấn công lật nhãn (Label-Flipping) lại nguy hiểm hơn việc đưa dữ liệu rác ngẫu nhiên?

Đưa dữ liệu rác ngẫu nhiên (Random Noise) sẽ làm suy giảm nghiêm trọng độ chính xác toàn cục ($G^{acc}$) của tất cả các nhãn, khiến quản trị viên máy chủ dễ dàng phát hiện sự cố qua hệ thống cảnh báo giám sát. Ngược lại, tấn công lật nhãn có chủ đích giữ vững độ chính xác của 90% các nhãn còn lại (Main Task), chỉ âm thầm vô hiệu hóa duy nhất nhãn mục tiêu (Target Task), đạt tính tàng hình gần như tuyệt đối.

3. Làm thế nào kẻ tấn công có thể vượt qua thuật toán FedAvg chỉ với một node duy nhất?

Bằng cách áp dụng hệ số khuếch đại Scale Factor $\gamma = \frac{N}{\eta}$ (với $N$ là tổng số client và $\eta$ là learning rate), vector gradient của kẻ tấn công được nhân lên gấp nhiều lần. Khi máy chủ trung tâm thực hiện tính trung bình cộng trọng số $\sum \frac{w_i}{N}$, giá trị bị khuếch đại này sẽ chiếm ưu thế áp đảo và ghi đè tham số của Global Model ngay lập tức.

4. Cơ chế phòng thủ nào hiệu quả nhất để chống lại phương pháp PoisonGAN?

Giải pháp đa tầng hiệu quả nhất gồm: (1) Gradient Norm Clipping để chặn các vector có chuẩn $L_2$ bất thường (vô hiệu hóa Scale Factor); (2) Sử dụng bộ tổng hợp Multi-Krum hoặc Bulyan để loại bỏ các cập nhật nằm quá xa cụm trung tâm của các client tin cậy; (3) Áp dụng Differential Privacy (DP) để làm mờ các chi tiết gradient đối kháng do ACGAN tạo ra.

5. Chi phí triển khai giải pháp phòng vệ Byzantine trong doanh nghiệp có cao không?

Chi phí tính toán tăng thêm chủ yếu nằm ở khâu tổng hợp tham số tại Central Server (các thuật toán như Krum có độ phức tạp tính toán $O(n^2 \cdot d)$ so với $O(n \cdot d)$ của FedAvg, trong đó $n$ là số client, $d$ là số chiều tham số). Tuy nhiên, mức tăng chi phí phần cứng này chỉ chiếm dưới 15% tổng chi phí vận hành hạ tầng FL và mang lại giá trị bảo vệ dữ liệu, ngăn ngừa tổn thất hàng triệu USD do sai lệch mô hình nghiệp vụ.

Kết luận

Khóa luận tốt nghiệp của tác giả Trần Nhật Tân đã nghiên cứu và thực nghiệm toàn diện các phương thức tấn công đầu độc đối với hệ thống Học hợp tác (Federated Learning). Thông qua việc xây dựng môi trường mạng phân tán thực tế trên nền tảng PyTorch, PySyft và PyGrid, nghiên cứu đã chứng minh tính khả thi và mức độ nguy hại đặc biệt nghiêm trọng của kỹ thuật tấn công lật nhãn dữ liệu (Label-Flipping Attacks).

Đặc biệt, đóng góp nổi bật của đề tài là việc đề xuất thành công mô hình PoisonGAN — kết hợp mạng tạo sinh ACGAN để tự động tổng hợp dữ liệu đối kháng từ Global Model và cơ chế khuếch đại Scale Factor $\gamma$. Phương pháp này cho phép kẻ tấn công đạt tỉ lệ phá hoại nhãn mục tiêu lên đến 94.8% chỉ trong một vòng tấn công duy nhất mà không làm suy giảm hiệu năng tổng thể của hệ thống.

Kết quả nghiên cứu gióng lên hồi chuông cảnh báo quan trọng cho các nhà phát triển và kiến trúc sư hệ thống AI: Không thể tuyệt đối tin cậy cơ chế bảo vệ quyền riêng tư mặc định của Federated Learning. Để xây dựng hệ thống AI phân tán bền vững, các tổ chức bắt buộc phải tích hợp đồng thời các cơ chế phòng thủ chịu lỗi Byzantine, kỹ thuật giới hạn chuẩn gradient và quyền riêng tư vi sai ngay từ giai đoạn thiết kế kiến trúc ban đầu.