Giới thiệu dự án

Sự bùng nổ của thị trường xe tự hành (Autonomous Vehicles - AV) toàn cầu – dự kiến tăng trưởng từ 513,31 tỷ USD năm 2023 với tốc độ tăng trưởng kép hàng năm (CAGR) đạt 21,6% (theo Fortune Business Insights) – đang thúc đẩy quá trình chuyển dịch mạnh mẽ trong ngành giao thông thông minh. Tại Việt Nam, thực hiện Nghị quyết 52-NQ/TW của Bộ Chính trị về chủ động tham gia cuộc Cách mạng công nghiệp lần thứ tư, nghiên cứu và phát triển các hệ thống điều khiển tự hành trở thành nhiệm vụ trọng tâm. Tuy nhiên, việc đưa các thuật toán thị giác máy tính và học sâu (Deep Learning) lên các nền tảng phần cứng nhúng biên (Edge AI) đối mặt với rào cản lớn về tài nguyên tính toán giới hạn, độ trễ xử lý và yêu cầu an toàn thời gian thực.

+-------------------------------------------------------------------------+
|                      HỆ THỐNG ĐIỀU KHIỂN XE TỰ HÀNH                     |
|                                                                         |
|  +--------------------+                     +------------------------+  |
|  |   Camera Sensor    |                     |     LiDAR Sensor       |  |
|  | (RGB Frame 224x224)|                     |  (Point Cloud / Range) |  |
|  +---------+----------+                     +-----------+------------+  |
|            |                                            |               |
|            v                                            v               |
|  +--------------------+                     +------------------------+  |
|  | Modified SSDLite   |                     | Spatial Filtering &    |  |
|  | + MobileNetV3      |                     | Distance Calculation   |  |
|  | (Pruned 2 layers)  |                     |                        |  |
|  +---------+----------+                     +-----------+------------+  |
|            | Bounding Boxes & Classes                   | Distance Data |
|            +-------------------+  +---------------------+               |
|                                |  |                                     |
|                                v  v                                     |
|                     +-----------------------+                           |
|                     | Multi-Thread Decision |                           |
|                     |   & Evasion Control   |                           |
|                     +-----------+-----------+                           |
|                                 | Actuator Commands                     |
|                                 v (Steer, Throttle, Brake)              |
|                     +-----------------------+                           |
|                     |   Vehicle Actuators   |                           |
|                     |  (CARLA / Jetson Nano)|                           |
|                     +-----------------------+                           |
+-------------------------------------------------------------------------+

Vấn đề cốt lõi đặt ra là cảm biến Camera thu nhận ngữ nghĩa hình ảnh tốt nhưng tốn tài nguyên xử lý mô hình sâu, trong khi cảm biến LiDAR (Light Detection and Ranging) đo đạc khoảng cách chính xác theo thời gian thực ($R = \frac{c \cdot t}{2}$) nhưng không phân loại được chi tiết vật thể với môi trường xung quanh. Nghiên cứu này hiện thực hóa giải pháp tích hợp đa cảm biến Camera - LiDAR kết hợp tối ưu hóa mạng nơ-ron tích chập nhẹ SSDLite-MobileNetV3 nhằm giải quyết bài toán phát hiện và né tránh vật cản trên nền tảng máy tính nhúng NVIDIA Jetson Nano.

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

  1. Thiết kế và tùy biến kiến trúc mạng nơ-ron phát hiện vật cản SSDLite với backbone MobileNetV3 cắt giảm 2 lớp cuối, tối ưu hóa cho tập dữ liệu đối tượng giao thông rút gọn.
  2. Xây dựng cơ chế xử lý đa luồng (Multi-threading) đồng bộ dữ liệu giữa luồng phân loại hình ảnh (Camera) và luồng đo đạc đám mây điểm (LiDAR).
  3. Thiết lập môi trường kiểm chứng mô phỏng hoàn chỉnh trên phần mềm CARLA Simulator thông qua giao thức truyền thông Client-Server.
  4. Đánh giá thực nghiệm hiệu năng trên kit phần cứng nhúng NVIDIA Jetson Nano với các chỉ số mAP, FPS và thời gian đáp ứng điều khiển.

Phạm vi giới hạn của đề tài tập trung vào bài toán phát hiện hai nhóm đối tượng ưu tiên cao nhất là người đi bộ (Pedestrian) và phương tiện cơ giới (Vehicles) trong các kịch bản tránh va chạm đô thị mô phỏng.

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

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

Các mô hình thị giác máy tính truyền thống chia thành hai trường phái: mô hình 2 giai đoạn (Two-stage detectors như Faster R-CNN) đạt độ chính xác cao nhờ mạng đề xuất vùng (Region Proposal Network - RPN) nhưng tốc độ suy luận quá chậm ($< 5$ FPS trên thiết bị nhúng), và mô hình 1 giai đoạn (One-stage detectors như YOLO, SSD) dự đoán trực tiếp bounding box và class score.

Tiêu chí Faster R-CNN (ResNet-50) YOLOv4-Tiny SSD (VGG-16) Đề xuất: Modified SSDLite-MobileNetV3
Kiến trúc mạng Two-stage (RPN + RoI) One-stage (CSPDarknet) One-stage (Standard Conv) One-stage (Depthwise Separable Conv)
Kích thước mô hình ~137 MB (41.5M params) ~23 MB (6.0M params) ~100 MB (26.2M params) ~8.4 MB (2.1M params)
Độ phức tạp tính toán ~180 GFLOPs ~6.9 GFLOPs ~31.4 GFLOPs ~1.2 GFLOPs
Khả năng chạy Edge AI Kém (Không khả thi) Khá Trung bình (Tải bộ nhớ cao) Tối ưu cao trên Jetson Nano

Yêu cầu hệ thống được lượng hóa theo chuẩn phân loại MoSCoW:

  • Must have: Phát hiện chính xác người và phương tiện với độ chính xác trung bình $AP > 70%$; Tốc độ xử lý hình ảnh trên Jetson Nano đạt trên $10$ FPS; Đồng bộ tín hiệu đo khoảng cách từ LiDAR thời gian thực.
  • Should have: Cơ chế điều khiển chuyển làn hoặc phanh tự động khi khoảng cách vật cản $< 5$ mét.
  • Could have: Tích hợp mô-đun lọc nhiễu điểm ảnh LiDAR khi môi trường có mưa/sương mù trong CARLA.
  • Won't have (lần này): Hệ thống lập quỹ đạo toàn cục sử dụng định vị GPS/IMU độ chính xác cao.

Thiết kế hệ thống

Kiến trúc giải pháp được chia làm 3 phân hệ chính kết nối qua mô hình Client-Server dạng Socket:

  1. Server Layer (CARLA Environment): Khởi tạo bản đồ thế giới ảo, điều khiển vật lý thời gian thực của xe ego-vehicle, spawn luồng giao thông và người đi bộ ngẫu nhiên, gắn các cảm biến ảo RGB Camera (độ phân giải $224 \times 224$) và LiDAR sensor ($360^\circ$, 32 channels).
  2. Perception Layer (Engine suy luận & xử lý tín hiệu):
    • Mô-đun Camera: Tiếp nhận frame hình ảnh, chuyển đổi tensor và tiền xử lý, đưa qua mạng SSDLite-MobileNetV3 đã cắt giảm 2 layer cuối để xuất bounding box $[x_{min}, y_{min}, x_{max}, y_{max}]$, class ID, confidence score.
    • Mô-đun LiDAR: Tiếp nhận ma trận tọa độ không gian 3D $[X, Y, Z]$, thực hiện phân đoạn không gian (Spatial Filtering) quét góc hình nón phía trước đầu xe để tính toán khoảng cách Euclidean tối thiểu đến chướng ngại vật: $$d_{min} = \min_{i} \sqrt{X_i^2 + Y_i^2 + Z_i^2}$$
  3. Control Layer (Bộ điều khiển tránh va chạm): Máy trạng thái hữu hạn (FSM) xử lý logic né tránh vật cản dựa trên khoảng cách và loại vật cản: giữ làn / giảm tốc / đánh lái né tránh / phanh khẩn cấp.
                   KIẾN TRÚC MÔ HÌNH MODIFIED SSDLITE-MOBILENETV3
                   
 Input (224x224x3)
        |
        v
+---------------------------------------------------------------------+
| Backbone: Pruned MobileNetV3 (Depthwise Separable + SE Blocks)      |
|  - Standard Conv 3x3 (Stride 2)                                     |
|  - Inverted Residual Bottleneck Blocks (Hard-Swish, ReLU6)          |
|  - [Removed: 2 Final Heavy Feature Extraction Layers]               |
+---------------------------------------------------------------------+
        |                     |                     |
        v Feature Map 1       v Feature Map 2       v Feature Map 3
+---------------------------------------------------------------------+
| SSDLite Head (Depthwise Separable Prediction Layers)                |
|  - Class Prediction: Depthwise 3x3 + Pointwise 1x1 -> (Classes * A) |
|  - Box Regression:   Depthwise 3x3 + Pointwise 1x1 -> (4 * A)       |
+---------------------------------------------------------------------+
        |
        v
 Non-Maximum Suppression (NMS, IoU threshold = 0.5)
        |
        v
 Final Output: Bounding Boxes + Focused Target Classes (Person, Vehicle)

Stack công nghệ và thông số phiên bản chi tiết:

  • Ngôn ngữ: Python 3.8.10.
  • Deep Learning Framework: PyTorch 1.12.0, Torchvision 0.13.0, CUDA 10.2, cuDNN 8.2.
  • Simulator: CARLA Simulator 0.9.13 (Unreal Engine 4.26).
  • Phần cứng mục tiêu: NVIDIA Jetson Nano Developer Kit (4GB 64-bit LPDDR4, 128-core NVIDIA Maxwell GPU, Quad-core ARM Cortex-A57 CPU).

Methodology

Quy trình phát triển theo mô hình Agile lặp 4 sprint:

  • Sprint 1 (Tuần 1-3): Nghiên cứu lý thuyết mạng CNN, cấu trúc MobileNetV3 Inverted Residuals, hàm kích hoạt $h\text{-}swish(x) = x \cdot \frac{\text{ReLU6}(x+3)}{6}$, hàm mất mát Multibox Loss kết hợp giữa Smooth L1 và Softmax Cross-Entropy.
  • Sprint 2 (Tuần 4-7): Trích xuất tệp dữ liệu MS COCO rút gọn, tinh chỉnh cấu trúc MobileNetV3 backbone (cắt giảm layer), huấn luyện Transfer Learning trên Google Colab GPU.
  • Sprint 3 (Tuần 8-11): Thiết lập môi trường CARLA Simulator, lập trình cơ chế Socket giao tiếp Client-Server, viết module xử lý đám mây điểm LiDAR.
  • Sprint 4 (Tuần 12-14): Tích hợp đa luồng, porting mô hình lên NVIDIA Jetson Nano, đánh giá benchmark và tinh chỉnh thuật toán tránh vật cản.

Implementation và kết quả

Development process

Cốt lõi cải tiến nằm ở việc can thiệp vào cấu trúc backbone của MobileNetV3. Mạng MobileNetV3 tiêu chuẩn chứa 15 khối Inverted Residual Bottleneck (bneck). Trong bài toán xe tự hành với tập nhãn mục tiêu thu hẹp (tập trung người và xe), các đặc trưng mức cao (high-level abstract features) ở 2 khối convolution cuối cùng không mang lại sự gia tăng mAP đáng kể nhưng lại chiếm tỉ trọng tham số lớn.

Nhóm nghiên cứu đã thực hiện cắt giảm 2 lớp tích chập cuối của backbone, tái định cấu trúc các nhánh trích xuất đặc trưng đa tỉ lệ (multi-scale feature maps) của SSDLite Head bằng cách thay thế tích chập chuẩn (Standard Convolution) bằng tích chập tách biệt theo chiều sâu (Depthwise Separable Convolution bao gồm Depthwise Conv $3 \times 3$ kết hợp Pointwise Conv $1 \times 1$).

import torch
import torch.nn as nn
from torchvision.models.detection.ssdlite import SSDLiteHead, SSDLiteClassificationHead

def create_pruned_mobilenetv3_ssdlite(num_classes=3):
    """
    Khởi tạo mô hình SSDLite với MobileNetV3-Large cắt giảm 2 lớp cuối
    num_classes = 3 (0: Background, 1: Pedestrian, 2: Vehicle)
    """
    # 1. Tải backbone MobileNetV3-Large tiền huấn luyện
    from torchvision.models import mobilenet_v3_large, MobileNet_V3_Large_Weights
    weights = MobileNet_V3_Large_Weights.DEFAULT
    backbone = mobilenet_v3_large(weights=weights).features
    
    # 2. Cắt giảm 2 khối layers cuối cùng (giảm tham số từ 3.44M -> 2.1M)
    pruned_backbone = nn.Sequential(*list(backbone.children())[:-2])
    
    # 3. Định nghĩa các điểm lấy Feature Maps cho SSDLite Head
    # Trích xuất đặc trưng đa tầng phục vụ multi-scale detection
    class BackboneWithFeatureExtractor(nn.Module):
        def __init__(self, base_net):
            super().__init__()
            self.base = base_net
            
        def forward(self, x):
            features = []
            for idx, stage in enumerate(self.base):
                x = stage(x)
                if idx in [12, 14]: # Trích xuất feature maps tại các stage rút gọn
                    features.append(x)
            return features

    return pruned_backbone

Để giải quyết vấn đề nghẽn cổ chai tính toán (I/O Bottleneck) khi nhận đồng thời dữ liệu hình ảnh độ phân giải cao và hàng chục nghìn điểm LiDAR mỗi giây, hệ thống cài đặt cơ chế xử lý đa luồng (threading.Thread trong Python):

import threading
import queue
import numpy as np

class SensorFusionPipeline:
    def __init__(self, model, carla_client):
        self.model = model
        self.client = carla_client
        self.image_queue = queue.Queue(maxsize=2)
        self.lidar_queue = queue.Queue(maxsize=2)
        self.control_state = {"steer": 0.0, "throttle": 0.0, "brake": 0.0}
        
    def camera_worker(self):
        while True:
            frame = self.image_queue.get()
            # Tiền xử lý và suy luận SSDLite MobileNetV3
            tensor = self.preprocess(frame)
            with torch.no_grad():
                detections = self.model(tensor)
            self.process_detections(detections)
            self.image_queue.task_done()

    def lidar_worker(self):
        while True:
            raw_lidar = self.lidar_queue.get()
            # Lọc điểm trước đầu xe: -1.5m <= Y <= 1.5m, 0m <= X <= 15m
            points = np.frombuffer(raw_lidar.raw_data, dtype=np.float32).reshape(-1, 4)
            front_points = points[(points[:, 0] > 0) & (points[:, 0] < 15.0) & 
                                  (np.abs(points[:, 1]) < 1.5)]
            if len(front_points) > 0:
                min_dist = np.min(front_points[:, 0])
                self.trigger_evasion_logic(min_dist)
            self.lidar_queue.task_done()

Testing và validation

Mô hình được huấn luyện trên tập dữ liệu COCO được lọc lấy các class tương ứng với giao thông, chia tỉ lệ 80% Train, 10% Validation, 10% Test. Môi trường thực nghiệm CARLA được thiết lập với 3 kịch bản kiểm thử nghiêm ngặt:

  1. Kịch bản 1 - Chướng ngại vật tĩnh: Xe di chuyển thẳng với vận tốc $30\text{ km/h}$, phát hiện xe tải đỗ chiếm làn đường phía trước $20\text{ m}$.
  2. Kịch bản 2 - Người đi bộ cắt ngang đường: Người đi bộ bất ngờ bước ra từ điểm mù bên phải khi xe đang di chuyển $25\text{ km/h}$.
  3. Kịch bản 3 - Phương tiện phía trước giảm tốc đột ngột: Đánh giá tính đồng bộ giữa tín hiệu cảnh báo thị giác và đo khoảng cách LiDAR.

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

Việc cắt giảm mạng giúp giảm số lượng tham số từ 3,44 triệu xuống còn 2,1 triệu tham số (tương đương giảm 39% dung lượng mô hình).

+-------------------------------------------------------------------------+
|                  SO SÁNH HIỆU NĂNG TRÊN NVIDIA JETSON NANO              |
|                                                                         |
|  Tốc độ xử lý (FPS) - [Càng cao càng tốt]                               |
|  Original SSDLite-V3:   [===] 3.8 FPS                                   |
|  Modified SSDLite-V3:   [===========] 11.0 FPS  (+289% Speedup)         |
|                                                                         |
|  Số lượng tham số (Parameters) - [Càng nhỏ càng tốt]                    |
|  Original SSDLite-V3:   [=================================] 3.44M Params|
|  Modified SSDLite-V3:   [=====================] 2.10M Params (-39.0%)   |
|                                                                         |
|  Độ chính xác trung bình (mAP %) - [Duy trì ổn định]                    |
|  Original SSDLite-V3:   [====================================] 75.9% AP |
|  Modified SSDLite-V3:   [==================================] 73.1% AP   |
|                                         (-2.8% Trade-off)               |
+-------------------------------------------------------------------------+

Độ chính xác nhận diện đạt $73,1%$ Average Precision (AP), chỉ suy giảm $2,8%$ so với mô hình gốc ($75,9%$ AP), nhưng bù lại mang đến bước nhảy vọt về tốc độ thực thi: tăng từ $3,8$ FPS lên $11,0$ FPS trên bo mạch NVIDIA Jetson Nano (cải thiện gấp $2,89$ lần).

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

  1. Tối ưu hóa kiến trúc mạng theo hướng tiếp cận Edge Computing: Không áp dụng nguyên bản các mô hình chuẩn, nghiên cứu đã chứng minh thực nghiệm việc cắt tỉa tầng trích xuất sâu (layer pruning) kết hợp Depthwise Separable Convolution ở phần head giúp thu nhỏ mô hình xuống còn $61%$ kích thước gốc, trực tiếp giải quyết bài toán nút thắt FPS trên chip nhúng ARM/Maxwell.
  2. Kiến trúc dung hợp đa luồng phân tán (Decoupled Multi-threaded Fusion): Thay vì xử lý tuần tự (Sequential processing) khiến FPS tổng thể bị kéo xuống bởi khâu suy luận mạng CNN, giải pháp phân tách luồng điều khiển giúp thuật toán an toàn LiDAR luôn chạy ở tần số cao ($20-30\text{ Hz}$) song song với luồng phân loại đối tượng ($11\text{ Hz}$).
  3. Cầu nối mô phỏng - thực tế (Sim-to-Real Architecture Pipeline): Xây dựng module kết nối thông qua socket chuẩn hóa, cho phép thuật toán chạy trên Jetson Nano điều khiển trực tiếp xe trong môi trường ảo CARLA Server qua mạng LAN, sẵn sàng chuyển giao lên xe mô hình thực tế.

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

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

  • Xe tự hành trong nhà xưởng / Kho vận thông minh (AGV - Automated Guided Vehicles): Điều hướng, vận chuyển pallet hàng hóa trong môi trường có công nhân và xe nâng qua lại.
  • Hệ thống trợ lái nâng cao (ADAS): Tích hợp làm mô-đun cảnh báo tiền va chạm và tự động phanh khẩn cấp (Autonomous Emergency Braking - AEB) giá rẻ cho các phương tiện thương mại.
  • Robot dịch vụ / Xe giao hàng chặng cuối (Last-mile delivery robots): Hoạt động trong khuôn viên trường đại học, khu đô thị đóng.
                              QUY TRÌNH TRIỂN KHAI PHẦN CỨNG
                              
+----------------------------+                     +----------------------------+
|  Host Workstation / Colab  |                     |  Target: NVIDIA Jetson Nano|
|  (PyTorch Model Training)  |                     |  (4GB Edge Computing Kit)  |
+--------------+-------------+                     +--------------+-------------+
               |                                                  ^
               | 1. Export Weights (.pth / ONNX)                  |
               v                                                  |
+----------------------------+                                    |
|   ONNX / TensorRT Engine   | -----------------------------------+
|   (FP16 Precision Opt)     |       2. Deploy via Local Socket
+----------------------------+
                                                                  |
                                                                  v
                                                   +----------------------------+
                                                   | CARLA Sim / Physical Robot |
                                                   |  (Closed-Loop Controller)  |
                                                   +----------------------------+

Hướng dẫn triển khai và vận hành

  1. Chuẩn bị phần cứng:
    • Kit NVIDIA Jetson Nano 4GB cài sẵn JetPack 4.6 (Ubuntu 18.04 LTS).
    • Nguồn cấp 5V-4A DC barrel jack (bật chế độ hiệu năng cao: sudo nvpmodel -m 0 && sudo jetson_clocks).
  2. Triển khai mã nguồn: 
    git clone https://github.com/uit-ce/autonomous-car-obstacle-evasion.git
cd autonomous-car-obstacle-evasion
pip3 install -r requirements.txt
# Khởi chạy client kết nối tới CARLA Server IP
python3 main_control.py --host 192.168.1.100 --port 2000 --device cuda

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

  • Hạn chế kỹ thuật: Tốc độ $11$ FPS trên Jetson Nano dù cải thiện $2,89$ lần nhưng vẫn chưa đạt mức chuẩn thời gian thực lý tưởng ($30$ FPS) cho xe di chuyển tốc độ cao ($> 50\text{ km/h}$). Mô hình dựa trên FSM còn đơn giản khi xử lý các tình huống giao thông hỗn loạn đa làn.
  • Hướng phát triển tiếp theo:
    1. Ứng dụng TensorRT để lượng hóa mô hình sang định dạng FP16 hoặc INT8, kỳ vọng nâng tốc độ xử lý lên $25-30$ FPS trên Jetson Nano.
    2. Nâng cấp bộ điều khiển né tránh sang thuật toán điều khiển dự báo mô hình (Model Predictive Control - MPC) kết hợp mạng sinh quỹ đạo (Trajectory Planning Network).
    3. Thử nghiệm trên mô hình xe phần cứng thực tế (RC Car tỷ lệ 1:10 gắn cảm biến RPLiDAR A1 và Camera CSI Sony IMX219).

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

  • Sinh viên / Học viên chuyên ngành: Cung cấp tài liệu tham khảo hoàn chỉnh từ lý thuyết mạng CNN, cấu trúc MobileNet, kỹ thuật cắt tỉa backbone đến cách thức kết nối phần mềm mô phỏng CARLA và lập trình nhúng.
  • Kỹ sư thị giác máy tính / Lập trình viên nhúng: Nắm bắt kỹ thuật tối ưu hóa mô hình học sâu cho phần cứng giới hạn, phương pháp phân luồng xử lý đa cảm biến (Camera + LiDAR) chống giật khung hình.
  • Doanh nghiệp R&D xe tự hành: Tham khảo phương án tối ưu chi phí BOM (Bill of Materials) cho các dòng AGV/Robot dịch vụ thông qua việc kết hợp cảm biến và chip xử lý biên giá rẻ.

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

1. Yêu cầu phần cứng tối thiểu để triển khai và chạy mô phỏng là gì?

Máy chủ chạy CARLA Simulator cần tối thiểu CPU Intel Core i7 (hoặc AMD Ryzen 7), 16GB RAM, card đồ họa rời NVIDIA RTX 2060 (6GB VRAM) trở lên. Phía bộ điều khiển nhúng (Client) yêu cầu tối thiểu NVIDIA Jetson Nano 4GB hoặc máy tính có hỗ trợ CUDA.

2. Việc cắt giảm 2 lớp cuối của MobileNetV3 ảnh hưởng như thế nào đến khả năng nhận diện?

Cắt giảm 2 lớp cuối làm giảm trường tiếp nhận đặc trưng (receptive field) ở mức cao nhất, khiến độ chính xác $AP$ tổng thể giảm nhẹ từ $75,9%$ xuống $73,1%$ (mất $2,8%$). Tuy nhiên, đối với bài toán nhận diện các vật thể kích thước trung bình và lớn như người và xe ở cự ly gần ($< 25\text{ m}$), sự suy giảm này không gây ảnh hưởng đến quyết định né tránh an toàn của xe.

3. LiDAR và Camera được đồng bộ dữ liệu như thế nào khi tốc độ lấy mẫu khác nhau?

Hệ thống sử dụng cấu trúc hàng đợi queue.Queue(maxsize=2) dạng non-blocking kết hợp Timestamp. Khi một frame hình ảnh mới được xử lý xong, nó sẽ lấy giá trị khoảng cách LiDAR gần nhất đã được lọc trong không gian 3D tương ứng với vùng quan tâm (ROI) của bounding box.

4. Tại sao không chọn mạng YOLOv5-Nano hay YOLOv7-Tiny thay vì SSDLite-MobileNetV3?

SSDLite kết hợp với MobileNetV3 tận dụng các khối Inverted Residuals và cơ chế tích chập Depthwise Separable, được thiết kế đặc thù cho các tập lệnh kiến trúc ARM trên thiết bị di động, giúp tối ưu hóa số phép tính nhân cộng (MACs/FLOPs) và giảm nhiệt lượng tỏa ra trên vi xử lý nhúng so với các kiến trúc nhóm YOLO.

5. Chi phí ước tính để chế tạo một mô hình xe thực nghiệm sử dụng giải pháp này là bao nhiêu?

Chi phí phần cứng ước tính khoảng 7.000.000 - 10.000.000 VNĐ, bao gồm: Kit NVIDIA Jetson Nano 4GB (~3,5 triệu), LiDAR 2D/3D quét laser 360 độ như RPLiDAR A1 (~2,5 triệu), Camera góc rộng Sony IMX219 (~600 nghìn), khung xe mô hình, mạch điều khiển động cơ và pin nguồn chuyên dụng.

Kết luận

Đồ án đã hiện thực hóa thành công giải pháp phát hiện và tránh vật cản cho xe tự hành thông qua việc kết hợp cảm biến Camera và LiDAR trên nền tảng mô phỏng CARLA và phần cứng nhúng NVIDIA Jetson Nano. Đóng góp nổi bật của đề tài là việc đề xuất biến thể mạng SSDLite-MobileNetV3 rút gọn 2 lớp cuối, cắt giảm $39%$ số lượng tham số và tăng tốc độ xử lý lên $11,0$ FPS (gấp $2,89$ lần) trên phần cứng biên trong khi vẫn duy trì độ chính xác $73,1%$ AP. Kết quả nghiên cứu mở ra hướng ứng dụng thực tiễn cao cho các hệ thống robot tự hành, AGV công nghiệp và phương tiện di chuyển thông minh chi phí thấp trong kỷ nguyên giao thông tương lai.