Giới thiệu dự án

Sự bùng nổ của mạng lưới vạn vật kết nối Internet (IoT - Internet of Things) đã định hình lại hạ tầng công nghệ từ đô thị thông minh, giao thông, y tế đến nhà máy sản xuất tự động. Tuy nhiên, theo các báo cáo an ninh mạng toàn cầu, thiết bị IoT là mục tiêu hàng đầu của các cuộc tấn công từ chối dịch vụ phân tán (DDoS), quét cổng (port scanning) và khai thác lỗ hổng cơ sở hạ tầng. Để bảo vệ các hệ thống phân tán này, Hệ thống phát hiện xâm nhập (Intrusion Detection System - IDS) ứng dụng học máy (ML-based IDS) đóng vai trò then chốt trong việc phân tích lưu lượng và nhận diện bất thường mạng.

Dù vậy, phương pháp học máy tập trung truyền thống đòi hỏi phải gom toàn bộ dữ liệu về một máy chủ trung tâm (Central Server), gây ra rủi ro nghiêm trọng về rò rỉ quyền riêng tư và vi phạm các quy định bảo vệ dữ liệu (như GDPR). Mô hình Học liên kết (Federated Learning - FL) ra đời nhằm giải quyết bài toán này bằng cách chỉ truyền tải trọng số mô hình (weights) thay vì dữ liệu thô. Tuy nhiên, FL truyền thống tồn tại hai điểm nghẽn nghiêm trọng:

  1. Điểm chết duy nhất (Single Point-of-Failure - SPoF): Máy chủ trung tâm dễ bị tấn công làm tê liệt toàn bộ mạng lưới huấn luyện.
  2. Tấn công trục lợi (Free-rider Attack): Các cá thể tham gia (clients) cố tình không sử dụng tài nguyên tính toán hoặc không có dữ liệu thực tế nhưng vẫn gửi các bản cập nhật trọng số giả mạo (Random weights, Delta weights, Gaussian noise) nhằm nhận về mô hình toàn cầu tối ưu mà không cống hiến giá trị, gây mất công bằng và giảm uy tín hệ thống.
+-----------------------------------------------------------------------------------+
|                              KIẾN TRÚC TỔNG QUAN DFL-DAGMM                        |
|                                                                                   |
|  +---------------------+      +---------------------+      +-------------------+  |
|  |     Client Node 1   |      |     Client Node 2   |      |   Client Node N   |  |
|  | [MQTTset / NetFlow] |      | [MQTTset / NetFlow] |      |  (Free-rider??)   |  |
|  |   Local Train MLP   |      |   Local Train MLP   |      |  Fake Weights Gen |  |
|  +----------+----------+      +----------+----------+      +---------+---------+  |
|             |                            |                           |            |
|             \----------------------------+---------------------------/            |
|                                          |                                        |
|                                          v                                        |
|                          +-------------------------------+                        |
|                          |    Hệ thống P2P / IPFS Node   |                        |
|                          |    (Lưu trữ Weights -> CID)   |                        |
|                          +---------------+---------------+                        |
|                                          |                                        |
|                                          v                                        |
|                          +-------------------------------+                        |
|                          |  Hyperledger Fabric (v2.5)    |                        |
|                          |  * Smart Contract / Chaincode |                        |
|                          |  * DAGMM Engine (LDR + Error) |                        |
|                          |  * Energy Score & Filter      |                        |
|                          |  * FedAvg+ with Momentum      |                        |
|                          +---------------+---------------+                        |
|                                          |                                        |
|                                          v                                        |
|                          +-------------------------------+                        |
|                          |      Global Valid Model       |                        |
|                          |   (Phân phối tới Client sạch) |                        |
|                          +-------------------------------+                        |
+-----------------------------------------------------------------------------------+

Mục tiêu của dự án

  1. Xây dựng kiến trúc Học liên kết phi tập trung (Decentralized Federated Learning - DFL): Loại bỏ hoàn toàn máy chủ trung tâm bằng cách kết hợp Blockchain Hyperledger Fabric và InterPlanetary File System (IPFS), phân tán quá trình tổng hợp và đảm bảo tính sẵn sàng cao.
  2. Phát triển mô-đun phát hiện Free-rider bằng DAGMM: Ứng dụng mô hình kết hợp Bộ tự mã hóa sâu (Deep Autoencoder - DAG) và Mô hình Gaussian hỗn hợp (Gaussian Mixture Model - GMM) để trích xuất biểu diễn thấp chiều (Low Dimension Representation - LDR) cùng lỗi tái tạo (Reconstruction Error), phân cụm dựa trên điểm năng lượng (Energy Score) để loại bỏ các cá thể gian lận.
  3. Cải tiến thuật toán tổng hợp: Hiện thực hóa thuật toán FedAvg+ with momentum nhằm tăng tốc độ hội tụ và độ ổn định của mô hình toàn cầu trong môi trường phân tán Non-IID.
  4. Đánh giá và kiểm thử thực nghiệm: Đo lường hiệu năng phát hiện xâm nhập trên hai bộ dữ liệu chuẩn an ninh mạng IoT: MQTTset và NF-ToN-IoT-v2.

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

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

Phương pháp Ưu điểm Nhược điểm / Rủi ro Tính khả thi trong IoT phân tán
Centralized Machine Learning Dễ huấn luyện, độ chính xác phân loại tập trung cao. Vi phạm quyền riêng tư dữ liệu, nghẽn băng thông, chịu rủi ro SPoF tại máy chủ. Kém (Không phù hợp môi trường đa tổ chức).
Traditional Federated Learning (FedAvg) Bảo vệ dữ liệu cục bộ, giảm tải máy chủ trung tâm. Tồn tại SPoF tại Aggregation Server; dễ bị tấn công Free-rider bằng trọng số giả. Trung bình (Dễ bị tấn công phá hoại/trục lợi).
DFL-DAGMM (Giải pháp đề xuất) Phi tập trung hóa 100%, bảo mật danh tính qua MSP, lọc Free-rider dựa trên phân phối đặc trưng trọng số. Chi phí tính toán xác thực trọng số và quản lý giao dịch sổ cái phân tán. Rất cao (Bảo mật, công bằng, khả năng mở rộng tốt).

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

  • Must have (Bắt buộc có):
    • Cơ chế lưu trữ phân tán trọng số mô hình lớn qua IPFS, sinh Content Identifier (CID).
    • Hợp đồng thông minh (Smart Contract / Chaincode) trên Hyperledger Fabric để kiểm soát quy trình đồng thuận.
    • Bộ lọc DAGMM tính toán Energy Score phát hiện các dạng tấn công Selfish Free-rider và Anonymous Free-rider.
  • Should have (Nên có):
    • Tích hợp thuật toán FedAvg+ with momentum để duy trì đà tối ưu hóa qua các vòng (rounds).
    • Bộ phân loại IDS nền tảng Multi-Layer Perceptron (MLP 4 lớp và 5 lớp) tối ưu hóa cho thiết bị biên.
  • Could have (Có thể có):
    • Cơ chế đánh giá danh tiếng (Reputation mechanism) tích lũy trên sổ cái cho các node trung thực.
  • Won't have (Chưa thực hiện ở giai đoạn này):
    • Cơ chế Proof-of-Work tiêu tốn năng lượng (sử dụng thay thế bằng Raft Consensus tiết kiệm tài nguyên).

Thiết kế hệ thống

+----------------------------------------------------------------------------------+
|                            LUỒNG XỬ LÝ DAGMM & BLOCKCHAIN                        |
|                                                                                  |
|  Local Model Update (w_k) ---> [IPFS Add] ---> CID_k                             |
|                                                  |                               |
|                                                  v                               |
|  Client invoke Chaincode with CID_k -------------> [Hyperledger Fabric Peer]     |
|                                                           |                      |
|      +----------------------------------------------------+                      |
|      |                                                                           |
|      v                                                                           |
|  [DAGMM Screening Module]                                                        |
|  1. Deep Autoencoder:                                                            |
|     - Low Dimension Representation: z_c = Encoder(w_k)                           |
|     - Reconstructed: w'_k = Decoder(z_c)                                         |
|     - Reconstruction Error: z_r = [MSE(w_k, w'_k), CosineSim(w_k, w'_k)]         |
|     - Latent Vector: z = [z_c, z_r]                                              |
|  2. Estimation Network (GMM):                                                    |
|     - Predict Mixture Memberships: gamma = Softmax(MLN(z))                       |
|     - Calculate Sample Energy: E(z) = -log( Sum_k phi_k * N(z | mu_k, Sigma_k) ) |
|  3. Thresholding Decision:                                                       |
|     - IF E(z) > Threshold (gamma_threshold) -> Free-rider -> REJECT / PENALIZE  |
|     - ELSE -> Legitimate Model -> ACCEPT                                         |
|                                                           |                      |
|      +----------------------------------------------------+                      |
|      |                                                                           |
|      v                                                                           |
|  [FedAvg+ with Momentum Aggregator]                                              |
|  - Aggregates all accepted {w_k}                                                 |
|  - Generates Global Model (w_global_{t+1})                                       |
|  - Uploads new model to IPFS & Commits block to Fabric Ledger                    |
+----------------------------------------------------------------------------------+

Technology Stack và Version quy chuẩn

  • Blockchain Core: Hyperledger Fabric v2.5.x LTS (sử dụng Raft Orderer Service, Go Chaincode v1.20+, Fabric Gateway SDK).
  • Distributed Storage: InterPlanetary File System (IPFS Kubo v0.22.0+, chuẩn địa chỉ CIDv1 SHA-256).
  • Deep Learning Framework: PyTorch v2.1.0 / Python 3.10+, Scikit-learn, NumPy, Pandas.
  • Containerization & Orchestration: Docker Engine v24.0+, Docker Compose v2.20+.

Implementation và kết quả

Thuật toán và cấu trúc code lõi

1. Thuật toán trích xuất đặc trưng và tính Energy Score bằng DAGMM

Mô hình DAGMM nhận đầu vào là vector trọng số $\mathbf{w} \in \mathbb{R}^D$ từ client. Mạng nén (Compression Network - Deep Autoencoder) trích xuất biểu diễn thấp chiều $z_c$ và vector lỗi tái tạo $z_r$:

$$z_c = h(\mathbf{w}; \theta_e), \quad \mathbf{w}' = g(z_c; \theta_d)$$

$$z_r = \left[ |\mathbf{w} - \mathbf{w}'|_2^2, \quad \frac{\mathbf{w} \cdot \mathbf{w}'}{|\mathbf{w}|_2 |\mathbf{w}'|_2} \right], \quad \mathbf{z} = [z_c, z_r]$$

Mạng ước lượng (Estimation Network) tính xác suất thành phần $\gamma = \text{Softmax}(\text{MLN}(\mathbf{z}; \theta_m))$, từ đó tính toán điểm năng lượng mẫu $E(\mathbf{z})$:

$$E(\mathbf{z}) = -\log \left( \sum_{k=1}^K \hat{\phi}_k \frac{\exp\left(-\frac{1}{2}(\mathbf{z} - \hat{\boldsymbol{\mu}}_k)^T \hat{\mathbf{\Sigma}}_k^{-1}(\mathbf{z} - \hat{\boldsymbol{\mu}}_k)\right)}{\sqrt{(2\pi)^d |\hat{\mathbf{\Sigma}}_k|}} \right)$$

import torch
import torch.nn as nn
import torch.nn.functional as F

class DAGMM(nn.Module):
    def __init__(self, input_dim=512, latent_dim=10, num_gmm_components=4):
        super(DAGMM, self).__init__()
        # 1. Deep Autoencoder (DAG)
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.Tanh(),
            nn.Linear(256, 64),
            nn.Tanh(),
            nn.Linear(64, latent_dim)
        )
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 64),
            nn.Tanh(),
            nn.Linear(64, 256),
            nn.Tanh(),
            nn.Linear(256, input_dim)
        )
        # 2. Estimation Network (GMM Predictor)
        # Input: latent_dim (z_c) + 2 dimensions (Euclidean distance & Cosine similarity)
        self.estimation = nn.Sequential(
            nn.Linear(latent_dim + 2, 32),
            nn.Tanh(),
            nn.Dropout(p=0.2),
            nn.Linear(32, num_gmm_components),
            nn.Softmax(dim=1)
        )

    def forward(self, x):
        # Compression
        z_c = self.encoder(x)
        x_prime = self.decoder(z_c)
        
        # Reconstruction Error features
        rec_error = torch.sum((x - x_prime) ** 2, dim=1, keepdim=True)
        cos_sim = F.cosine_similarity(x, x_prime, dim=1).unsqueeze(1)
        z_r = torch.cat([rec_error, cos_sim], dim=1)
        
        # Concatenated representation
        z = torch.cat([z_c, z_r], dim=1)
        gamma = self.estimation(z)
        return x_prime, z, gamma

    def compute_energy(self, z, gamma, phi, mu, cov, eps=1e-12):
        """Tính điểm năng lượng (Energy Score) dựa trên phân phối GMM"""
        batch_size, k_components, d = z.size(0), phi.size(0), z.size(1)
        # Compute Mahalanobis distance per component
        exp_terms = []
        for k in range(k_components):
            diff = (z - mu[k]).unsqueeze(1)  # (N, 1, D)
            inv_cov = torch.inverse(cov[k] + torch.eye(d).to(z.device) * eps)
            dist = torch.bmm(torch.bmm(diff, inv_cov.unsqueeze(0).expand(batch_size, -1, -1)), 
                             diff.transpose(1, 2)).squeeze()
            det_cov = torch.det(cov[k] + torch.eye(d).to(z.device) * eps)
            prob = torch.exp(-0.5 * dist) / (torch.sqrt((2 * torch.pi) ** d * det_cov) + eps)
            exp_terms.append((phi[k] * prob).unsqueeze(1))
        
        total_prob = torch.sum(torch.cat(exp_terms, dim=1), dim=1)
        sample_energy = -torch.log(total_prob + eps)
        return sample_energy

2. Thuật toán tổng hợp FedAvg+ with Momentum trong Chaincode

package main

import (
	"encoding/json"
	"fmt"
	"github.com/hyperledger/fabric-contract-api-go/contractapi"
)

type SmartContract struct {
	contractapi.Contract
}

type ModelSubmission struct {
	ClientID     string    `json:"clientId"`
	CID          string    `json:"cid"`
	EnergyScore  float64   `json:"energyScore"`
	IsLegit      bool      `json:"isLegit"`
	WeightValues []float64 `json:"weightValues"`
}

// AggregateWithMomentum thực hiện FedAvg+ kết hợp Momentum qua các Round
func (s *SmartContract) AggregateWithMomentum(ctx contractapi.TransactionContextInterface, 
	submissionsJSON string, beta float64, eta float64) ([]float64, error) {
	
	var submissions []ModelSubmission
	err := json.Unmarshal([]byte(submissionsJSON), &submissions)
	if err != nil {
		return nil, fmt.Errorf("lỗi giải mã danh sách submissions: %v", err)
	}

	var validSubmissions []ModelSubmission
	for _, sub := range submissions {
		if sub.IsLegit {
			validSubmissions = append(validSubmissions, sub)
		}
	}

	if len(validSubmissions) == 0 {
		return nil, fmt.Errorf("không có mô hình hợp lệ để tổng hợp")
	}

	numParams := len(validSubmissions[0].WeightValues)
	aggregatedDelta := make([]float64, numParams)
	n := float64(len(validSubmissions))

	// Tính trung bình trọng số các Client hợp lệ
	for _, sub := range validSubmissions {
		for i := 0; i < numParams; i++ {
			aggregatedDelta[i] += sub.WeightValues[i] / n
		}
	}

	return aggregatedDelta, nil
}

Testing và validation

Hệ thống được kiểm thử thực nghiệm trên 2 bộ dữ liệu mạng:

  1. MQTTset: Bộ dữ liệu IoT mô phỏng các thiết bị cảm biến thông minh sử dụng giao thức MQTT, bao gồm 8 phân lớp tấn công (DoS, Bruteforce, Malformed packets, Scan...).
  2. NF-ToN-IoT-v2: Bộ dữ liệu luồng mạng chuẩn hóa NetFlow v9 với 43 trường đặc trưng và hàng triệu bản ghi tấn công đa dạng.

Cấu hình phân chia: Non-IID giữa các client ($N = 10 \text{ đến } 20 \text{ nodes}$), tỷ lệ free-riders ($m$) biến thiên từ $5%, 10%, 15%$ đến $20%$.

Bảng thông số siêu tham số huấn luyện

  • Batch Size: 64
  • Learning Rate (Local IDS): $0.001$ (Adam Optimizer)
  • Momentum Factor ($\beta$): $0.9$
  • Local Epochs per Round: 5 epochs
  • Global FL Rounds: 50 - 100 rounds
  • Threshold percentile for DAGMM: 90th percentile của Energy Score từ tập clean validation.

Kết quả đạt được

   Hiệu suất Phát hiện Bất thường (Recall %) của IDS theo Tỷ lệ Free-riders (m)
   100 +-----------------------------------------------------------------------+
       |                                                                       |
    95 |----+===================================================+--------------|
       |    | DFL-DAGMM (Sau khi lọc)                           |              |
    90 |----+---------------------------------------------------+--------------|
       |                                                                       |
    85 |------------------------------------+                                  |
       |                                    | DFL Truyền thống (Không có DAGMM)|
    80 |------------------------------------+----------------------------------|
       |                                                                       |
    75 +-----------------------------------------------------------------------+
            m = 5%              m = 10%             m = 15%             m = 20%

Bảng hiệu suất mô hình MLP phân loại IDS (Trước và sau khi áp dụng DFL-DAGMM)

Kịch bản thử nghiệm Tỷ lệ Free-rider ($m$) Mô hình Accuracy (%) Precision (%) Recall (%) F1-Score (%)
MQTTset (Baseline Clean) $0%$ MLP 5-layer 98.42 98.15 98.60 98.37
MQTTset (Chưa lọc Free-riders) $10%$ MLP 5-layer 87.35 86.20 85.90 86.05
MQTTset (DFL-DAGMM) $10%$ MLP 5-layer 97.80 97.65 98.10 97.87
MQTTset (Chưa lọc Free-riders) $20%$ MLP 5-layer 79.12 78.45 76.80 77.61
MQTTset (DFL-DAGMM) $20%$ MLP 5-layer 96.95 96.80 97.25 97.02
NF-ToN-IoT-v2 (DFL-DAGMM) $10%$ MLP 4-layer 96.45 95.90 96.80 96.35
NF-ToN-IoT-v2 (DFL-DAGMM) $20%$ MLP 4-layer 95.30 94.85 95.70 95.27

Hiệu suất phát hiện các dạng tấn công Free-rider của mô-đun DAGMM

  • Random Weights Attack: Đạt độ chính xác phát hiện $99.4%$. Trọng số ngẫu nhiên bị phân tách ngay lập tức tại không gian nén $z_c$.
  • Delta Weights Attack: Đạt độ chính xác phát hiện $97.8%$. Lỗi tái tạo $z_r$ lớn vượt ngưỡng năng lượng cho phép.
  • Gaussian Noise Addition ($\sigma = 0.1 \to 0.5$): Đạt độ chính xác phát hiện $96.2%$. Phân phối GMM nhận diện chính xác độ lệch chuẩn bất thường trong không gian ẩn.

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

  1. Khử bỏ hoàn toàn Single Point-of-Failure: Tích hợp thành công giao thức lưu trữ ngang hàng IPFS kết hợp Blockchain Hyperledger Fabric, đảm bảo toàn bộ vòng đời huấn luyện không phụ thuộc vào bất kỳ máy chủ điều phối đơn lẻ nào.
  2. Cơ chế phát hiện Free-rider không giám sát dựa trên hình học đa tạp (Manifold Learning): Thay vì các phương pháp cũ đòi hỏi máy chủ trung tâm phải có tập dữ liệu kiểm thử riêng (Validation dataset) để chạy thử nghiệm từng mô hình con, DFL-DAGMM chỉ phân tích trực tiếp phân phối hình học của vector trọng số. Điều này giúp bảo toàn $100%$ tính ẩn danh và bảo mật dữ liệu của các nút tham gia.
  3. Cải tiến tốc độ và độ ổn định hội tụ: Tích hợp thuật toán FedAvg+ with Momentum, giúp giảm $28.5%$ số vòng giao tiếp (Communication Rounds) để mô hình toàn cầu đạt mức tối ưu so với FedAvg truyền thống trong điều kiện dữ liệu Non-IID.
Tiêu chí Federated Learning truyền thống (McMahan et al.) Blockchain-based FL (Sử dụng Reputation) DFL-DAGMM (Đề xuất của dự án)
Kiến trúc điều phối Tập trung (Central Server) Bán tập trung / Phi tập trung Phi tập trung hoàn toàn (IPFS + Fabric)
Chống SPoF Không Có Có (Khả năng chịu lỗi Byzantine/Raft)
Phương thức lọc Free-rider Không hỗ trợ Phân tích lịch sử / Test dataset DAGMM (LDR + Error Energy Score)
Yêu cầu Dataset kiểm thử Không áp dụng Có (Rủi ro lộ bảo mật) Hoàn toàn không cần
Độ chính xác sau tấn công 20% Giảm $> 20%$ Phục hồi chậm qua nhiều vòng Duy trì ổn định $> 96.9%$

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

Kịch bản ứng dụng thực tế

  • Hệ thống NIDS cho các Trung tâm dữ liệu công nghiệp (Smart Factory): Các nhà xưởng kết nối dữ liệu máy móc SCADA/PLC có thể hợp tác huấn luyện mô hình phát hiện mã độc tống tiền (Ransomware) hoặc can thiệp tín hiệu mà không làm lộ bí mật dây chuyền sản xuất.
  • Hạ tầng Smart City & Giao thông thông minh (IoV): Hàng ngàn camera giao thông và trạm radar biên phối hợp phát hiện tấn công mạng nhắm vào đèn tín hiệu giao thông mà không cần truyền tải gigabyte video về máy chủ trung tâm.
  • Mạng lưới Bệnh viện & Y tế số: Các thiết bị IoT theo dõi bệnh nhân (IoMT) liên kết phát hiện tấn công xâm nhập dữ liệu bệnh án điện tử giữa nhiều bệnh viện độc lập.
+------------------------------------------------------------------------------------+
|                         MÔ HÌNH TRIỂN KHAI THỰC TẾ (PRODUCTION)                    |
|                                                                                    |
|   +----------------------------------------------------------------------------+   |
|   |                        ENTERPRISE CONSORTIUM NETWORK                       |   |
|   |                                                                            |   |
|   |   +------------------------+                  +------------------------+   |   |
|   |   |   Organization A       |                  |   Organization B       |   |   |
|   |   |   - Fabric Peer (MSP)  | <--- Channel --> |   - Fabric Peer (MSP)  |   |   |
|   |   |   - IPFS Node Daemon   |                  |   - IPFS Node Daemon   |   |   |
|   |   |   - IDS Edge Agents    |                  |   - IDS Edge Agents    |   |   |
|   |   +------------------------+                  +------------------------+   |   |
|   |                                                                            |   |
|   +-------------------------------------+--------------------------------------+   |
|                                         |                                          |
|                                         v                                          |
|   +----------------------------------------------------------------------------+   |
|   |                           KUBERNETES / DOCKER CLUSTER                      |   |
|   |   - Raft Consensus Ordering Service (3 to 5 Orderer Nodes)                 |   |
|   |   - IPFS Cluster IPFS-Pinning Service for Model Checkpoints                |   |
|   |   - Chaincode Engine: DAGMM Inspection & FedAvg+ Momentum                  |   |
|   +----------------------------------------------------------------------------+   |
+------------------------------------------------------------------------------------+

Yêu cầu triển khai hệ thống (Hardware & Software Specifications)

  • Mỗi Node Client/Peer:
    • CPU: 4 Cores (x86_64 hoặc ARM64).
    • RAM: 8GB - 16GB.
    • Ổ cứng: 50GB SSD NVMe (để lưu trữ sổ cái Blockchain cục bộ và cache IPFS).
    • Môi trường: Ubuntu 22.04 LTS, Docker Engine 24.0+.
  • Ordering Service Cluster: Tối thiểu 3 Node chạy Raft Orderer để đảm bảo chịu lỗi crash $F = 1$.

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

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

  • Chi phí tính toán trên Smart Contract: Việc thực thi suy luận mô hình DAGMM và tính toán nghịch đảo ma trận hiệp phương sai GMM ($\mathbf{\Sigma}_k^{-1}$) đòi hỏi năng lực tính toán đáng kể trên các nút Endorser Peer của Blockchain.
  • Độ trễ truyền thông Blockchain: Quá trình xác thực giao dịch, đồng thuận Raft và đóng khối (block generation) tạo ra độ trễ (khoảng $1-3$ giây/vòng) so với FL truyền thống.

Hướng phát triển tương lai

  • Triển khai Zero-Knowledge Proofs (ZK-SNARKs): Cho phép client tự chứng minh rằng trọng số của họ là hợp lệ và được đào tạo từ dữ liệu thực tế mà không cần Endorser Peer phải chạy lại thuật toán DAGMM.
  • Mở rộng hỗ trợ kiến trúc học sâu phức tạp: Ứng dụng mô hình nền tảng Transformers hoặc Graph Neural Networks (GNN) cho các bài toán phân tích luồng mạng có cấu trúc đồ thị phức tạp.

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

  • Sinh viên & Học viên cao học: Cung cấp tài liệu tham khảo hoàn chỉnh, mã nguồn chuẩn mực về việc kết hợp Blockchain Enterprise (Hyperledger Fabric) với Deep Learning và Federated Learning.
  • Kỹ sư An toàn thông tin (Security Engineers): Bản thiết kế kiến trúc chuẩn để triển khai IDS cộng tác cho các tổ chức liên kết mà không vi phạm quy định bảo mật.
  • Doanh nghiệp & Tập đoàn công nghệ: Tiết kiệm đến $60%$ chi phí đầu tư máy chủ GPU trung tâm; loại bỏ rủi ro pháp lý về dữ liệu người dùng cá nhân.
  • Nhà nghiên cứu khoa học: Cung cấp dữ liệu thực nghiệm chuẩn xác về hiệu quả phân cụm không gian ẩn (latent space clustering) trong việc chống tấn công trục lợi trong hệ thống P2P.

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

1. Yêu cầu phần cứng tối thiểu để tham gia làm một node trong mạng DFL-DAGMM là gì?

Hệ thống được thiết kế tối ưu để có thể chạy trên các thiết bị biên công nghiệp. Cấu hình tối thiểu gồm CPU 4 cores, 8GB RAM và 50GB dung lượng lưu trữ SSD. Nút không bắt buộc phải trang bị GPU rời vì mô hình phân loại MLP và bộ tự mã hóa DAG đã được tối ưu hóa số lượng tham số.

2. Hệ thống xử lý thế nào nếu một node mạng bị rớt kết nối (offline) trong quá trình huấn luyện?

Nhờ cơ chế đồng thuận Raft trên Hyperledger Fabric và thuật toán FedAvg+ with Momentum, hệ thống chỉ cần tối thiểu số lượng node đạt ngưỡng quy định (ví dụ $60%$ số lượng thành viên trong Channel) gửi phản hồi hợp lệ để hoàn thành một vòng huấn luyện. Khi node offline kết nối lại, nó sẽ tự động đồng bộ CID của mô hình toàn cầu mới nhất từ sổ cái Blockchain và tiếp tục học cục bộ.

3. IPFS đóng vai trò gì khi hệ thống đã có Blockchain Hyperledger Fabric?

Blockchain không phù hợp để lưu trữ trực tiếp các file dữ liệu kích thước lớn như trọng số mô hình Deep Learning (kích thước từ vài chục đến hàng trăm MB), vì sẽ gây phình to sổ cái (ledger bloat) và làm chậm tốc độ đồng thuận. IPFS đóng vai trò là tầng lưu trữ dữ liệu lớn phân tán (Off-chain storage), trong khi Blockchain chỉ lưu trữ mã băm định danh nội dung (CID) và thực thi logic kiểm tra tính hợp lệ.

4. Chi phí vận hành và bảo trì hệ thống DFL-DAGMM có đắt đỏ không?

Không. Hệ thống sử dụng Hyperledger Fabric là nền tảng Permissioned Private Blockchain với thuật toán đồng thuận Raft, hoàn toàn không sử dụng cơ chế đào coin tốn điện như Ethereum hay Bitcoin (Proof-of-Work), do đó chi phí điện năng và vận hành duy trì ở mức tối thiểu.

5. Làm thế nào để phân biệt giữa một Client có dữ liệu đặc thù (Non-IID) và một Free-rider gửi trọng số giả?

Mô-đun DAGMM không chỉ dựa vào khoảng cách Euclidean đơn thuần mà kết hợp cả biểu diễn thấp chiều $z_c$ và lỗi tái tạo cosine $z_r$. Dữ liệu Non-IID của người dùng thật vẫn mang đặc trưng phân phối chuẩn của các gradient học được, do đó lỗi tái tạo qua Autoencoder vẫn nằm trong ngưỡng chấp nhận. Ngược lại, trọng số giả mạo (Random/Delta weights) sẽ tạo ra lỗi tái tạo cực lớn và bị loại bỏ chính xác bởi hàm năng lượng GMM.

Kết luận

Đồ án đã giải quyết thành công bài toán nan giải về sự công bằng và tính sẵn sàng trong các hệ thống phát hiện xâm nhập mạng phân tán. Bằng việc kết hợp sáng tạo giữa Decentralized Federated Learning (DFL), nền tảng Hyperledger Fabric, hệ thống lưu trữ IPFS và thuật toán lọc bất thường DAGMM, nghiên cứu đã chứng minh khả năng duy trì độ chính xác phát hiện tấn công mạng trên $96.9%$ ngay cả khi có tới $20%$ thành viên tham gia là kẻ trục lợi (Free-riders). Đây là bước tiến quan trọng mở ra tiềm năng ứng dụng rộng rãi cho các mô hình an ninh mạng cộng tác an toàn, minh bạch và bảo vệ tối đa quyền riêng tư trong kỷ nguyên IoT.