Giới thiệu dự án

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

Ngành công nghiệp xe tự hành (Autonomous Vehicles - AV) đang trải qua bước chuyển mình mạnh mẽ với sự tham gia của các tập đoàn công nghệ hàng đầu như Tesla, Waymo, Baidu và các nhà sản xuất xe truyền thống (Toyota, Nissan). Theo các báo cáo thống kê giao thông quốc tế, hơn 90% các vụ tai nạn giao thông bắt nguồn từ lỗi chủ quan của con người. Việc tích hợp hệ thống trí tuệ nhân tạo (AI) và thị giác máy tính vào xe tự hành là chìa khóa then chốt nhằm giảm thiểu rủi ro va chạm, tối ưu hóa lưu lượng giao thông và vận hành các dịch vụ Robotaxi thương mại.

Hệ thống nhận thức (Perception System) của xe tự hành yêu cầu xử lý đồng thời ba tác vụ thị giác cốt lõi:

  1. Phát hiện đối tượng (Object Detection): Định vị và phân loại các phương tiện, người đi bộ, chướng ngại vật trên đường.
  2. Phân đoạn khu vực lái xe (Drivable Area Segmentation): Xác định không gian an toàn mà phương tiện được phép di chuyển (Directly Drivable Area và Alternative Area).
  3. Phát hiện làn đường (Lane Detection): Nhận diện vạch kẻ đường để điều hướng và giữ làn (Lane Keeping Assist).
+-----------------------------------------------------------------------+
|                       HỆ THỐNG NHẬN THỨC XE TỰ HÀNH                  |
+-----------------------------------------------------------------------+
        |                                   |                    |
        v                                   v                    v
+-----------------------+   +-----------------------+   +---------------+
| Object Detection      |   | Drivable Area Seg.    |   | Lane Detection|
| (YOLOv7-tiny/v8n/v8s) |   | (TwinLiteNet - 0.4M)  |   | (TwinLiteNet) |
+-----------------------+   +-----------------------+   +---------------+

Vấn đề kỹ thuật (Problem Statement)

Mặc dù các mô hình học sâu hiện đại đạt độ chính xác rất cao, việc triển khai chúng trên các hệ thống nhúng biên (Edge AI Devices như NVIDIA Jetson TX2, Jetson AGX Xavier) gắn trên xe đối mặt với các nút thắt kỹ thuật nghiêm trọng:

  • Độ trễ suy luận (Inference Latency): Việc thực thi tuần tự (sequential execution) từng mô hình học sâu đơn nhiệm làm tăng tổng thời gian xử lý ($Latency_{total} = \sum Latency_{task}$), gây nguy hiểm khi xe vận hành ở tốc độ cao đòi hỏi phản xạ dưới $30\text{ms}$.
  • Tài nguyên tính toán cồng kềnh: Các mạng đa nhiệm nguyên khối (End-to-End Multi-task Networks) như YOLOP ($>91.9\text{M}$ tham số) hay HybridNets ($>31.8\text{M}$ tham số) tiêu tốn bộ nhớ VRAM lớn, khó tối ưu hóa và làm bão hòa năng lực tính toán của phần cứng nhúng công suất thấp ($<15\text{W}$).
  • Tối ưu hóa không đồng nhất: Khó cân bằng hàm mất mát (loss balancing) giữa các tác vụ phân loại hộp giới hạn (Bounding Box Regression) và phân đoạn ngữ nghĩa theo từng điểm ảnh (Pixel-wise Segmentation).

Mục tiêu dự án

  1. Nghiên cứu và tinh chỉnh các biến thể nhẹ của họ mô hình YOLO (YOLOv7-tiny, YOLOv8n, YOLOv8s) cho tác vụ phát hiện phương tiện giao thông trên tập dữ liệu chuẩn BDD100K.
  2. Thiết kế và phát triển mô hình TwinLiteNet – mạng phân đoạn ngữ nghĩa đa nhiệm siêu nhẹ chỉ với 0.4 triệu tham số (0.4M params) giải quyết đồng thời bài toán phân đoạn vùng lái và nhận diện làn đường.
  3. Xây dựng kiến trúc phần mềm đa tiến trình (Multiprocessing Architecture) với hàng đợi bất đồng bộ (Queue-based Pipeline), cho phép thực thi đồng thời cả hai mô hình trên GPU, loại bỏ thời gian chờ nhàn rỗi.
  4. Đánh giá thực nghiệm toàn diện trên thiết bị biên NVIDIA Jetson TX2 và Jetson Xavier dưới định dạng tăng tốc TensorRT FP16 về các chỉ số: FPS, Latency, FLOPs, độ chính xác (mAP, mIoU, IoU) và công suất tiêu thụ năng lượng (Watts).

Phương pháp tiếp cận và kết quả kỳ vọng

Dự án áp dụng phương pháp tiếp cận mô-đun hóa kết hợp thực thi song song: tách biệt mạng phát hiện vật thể và mạng phân đoạn, sau đó đồng bộ hóa qua kiến trúc đa tiến trình có định danh khung hình (Frame ID Tracking).

Chỉ số kỳ vọng Tác vụ Phát hiện đối tượng Tác vụ Vùng lái xe Tác vụ Làn đường
Mô hình YOLOv7-tiny / YOLOv8n / YOLOv8s TwinLiteNet TwinLiteNet
Số lượng tham số $3.2\text{M} - 11.2\text{M}$ $0.4\text{M}$ $0.4\text{M}$
Mục tiêu độ chính xác $\text{mAP}_{50} \ge 75%$ $\text{mIoU} \ge 90.0%$ $\text{IoU} \ge 26.0%$
Tốc độ trên Jetson $\ge 30\text{ FPS}$ $\ge 60\text{ FPS}$ $\ge 60\text{ FPS}$

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ước đây thường lựa chọn một trong hai hướng tiếp cận: mô hình đơn nhiệm chạy nối tiếp hoặc mô hình đa nhiệm dùng chung xương sống (Shared Backbone).

Tiêu chí Mô hình đơn nhiệm tuần tự (Sequential Single-task) Mô hình đa nhiệm nguyên khối (YOLOP / HybridNets) Giải pháp đề xuất (YOLO + TwinLiteNet Parallel)
Cơ chế hoạt động Chạy lần lượt từng mạng CNN Shared Backbone + Multi-Head Decoder Đa tiến trình song song 2 mạng siêu nhẹ
Kích thước mô hình Lớn (tổng dung lượng các mạng) Rất lớn ($31.8\text{M} - 91.9\text{M}$ tham số) Siêu nhẹ ($0.4\text{M}$ TwinLiteNet + $3.2\text{M}$ YOLOv8n)
Độ trễ suy luận Rất cao ($>160\text{ms}$ trên TX2) Trung bình - Cao Thấp ($<15\text{ms}$ trên Xavier TensorRT)
Tận dụng tài nguyên GPU Kém (GPU chờ CPU điều phối giữa các batch) Khá (dễ nghẽn cổ chai tính toán) Tối ưu (khai thác tối đa CUDA Cores đồng thời)
Độ linh hoạt khi nâng cấp Cao (thay đổi từng mô hình độc lập) Kém (phải huấn luyện lại toàn bộ mạng) Rất cao (thay thế độc lập YOLO hoặc TwinLiteNet)

Phân loại yêu cầu hệ thống (MoSCoW Prioritization)

  • Must-have (Bắt buộc): Xử lý thời gian thực ($\ge 30\text{ FPS}$ trên Jetson Xavier), tích hợp TensorRT FP16, nhận diện chính xác phương tiện, vùng lái và làn đường.
  • Should-have (Cần có): Đồng bộ hóa đa tiến trình không xung đột bộ nhớ qua Frame ID, mức tiêu thụ năng lượng $\le 15\text{W}$.
  • Could-have (Có thể mở rộng): Lượng tử hóa mô hình xuống INT8, hỗ trợ video đa camera đầu vào.
  • Won't-have (Chưa thực hiện): Tích hợp bản đồ độ sâu 3D Point Cloud từ cảm biến LiDAR.

Thiết kế hệ thống

flowchart TD
    A[Camera Input / Video Stream] --> B[Preprocessing Engine: Resize 640x384, Normalize, Tensor Conversion]
    B --> C[Assign Frame ID]
    C --> D[(Input Queue)]
    
    subgraph Process 1: Object Detection
        D -->|Fetch Frame| E[YOLO Engine: YOLOv7-tiny / YOLOv8n / YOLOv8s]
        E -->|TensorRT FP16 Inference| F[Format: ID, Model, BBox, Confidence, Class]
    end
    
    subgraph Process 2: Semantic Segmentation
        D -->|Fetch Frame| G[TwinLiteNet Engine: ESPNet-C + DAM]
        G -->|TensorRT FP16 Inference| H[Format: ID, Model, Lane Mask, Drivable Mask]
    end
    
    F --> I[(Output Queue)]
    H --> I
    
    I --> J[Data Synchronization & Post-Processing Module]
    J --> K[Vehicle Control / ADAS Actuation]

Ngăn xếp công nghệ (Technology Stack)

  • Framework học sâu: PyTorch v2.0.1 với CUDA 11.4 / 11.8.
  • Thư viện thị giác & xử lý ảnh: OpenCV v4.8.0, Albumentations v1.3.1.
  • Tăng tốc phần cứng: NVIDIA TensorRT v8.5.2, cuDNN v8.6.0.
  • Môi trường nhúng: NVIDIA JetPack v4.6 / v5.0 (Jetson Linux Driver Package).
  • Hệ thống điều phối: Python Multiprocessing (IPC Queue, Shared Memory).

Thiết kế cấu trúc dữ liệu đầu ra

Để đảm bảo tính nhất quán khi hai tiến trình hoàn thành ở thời điểm khác nhau, dữ liệu được đóng gói thành các cấu trúc chuẩn hóa:

# Cấu trúc gói tin từ Process 1 (Detection Output)
detection_packet = {
    "model": "YOLOv8n-TRT",
    "frame_id": 10425,
    "predictions": [
        {"class": "vehicle", "confidence": 0.92, "bbox": [x1, y1, x2, y2]}
    ]
}

# Cấu trúc gói tin từ Process 2 (Segmentation Output)
segmentation_packet = {
    "model": "TwinLiteNet-TRT",
    "frame_id": 10425,
    "drivable_area_mask": np.ndarray,  # Binary Tensor (H, W)
    "lane_line_mask": np.ndarray       # Binary Tensor (H, W)
}

Phương pháp nghiên cứu và quản lý dự án

Dự án được triển khai theo mô hình Agile/Scrum với 4 giai đoạn cụ thể:

  1. Giai đoạn 1 (Tuần 1 - 3): Phân tích dữ liệu BDD100K, tái cấu trúc nhãn nhị phân, thiết lập baseline với PyTorch.
  2. Giai đoạn 2 (Tuần 4 - 8): Thiết kế kiến trúc TwinLiteNet (ESPNet-C backbone, PAM/CAM Attention), tối ưu hóa hàm mất mát Focal + Tversky Loss.
  3. Giai đoạn 3 (Tuần 9 - 12): Tinh chỉnh YOLOv7-tiny, YOLOv8n/s, nén tensor đầu ra, chuyển đổi mô hình sang ONNX và TensorRT Engine (FP16).
  4. Giai đoạn 4 (Tuần 13 - 16): Xây dựng framework đa tiến trình, thực nghiệm đo đạc FPS, Latency, Power trên Jetson TX2 và Jetson Xavier.

Implementation và kết quả

Quy trình phát triển và chi tiết thuật toán

1. Kiến trúc mô hình TwinLiteNet

TwinLiteNet được thiết kế với tiêu chí tối ưu hóa số lượng phép tính FLOPs thông qua ba thành phần:

  • Bộ mã hóa (Encoder - ESPNet-C): Thay vì tích chập chuẩn tốn kém, ESPNet-C chia tích chập thành $1 \times 1$ Point-wise Conv để giảm chiều từ $M$ xuống $N$, sau đó đưa qua $K$ nhánh tích chập giãn nở không gian song song (Dilated Convolutions) với hệ số giãn nở $2^{k-1} = {1, 2, 4, 8, \dots}$. Điều này mở rộng trường tiếp nhận (Receptive Field) mà không làm tăng tham số.
  • Dual Attention Modules (DAM):
    • Position Attention Module (PAM): Nắm bắt mối quan hệ phụ thuộc không gian toàn cục giữa mọi cặp pixel: $$S = \text{softmax}(B^T \cdot C), \quad E_{PAM} = \alpha (D \cdot S) + A$$
    • Channel Attention Module (CAM): Khai thác mối tương quan giữa các kênh đặc trưng ngữ nghĩa: $$X = \text{softmax}(A \cdot A^T), \quad E_{CAM} = \beta (X \cdot A) + A$$
    • Tổng hợp đặc trưng: $E_{total} = \text{Conv}(E_{PAM} + E_{CAM})$.
  • Bộ giải mã kép (Dual Decoders): Gồm 2 nhánh độc lập sử dụng tích chập chuyển vị (Transposed Convolution) kết hợp BatchNorm và PReLU để phục hồi độ phân giải về $2 \times H \times W$ tương ứng cho Drivable Area và Lane Line.
Input (640x360x3) ---> [ ESPNet-C Encoder ] ---> Feature Map A (C x H/8 x W/8)
                              |
                     +--------+--------+
                     |                 |
                     v                 v
                 [  PAM  ]         [  CAM  ]
                     |                 |
                     +--------+--------+
                              |
                              v
                     [ Feature Summation ]
                              |
                     +--------+--------+
                     |                 |
                     v                 v
             [ Drivable Decoder ]  [ Lane Decoder ]
                     |                 |
                     v                 v
             Drivable Mask (H x W)  Lane Mask (H x W)

2. Hàm mất mát hỗn hợp (Loss Function)

Mô hình sử dụng kết hợp giữa Focal Loss ($\mathcal{L}{focal}$) và Tversky Loss ($\mathcal{L}{tversky}$) nhằm xử lý triệt để sự mất cân bằng giữa vùng điểm ảnh nền và làn đường/vùng lái: $$\mathcal{L}{total} = \mathcal{L}{focal} + \mathcal{L}_{tversky}$$

Trong đó: $$\mathcal{L}{focal} = -\frac{1}{N} \sum{i=1}^{N} \sum_{c=1}^{C} y_i(c) \left(1 - p_i(c)\right)^\gamma \log\left(p_i(c)\right)$$ $$\mathcal{L}_{tversky} = 1 - \frac{TP + \epsilon}{TP + \alpha FP + \beta FN + \epsilon}$$ (Thiết lập thực nghiệm: $\gamma = 2.0$, $\alpha = 0.7$, $\beta = 0.3$ nhằm tăng trọng số phạt cho các trường hợp âm tính giả FN của làn đường).

3. Tối ưu hóa đầu ra mô hình YOLO (Tensor Output Compression)

Đối với tập dữ liệu BDD100K, các lớp "car", "truck", "bus", "train" được gộp thành lớp duy nhất "vehicles". Sự thay đổi này trực tiếp cắt giảm kích thước Tensor đầu ra tại mỗi ô lưới $S \times S$:

  • Với tập dữ liệu gốc COCO (80 classes, 3 anchors): $$\text{Size} = S \times S \times [3 \times (4_{bbox} + 1_{conf} + 80_{class})] = S \times S \times 255$$
  • Với phương pháp đề xuất (1 class "vehicles", 3 anchors): $$\text{Size} = S \times S \times [3 \times (4_{bbox} + 1_{conf} + 1_{class})] = S \times S \times 18$$ Giúp giảm tới 92.9% kích thước tensor đầu ra, tiết kiệm băng thông bộ nhớ VRAM và tăng tốc độ xử lý Non-Maximum Suppression (NMS).
import torch
import torch.multiprocessing as mp

def run_inference_process(model_path, input_queue, output_queue, is_yolo=True):
    # Khởi tạo engine TensorRT FP16
    engine = load_tensorrt_engine(model_path)
    context = engine.create_execution_context()
    
    while True:
        frame_data = input_queue.get()
        if frame_data is None:  # Tín hiệu dừng
            break
            
        frame_id, input_tensor = frame_data["id"], frame_data["tensor"]
        
        # Suy luận bất đồng bộ trên CUDA Stream riêng biệt
        output = execute_trt(context, input_tensor)
        
        if is_yolo:
            result = post_process_yolo(output, frame_id)
        else:
            result = post_process_twinlite(output, frame_id)
            
        output_queue.put(result)

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

1. Đánh giá chi phí tính toán trên GPU máy chủ (NVIDIA RTX A5000)

Môi trường thử nghiệm: Intel Core i9-10900X, 32GB RAM, NVIDIA RTX A5000.

Model FLOPs (G) Tham số (#Params) CPU FPS GPU FPS (PyTorch) GPU FPS (TensorRT FP16)
YOLOv8n 4.38 3.01M 59 234 947
YOLOv7-tiny 6.78 6.01M 41 249 919
YOLOv8s 14.28 11.14M 31 229 554
TwinLiteNet 0.82 0.40M 68 312 1050

2. Đánh giá độ chính xác nhận diện phương tiện theo độ phân giải

Đánh giá trên tập kiểm thử BDD100K (không qua tinh chỉnh kích thước riêng lẻ):

Độ phân giải Mô hình Precision (%) Recall (%) $\text{mAP}_{50}$ (%) $\text{mAP}_{50:95}$ (%) FLOPs (G)
640x384 YOLOv8s 86.8 78.2 85.4 54.2 17.06
YOLOv7-tiny 84.5 77.9 84.1 51.8 8.10
YOLOv8n 85.9 74.6 82.7 52.1 4.90
480x288 YOLOv8s 84.2 75.1 82.3 50.1 9.60
YOLOv7-tiny 82.1 74.8 81.0 48.2 4.56
YOLOv8n 83.5 71.3 79.4 48.5 2.76
352x224 YOLOv8s 80.1 68.4 75.8 40.8 4.88
YOLOv7-tiny 78.4 66.2 74.6 38.9 2.32
YOLOv8n 79.2 61.0 72.1 39.5 1.40

3. Thực nghiệm trên thiết bị biên (NVIDIA Jetson Xavier vs Jetson TX2)

Đo đạc độ trễ thuần suy luận (FPS) và công suất tiêu thụ điện (Watts) ở độ phân giải $640 \times 384$:

Mô hình Batch Size (BS) Jetson AGX Xavier (FPS) Jetson AGX Xavier (Watts) Jetson TX2 (FPS) Jetson TX2 (Watts)
YOLOv8n $\text{BS}=1$ 184 9.74W 83 3.07W
$\text{BS}=8$ 277 10.96W 98 3.51W
YOLOv7-tiny $\text{BS}=1$ 172 10.84W 76 4.39W
$\text{BS}=8$ 251 12.10W 85 4.88W
YOLOv8s $\text{BS}=1$ 101 12.62W 38 5.17W
$\text{BS}=8$ 143 18.19W 43 6.51W
TwinLiteNet $\text{BS}=1$ 215 8.12W 94 2.85W

4. Hiệu năng hệ thống xử lý đồng thời đa tác vụ

Khi triển khai đồng thời YOLOv8n và TwinLiteNet qua kiến trúc hàng đợi đa tiến trình trên thiết bị biên:

  • Trên Jetson Xavier: Tổng độ trễ toàn hệ sinh thái giảm $1.6\text{ms}$ so với chạy tuần tự, đạt tốc độ khung hình hợp nhất $62.5\text{ FPS}$ ($<16\text{ms/frame}$).
  • Trên Jetson TX2: Giảm mạnh độ trễ từ $163.6\text{ms}$ (chạy tuần tự không tối ưu) xuống còn $28.4\text{ms}$, mức độ chiếm dụng GPU (GPU Occupancy) tăng từ 41% lên 88%, triệt tiêu hoàn toàn thời gian nhàn rỗi của bộ nhớ.

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

  1. Kiến trúc TwinLiteNet siêu gọn nhẹ (0.4M tham số): So với các mô hình phân đoạn SOTA như YOLOP ($91.9\text{M}$ tham số) hay HybridNets ($31.8\text{M}$ tham số), TwinLiteNet cắt giảm hơn 98.7% số lượng tham số nhưng vẫn duy trì độ chính xác ấn tượng: $91.3%\text{ mIoU}$ cho phân đoạn vùng lái xe và $31.08%\text{ IoU}$ cho nhận diện làn đường trên BDD100K.
  2. Kỹ thuật nén Tensor đầu ra YOLO (Single-Class Aggregation): Việc gộp các nhóm phương tiện về 1 nhãn tổng quát giúp rút ngắn tensor dự đoán từ kích thước $S \times S \times 255$ xuống $S \times S \times 18$, giảm $92.9%$ dung lượng lưu trữ trung gian và giải phóng băng thông bộ nhớ GPU nhúng.
  3. Mô hình thực thi đa tiến trình bất đồng bộ (Queue-based Multi-task Pipeline): Giải quyết triệt để sự chênh lệch thời gian suy luận giữa hai mô hình thông qua cơ chế gắn nhãn Frame ID và hàng đợi bất đồng bộ IPC Queue, ngăn chặn hiện tượng rò rỉ dữ liệu hoặc nghẽn cổ chai I/O.
  4. Tối ưu hóa toàn diện cho phần cứng biên: Toàn bộ mạng được cấu trúc tương thích hoàn hảo với TensorRT FP16, giúp hệ thống vận hành mượt mà trên nền tảng Jetson TX2 giá rẻ với mức tiêu thụ điện năng chỉ từ $3.07\text{W} - 5.17\text{W}$.

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

Tình huống ứng dụng thực tế (Real-world Use Cases)

  • Hệ thống hỗ trợ lái xe nâng cao (ADAS Level 2+/3): Tích hợp cảnh báo chệch làn đường (LDW), hỗ trợ giữ làn (LKA) và phanh khẩn cấp tự động (AEB) khi phát hiện phương tiện phía trước.
  • Robot giao hàng và phương tiện tự hành đô thị (Autonomous Delivery Robots): Vận hành trong khuôn viên trường đại học, khu công nghiệp với chi phí phần cứng biên cực thấp (Jetson TX2).
  • Thiết bị giám sát hành trình thông minh (Smart Dashcam Edge AI): Xử lý trực tiếp trên camera hành trình gắn trên gương chiếu hậu mà không cần gửi dữ liệu về Cloud.
+-----------------------------------------------------------------------------------+
|                        LỘ TRÌNH TRIỂN KHAI HỆ THỐNG (ROADMAP)                     |
+-----------------------------------------------------------------------------------+
| Giai đoạn 1 (Tháng 1-2): Setup JetPack 5.0, Build TensorRT Engine từ file ONNX    |
| Giai đoạn 2 (Tháng 3-4): Tích hợp Camera MIPI-CSI / USB GMSL với VideoCapture API |
| Giai đoạn 3 (Tháng 5-6): Kiểm thử đường phố thực tế (Edge Field Testing)          |
| Giai đoạn 4 (Tháng 7+):  Đóng gói OTA Firmware & Tối ưu hóa INT8 Quantization     |
+-----------------------------------------------------------------------------------+

Hướng dẫn triển khai kỹ thuật (Deployment Instructions)

# 1. Cài đặt môi trường trên Jetson JetPack
sudo apt-get update && sudo apt-get install -y libnvinfer8 python3-libnvinfer
pip install onnx onnxruntime-gpu opencv-python

# 2. Xuất mô hình PyTorch sang ONNX
python export.py --weights twinlitenet.pth --include onnx --imgsz 360 640

# 3. Tối ưu hóa mô hình với TensorRT (FP16 Mode)
/usr/src/tensorrt/bin/trtexec \
    --onnx=twinlitenet.onnx \
    --saveEngine=twinlitenet_fp16.engine \
    --fp16 \
    --workspace=2048

# 4. Chạy hệ thống xử lý đồng thời
python main_multiprocess.py \
    --yolo_engine=yolov8n_fp16.engine \
    --twinlite_engine=twinlitenet_fp16.engine \
    --source=csi://0

Phân tích chi phí - lợi ích (Cost-Benefit & ROI)

  • Tiết kiệm chi phí phần cứng (BOM Cost): Thay vì sử dụng máy tính công nghiệp x86 trang bị GPU rời đắt đỏ ($>1.500\text{ USD}$), giải pháp có thể vận hành ổn định trên các kit Jetson TX2 ($<300\text{ USD}$) hoặc Xavier NX ($<500\text{ USD}$), giúp giảm 65 - 75% chi phí chế tạo phần cứng cho mỗi phương tiện.
  • Tiết kiệm điện năng: Giảm thiểu lượng xả pin trên xe điện nhờ mức tiêu thụ công suất chỉ dưới $15\text{W}$, kéo dài quãng đường di chuyển của xe.

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

Hạn chế kỹ thuật

  • Điều kiện ánh sáng khắc nghiệt: Trong điều kiện ban đêm ngược sáng mạnh (đèn pha đối diện chói lóa) hoặc sương mù dày đặc, độ chính xác nhận diện làn đường bị suy giảm khoảng $8 - 12%$.
  • Đối tượng bị che khuất một phần (Occlusion): Mô hình YOLOv8n siêu nhẹ đôi khi bỏ sót các phương tiện nhỏ ở khoảng cách xa trong khu vực đô thị đông đúc.
  • Dữ liệu 2D thuần túy: Chưa ước lượng được khoảng cách thực tế (Depth Estimation) theo trục Z nếu không có camera stereo hoặc LiDAR.

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

  1. Lượng tử hóa INT8 (INT8 Quantization-Aware Training): Nén sâu mô hình TwinLiteNet và YOLOv8 để tăng tốc thêm $1.5 - 2.0\text{x}$ trên các lõi DLA (Deep Learning Accelerator) của dòng Jetson Orin.
  2. Ước lượng hộp giới hạn 3D (3D Bounding Box Estimation): Nâng cấp nhánh phát hiện để dự đoán trực tiếp tọa độ 3D và vector vận tốc của xe phía trước.
  3. Sensor Fusion: Kết hợp dữ liệu Camera với Radar tầm ngắn thông qua bộ lọc Kalman mở rộng (EKF) để đảm bảo độ tin cậy trong mọi thời tiết.

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

+-----------------------------------------------------------------------------------+
|                               ĐỐI TƯỢNG HƯỞNG LỢI                                 |
+-----------------------------------------------------------------------------------+
|  [Sinh viên / Nghiên cứu sinh]  ---> Source code tham khảo chuẩn, kiến trúc       |
|                                      TwinLiteNet 0.4M độc đáo, kỹ thuật tối ưu.   |
|                                                                                   |
|  [Kỹ sư AI / Lập trình viên]    ---> Pipeline đa tiến trình (Multiprocessing IPC),|
|                                      cách build TensorRT FP16 engine thực tế.     |
|                                                                                   |
|  [Doanh nghiệp xe / Robotics]   ---> Cắt giảm 70% chi phí phần cứng, vận hành     |
|                                      ổn định ở công suất thấp (<15W).             |
+-----------------------------------------------------------------------------------+
  • Sinh viên và Nghiên cứu sinh: Cung cấp tài liệu tham khảo hoàn chỉnh về cách tiếp cận mạng học sâu hiệu quả (Efficient Deep Learning) và phương pháp đánh giá chuẩn trên bộ dữ liệu BDD100K.
  • Kỹ sư AI & Hệ thống nhúng: Nhận được mẫu kiến trúc xử lý song song đa tiến trình (Inter-Process Communication Pipeline) có thể tái sử dụng trực tiếp cho các bài toán thị giác máy tính khác.
  • Doanh nghiệp và Nhà sản xuất thiết bị gốc (OEMs): Sở hữu giải pháp công nghệ sẵn sàng triển khai thực tế trên phần cứng chi phí thấp, rút ngắn thời gian đưa sản phẩm ra thị trường (Time-to-Market).

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

1. Yêu cầu phần cứng tối thiểu để triển khai hệ thống là gì?

Hệ thống yêu cầu tối thiểu một board máy tính nhúng hỗ trợ CUDA như NVIDIA Jetson TX2 (8GB VRAM) hoặc Jetson Nano (chạy ở độ phân giải $416 \times 256$). Để đạt hiệu năng tối ưu trên $60\text{ FPS}$ ở độ phân giải $640 \times 384$, khuyến nghị sử dụng NVIDIA Jetson Xavier NX hoặc Jetson AGX Xavier / Orin.

2. Làm thế nào để giải quyết vấn đề lệch khung hình giữa hai tiến trình?

Hệ thống sử dụng cơ chế gán nhãn frame_id duy nhất ngay tại bước tiền xử lý trước khi đẩy vào Input Queue. Khi kết quả từ hai mô hình trả về Output Queue, mô-đun đồng bộ sẽ sử dụng frame_id để khớp đúng mặt nạ phân đoạn với các bounding box tương ứng trước khi chuyển tiếp cho bộ điều khiển xe.

3. Tại sao không sử dụng một mô hình duy nhất như YOLOP thay vì kết hợp hai mô hình?

Mô hình đơn lẻ như YOLOP có kích thước rất lớn ($91.9\text{M}$ tham số), khó tinh chỉnh riêng lẻ từng tác vụ và gây nghẽn phần cứng trên Jetson TX2. Việc tách thành YOLOv8n ($3.0\text{M}$) và TwinLiteNet ($0.4\text{M}$) vừa giúp tổng số tham số nhỏ hơn 26 lần, vừa cho phép thay thế hoặc nâng cấp độc lập từng mô hình mà không cần huấn luyện lại từ đầu.

4. Chi phí bản quyền và tính sẵn sàng của các thư viện mã nguồn mở?

Toàn bộ giải pháp được xây dựng trên nền tảng các công cụ mã nguồn mở uy tín (PyTorch - BSD License, OpenCV - Apache 2, TensorRT - NVIDIA SLA). Doanh nghiệp hoàn toàn có thể thương mại hóa mà không chịu chi phí bản quyền phần mềm định kỳ.

5. Hệ thống hoạt động ra sao nếu một trong hai tiến trình gặp sự cố (Crash)?

Kiến trúc phần mềm tích hợp cơ chế giám sát tiến trình con (Process Health-Check Supervisor). Nếu tiến trình phân đoạn bị gián đoạn, hệ thống vẫn duy trì luồng phát hiện đối tượng YOLO để kích hoạt chế độ dừng khẩn cấp an toàn (Fail-Safe Emergency Brake).

Kết luận

Khóa luận đã nghiên cứu và hiện thực hóa thành công giải pháp xử lý đồng thời đa tác vụ thời gian thực cho xe tự hành, giải quyết triệt để mâu thuẫn giữa độ chính xác học sâu và giới hạn phần cứng biên. Với việc đề xuất mô hình TwinLiteNet siêu nhẹ (0.4M tham số) kết hợp các biến thể YOLOv8/v7 tối ưu, hệ thống đạt tốc độ xử lý vượt trội $62.5\text{ FPS}$ trên Jetson Xavier và $35\text{ FPS}$ trên Jetson TX2 trong khi tiêu thụ chưa đến $12\text{W}$ điện năng. Đây là bước tiến quan trọng mở ra tiềm năng thương mại hóa rộng rãi các hệ thống hỗ trợ lái xe an toàn trên các phương tiện giao thông thông minh thế hệ mới.