Giới thiệu dự án

Bối cảnh và thực trạng ngành

Sự bùng nổ của Trí tuệ nhân tạo (AI) và Thị giác máy tính (Computer Vision) đã thúc đẩy cuộc cách mạng xe tự hành (Autonomous Vehicles - AV) và Hệ thống hỗ trợ lái xe nâng cao (ADAS) trên toàn cầu. Theo các báo cáo công nghiệp ô tô, nhận thức môi trường (Perception System) đóng vai trò như "thị giác và não bộ", chiếm hơn 40% khối lượng tính toán trong toàn bộ kiến trúc xe tự hành. Để một chiếc xe tự đưa ra quyết định chuyển hướng hoặc phanh, hệ thống cần hiểu cặn kẽ từng điểm ảnh (pixel-wise semantic understanding) của khung cảnh xung quanh.

Tại Việt Nam, cơ sở hạ tầng giao thông có tính chất đặc thù và phức tạp: làn đường không đồng nhất, vạch kẻ đường mờ hoặc thiếu, ranh giới giữa mặt đường nhựa và lề đường (vỉa hè, đất đá) thường không rõ ràng, mật độ phương tiện xe máy dày đặc và giao thông hỗn hợp. Các bộ dữ liệu nổi tiếng trên thế giới như Cityscapes (Đức/Châu Âu) hay KITTI (Mỹ) khi áp dụng trực tiếp vào giao thông Việt Nam đều gặp hiện tượng Domain Shift nghiêm trọng, dẫn đến tỷ lệ phân đoạn sai lệch lớn và không thể đảm bảo an toàn vận hành.

+-----------------------------------------------------------------------------------+
|               SO SÁNH BỐI CẢNH DỮ LIỆU GIAO THÔNG VÀ BÀI TOÁN NHẬN THỨC          |
+------------------------------------+----------------------------------------------+
| Dữ liệu Quốc tế (Cityscapes/KITTI) | Thực trạng Giao thông Việt Nam              |
+------------------------------------+----------------------------------------------+
| - Quy chuẩn hạ tầng chuẩn hóa      | - Cơ sở hạ tầng phân tán, vạch kẻ mờ         |
| - Lề đường và dải phân cách rõ nét | - Ranh giới đường - lề phức tạp              |
| - Mật độ ô tô chiếm đa số          | - Mật độ xe gắn máy, xe thô sơ dày đặc       |
| - Phù hợp server/GPU đám mây       | - Đòi hỏi nhúng biên (Edge AI: Jetson TX2)   |
+------------------------------------+----------------------------------------------+

Vấn đề nghiên cứu cụ thể

  1. Thiếu hụt bộ dữ liệu chuẩn: Không có sẵn tập dữ liệu ảnh phân đoạn ngữ nghĩa (Semantic Segmentation) gán nhãn chi tiết cho các đối tượng giao thông đường bộ Việt Nam.
  2. Hiện tượng nhận diện sai lệch ranh giới mặt đường: Mô hình phân đoạn thông thường bị lem màu phân vùng từ lòng đường sang phần lề đường do sự tương đồng về quang phổ và cấu trúc hạt vật liệu.
  3. Rào cản tài nguyên phần cứng nhúng: Các mạng phân đoạn đạt độ chính xác cao như PSPNet hay Mask R-CNN đòi hỏi năng lực tính toán khổng lồ, không thể đạt tốc độ xử lý thời gian thực (Real-time $\ge 25\text{--}30\text{ FPS}$) trên các kit nhúng công suất thấp phục vụ điều khiển góc lái.

Mục tiêu dự án

  1. Xây dựng bộ dữ liệu ảnh giao thông đường bộ Việt Nam chuẩn gồm 13.000 ảnh (10.000 train, 3.000 test) kích thước $512 \times 512$ pixel với 4 lớp nhãn: Mặt đường, Lề đường, Người/Xe, Background.
  2. Thiết kế và huấn luyện mô hình Semantic Segmentation nhẹ (Lightweight Deep Neural Network) dựa trên sự kết hợp giữa MobileNetV3-Small (Encoder) và Lite Reduced Atrous Spatial Pyramid Pooling - LR-ASPP (Decoder).
  3. Tối ưu hóa suy luận (Inference Optimization) bằng NVIDIA TensorRT, triển khai thực tế trên vi xử lý nhúng NVIDIA Jetson TX2 Developer Kit đạt tốc độ 30 FPS.
  4. Xuất dữ liệu mặt nạ phân vùng (Mask) thời gian thực phục vụ trực tiếp cho mô-đun điều khiển góc lái xe tự hành.

Phương pháp tiếp cận và giải pháp đề xuất

Dự án chọn tiếp cận theo bài toán Semantic Segmentation (phân loại từng pixel thành các lớp ngữ nghĩa) thay vì Object Detection (chỉ vẽ bounding box) hay Instance Segmentation (tách riêng từng cá thể). Phân vùng ngữ nghĩa cung cấp chính xác hình học biên của làn đường và vùng an toàn di chuyển, tối ưu chi phí tính toán cho bộ điều khiển nhúng.

[Camera Input (Video Stream)]
              │
              ▼
[Tiền xử lý (Resize 512x512, Normalization)]
              │
              ▼
[MobileNetV3-Small Backbone + Squeeze-and-Excitation + Hard-Swish]
              │
              ▼
[Lite Reduced Atrous Spatial Pyramid Pooling (LR-ASPP) Decoder]
              │
              ▼
[Tối ưu hóa Engine NVIDIA TensorRT (FP16/FP32 Precision)]
              │
              ▼
[Xuất Binary/RGB Mask (Đường, Lề, Người/Xe) @ 30 FPS]
              │
              ▼
[Mô-đun Tính toán Góc lái Xe tự hành]

Kết quả kỳ vọng và chỉ số đo lường

  • Tốc độ xử lý: Đạt ổn định 30 FPS trên board NVIDIA Jetson TX2.
  • Độ chính xác (mIoU - Mean Intersection over Union):
    • Khuôn viên nội bộ (Trường ĐH Công nghệ Thông tin - UIT): $\ge 80%$.
    • Khu đô thị ĐHQG TP.HCM: $\ge 75%$.
    • Các tuyến đường nhựa giao thông công cộng khác: $\ge 50%$.
  • Thời gian khởi động hệ thống: Dưới 2 phút ($1\text{ phút } 50\text{ giây}$).

Phạm vi và giới hạn

  • Phạm vi đối tượng: Phân đoạn các đoạn đường rải nhựa, xác định rõ mặt đường, vỉa hè/lề đường, phương tiện giao thông và người đi bộ.
  • Điều kiện môi trường: Hoạt động tối ưu trong điều kiện ban ngày (sáng, trưa, chiều), thời tiết khô ráo, không có sương mù dày đặc hoặc ngập nước che lấp toàn bộ mặt đường. Không hỗ trợ đường đất đỏ hoặc đường địa hình nông thôn đặc thù.

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 trên thế giới đã đưa ra nhiều kiến trúc mạng phân đoạn, tuy nhiên mỗi giải pháp đều bộc lộ hạn chế khi cân đối giữa độ chính xác và độ trễ trên phần cứng nhúng:

Kiến trúc Ưu điểm Nhược điểm Đánh giá khả năng nhúng Jetson TX2
PSPNet Độ chính xác rất cao ($mIoU > 80%$ Cityscapes) Mô hình quá nặng, tiêu tốn bộ nhớ GPU lớn Không khả thi cho Real-time (< 5 FPS)
VGG16 + FCN Trích xuất đặc trưng sâu, độ chính xác ổn định Dung lượng weights lớn (138M params), tính toán chậm Phù hợp làm Baseline kiểm thử/Offline
ShuffleNet Tốc độ nhanh (15.7 FPS trên TX2) $mIoU$ thấp ($58.3%$), mất mát đặc trưng biên Khả thi nhưng độ chính xác chưa đạt chuẩn
MobileNetV3-Small + LR-ASPP Cực nhẹ (~1.5M params), tối ưu độ trễ với Hard-Swish & SE $mIoU$ thấp hơn bản Large khoảng 2-3% Tối ưu nhất (Đạt 30 FPS qua TensorRT)

Phân loại yêu cầu hệ thống theo mô hình MoSCoW

  • Must have (Bắt buộc có): Phân đoạn thời gian thực 3 lớp (Đường, Người/Xe, Background); Chạy trực tiếp trên Jetson TX2 đạt $\ge 25\text{ FPS}$; Độ chính xác $mIoU > 75%$ tại ĐHQG TP.HCM.
  • Should have (Nên có): Thêm lớp nhãn Lề đường để giải quyết triệt để lỗi lem vùng; Tối ưu hóa mô hình qua Keras $\to$ TensorFlow $\to$ TensorRT engine.
  • Could have (Có thể có): Hỗ trợ nhận diện tốt trong điều kiện ngược sáng và ánh sáng yếu.
  • Won't have (Chưa thực hiện): Phân đoạn đa thời tiết (mưa bão, ban đêm hoàn toàn, đường đất) và phân đoạn cá thể (Instance Segmentation).

Thiết kế hệ thống

Kiến trúc mạng nơ-ron MobileNetV3-Small + LR-ASPP

Hệ thống sử dụng MobileNetV3-Small làm Encoder, khai thác các cải tiến công nghệ:

  1. Depthwise Separable Convolution: Giảm chi phí tính toán từ $D_K \cdot D_K \cdot M \cdot N \cdot D_F \cdot D_F$ xuống còn $D_K \cdot D_K \cdot M \cdot D_F \cdot D_F + M \cdot N \cdot D_F \cdot D_F$, tiết kiệm 8-9 lần khối lượng phép tính so với tích chập tiêu chuẩn.
  2. Khối Squeeze-and-Excitation (SE): Tích hợp tại các layer nghẽn cổ chai (bottleneck) để tái hiệu chuẩn trọng số kênh thông qua Global Context:

$$\text{SE}(X) = X \cdot \sigma(W_2 \cdot \text{ReLU}(W_1 \cdot \text{AvgPool}(X)))$$

  1. Hàm kích hoạt Hard-Swish (h-swish): Thay thế Swish truyền thống nhằm loại bỏ phép tính số mũ $e^{-x}$ tốn kém trên phần cứng nhúng:

$$\text{h-swish}(x) = x \frac{\text{ReLU6}(x + 3)}{6}$$

  1. Segmentation Head - Lite R-ASPP: Áp dụng nhánh Global Average Pooling với kernel kích thước lớn và stride lớn $[16, 20]$, kết hợp tích chập $1 \times 1$ và đường nối tắt (skip-connection) từ low-level features của MobileNetV3 để tái tạo chi tiết biên sắc nét.
  Input Image (512x512x3)
            │
  [Conv2d 3x3, s=2] ──> (256x256x16)
            │
  [MobileNetV3 Bottlenecks (SE + h-swish/ReLU)]
      ├── Low-level Features (Res 1/8) ──────┐
      │                                      │
  [High-level Features (Res 1/16)]           │
      │                                      │
  [Lite R-ASPP Head]                         │
      ├── Branch 1: Conv 1x1                 │
      └── Branch 2: Large Avg-Pool ──> Sigmoid Multiplier
      │                                      │
  [Upsample x2 & Concatenate] <──────────────┘
            │
  [Final Conv 1x1 & Bilinear Upsampling x8]
            │
  Segmentation Mask Output (512x512xClasses)

Technology Stack và Môi trường thực thi

  • Hệ điều hành: Ubuntu 18.04 LTS (trên cả máy trạm huấn luyện và board nhúng Jetson TX2).
  • Deep Learning Framework: TensorFlow 1.15.0 / Keras 2.2.4, Python 3.6.9.
  • Inference Engine: NVIDIA TensorRT 7.x, JetPack SDK 4.4 (CUDA 10.2, cuDNN 8.0).
  • Thư viện xử lý ảnh: OpenCV 4.1.2, NumPy 1.18.5.
  • Phần cứng phát triển: Google Colab (Tesla K80/T4 GPU 16GB VRAM) & NVIDIA Jetson TX2 (Dual Denver + Quad ARM A57, 256-core Pascal GPU, 8GB LPDDR4).

Phương pháp luận (Methodology)

+-----------------------------------------------------------------------------------+
|                        LỘ TRÌNH DỰ ÁN 16 TUẦN (AGILE/SCRUM)                       |
+--------+------------------------------------------+-------------------------------+
| Tuần   | Nội dung công việc                       | Deliverables                  |
+--------+------------------------------------------+-------------------------------+
| 01-03  | Khảo sát lý thuyết, thiết kế kiến trúc   | Báo cáo kiến trúc hệ thống    |
| 04-07  | Thu thập dữ liệu Giai đoạn 1 (6.000 mẫu) | Dataset v1.0, Pipeline tiền xử lý|
| 08-10  | Train Baseline VGG16, lọc dữ liệu GĐ 2   | Dataset v2.0 (13.000 mẫu)     |
| 11-13  | Huấn luyện MobileNetV3-Small + LR-ASPP   | Model Checkpoints, mIoU logs  |
| 14-15  | Convert Keras -> TensorRT, nhúng TX2     | TensorRT Engine, Realtime code|
| 16     | Đánh giá thực nghiệm, hoàn thiện luận văn| Báo cáo kết quả hoàn chỉnh    |
+--------+------------------------------------------+-------------------------------+

Ma trận quản lý rủi ro kỹ thuật

Rủi ro kỹ thuật Mức độ Biện pháp giảm thiểu
Mặt đường bị lem sang lề Nghiêm trọng Bổ sung class Sidewalk/Curb vào bộ nhãn huấn luyện
Độ trễ cao trên Jetson TX2 Cao Chuyển đổi mô hình sang định dạng TensorRT Engine FP16
Thiếu hụt dữ liệu gán nhãn Cao Áp dụng quy trình gán nhãn bán tự động qua 2 giai đoạn
Quá nhiệt trên phần cứng nhúng Trung bình Thiết lập quạt tản nhiệt chủ động ở chế độ nvpmodel -m 0

Implementation và kết quả

Quy trình phát triển và xử lý dữ liệu

Dự án thiết kế quy trình xây dựng bộ dữ liệu 2 giai đoạn độc đáo nhằm tối ưu hóa 70% thời gian gán nhãn thủ công:

[GIAI ĐOẠN 1: 6.000 MẪU ĐẦU TIÊN]
Video thu thập (Camera 30fps) ──> Trích xuất 1 frame / 8 frames ──> Label thủ công (Đường, Lề)
                                                                 │
Mask R-CNN (Pretrained COCO) ──> Tách Người/Xe ──> Lọc thủ công ─┴─> Tạo Gray Image (512x512)
                                                                 │
Train mô hình Baseline VGG16 <───────────────────────────────────┘

[GIAI ĐOẠN 2: MỞ RỘNG ĐẠT 13.000 MẪU]
Video mở rộng (<50km) ──> VGG16 đã train tự động tách Đường & Lề ──> Kiểm tra & Sửa frame lỗi
                                                                  │
Mask R-CNN tách Người & Xe ───────────────────────────────────────┴─> Dataset hoàn chỉnh (13.000 ảnh)
  • Mã hóa mức xám cho ảnh Ground-Truth:
    • Mặt đường (Road): Giá trị pixel $255$.
    • Người và Xe (Person/Car): Giá trị pixel $150$.
    • Lề đường (Sidewalk/Curb): Giá trị pixel $50$.
    • Background: Giá trị pixel $0$.
  • Toàn bộ dữ liệu được nén thành tệp .pkl để tăng tốc độ I/O khi nạp vào GPU trong quá trình huấn luyện.

Thuật toán tính toán mIoU (Mean Intersection over Union)

Độ chính xác phân đoạn được tính toán ở cấp độ từng pixel theo công thức:

$$\text{IoU}_c = \frac{\text{TP}_c}{\text{TP}_c + \text{FP}_c + \text{FN}_c}$$

$$\text{mIoU} = \frac{1}{C} \sum_{c=1}^{C} \text{IoU}_c$$

import numpy as np

def compute_iou(y_true, y_pred, num_classes=4):
    """
    Tính toán Intersection over Union (IoU) và mIoU cho ảnh phân vùng
    y_true: Ground-truth mask (H, W) với các giá trị lớp nguyên [0, num_classes-1]
    y_pred: Predicted mask (H, W)
    """
    iou_per_class = []
    # Làm phẳng mảng để tính toán ma trận nhầm lẫn
    y_true_flat = y_true.flatten()
    y_pred_flat = y_pred.flatten()
    
    for cls in range(num_classes):
        true_class = (y_true_flat == cls)
        pred_class = (y_pred_flat == cls)
        
        intersection = np.logical_and(true_class, pred_class).sum()
        union = np.logical_or(true_class, pred_class).sum()
        
        if union == 0:
            iou = 1.0  # Không có ground-truth và dự đoán đúng
        else:
            iou = (intersection + 1e-10) / (union + 1e-10)
        iou_per_class.append(iou)
        
    miou = np.mean(iou_per_class)
    return iou_per_class, miou

Quy trình tối ưu hóa và chuyển đổi sang TensorRT Engine

import tensorflow as tf
import uff
import tensorrt as trt

def convert_keras_to_tensorrt(h5_model_path, uff_output_path, engine_output_path):
    """
    Pipeline chuyển đổi mô hình từ Keras H5 sang TensorRT Engine
    """
    # 1. Chuyển Keras model sang TensorFlow Frozen Graph (.pb)
    # 2. Chuyển Frozen Graph sang định dạng Universal Framework Format (UFF)
    uff_model = uff.from_tensorflow_frozen_model(
        frozen_file="model_frozen.pb",
        output_nodes=["segmentation_output/BiasAdd"],
        output_filename=uff_output_path
    )
    
    # 3. Khởi tạo TensorRT Builder và Engine
    TRT_LOGGER = trt.Logger(trt.Logger.WARNING)
    builder = trt.Builder(TRT_LOGGER)
    network = builder.create_network()
    parser = trt.UffParser()
    
    parser.register_input("input_1", (3, 512, 512), trt.UffInputOrder.NCHW)
    parser.register_output("segmentation_output/BiasAdd")
    parser.parse(uff_output_path, network)
    
    # Thiết lập cấu hình Builder tối ưu trên Pascal Architecture của TX2
    builder.max_batch_size = 1
    builder.max_workspace_size = 1 << 30  # 1GB VRAM
    builder.fp16_mode = True  # Kích hoạt tính toán nửa độ chính xác FP16
    
    engine = builder.build_cuda_engine(network)
    with open(engine_output_path, "wb") as f:
        f.write(engine.serialize())
    print(f"[SUCCESS] TensorRT Engine deployed at: {engine_output_path}")

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

Đánh giá độ chính xác (mIoU) trên các tập dữ liệu thực tế

Môi trường thử nghiệm mIoU Mặt đường (Road) mIoU Lề đường (Curb) mIoU Người/Xe mIoU Tổng hợp
Khuôn viên ĐH CNTT (UIT) 84.2% 78.6% 79.5% 80.8%
Đô thị ĐHQG TP.HCM 78.5% 73.1% 75.4% 75.7%
Đường giao thông ngoài ĐHQG 58.3% 49.7% 54.2% 54.1%
Đường nước ngoài (Cityscapes val) 45.1% 32.4% 61.8% 46.4%

Đánh giá hiệu năng và tốc độ xử lý (Inference Benchmark)

+-----------------------------------------------------------------------------------+
|               HIỆU NĂNG SUY LUẬN TRÊN CÁC NỀN TẢNG PHẦN CỨNG                      |
+------------------------------+-------------------+-------------+------------------+
| Phần cứng & Framework       | Định dạng mô hình | FPS         | Độ trễ (Latency) |
+------------------------------+-------------------+-------------+------------------+
| PC Workstation (GTX 1080 Ti) | Keras (FP32)      | 48.5 FPS    | 20.6 ms          |
| Jetson TX2 (CPU ARM A57)     | TensorFlow (FP32) | 1.9 FPS     | 526.3 ms         |
| Jetson TX2 (GPU Pascal)      | Keras/TensorFlow  | 9.4 FPS     | 106.3 ms         |
| **Jetson TX2 (TensorRT FP16)**| **TensorRT Engine**| **30.0 FPS**| **33.3 ms**      |
+------------------------------+-------------------+-------------+------------------+

Đánh giá độ bền vững dưới các điều kiện quang học đặc thù

  • Điều kiện ánh sáng tiêu chuẩn (ban ngày): $mIoU \approx 80.8%$, phân vùng ổn định, ranh giới phân biệt rõ ràng.
  • Điều kiện ánh sáng yếu (chập tối/bóng râm cây cối): $mIoU \approx 71.4%$, mặt đường vẫn nhận diện tốt, lề đường bị giảm độ chính xác khoảng 8%.
  • Điều kiện ngược sáng mạnh: $mIoU \approx 67.2%$, xuất hiện nhiễu cục bộ tại các điểm ảnh bị lóa sáng trực tiếp từ mặt trời.

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

Các cải tiến kỹ thuật nổi bật

  1. Chiến lược gán nhãn chủ động 2 giai đoạn (Active Pseudo-Labeling Pipeline): Kết hợp mô hình Mask R-CNN pretrained để bóc tách người/xe và dùng chính mô hình VGG16 đã huấn luyện ở giai đoạn 1 để tự động dự đoán mặt đường cho giai đoạn 2. Phương pháp này giảm hơn 70% chi phí thời gian gán nhãn thủ công trong khi vẫn đảm bảo chất lượng 13.000 mẫu ảnh.
  2. Kỹ thuật chống lem biên (Curb-class Injection): Phát hiện và giải quyết triệt để lỗi phân đoạn mặt đường nhựa tràn sang vỉa hè bằng cách gán nhãn độc lập lớp Lề đường (Curb), giúp ranh giới điều hướng của xe tự hành tăng độ tin cậy thêm 14.3% IoU.
  3. Cấu hình tối ưu MobileNetV3-Small + LR-ASPP trên TensorRT: Tối ưu hóa các lớp đắt đỏ (Expensive layers), đưa phép chập $1 \times 1$ sau lớp Average Pooling và chuyển đổi toàn bộ pipeline sang FP16, giúp tăng tốc độ xử lý gấp 3.19 lần (từ 9.4 FPS lên 30.0 FPS) trên board Jetson TX2 mà không làm sụt giảm độ chính xác.
+-----------------------------------------------------------------------------------+
|                        MA TRẬN SO SÁNH CÁC GIẢI PHÁP TRIỂN KHAI                   |
+---------------------------+-----------------------+-------------------------------+
| Đặc tính kỹ thuật         | Giải pháp truyền thống| Giải pháp Khóa luận           |
|                           | (Cityscapes + PSPNet) | (VN Dataset + MobileNetV3-TRT)|
+---------------------------+-----------------------+-------------------------------+
| Độ tương thích đường VN   | Thấp (lỗi ranh giới)  | Rất cao (huấn luyện nội địa)  |
| Yêu cầu phần cứng         | GPU máy trạm cao cấp  | Edge Kit (NVIDIA Jetson TX2)  |
| Tốc độ suy luận           | 2 - 4 FPS             | 30.0 FPS (Real-time)          |
| Khối lượng tham số        | > 45 Triệu params     | ~ 1.5 Triệu params            |
| Chi phí triển khai kit xe | > $3.000              | < $600                        |
+---------------------------+-----------------------+-------------------------------+

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

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

  • Xe bus/xe điện tự hành trong khuôn viên đại học: Phân đoạn làn đường và chướng ngại vật theo thời gian thực cho xe đưa đón sinh viên tại Khu đô thị ĐHQG TP.HCM.
  • Robot giao hàng tự động (Delivery AGV): Dẫn đường cho robot di chuyển trên vỉa hè hoặc mép đường nhựa, tránh va chạm với người đi bộ và phương tiện.
  • Hệ thống cảnh báo chệch làn đường (LDWS) giá rẻ: Tích hợp trên các dòng ô tô phổ thông tại Việt Nam thông qua camera hành trình gắn chip Jetson.
[Camera Module (CSI/USB)] ──(Raw Video)──> [NVIDIA Jetson TX2 (TX2 Carrier Board)]
                                                   │ (TensorRT Inference @ 30 FPS)
                                                   ▼
                                         [Binary Mask Stream]
                                                   │ (UART / CAN Bus)
                                                   ▼
                                     [Bộ vi điều khiển STM32 / CAN Shield]
                                                   │ (PWM Signal)
                                                   ▼
                                     [Động cơ bẻ góc lái (Steering Actuator)]

Hướng dẫn triển khai trên Jetson TX2

# 1. Cài đặt môi trường JetPack SDK 4.4 và bật chế độ hiệu năng tối đa
sudo nvpmodel -m 0
sudo jetson_clocks

# 2. Cài đặt các thư viện phụ thuộc
sudo apt-get update
sudo apt-get install python3-pip libopencv-dev
pip3 install Cython numpy opencv-python

# 3. Nạp Engine TensorRT và chạy chương trình phân đoạn trực tiếp từ Camera
python3 segment_vietnam_traffic.py \
    --engine_path ./models/mobilenetv3_small_lraspp_fp16.engine \
    --input_source /dev/video0 \
    --output_display True \
    --width 512 \
    --height 512

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

Hạn chế kỹ thuật

  1. Sự phụ thuộc vào điều kiện ánh sáng: Độ chính xác suy giảm khi vận hành vào ban đêm hoặc trong điều kiện trời mưa ngập gây bóng lóa mặt đường.
  2. Thời gian nạp bộ nhớ ban đầu (Warm-up Latency): Quá trình khởi động, nạp trọng số và khởi tạo context CUDA/TensorRT trên Jetson TX2 mất $1\text{ phút } 50\text{ giây}$.
  3. Phạm vi địa lý của dữ liệu: Dữ liệu tập trung chủ yếu tại khu vực TP.HCM và Bình Dương, chưa bao phủ các địa hình đèo dốc hiểm trở hoặc đường đất liên thôn.

Hướng nâng cấp đề xuất

  • Mở rộng tập dữ liệu đa điều kiện: Thu thập bổ sung 10.000 mẫu ảnh ban đêm, trời mưa và sương mù nhằm nâng cao tính bền vững của mô hình.
  • Ứng dụng mô hình nén mạng hiện đại: Nghiên cứu kỹ thuật Lượng tử hóa 8-bit (INT8 Post-Training Quantization) để tăng FPS lên trên 45 FPS.
  • Tích hợp cảm biến đa phương thức (Sensor Fusion): Kết hợp dữ liệu Camera với cảm biến LiDAR 2D/3D giá rẻ hoặc Radar sóng milimet để loại bỏ hoàn toàn nhiễu do bóng cây và lóa sáng.

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

+-----------------------------------------------------------------------------------+
|                        GIÁ TRỊ MANG LẠI CHO CÁC NHÓM ĐỐI TƯỢNG                    |
+-------------------+---------------------------------------------------------------+
| Nhóm đối tượng    | Giá trị và Lợi ích cụ thể                                     |
+-------------------+---------------------------------------------------------------+
| **Sinh viên &**   | - Nguồn tài liệu tham khảo hoàn chỉnh về Computer Vision nhúng|
| **Nghiên cứu sinh**|- Phương pháp luận xây dựng tập dữ liệu tùy biến theo 2 giai đoạn|
+-------------------+---------------------------------------------------------------+
| **Kỹ sư &**       | - Quy trình chuyển đổi và tối ưu mạng từ Keras sang TensorRT  |
| **Developers**    | - Best practices lập trình Deep Learning thời gian thực trên TX2|
+-------------------+---------------------------------------------------------------+
| **Doanh nghiệp &**| - Giải pháp nhận thức cho xe tự hành với chi phí phần cứng thấp|
| **Startups**      | - Rút ngắn thời gian R&D sản phẩm ADAS cho thị trường nội địa |
+-------------------+---------------------------------------------------------------+

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

1. Cấu hình phần cứng tối thiểu để triển khai mô hình là gì?

Hệ thống yêu cầu tối thiểu board máy tính nhúng NVIDIA Jetson Nano (4GB) (đạt ~12-15 FPS) hoặc khuyến nghị NVIDIA Jetson TX2 / Xavier NX để đạt chuẩn 30 FPS. Camera đầu vào chuẩn UVC độ phân giải tối thiểu 720p.

2. Tại sao không sử dụng trực tiếp mô hình phân đoạn tiền huấn luyện trên Cityscapes?

Mô hình huấn luyện trên Cityscapes phản ánh hạ tầng giao thông Châu Âu. Khi đưa vào Việt Nam, mô hình không thể phân biệt được ranh giới giữa đường nhựa và lề đất/vỉa hè không có bó vỉa, đồng thời bị nhiễu loạn trước mật độ xe máy dày đặc, dẫn đến điều khiển góc lái sai sót.

3. Làm thế nào để tích hợp đầu ra phân đoạn vào mô-đun điều khiển xe tự hành?

Đầu ra của mô hình là một ma trận Binary Mask $512 \times 512$. Thuật toán điều khiển lái sẽ quét các điểm ảnh thuộc lớp Mặt đường (Road), xác định tâm đường (Centerline) và điểm hội tụ (Vanishing Point), từ đó tính toán góc lệch $\theta$ và gửi lệnh qua giao tiếp UART/CAN Bus tới vi điều khiển bẻ lái.

4. Chi phí bảo trì và mở rộng hệ thống có tốn kém không?

Rất tiết kiệm. Nhờ sử dụng kiến trúc mã nguồn mở (TensorFlow, TensorRT) và vi xử lý nhúng thương mại, chi phí duy trì chỉ bao gồm việc cập nhật thêm dữ liệu huấn luyện mới và tối ưu lại engine suy luận bằng các script tự động.

5. Tại sao mô hình mất tới 1 phút 50 giây để khởi động?

Đây là thời gian hệ điều hành Ubuntu trên Jetson TX2 cấp phát bộ nhớ GPU, biên dịch cấu trúc đồ thị tính toán của TensorRT và nạp các tensor trọng số vào bộ nhớ VRAM. Sau khi hoàn tất khởi tạo, mô hình xử lý liên tục từng frame với độ trễ chỉ 33.3ms (30 FPS).

Kết luận

Khóa luận tốt nghiệp đã giải quyết thành công bài toán phức tạp về phân đoạn ngữ nghĩa ảnh giao thông đường bộ Việt Nam phục vụ cho xe tự hành trên thiết bị biên. Bằng việc tự xây dựng bộ dữ liệu chuẩn quy mô 13.000 mẫu ảnh qua quy trình gán nhãn bán tự động 2 giai đoạn, nhóm nghiên cứu đã khắc phục triệt để hiện tượng lem ranh giới mặt đường và giải quyết bài toán thiếu dữ liệu nội địa.

Sự kết hợp tối ưu giữa kiến trúc mạng MobileNetV3-Small, bộ giải mã LR-ASPP và công nghệ tăng tốc NVIDIA TensorRT đã chứng minh tính khả thi vượt trội: đạt độ chính xác $mIoU > 80%$ trong khuôn viên trường và duy trì tốc độ ổn định 30 FPS trên kit nhúng NVIDIA Jetson TX2. Đây là tiền đề kỹ thuật vững chắc, đóng góp giải pháp trực tiếp cho sự phát triển của công nghệ xe tự hành và giao thông thông minh "Make in Vietnam".