Giới thiệu dự án

Sự gia tăng nhanh chóng của các phương tiện cơ giới tại Việt Nam đang đặt ra thách thức lớn đối với hạ tầng giao thông đô thị và công tác quản lý bãi đỗ xe. Theo thống kê từ Cục Cảnh sát Giao thông, số lượng ô tô đăng ký mới tăng trưởng trung bình 10–15% mỗi năm, dẫn đến tình trạng quá tải nghiêm trọng tại các trạm thu phí, bãi giữ xe thông minh và các nút giao thông trọng điểm. Việc giám sát và kiểm soát phương tiện thủ công không chỉ tiêu tốn nguồn nhân lực mà còn gây ùn tắc và sai sót trong quá trình ghi nhận thông tin.

       +--------------------------------------------------------+
       |               HỆ THỐNG ANPR TRÊN RASPBERRY PI           |
       +--------------------------------------------------------+
                                   |
         +-------------------------+-------------------------+
         |                                                   |
         v                                                   v
+------------------+                               +--------------------+
| CAMERA MODULE V1 |                               |  ALGORITHM STACK   |
| - Sensor: OV5647 |                               | - Preprocessing    |
| - Res: 2592x1944 |                               | - Character Seg.   |
| - MIPI CSI Bus   |                               | - MobileNetV1 CNN  |
+------------------+                               +--------------------+
         |                                                   |
         +------------------------>+<------------------------+
                                   |
                                   v
                 +-----------------------------------+
                 |    RASPBERRY PI 3B+ (ARMv8 SoC)   |
                 | - BCM2837B0 Quad-Core @ 1.4GHz    |
                 | - 1GB LPDDR2 RAM                  |
                 | - Real-time Inference (~1.2s)     |
                 +-----------------------------------+
                                   |
                                   v
                 +-----------------------------------+
                 |  OUTPUT: TEXT / SQLITE / BARRIER  |
                 +-----------------------------------+

Vấn đề thực tế và các điểm nghẽn kỹ thuật

Các hệ thống nhận dạng biển số xe tự động (ANPR - Automatic Number Plate Recognition) truyền thống thường yêu cầu máy tính cá nhân (PC) cấu hình cao với card đồ họa rời (GPU), làm tăng chi phí đầu tư phần cứng và hạn chế khả năng triển khai linh hoạt ở các bãi đỗ xe ngoài trời hoặc trạm gác di động. Trong khi đó, việc đưa các mô hình thị giác máy tính và học sâu (Deep Learning) lên các thiết bị phần cứng giới hạn tài nguyên như Raspberry Pi gặp phải nhiều trở ngại:

  • Băng thông xử lý của CPU nhúng thấp, dung lượng RAM hạn chế (1GB).
  • Tốc độ khung hình bị sụt giảm khi chạy các mạng nơ-ron tích chập (CNN) tiêu chuẩn như VGG hay ResNet.
  • Biến dạng hình ảnh do điều kiện ánh sáng môi trường thay đổi, góc quay nghiêng và rung lắc của camera.

Mục tiêu dự án

Đề tài "Nghiên cứu và xây dựng chương trình nhận diện biển số xe với Deep Learning sử dụng Raspberry Pi" do nhóm tác giả Nguyễn Quốc Toản và Nguyễn Quang Huy thực hiện dưới sự hướng dẫn của ThS. Lê Hoài Nghĩa tại Trường Đại học Công nghệ Thông tin - ĐHQG-HCM hướng tới các mục tiêu:

  1. Nghiên cứu và tối ưu hóa giải thuật phát hiện, tách vùng biển số ô tô dựa trên tiêu chuẩn hình thái học của biển số xe Việt Nam.
  2. Xây dựng và tinh chỉnh mô hình mạng nơ-ron học sâu dạng nhẹ (Lightweight CNN) dựa trên kiến trúc MobileNetV1 để nhận diện chính xác 36 ký tự (gồm 10 chữ số từ 0–9 và 26 chữ cái từ A–Z).
  3. Tích hợp hoàn chỉnh hệ thống phần cứng và phần mềm trên máy tính nhúng Raspberry Pi 3B+, đáp ứng tiêu chuẩn xử lý cục bộ độc lập (Edge Computing).
  4. Đạt độ chính xác nhận diện tối thiểu 90% trên tập dữ liệu ảnh tĩnh và 85% đối với dữ liệu thu nhận trực tiếp từ camera.

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

Giải pháp tiếp cận là sự kết hợp giữa các kỹ thuật xử lý ảnh cổ điển (OpenCV) nhằm khoanh vùng và phân đoạn ký tự với tốc độ cao, kết hợp cùng mạng MobileNetV1 sử dụng phép tích chập tách biệt chiều sâu (Depthwise Separable Convolution) để phân loại ký tự với lượng tham số tối thiểu.

Chỉ số đánh giá Giá trị kỳ vọng Giá trị thực tế đạt được
Độ chính xác nhận diện (Ảnh tĩnh) $\ge 90.0%$ $90.8%$
Độ chính xác nhận diện (Camera Pi trực tiếp) $\ge 85.0%$ $85.4%$
Thời gian suy luận trung bình (Inference Time) $\le 1.5\text{ s/ảnh}$ $1.20 - 1.35\text{ s/ảnh}$
Bộ nhớ RAM tiêu thụ trong quá trình xử lý $\le 500\text{ MB}$ $\sim 380\text{ MB}$

Phạm vi và giới hạn đề tài

  • Đối tượng nhận dạng: Biển số xe ô tô đăng ký tại Việt Nam tuân theo quy chuẩn kích thước và màu sắc của Thông tư 58/2020/TT-BCA (gồm biển vuông $330 \times 165\text{ mm}$ và biển dài $520 \times 110\text{ mm}$).
  • Điều kiện môi trường: Ảnh chụp biển số theo phương ngang, góc lệch không quá $25^\circ$, không bị che khuất và độ phân giải camera đảm bảo các ký tự có thể quan sát rõ bằng mắt thường.

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

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

Trước khi đi sâu vào thiết kế mô hình nhúng, các hướng tiếp cận ANPR hiện nay được phân tích chi tiết nhằm chỉ rõ ưu và nhược điểm:

Phương pháp Ưu điểm Nhược điểm Khả năng chạy trên Raspberry Pi 3B+
Phép biến đổi Hough & Morphology Tốc độ cực nhanh ($<100\text{ ms}$), không cần huấn luyện mô hình. Dễ vỡ khung khi biển số bị bẩn, trầy xước hoặc ánh sáng phức tạp. Rất tốt (Chiếm ít CPU/RAM).
Mạng Faster R-CNN Độ chính xác định vị và phát hiện đối tượng rất cao ($>95%$). Kích thước mô hình nặng ($>100\text{ MB}$), yêu cầu GPU rời, độ trễ trên CPU $>5\text{ s}$. Không khả thi (Gây tràn RAM 1GB).
Mạng SSD (Single Shot MultiBox Detector) Cân bằng tốt giữa tốc độ và độ chính xác trên GPU. Cần phần cứng hỗ trợ CUDA như NVIDIA Jetson Nano để đạt thời gian thực. Kém khả thi (FPS $<0.5$).
MobileNetV1 + Phân đoạn hình thái Tối ưu hóa số lượng tham số ($4.2\text{M}$ params), tốc độ xử lý nhanh trên CPU ARM. Cần bước tiền xử lý phân đoạn ký tự chính xác trước khi đưa vào mạng. Khả thi và tối ưu nhất.

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

  • Must Have: Thu nhận hình ảnh qua Camera Pi V1; Tách chính xác vùng biên chứa biển số; Phân đoạn từng ký tự riêng biệt; Nhận diện chuỗi ký tự bằng mô hình CNN; Lưu trữ kết quả chuỗi ký tự dạng text.
  • Should Have: Giao diện trực quan hiển thị bounding box quanh biển số; Lọc nhiễu ánh sáng tự động bằng cân bằng lược đồ màu (Histogram Equalization).
  • Could Have: Kết nối cơ sở dữ liệu SQLite cục bộ để đối soát biển số; Tích hợp module GPIO điều khiển đóng/mở thanh chắn tự động (Barrier).
  • Won't Have (Giai đoạn này): Nhận diện phương tiện di chuyển ở tốc độ cao trên $60\text{ km/h}$; Xử lý đa luồng đồng thời 4–8 camera trên cùng một mạch nhúng.

Thiết kế hệ thống

Kiến trúc hệ thống bao gồm hai thành phần chính: phần cứng thu nhận tín hiệu và luồng pipeline xử lý phần mềm:

[Ảnh từ Camera Pi / File]
          │
          ▼
┌────────────────────────────────────────────────────────┐
│ 1. Tiền xử lý & Xác định vùng biển số (OpenCV)         │
│    - Chuyển ảnh xám (Grayscale)                        │
│    - Nhị phân hóa ngưỡng thích nghi (Adaptive Threshold)│
│    - Tìm đường biên & Lọc tỉ lệ hình học (Aspect Ratio) │
└────────────────────────────────────────────────────────┘
          │
          ▼
┌────────────────────────────────────────────────────────┐
│ 2. Phân đoạn ký tự (Character Segmentation)           │
│    - Cắt vùng ROI biển số                              │
│    - Phân tích thành phần liên thông (Connected Comp.)  │
│    - Sắp xếp tọa độ ký tự từ trái sang phải            │
└────────────────────────────────────────────────────────┘
          │
          ▼
┌────────────────────────────────────────────────────────┐
│ 3. Nhận dạng ký tự (MobileNetV1 Inference)            │
│    - Chuẩn hóa kích thước ký tự về 28x28 / 32x32       │
│    - Phân loại qua 36 lớp đầu ra (Softmax)             │
└────────────────────────────────────────────────────────┘
          │
          ▼
[Hiển thị kết quả Text & Lưu trữ Database]

Technology Stack chi tiết

  • Nền tảng phần cứng:
    • Vi xử lý: Broadcom BCM2837B0, Quad-core Cortex-A53 (ARMv8) 64-bit SoC @ 1.4GHz.
    • Bộ nhớ RAM: 1GB LPDDR2 SDRAM.
    • Cảm biến hình ảnh: Raspberry Pi Camera Module V1 (Cảm biến OmniVision OV5647 5MP, Native Resolution $2592 \times 1944$, kết nối qua giao tiếp MIPI CSI-2).
  • Môi trường phần mềm:
    • Hệ điều hành: Raspberry Pi OS (Raspbian Buster, Kernel 4.19, kiến trúc armv7l).
    • Ngôn ngữ lập trình: Python 3.7.3.
    • Thư viện xử lý ảnh: OpenCV 3.4.3 (Biên dịch trực tiếp từ source với các cờ tối ưu hóa NEON và VFPV4 cho ARM).
    • Thư viện Deep Learning: TensorFlow 1.14.0 / Keras 2.2.4 (Biên dịch hỗ trợ tập lệnh ARM NEON).
    • Thư viện phụ trợ: Scikit-learn 0.20.4, NumPy 1.16.2, Matplotlib 3.0.2.

Phương pháp quản lý và lộ trình thực hiện

Dự án được thực hiện theo mô hình phát triển linh hoạt (Agile) chia thành 4 giai đoạn chính trong 16 tuần:

  1. Tuần 1–4: Khảo sát lý thuyết, thu thập tập dữ liệu 500 ảnh biển số xe ô tô thực tế tại Việt Nam, gán nhãn thủ công.
  2. Tuần 5–8: Xây dựng thuật toán tiền xử lý ảnh, trích xuất vùng biển số và phân đoạn ký tự bằng OpenCV trên máy tính phát triển.
  3. Tuần 9–12: Huấn luyện mô hình MobileNetV1 trên tập dữ liệu ký tự, thực hiện đóng gói và tối ưu hóa trọng số (Weight Quantization).
  4. Tuần 13–16: Biên dịch môi trường lên Raspberry Pi 3B+, tích hợp Camera Module V1, chạy thực nghiệm và tinh chỉnh tham số theo thời gian thực.

Implementation và kết quả

Quy trình phát triển thuật toán và toán học nền tảng

Cốt lõi tạo nên khả năng chạy mượt mà của mạng MobileNetV1 trên phần cứng nhúng là việc thay thế phép tích chập 2D tiêu chuẩn bằng Tích chập tách biệt chiều sâu (Depthwise Separable Convolution).

1. Nguyên lý toán học của Depthwise Separable Convolution

Giả sử bản đồ đặc trưng đầu vào có kích thước $D_F \times D_F \times M$ và cần tạo ra bản đồ đặc trưng đầu ra $D_F \times D_F \times N$ với kích thước bộ lọc là $D_K \times D_K$:

  • Chi phí tính toán của tích chập thông thường: $$\text{Cost}_{\text{Standard}} = D_K \cdot D_K \cdot M \cdot N \cdot D_F \cdot D_F$$

  • Tích chập tách biệt chiều sâu chia quá trình làm 2 bước:

    1. Depthwise Convolution: Áp dụng 1 bộ lọc đơn lẻ cho từng kênh đầu vào ($M$ bộ lọc kích thước $D_K \times D_K \times 1$).
    2. Pointwise Convolution: Áp dụng tích chập $1 \times 1$ qua $N$ bộ lọc kích thước $1 \times 1 \times M$ để tổng hợp tuyến tính các đặc trưng.

  • Tổng chi phí tính toán của Depthwise Separable Convolution: $$\text{Cost}_{\text{Separable}} = D_K \cdot D_K \cdot M \cdot D_F \cdot D_F + M \cdot N \cdot D_F \cdot D_F$$

  • Tỷ lệ giảm tải tính toán: $$\text{Ratio} = \frac{D_K \cdot D_K \cdot M \cdot D_F \cdot D_F + M \cdot N \cdot D_F \cdot D_F}{D_K \cdot D_K \cdot M \cdot N \cdot D_F \cdot D_F} = \frac{1}{N} + \frac{1}{D_K^2}$$

Với kích thước bộ lọc tiêu chuẩn $D_K = 3$, khối lượng tính toán giảm khoảng $8$ đến $9$ lần so với tích chập tiêu chuẩn, trong khi độ chính xác suy giảm không đáng kể ($<1%$).

STANDARD CONVOLUTION (KxKxM per filter):
[ Input: D_F x D_F x M ]  ---> [ Filter: D_K x D_K x M x N ] ---> [ Output: D_F x D_F x N ]
Computation: D_K * D_K * M * N * D_F * D_F

DEPTHWISE SEPARABLE CONVOLUTION:
1. Depthwise (Spatial):
   [ Input: D_F x D_F x M ] ---> [ Filter: D_K x D_K x 1 x M ] ---> [ Intermediate: D_F x D_F x M ]
2. Pointwise (Channel):
   [ Intermediate ]         ---> [ Filter: 1 x 1 x M x N ]     ---> [ Output: D_F x D_F x N ]
Computation: D_K * D_K * M * D_F * D_F + M * N * D_F * D_F

2. Mã nguồn triển khai tiền xử lý và phân tách vùng biển số (OpenCV)

import cv2
import numpy as np

def locate_and_extract_plate(image_path):
    # Đọc ảnh gốc và chuyển sang ảnh xám
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Làm mờ Gauss để giảm nhiễu hạt tần số cao
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # Nhị phân hóa cục bộ thích nghi Otsu
    _, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    
    # Toán tử hình thái học đóng (Morphological Close) để nối liền các đường biên
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (17, 3))
    closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
    
    # Tìm các đường bao (Contours)
    contours, _ = cv2.findContours(closed.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    
    plate_candidates = []
    for c in contours:
        x, y, w, h = cv2.boundingRect(c)
        aspect_ratio = float(w) / h
        area = w * h
        
        # Lọc theo tỉ lệ tiêu chuẩn của biển số ô tô Việt Nam (biển dài hoặc biển vuông)
        if (1.5 <= aspect_ratio <= 5.5) and (area > 1500):
            plate_roi = gray[y:y+h, x:x+w]
            plate_candidates.append((plate_roi, (x, y, w, h)))
            
    return plate_candidates

3. Cấu trúc mô hình phân loại ký tự MobileNetV1 rút gọn

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, DepthwiseConv2D, BatchNormalization, ReLU, GlobalAveragePooling2D, Dense, Dropout

def build_lightweight_mobilenet(input_shape=(28, 28, 1), num_classes=36):
    model = Sequential([
        # Standard Convolution Layer
        Conv2D(32, (3, 3), strides=(2, 2), padding='same', input_shape=input_shape),
        BatchNormalization(),
        ReLU(),
        
        # Depthwise Separable Block 1
        DepthwiseConv2D((3, 3), strides=(1, 1), padding='same'),
        BatchNormalization(),
        ReLU(),
        Conv2D(64, (1, 1), strides=(1, 1), padding='same'),
        BatchNormalization(),
        ReLU(),
        
        # Depthwise Separable Block 2
        DepthwiseConv2D((3, 3), strides=(2, 2), padding='same'),
        BatchNormalization(),
        ReLU(),
        Conv2D(128, (1, 1), strides=(1, 1), padding='same'),
        BatchNormalization(),
        ReLU(),
        
        # Classifier Head
        GlobalAveragePooling2D(),
        Dropout(0.3),
        Dense(num_classes, activation='softmax')
    ])
    return model

Thử nghiệm và đánh giá hiệu năng

Hệ thống được kiểm thử thực nghiệm trên 2 kịch bản độc lập:

  1. Tập dữ liệu tĩnh: 500 ảnh chụp xe ô tô thực tế tải từ diễn đàn ô tô và nguồn dữ liệu giao thông Việt Nam.
  2. Tập dữ liệu thời gian thực: Thu nhận trực tiếp tại góc quay camera đặt cố định ở cổng kiểm soát xe với 100 lượt xe ra vào.
       PHÂN BỔ THỜI GIAN SUY LUẬN TRÊN RASPBERRY PI 3B+ (Tổng: 1250ms)
┌──────────────────────────────┬──────────────────────────┬──────────────────────────┐
│  Tiền xử lý & Cắt ROI        │  Phân đoạn ký tự         │  MobileNetV1 Classifier  │
│  (350ms - 28.0%)             │  (180ms - 14.4%)         │  (720ms - 57.6%)         │
└──────────────────────────────┴──────────────────────────┴──────────────────────────┘
Kịch bản kiểm thử Tổng số mẫu Số mẫu nhận diện đúng Độ chính xác tổng thể Thời gian xử lý trung bình/ảnh
Ảnh chụp chính diện (Góc lệch $<10^\circ$) 300 282 $94.0%$ $1.20\text{ s}$
Ảnh có độ nghiêng vừa phải ($10^\circ - 25^\circ$) 200 172 $86.0%$ $1.35\text{ s}$
Tổng tập dữ liệu tĩnh (500 ảnh) 500 454 90.8% 1.25 s
Dữ liệu trực tiếp từ Camera Pi V1 100 85 85.0% 1.32 s

Phân tích lỗi và các trường hợp ngoại lệ

Qua quá trình chạy thực nghiệm, các lỗi nhận diện ký tự tập trung vào 2 nhóm chính:

  • Nhầm lẫn giữa các ký tự có đặc trưng hình thái tương đồng: Nhầm ký tự 8 với B, G với C, 0 với D, và 5 với S. Nguyên nhân do độ phân giải tại vùng ROI nhỏ sau khi tách bị vỡ hạt.
  • Mất ký tự do bóng râm hoặc ốc vít biển số: Một số phương tiện bắt ốc vít trúng vào nét chữ khiến thuật toán phân đoạn tách rời một ký tự thành hai phần riêng biệt, dẫn đến việc mô hình bỏ qua hoặc phân loại sai.

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

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

  1. Ứng dụng hiệu quả mô hình tích chập chiều sâu trên phần cứng rẻ tiền: Thay vì sử dụng các mô hình cồng kềnh tiêu tốn nhiều GFLOPS, việc triển khai MobileNetV1 trên Raspberry Pi 3B+ giúp giảm dung lượng mô hình xuống chỉ còn 4.2MB (nhỏ hơn 33 lần so với VGG16 có dung lượng 138MB), cho phép chạy hoàn toàn trên bộ nhớ RAM 1GB mà không gây nghẽn cổ chai I/O.
  2. Pipeline tích hợp linh hoạt: Kết hợp hoàn hảo giữa thuật toán hình thái học (Morphology) nhanh của OpenCV để giảm bớt không gian tìm kiếm trước khi đẩy ma trận điểm ảnh vào mạng Deep Learning, giúp giảm thời gian phân loại ký tự xuống dưới $1.5\text{ s}$.

So sánh với các công trình nghiên cứu liên quan

Tiêu chí so sánh Đề tài "Nghiên cứu thuật toán SSD" (Phan Đình Duy et al.) Đề tài "Trích xuất thông tin biển số" (Trương Văn Cương et al.) Giải pháp trong đề tài (MobileNetV1 trên Pi 3B+)
Nền tảng phần cứng NVIDIA Jetson Nano (GPU Maxwell) PC Core i7 Gen 7 + GPU GTX 1050Ti Raspberry Pi 3B+ (Không GPU rời)
Mô hình học sâu SSD (GluonCV + MXNet) Fast R-CNN / YOLO MobileNetV1 (TensorFlow/Keras)
Công suất tiêu thụ $\sim 10 - 15\text{ W}$ $> 150\text{ W}$ $\sim 3.5 - 5\text{ W}$
Chi phí phần cứng ước tính $\sim 3.500.000\text{ VNĐ}$ $\sim 18.000.000\text{ VNĐ}$ $\sim 1.200.000\text{ VNĐ}$
Độ chính xác nhận diện $\sim 85.0%$ Biển số: $95%$, Ký tự: $85%$ Ảnh tĩnh: $90.8%$, Live: $85.0%$
Thời gian thực thi $1.50\text{ s/ảnh}$ Real-time trên GPU $1.25\text{ s/ảnh}$

Việc tối ưu hóa thành công hệ thống trên bo mạch nhúng giá rẻ Raspberry Pi mang lại hiệu quả kinh tế vượt trội, giảm chi phí đầu tư thiết bị tới 65–70% so với giải pháp sử dụng Jetson Nano và hơn 90% so với giải pháp lắp đặt máy tính công nghiệp.

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

Kịch bản triển khai thực tế

+--------------------------------------------------------+
|               CỔNG BÃI ĐỖ XE THÔNG MINH                |
+--------------------------------------------------------+
                           |
        [ Xe tiến vào vùng quét cảm biến ]
                           |
                           v
+------------------+               +--------------------+
| CAMERA MODULE V1 |               | CẢM BIẾN TIỆM CẬN  |
| (Góc nghiêng <20)|               | (Phát hiện xe vào) |
+------------------+               +--------------------+
        │                                    │
        └─────────────────┬──────────────────┘
                          │
                          v
         +----------------------------------+
         |   RASPBERRY PI 3B+ XỬ LÝ ANPR    |
         |  - Tiền xử lý + MobileNetV1      |
         |  - Thời gian: ~1.25 giây         |
         +----------------------------------+
                          │
         +────────────────┴─────────────────+
         │                                  │
         v                                  v
+--------------------+            +---------------------+
| ĐIỀU KHIỂN GPIO    |            | GỬI DỮ LIỆU LOGGING |
| (Kích Relay mở     |            | (Lưu SQLite / Gửi   |
| thanh chắn Barie)  |            | REST API lên Cloud) |
+--------------------+            +---------------------+
  1. Hệ thống quản lý bãi giữ xe thông minh di động: Thiết bị được đóng gói trong một hộp chuyên dụng nhỏ gọn kết nối trực tiếp với thanh chắn barrier thông qua cổng GPIO của Raspberry Pi. Khi có tín hiệu xe vào vùng cảm biến tiệm cận, camera Pi chụp ảnh, mô hình xử lý và kích hoạt relay mở cổng trong vòng 1.5 giây.
  2. Trạm kiểm soát an ninh tại các cơ quan, xí nghiệp: Tự động đối chiếu chuỗi biển số nhận dạng được với danh sách biển số đã đăng ký nội bộ trong cơ sở dữ liệu SQLite cục bộ.

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

  • Chi phí thiết lập 1 cổng kiểm soát:
    • Raspberry Pi 3B+ & Nguồn 5V/2.5A: 950.000 VNĐ.
    • Camera Module Pi V1: 250.000 VNĐ.
    • Thẻ nhớ MicroSD 32GB SanDisk: 120.000 VNĐ.
    • Hộp bảo vệ, phụ kiện relay kết nối: 150.000 VNĐ.
    • Tổng chi phí phần cứng: $\approx 1.470.000\text{ VNĐ / node}$.
  • Thời gian hoàn vốn: So với việc thuê nhân sự soát vé thủ công (chi phí 6–8 triệu VNĐ/tháng/vị trí), một trạm kiểm soát tự động hoàn vốn đầu tư chỉ sau chưa đầy 1 tháng vận hành.

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

Các hạn chế kỹ thuật hiện tại

  • Độ nhạy sáng và khả năng lấy nét: Camera Pi V1 sử dụng cảm biến tiêu cự cố định (Fixed Focus), khẩu độ nhỏ nên chất lượng ảnh suy giảm rõ rệt trong điều kiện ánh sáng yếu vào ban đêm hoặc khi xe di chuyển ở tốc độ $>30\text{ km/h}$.
  • Chưa xử lý triệt để góc nghiêng lớn: Khi biển số bị nghiêng một góc vượt quá $30^\circ$, thuật toán trích xuất khung chữ nhật bao quanh dễ làm mất một phần ký tự ở rìa ngoài.
  • Tốc độ xử lý: Thời gian $1.25\text{ s/ảnh}$ đáp ứng tốt cho trạm dừng đỗ kiểm soát nhưng chưa đủ nhanh để áp dụng cho hệ thống thu phí không dừng (ETC) trên đường cao tốc.

Hướng nâng cấp và phát triển

┌────────────────────────────────────────────────────────┐
│             HƯỚNG NÂNG CẤP VÀ TỐI ƯU HÓA              │
└────────────────────────────────────────────────────────┘
                           │
         +-----------------+-----------------+
         │                                   │
         ▼                                   ▼
┌──────────────────┐               ┌────────────────────┐
│ PHẦN CỨNG        │               │ THUẬT TOÁN         │
│ - Pi 4B (4GB RAM)│               │ - YOLOv8-Nano / NCNN│
│ - Coral USB NPU  │               │ - TFLite INT8 Quant│
│ - IR Night Cam   │               │ - Spatial Trans.Net│
└──────────────────┘               └────────────────────┘
         │                                   │
         +-----------------+-----------------+
                           │
                           v
         ┌───────────────────────────────────┐
         │ KẾT QUẢ: 25-30 FPS, Latency <100ms│
         └───────────────────────────────────┘
  1. Nâng cấp phần cứng: Chuyển dịch sang sử dụng Raspberry Pi 4B (4GB/8GB RAM) hoặc tích hợp thêm USB tăng tốc thần kinh chuyên dụng như Google Coral TPU (Edge TPU) để nâng tốc độ xử lý lên mức $25 - 30\text{ FPS}$.
  2. Tối ưu hóa mô hình với TensorFlow Lite (TFLite): Chuyển đổi mô hình MobileNet sang định dạng TFLite và lượng tử hóa số nguyên 8-bit (INT8 Quantization), giúp giảm $75%$ dung lượng mô hình và tăng tốc độ suy luận gấp $2-3$ lần trên kiến trúc ARM.
  3. Cải tiến camera: Trang bị module Camera góc rộng có khả năng tự động điều chỉnh tiêu cự (Auto-focus) và hỗ trợ đèn LED hồng ngoại (IR Night Vision) để đảm bảo độ chính xác nhận diện ban đêm đạt trên $90%$.

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

  • Sinh viên & Học viên ngành Kỹ thuật Máy tính / IoT: Cung cấp tài liệu tham khảo chi tiết về quy trình tối ưu hóa mô hình học sâu, biên dịch thư viện mã nguồn mở C++/Python (OpenCV, TensorFlow) trực tiếp trên môi trường vi điều khiển/máy tính nhúng.
  • Lập trình viên & Kỹ sư nhúng: Mô hình mẫu về kiến trúc Edge AI chi phí thấp; giải pháp khắc phục triệt để bài toán thắt nút cổ chai phần cứng khi không có GPU rời.
  • Doanh nghiệp & Đơn vị quản lý bãi đỗ xe: Bản thiết kế hệ thống hoàn chỉnh, sẵn sàng thương mại hóa với mức chi phí đầu tư ban đầu cực thấp, dễ dàng bảo trì và thay thế linh kiện.
  • Cộng đồng nghiên cứu Computer Vision: Dữ liệu thực nghiệm phong phú về việc so sánh hiệu năng giữa các kiến trúc mạng cổ điển (VGG, Fast R-CNN) và kiến trúc nhẹ (MobileNet) trên bài toán xử lý ảnh biển số xe đặc thù tại Việt Nam.

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

1. Yêu cầu phần cứng tối thiểu để hệ thống vận hành ổn định là gì?

Hệ thống yêu cầu bo mạch tối thiểu từ Raspberry Pi 3 Model B+ (CPU Quad-Core 1.4GHz, RAM 1GB), thẻ nhớ MicroSD dung lượng từ 16GB chuẩn Class 10/UHS-1, bộ nguồn ổn định 5V/2.5A và Module Camera Pi V1 hoặc V2 tương thích giao tiếp MIPI CSI.

2. Làm thế nào để giải quyết hiện tượng tràn RAM khi huấn luyện hoặc load mô hình Deep Learning trên Raspberry Pi?

Không thực hiện huấn luyện mô hình trực tiếp trên Raspberry Pi. Toàn bộ quá trình training được thực hiện trên máy tính cấu hình cao hoặc Google Colab. Sau khi huấn luyện xong, mô hình được đóng gói sang dạng file trọng số nhẹ .h5 hoặc .tflite rồi nạp vào Pi chỉ để phục vụ quá trình suy luận (Inference Only).

3. Hệ thống có thể tích hợp với các hệ thống quản trị bãi xe có sẵn không?

Hoàn toàn có thể. Chương trình viết bằng Python có thể dễ dàng xuất dữ liệu đầu ra dưới dạng JSON, ghi trực tiếp vào cơ sở dữ liệu SQLite/MySQL nội bộ hoặc gửi bản tin HTTP POST qua mạng LAN/Wi-Fi tới hệ thống quản lý trung tâm.

4. Tại sao nhóm tác giả lại tự biên dịch (build from source) OpenCV 3 thay vì cài đặt bằng pip install?

Việc tự biên dịch OpenCV trực tiếp trên hệ điều hành Raspbian cho phép bật các cờ tối ưu hóa phần cứng dành riêng cho chip ARM Cortex-A53 (như tập lệnh NEON và VFPV4). Điều này giúp tốc độ xử lý các phép toán ma trận điểm ảnh nhanh hơn từ $20 - 35%$ so với các bản phân phối tiền biên dịch qua pip.

5. Chi phí tổng thể và thời gian triển khai một điểm kiểm soát là bao nhiêu?

Chi phí linh kiện trọn gói cho một bộ thiết bị phần cứng dao động từ 1.200.000 đến 1.500.000 VNĐ. Thời gian lắp đặt, nạp thẻ nhớ hệ điều hành và cân chỉnh góc quay camera chỉ mất khoảng 2 đến 3 giờ làm việc.

Kết luận

Đề tài tốt nghiệp "Nghiên cứu và xây dựng chương trình nhận diện biển số xe với Deep Learning sử dụng Raspberry Pi" của sinh viên Nguyễn Quốc Toản và Nguyễn Quang Huy tại Trường Đại học Công nghệ Thông tin - ĐHQG-HCM đã chứng minh tính khả thi vượt trội của việc ứng dụng công nghệ Trí tuệ Nhân tạo tại biên (Edge AI). Bằng cách khai thác tối đa sức mạnh của kiến trúc mạng MobileNetV1 với cơ chế tích chập tách biệt chiều sâu cùng các thuật toán hình thái học tối ưu của OpenCV, hệ thống đạt độ chính xác $90.8%$ trên ảnh tĩnh và $85.0%$ trên camera thực tế với thời gian xử lý chỉ $1.25\text{ giây/ảnh}$.

Đây là giải pháp công nghệ mang tính ứng dụng thực tiễn cao, giải quyết bài toán cân bằng giữa hiệu năng kỹ thuật và chi phí kinh tế, mở ra tiềm năng ứng dụng rộng rãi trong các hệ thống giao thông thông minh và đô thị thông minh tại Việt Nam. Bạn có thể áp dụng ngay kiến trúc này để xây dựng các giải pháp IoT nhận dạng hình ảnh tiết kiệm chi phí cho doanh nghiệp của mình.