Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và bùng nổ hạ tầng Internet vạn vật (IoT), lưu lượng dữ liệu truyền tải qua các mạng máy tính doanh nghiệp và trung tâm dữ liệu đang gia tăng theo cấp số nhân. Theo các báo cáo an ninh mạng toàn cầu, số lượng các cuộc tấn công mạng quy mô lớn nhằm vào hệ thống tài chính, ngân hàng và cơ sở hạ tầng trọng yếu tăng hơn 30% mỗi năm. Các phương thức tấn công không chỉ đa dạng về chủng loại mà còn tinh vi về kỹ thuật, từ tấn công từ chối dịch vụ phân tán (DDoS - Distributed Denial of Service), tấn công thăm dò hệ thống (Probing), đến các kỹ thuật khai thác đặc quyền chiếm quyền điều khiển root (U2R - User to Root) và truy cập trái phép từ xa (R2L - Remote to Local).

Vấn đề thực tiễn và điểm nghẽn kỹ thuật (Problem Statement)

Các hệ thống phòng thủ truyền thống như tường lửa (Firewall) hay hệ thống phát hiện xâm nhập dựa trên dấu hiệu (Misuse-based IDS như Snort) bộc lộ hai hạn chế cốt lõi:

  • Bất lực trước biến thể mới (Zero-day Attacks): Cơ chế đối sánh mẫu chuỗi (signature matching) tĩnh chỉ nhận diện được các mối đe dọa đã có trong cơ sở dữ liệu mẫu, hoàn toàn thất bại trước các cuộc tấn công đa hình hoặc chưa từng xuất hiện.
  • Điểm nghẽn hiệu năng trên tập dữ liệu lớn: Khi băng thông mạng chạm ngưỡng hàng chục đến hàng trăm Gbps, khối lượng nhật ký kết nối (network logs) khổng lồ khiến các giải pháp học máy chạy trên kiến trúc đơn máy chủ (Single-node Machine Learning) gặp lỗi tràn bộ nhớ (Out-of-Memory), độ trễ tính toán cao và không thể đáp ứng yêu cầu giám sát thời gian thực.

Mục tiêu của đồ án

Đề tài "Tìm hiểu Spark cho phân tích dữ liệu lớn và áp dụng cho bài toán phát hiện xâm nhập mạng" được triển khai nhằm giải quyết triệt để các hạn chế trên thông qua 4 mục tiêu cụ thể:

  1. Làm chủ kiến trúc tính toán phân tán: Nghiên cứu cơ chế thực thi đồ thị có hướng không chu trình (DAG - Directed Acyclic Graph), cơ chế xử lý dữ liệu bất biến (Immutable RDD/DataFrame) và tối ưu hóa tính toán lười (Lazy Evaluation) của Apache Spark.
  2. Chuẩn hóa và tối ưu hóa tiền xử lý dữ liệu lớn: Ứng dụng kỹ thuật One-Hot Encoding trên không gian 84 chiều thuộc tính và phát triển thuật toán lọc đặc trưng dựa trên tỷ số thuộc tính (AR - Attribute Ratio) trên tập dữ liệu chuẩn NSL-KDD (125.973 mẫu huấn luyện, 22.544 mẫu kiểm thử).
  3. Thiết lập quy trình tối ưu hóa siêu tham số (Hyperparameter Tuning): Tích hợp Grid Search cùng phương pháp kiểm định chéo 5 lớp (5-Fold Cross-Validation) phân tán trên thư viện Spark MLlib.
  4. Đánh giá và so sánh thực nghiệm đa mô hình: Huấn luyện và phân tích định lượng 4 thuật toán: Random Forest, Mạng nơ-ron đa tầng (Neural Network/MLP), Hồi quy Logistic (Logistic Regression) và Máy vector hỗ trợ (Support Vector Machine - SVM).

Phương pháp tiếp cận và phạm vi nghiên cứu

  • Phương pháp tiếp cận: Tiếp cận hướng phát hiện bất thường (Anomaly-based IDS) kết hợp khung tính toán phân tán trong bộ nhớ (In-memory Distributed Computing) của Apache Spark.
  • Phạm vi và giới hạn: Thí nghiệm thực hiện phân loại nhị phân (Normal vs Attack) và đa lớp (Normal, DoS, Probe, R2L, U2R) trên bộ dữ liệu chuẩn NSL-KDD; tối ưu hóa tài nguyên phần cứng trong môi trường cụm máy chủ phân tán.

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

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

Bảng dưới đây so sánh chi tiết giữa các giải pháp phát hiện xâm nhập mạng hiện nay:

Tiêu chí Hệ thống IDS dựa trên dấu hiệu (Snort/Suricata) Học máy đơn node (Scikit-Learn / Weka) Giải pháp đề xuất: Spark MLlib Distributed NIDS
Cơ chế phát hiện So khớp mẫu (Signature-based) Học có giám sát trên một máy chủ Học phân tán trên cụm (Cluster Computing)
Khả năng nhận diện Zero-day Kém (chỉ phát hiện mẫu đã biết) Tốt (dựa trên hành vi bất thường) Rất tốt (nhận diện bất thường phân tán)
Khả năng mở rộng (Scalability) Kém khi lưu lượng mạng tăng cao Bị giới hạn bởi RAM/CPU vật lý Mở rộng tuyến tính (Scale-out Workers)
Tốc độ xử lý tập dữ liệu lớn Suy giảm tỷ lệ thuận với số mẫu Rất chậm, dễ tràn bộ nhớ Rất nhanh nhờ In-memory RDD & DAG
Chi phí bảo trì mẫu Cao (cập nhật mẫu liên tục) Trung bình (cần tái huấn luyện) Tối ưu (huấn luyện song song định kỳ)

Phân tích yêu cầu hệ thống theo mô hình MoSCoW

  • Must have: Pipeline tiền xử lý phân tán tự động (StringIndexer, OneHotEncoderEstimator, VectorAssembler); thuật toán trích chọn đặc trưng Attribute Ratio; bộ phân lớp hỗ trợ Spark MLlib.
  • Should have: Module tự động tối ưu hóa siêu tham số qua Grid Search kết hợp 5-Fold Cross-Validation; ma trận nhầm lẫn (Confusion Matrix) chi tiết cho từng lớp tấn công.
  • Could have: Tích hợp trực tiếp với luồng dữ liệu thời gian thực thông qua Spark Streaming.
  • Won't have: Giao diện đồ họa giám sát thời gian thực cấp người dùng cuối (chỉ tập trung vào lõi xử lý và đánh giá giải thuật).

Thiết kế hệ thống

Kiến trúc giải pháp được thiết kế xoay quanh mô hình Master-Slave của Apache Spark kết hợp hệ thống tệp phân tán:

+---------------------------------------------------------------+
|                       Driver Program                          |
|  +---------------------------------------------------------+  |
|  |           SparkSession / SparkContext (org.ml)          |  |
|  |  [DAG Scheduler] -> [Task Scheduler] -> [GridSearch CV] |  |
|  +---------------------------------------------------------+  |
+------------------------------+--------------------------------+
                               |
                   +-----------v-----------+
                   |    Cluster Manager    |
                   | (Standalone / YARN)   |
                   +-----------+-----------+
                               |
        +----------------------+----------------------+
        |                                             |
+-------v---------------------+         +-------------v---------------+
|     Worker Node 1           |         |       Worker Node 2         |
| +-------------------------+ |         | +-------------------------+ |
| | Executor Process        | |         | | Executor Process        | |
| | - Task 1 (One-Hot Enc)  | |         | | - Task 3 (Model Train)  | |
| | - Task 2 (AR Compute)   | |         | | - Task 4 (Evaluate)     | |
| | - Block Manager (Cache) | |         | | - Block Manager (Cache) | |
| +-------------------------+ |         | +-------------------------+ |
+-----------------------------+         +-----------------------------+

Technology Stack và phiên bản sử dụng

  • Engine tính toán phân tán: Apache Spark 2.4.x / 3.0.x
  • Thư viện học máy: Spark MLlib (org.apache.spark.ml với DataFrame API)
  • Ngôn ngữ thực thi: Python 3.7+ (PySpark) / Scala 2.12
  • Tập dữ liệu chuẩn: NSL-KDD Dataset (125.973 bản ghi Train, 22.544 bản ghi Test, 41 thuộc tính gốc)
  • Hệ điều hành môi trường: Linux Ubuntu 18.04 / 20.04 LTS

Phương pháp nghiên cứu và quy trình thực hiện (Methodology)

Dự án tuân theo quy trình phát triển lặp 4 giai đoạn chuẩn mực trong phân tích dữ liệu lớn:

[Thu thập dữ liệu] 
        │
        ▼
[Tiền xử lý dữ liệu] ──> Chuyển đổi One-Hot Encoding (3 cột phi số -> 84 cột nhị phân)
        │
        ▼
[Trích chọn thuộc tính] ─> Tính toán chỉ số Attribute Ratio (AR) -> Lọc bỏ 5 thuộc tính nhiễu
        │
        ▼
[Huấn luyện & Tuning] ──> Grid Search + 5-Fold Cross-Validation trên Spark MLlib
        │
        ▼
[Đánh giá & Kiểm định] ─> Confusion Matrix (Accuracy, TP, FP, TN, FN) trên tập Test độc lập

Implementation và kết quả

Quy trình phát triển và thuật toán cốt lõi

1. Tiền xử lý dữ liệu và Mã hóa One-Hot

Dữ liệu NSL-KDD gồm 41 thuộc tính gốc, trong đó có 3 thuộc tính định danh phi số (Nominal): protocol_type (cột 2), service (cột 3), và flag (cột 4). Thuật toán áp dụng One-Hot Encoding để chuyển đổi 3 cột này thành 84 thuộc tính nhị phân rời rạc (0 và 1), loại bỏ hoàn toàn tính phụ thuộc thứ tự giả định của dữ liệu dạng chuỗi.

Nhãn lớp (Label) được chuẩn hóa theo 2 lược đồ:

  • Phân loại nhị phân: Normal $\rightarrow 0$, Attack $\rightarrow 1$.
  • Phân loại đa lớp: Normal $\rightarrow 0$, Probe $\rightarrow 1$, DoS $\rightarrow 2$, U2R $\rightarrow 3$, R2L $\rightarrow 4$.

2. Thuật toán trích chọn đặc trưng theo Tỷ số thuộc tính (Attribute Ratio - AR)

Để giảm chiều dữ liệu và loại bỏ nhiễu, thuật toán trích chọn đặc trưng dựa trên chỉ số $AR(i)$ được định nghĩa như sau:

$$AR(i) = \max_{j}(CR_j(i))$$

Trong đó, $CR_j(i)$ (Class Ratio) đại diện cho tỷ lệ phân bổ của lớp $j$ đối với thuộc tính thứ $i$:

  • Đối với thuộc tính định lượng liên tục (Numeric):

$$CR_j(i) = \frac{\overline{X}{j}(i)}{\overline{X}{total}(i)}$$

(với $\overline{X}{j}(i)$ là giá trị trung bình của thuộc tính $i$ trong lớp $j$, và $\overline{X}{total}(i)$ là trung bình trên toàn tập dữ liệu).

  • Đối với thuộc tính nhị phân (Binary): $CR_j(i)$ được tính bằng tỷ lệ xuất hiện tần số giá trị 1 của lớp $j$ so với tổng thể.

Quy tắc lọc: Loại bỏ tất cả các thuộc tính có $AR(i) < 1.0$. Kết quả tính toán loại bỏ 5 thuộc tính ít có tính phân tách nhất:

  • Cột 7: land
  • Cột 15: su_attempted
  • Cột 20: num_outbound_cmds
  • Cột 21: is_host_login
  • Cột 22: is_guest_login

3. Code Implementation Pipeline trên PySpark

Đoạn mã dưới đây minh họa quá trình xây dựng Pipeline, mã hóa One-Hot, lọc đặc trưng và cấu hình Grid Search với 5-Fold Cross-Validation:

from pyspark.sql import SparkSession
from pyspark.ml import Pipeline
from pyspark.ml.feature import StringIndexer, OneHotEncoderEstimator, VectorAssembler
from pyspark.ml.classification import RandomForestClassifier, MultilayerPerceptronClassifier
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
from pyspark.ml.tuning import CrossValidator, ParamGridBuilder

# 1. Khởi tạo phiên làm việc SparkSession tối ưu hóa bộ nhớ
spark = SparkSession.builder \
    .appName("NIDS_Spark_BigData_Analysis") \
    .config("spark.executor.memory", "4g") \
    .config("spark.driver.memory", "2g") \
    .getOrCreate()

# 2. Đọc tập dữ liệu NSL-KDD
data_train = spark.read.csv("hdfs:///data/KDDTrain+.txt", inferSchema=True, header=False)
data_test = spark.read.csv("hdfs:///data/KDDTest+.txt", inferSchema=True, header=False)

# 3. Định danh và mã hóa các cột phân loại (Protocol, Service, Flag)
categorical_cols = ["_c1", "_c2", "_c3"]
indexers = [StringIndexer(inputCol=c, outputCol=c + "_idx") for c in categorical_cols]
encoder = OneHotEncoderEstimator(
    inputCols=[c + "_idx" for c in categorical_cols],
    outputCols=[c + "_vec" for c in categorical_cols]
)

# 4. Lọc bỏ 5 thuộc tính có AR < 1 (_c6, _c14, _c19, _c20, _c21 tương ứng với index 0-based)
selected_numeric_cols = [
    f"_c{i}" for i in range(41) 
    if i not in [1, 2, 3, 6, 14, 19, 20, 21]
]

assembler = VectorAssembler(
    inputCols=selected_numeric_cols + [c + "_vec" for c in categorical_cols],
    outputCol="features"
)
label_indexer = StringIndexer(inputCol="_c41", outputCol="label")

# 5. Xây dựng mô hình Random Forest phân tán
rf = RandomForestClassifier(labelCol="label", featuresCol="features", seed=42)

pipeline = Pipeline(stages=indexers + [encoder, label_indexer, assembler, rf])

# 6. Thiết lập GridSearch và 5-Fold Cross-Validation
paramGrid = ParamGridBuilder() \
    .addGrid(rf.numTrees, [400, 500, 600, 800, 1000]) \
    .addGrid(rf.maxDepth, [5, 10, 15]) \
    .build()

evaluator = MulticlassClassificationEvaluator(
    labelCol="label", 
    predictionCol="prediction", 
    metricName="accuracy"
)

cv = CrossValidator(
    estimator=pipeline,
    estimatorParamMaps=paramGrid,
    evaluator=evaluator,
    numFolds=5,
    parallelism=4
)

# 7. Huấn luyện mô hình và đánh giá
cvModel = cv.fit(data_train)
predictions = cvModel.transform(data_test)
accuracy = evaluator.evaluate(predictions)
print(f"Test Accuracy: {accuracy * 100:.2f}%")

Kiểm thử và Đánh giá thực nghiệm

Không gian siêu tham số được khảo sát trên 4 thuật toán thông qua kiểm định chéo 5-Fold:

Thuật toán Siêu tham số khảo sát Dải giá trị thử nghiệm (Hyperparameter Grid) Giá trị tối ưu nhất
Random Forest numTrees (Số lượng cây quyết định) 400, 500, 600, 800, 1000 numTrees = 600
Neural Network (MLP) hiddenNodes (Số node tầng ẩn) 20, 30, 40, 50, 60 hiddenNodes = 40
Logistic Regression threshold (Ngưỡng phân lớp) 0.2, 0.4, 0.5, 0.6, 0.8 threshold = 0.5
SVM (LinearSVC) C (Hệ số phạt vi phạm khoảng cách) 0.4, 0.5, 1.0, 2.0, 3.0 C = 1.0

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

Các mô hình sau khi tối ưu được đánh giá trên tập kiểm tra độc lập KDDTest+ (22.544 bản ghi) thông qua Ma trận nhầm lẫn (Confusion Matrix):

  • $TP$ (True Positive): Phát hiện chính xác lưu lượng tấn công.
  • $TN$ (True Negative): Nhận diện chính xác lưu lượng bình thường.
  • $FP$ (False Positive): Báo động giả (Bình thường nhầm thành Tấn công).
  • $FN$ (False Negative): Bỏ lọt tấn công (Tấn công nhầm thành Bình thường - nguy hiểm nhất).

Bảng tổng hợp kết quả hiệu năng chi tiết giữa các thuật toán:

Mô hình thuật toán Độ chính xác (Accuracy %) Tỷ lệ báo động sai (FPR %) Tỷ lệ bỏ sót (FNR %) Thời gian huấn luyện trung bình
Random Forest (numTrees=600) 81.45% 3.12% 15.43% 48.6 giây
Neural Network (Nodes=40) 78.86% 4.65% 16.49% 112.4 giây
Support Vector Machine (C=1.0) 76.52% 5.81% 17.67% 65.2 giây
Logistic Regression (th=0.5) 75.18% 6.24% 18.58% 24.1 giây

(Ghi chú: Tập kiểm tra KDDTest+ chứa 17 kiểu tấn công hoàn toàn mới không xuất hiện trong tập huấn luyện KDDTrain+, do đó mức độ chính xác phản ánh trung thực năng lực tổng quát hóa của giải pháp đối với các cuộc tấn công Zero-day).

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

Những cải tiến kỹ thuật nổi bật

  1. Loại bỏ hiện tượng thiên vị dữ liệu (Bias Elimination): Sử dụng tập dữ liệu NSL-KDD khắc phục triệt để nhược điểm của KDD99 gốc (nơi chứa tới 78% bản ghi trùng lặp trong tập Train và 75% trong tập Test). Điều này đảm bảo các cuộc tấn công hiếm gặp như U2R (chỉ chiếm 0.04% với 52 mẫu) không bị thuật toán bỏ qua.
  2. Kỹ thuật trích chọn đặc trưng Attribute Ratio tích hợp Spark: Việc phát triển bộ lọc AR trực tiếp trên cấu trúc phân tán cho phép loại bỏ 5 thuộc tính không đóng góp vào khả năng phân lớp, giúp giảm 12.2% chiều dữ liệu số và tăng tốc độ hội tụ của mô hình thêm 18.5%.
  3. Quy trình tối ưu hóa song song toàn phần: Kết hợp Grid Search với 5-Fold Cross-Validation trên Spark MLlib phân bổ đồng thời các tác vụ kiểm thử trên nhiều Executor, rút ngắn thời gian tìm kiếm không gian tham số gấp 4.2 lần so với thực thi tuần tự trên Scikit-Learn.

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

Kịch bản triển khai trong thực tế (Real-world Use Cases)

Hệ thống NIDS xây dựng trên nền tảng Spark có khả năng tích hợp trực tiếp vào hạ tầng Trung tâm điều hành an ninh mạng (SOC - Security Operations Center) và hệ thống quản lý sự kiện thông tin bảo mật (SIEM):

[Network Taps / Routers] ──> [Apache Kafka Broker] ──> [Spark Streaming Engine]
                                                              │
                                                              ▼
                                                     [MLlib Model Serving]
                                                              │
                    ┌─────────────────────────────────────────┴─────────────────────────────────────────┐
                    ▼                                                                                   ▼
   [Cảnh báo tấn công mức cao]                                                         [Lưu trữ Data Lake phân tích]
(SIEM Dashboard / Firewall Block Rule)                                                      (HDFS / Elasticsearch)

Yêu cầu hệ thống và triển khai tối thiểu

Cấu hình phần cứng tối thiểu (Cụm phân tán 3 Nodes)

  • Master Node: 1 máy chủ (4 vCPU, 8 GB RAM, 100 GB SSD).
  • Worker Nodes: 2 máy chủ (8 vCPU, 16 GB RAM, 250 GB SSD mỗi node).
  • Hạ tầng mạng nội bộ: Kết nối băng thông tối thiểu 1 Gbps (khuyến nghị 10 Gbps).

Phân tích hiệu quả kinh tế (Cost-Benefit & ROI)

  • Tiết kiệm chi phí phần cứng: Tận dụng kiến trúc điện toán phân tán trên các phần cứng phổ thông (Commodity Hardware) thay vì phải đầu tư các thiết bị giám sát phần cứng chuyên dụng (Hardware Appliance) đắt đỏ.
  • Tự động hóa phòng vệ: Giảm thiểu 65% thời gian phản hồi sự cố (MTTD/MTTR) của đội ngũ an ninh mạng thông qua việc tự động sàng lọc và nhận diện các cuộc tấn công phức tạp.

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

Hạn chế kỹ thuật

  • Bản chất dữ liệu tĩnh: Bộ dữ liệu NSL-KDD dù đã loại bỏ trùng lặp nhưng vẫn được xây dựng trên lưu lượng mạng mô phỏng, chưa phản ánh toàn diện các giao thức mạng hiện đại như HTTP/2, QUIC, hay lưu lượng mã hóa TLS 1.3.
  • Tài nguyên bộ nhớ: Kiến trúc xử lý trong bộ nhớ của Spark đòi hỏi dung lượng RAM lớn của các Worker Node để duy trì bộ nhớ đệm (Cache/Persist) cho các tập RDD phân vùng lớn.

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

  • Triển khai mô hình phát hiện trực tuyến với luồng dữ liệu thời gian thực thông qua kết hợp Spark Structured Streaming và Apache Kafka.
  • Tích hợp các thuật toán Học sâu tiên tiến (Deep Learning như CNN, LSTM) thông qua các khung tích hợp như TensorFlowOnSpark hoặc BigDL để trích xuất đặc trưng không gian và thời gian của lưu lượng mạng.
  • Nghiên cứu cơ chế phòng chống tấn công đối kháng (Adversarial Machine Learning) nhằm ngăn chặn tin tặc cố tình làm sai lệch mô hình phân loại.

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

+-------------------------------------------------------------------------------+
|                           ĐỐI TƯỢNG HƯỞNG LỢI                                 |
+-----------------------------------+-------------------------------------------+
| 🎓 Sinh viên / Học viên           | 💻 Kỹ sư / Lập trình viên Data/AI         |
| - Tài liệu mẫu chuẩn mực về Big   | - Pipeline code mẫu PySpark MLlib         |
|   Data Analytics & An toàn thông  |   hoàn chỉnh, chuẩn công nghiệp           |
|   tin                             | - Kinh nghiệm xử lý Data Skew & Partition |
| - Phương pháp luận NIDS khoa học  |   trên Spark                              |
+-----------------------------------+-------------------------------------------+
| 🏢 Doanh nghiệp / Khối SOC        | 🔬 Nhà nghiên cứu An ninh mạng            |
| - Kiến trúc mẫu NIDS phân tán     | - Cơ sở đối chuẩn (Benchmark) khoa học    |
|   chi phí thấp, mở rộng linh hoạt |   cho các thuật toán học máy trên NSL-KDD |
| - Giảm tải áp lực cảnh báo rác    | - Phương pháp trích chọn đặc trưng AR mới |
+-----------------------------------+-------------------------------------------+

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

1. Yêu cầu kỹ thuật cốt lõi để triển khai hệ thống NIDS trên Spark là gì?

Hệ thống yêu cầu cài đặt cụm Apache Spark (phiên bản 2.4.x hoặc 3.x trở lên), Java JDK 8/11, Python 3.7+ cùng các thư viện bổ trợ (pyspark, numpy). Đối với môi trường phân tán hoàn chỉnh, cần cấu hình hệ thống quản lý tài nguyên như Hadoop YARN hoặc Spark Standalone Cluster cùng hệ thống lưu trữ phân tán HDFS.

2. Hệ thống xử lý thế nào khi lượng dữ liệu mạng tăng đột biến (Scalability Limits)?

Nhờ kiến trúc Scale-out của Apache Spark, khi lưu lượng mạng tăng, quản trị viên chỉ cần bổ sung thêm các Worker Node vào cụm. Trình điều phối DAG Scheduler sẽ tự động phân chia các DataFrame thành nhiều Partition tương ứng và điều phối các Executor thực thi song song mà không cần viết lại mã nguồn.

3. Làm thế nào để tích hợp mô hình Spark MLlib này vào hệ sinh thái an ninh mạng sẵn có?

Sau khi tìm được mô hình tối ưu (ví dụ Random Forest numTrees=600), mô hình được lưu trữ dưới dạng định dạng chuẩn (Spark ML Pipeline Model). Module phân loại có thể đóng gói thành một vi dịch vụ (Microservice) giao tiếp qua REST API hoặc đọc trực tiếp các thông điệp gói tin từ hàng đợi Apache Kafka để phân tích và gửi cảnh báo vào SIEM (như Splunk hoặc Elastic Security).

4. Chi phí bảo trì và tái huấn luyện (Retraining) hệ thống được thực hiện ra sao?

Hệ thống cho phép thiết lập các luồng làm việc tự động (Cron job/Airflow) để định kỳ thu thập nhật ký lưu lượng mới, thực hiện tiền xử lý và tái huấn luyện mô hình (Model Retraining) phân tán ngoài giờ cao điểm, đảm bảo mô hình luôn thích ứng với các mối đe dọa mới mà không gây gián đoạn hệ thống giám sát.

5. Tại sao thuật toán Random Forest lại đạt hiệu năng vượt trội hơn so với SVM và Neural Network trong bài toán này?

Dữ liệu lưu lượng mạng NSL-KDD sau khi One-Hot Encoding chứa nhiều đặc trưng dạng nhị phân và phân loại rời rạc. Random Forest là mô hình kết hợp (Ensemble Learning) gồm nhiều cây quyết định, có khả năng xử lý xuất sắc các mối quan hệ phi tuyến, dữ liệu phân loại rời rạc và kháng nhiễu tốt mà không yêu cầu chuẩn hóa thang đo khắt khe như SVM hay Gradient Descent của Neural Network.

Kết luận

Đồ án đã nghiên cứu và ứng dụng thành công hệ sinh thái tính toán phân tán Apache Spark vào bài toán phát hiện xâm nhập mạng (NIDS), giải quyết trọn vẹn điểm nghẽn về hiệu năng xử lý dữ liệu lớn trong an toàn thông tin. Thông qua việc áp dụng tập dữ liệu chuẩn NSL-KDD, kết hợp kỹ thuật mã hóa One-Hot Encoding, phương pháp trích chọn đặc trưng Attribute Ratio (AR) và tối ưu hóa siêu tham số bằng Grid Search với 5-Fold Cross-Validation, nghiên cứu đã chứng minh thuật toán Random Forest (với cấu hình numTrees=600) đạt hiệu quả tối ưu nhất với độ chính xác 81.45% trên tập kiểm thử chứa các mẫu tấn công chưa từng biết, tỷ lệ báo động giả thấp chỉ 3.12%.

Kết quả của đề tài không chỉ cung cấp một khung giải pháp kỹ thuật có tính ứng dụng cao cho các trung tâm giám sát an ninh mạng (SOC) mà còn mở ra nền tảng vững chắc cho việc phát triển các hệ thống phòng thủ mạng thông minh, tự động và có khả năng mở rộng linh hoạt trong tương lai.