Giới thiệu dự án

Sự bùng nổ của cuộc Cách mạng Công nghiệp 4.0 cùng Internet vạn vật (IoT - Internet of Things) đã tạo ra bước nhảy vọt về số lượng thiết bị kết nối toàn cầu. Theo báo cáo từ IoT Analytics, số lượng thiết bị kết nối IoT đạt xấp xỉ 23.9 tỷ thiết bị vào năm 2020 và dự kiến tăng trưởng với tốc độ CAGR 13%, vượt mốc 41.2 tỷ thiết bị vào năm 2025. Đồng thời, theo thống kê từ Statista, khối lượng dữ liệu sinh ra từ các hệ thống IoT tăng phi mã từ 13.6 Zettabytes (2016) lên đến 79.4 Zettabytes (2025).

Trong lĩnh vực giao thông thông minh (Intelligent Transportation Systems - ITS), việc triển khai hàng triệu camera giám sát độ phân giải cao truyền tải luồng video trực tiếp (raw video streaming) về máy chủ đám mây trung tâm (Cloud Computing) đang bộc lộ những điểm nghẽn nghiêm trọng:

  • Nghẽn băng thông mạng (Network Bandwidth Saturation): Truyền tải liên tục hàng nghìn luồng video 1080p/4K gây quá tải hạ tầng mạng truyền dẫn.
  • Độ trễ cao (High Latency Bottleneck): Thời gian phản hồi vòng (Round-trip time - RTT) từ camera lên đám mây và trả về kết quả thường vượt ngưỡng 1.5–3 giây, không đáp ứng được yêu cầu phản ứng thời gian thực trong việc phát hiện vi phạm hoặc xe bị đánh cắp.
  • Rủi ro an toàn và bảo mật dữ liệu (Privacy & Single Point of Failure): Dữ liệu hình ảnh thô dễ bị đánh chặn trên đường truyền, đồng thời rủi ro sập máy chủ trung tâm làm tê liệt toàn bộ mạng lưới giám sát.
+-------------------------------------------------------------------------+
|                              CLOUD LAYER                                |
|   +-----------------------------------------------------------------+   |
|   | Microsoft Azure VM (K3s Master Node) + MongoDB Atlas + Web API |   |
|   +-----------------------------------------------------------------+   |
+-------------------------------------------------------------------------+
                                    ▲
                                    │ (Metadata & Alert Logs Only)
                                    ▼
+-------------------------------------------------------------------------+
|                               EDGE LAYER                                |
|   +-----------------------------------------------------------------+   |
|   | Raspberry Pi 3B+ (K3s Worker Node / Docker Container)           |   |
|   | - TensorFlow Lite Inference Engine (YOLOv4-TFLite)              |   |
|   | - OpenCV Preprocessing & Character Extraction                   |   |
|   +-----------------------------------------------------------------+   |
+-------------------------------------------------------------------------+
                                    ▲
                                    │ (Raw Video Stream)
                                    ▼
+-------------------------------------------------------------------------+
|                              DEVICE LAYER                               |
|   [ USB/CSI Traffic Surveillance Cameras (Xe tuần tra / Ngã tư) ]      |
+-------------------------------------------------------------------------+

Phát biểu vấn đề

Đề tài "Ứng dụng Edge Computing để phát triển Camera thông minh cho hệ thống giám sát phương tiện giao thông" tập trung giải quyết bài toán phân tán năng lực tính toán và ứng dụng trí tuệ nhân tạo (AI - Artificial Intelligence) trực tiếp tại cận biên (Edge), chuyển đổi luồng xử lý từ mô hình thuần Cloud sang mô hình Hybrid Cloud-Edge.

Mục tiêu dự án

  1. Xây dựng mô hình AI nhận diện biển số xe: Huấn luyện mô hình học sâu (Deep Learning) tối ưu hóa phát hiện vùng chứa biển số xe máy và ô tô từ hình ảnh camera, chuyển đổi mô hình sang định dạng siêu nhẹ phù hợp cho phần cứng nhúng.
  2. Triển khai kiến trúc tính toán cận biên (Edge Computing): Đóng gói ứng dụng xử lý thị giác máy tính vào Docker Container và vận hành trên vi máy tính nhúng Raspberry Pi 3 Model B+.
  3. Điều phối container tự động với Kubernetes (K3s): Thiết lập mô hình phân tán từ Cloud (Master Node) đến Edge (Worker Node) bằng K3s nhằm đảm bảo khả năng mở rộng (scalability), cân bằng tải, tự phục hồi (self-healing) và cập nhật không downtime (zero-downtime rolling update).
  4. Xây dựng trung tâm điều hành Web Application: Phát triển giao diện quản trị thời gian thực để tiếp nhận metadata, tra cứu phương tiện nghi vấn/vi phạm trong cơ sở dữ liệu và cung cấp công cụ tìm kiếm thủ công cho lực lượng chức năng.

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

  • Phương pháp tiếp cận: Sử dụng YOLOv4 huấn luyện trên Google Colab với tập dữ liệu hơn 3,000 ảnh gán nhãn thực tế, chuyển đổi sang TensorFlow Lite (.tflite), kết hợp kỹ thuật tiền xử lý hình ảnh OpenCV trên nền tảng K3s/Docker.
  • Chỉ số kỳ vọng: Tốc độ suy luận (inference time) dưới 350ms/khung hình trên vi xử lý ARM; giảm hơn 80% lưu lượng băng thông truyền về Cloud; độ chính xác phát hiện biển số đạt trên 90%.
  • Phạm vi và giới hạn: Thử nghiệm trên biển số xe cơ giới tại Việt Nam trong điều kiện ánh sáng đa dạng; hệ thống biên chạy trên phần cứng Raspberry Pi 3B+ (Broadcom BCM2837B0, RAM 1GB).

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

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

Hiện nay, các giải pháp nhận diện biển số tự động (ALPR - Automatic License Plate Recognition) trên thị trường chủ yếu chia làm hai trường phái: Cloud-centric (toàn bộ video gửi về máy chủ đám mây) và Pure Edge độc lập (xử lý cục bộ không có quản lý tập trung).

Tiêu chí phân tích Hệ thống Pure Cloud ALPR Hệ thống Pure Edge ALPR Hệ thống Hybrid Edge-Cloud (Đề tài)
Băng thông mạng tiêu thụ Cực lớn (stream video 1080p liên tục) Rất thấp (không gửi video) Tối ưu (chỉ gửi ảnh cắt biển số + chuỗi text)
Độ trễ xử lý (Latency) Cao (1.5s - 3.5s do trễ truyền dẫn) Rất thấp (< 300ms) Thấp và ổn định (200ms - 400ms)
Khả năng quản trị hạ tầng Rất tốt (quản lý tập trung trên Cloud) Kém (cấu hình thủ công từng thiết bị) Xuất sắc (điều phối qua Kubernetes/K3s)
Bảo mật và riêng tư dữ liệu Nguy cơ rò rỉ dữ liệu video cao Dữ liệu cô lập, khó đồng bộ Bảo mật cao (mã hóa metadata, lọc dữ liệu biên)
Khả năng phục hồi sự cố Phụ thuộc hoàn toàn vào kết nối mạng Thiết bị lỗi cần can thiệp tại chỗ Tự phục hồi (K3s self-healing pods)

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

  • Must Have (Bắt buộc): Nhận diện chính xác vị trí biển số xe; trích xuất chuỗi ký tự biển số; xử lý thời gian thực trên Raspberry Pi; gửi kết quả phân tích về Cloud; giao diện tra cứu phương tiện.
  • Should Have (Nên có): Điều phối tự động bằng K3s Cluster; cập nhật container image từ xa qua Docker Hub; đối soát tự động với danh sách xe mất cắp trong cơ sở dữ liệu.
  • Could Have (Có thể có): Phân tích hướng di chuyển; phát hiện vi phạm vượt đèn đỏ; tích hợp cảnh báo đẩy thời gian thực qua Webhook.
  • Won't Have (Chưa thực hiện đợt này): Nhận diện khuôn mặt người điều khiển; xử lý video tốc độ cao 60fps trên phần cứng không có GPU chuyên dụng.

Thiết kế hệ thống

graph TD
    subgraph Edge_Device["Edge Node (Raspberry Pi 3B+)"]
        Cam[Camera Feed] --> Capture[Frame Capture & Queue]
        Capture --> TFLiteEngine["TensorFlow Lite Engine (YOLOv4-tiny quantized)"]
        TFLiteEngine --> Cropper[Plate Extraction]
        Cropper --> CVProcessing["OpenCV Preprocessing (Binarization & OCR)"]
        CVProcessing --> EdgeAgent[Node.js Edge Client]
    end

    subgraph Cloud_Cluster["Cloud Server (Azure VM - Master Node)"]
        EdgeAgent -->|HTTP POST JSON + Cropped Image| APIGateway[Node.js / Express Web Server]
        K3sMaster[K3s Master Controller] -.->|Orchestration & Deployments| Edge_Device
        APIGateway --> MongoService[(MongoDB Atlas Database)]
        APIGateway --> WebUI[Realtime Dashboard Interface]
    end

    WebUI --> PoliceUser[Cán bộ CSGT / Giám sát viên]

Tech Stack và phiên bản công nghệ:

  • Hạ tầng AI/Training: Google Colab (Tesla T4 GPU), Darknet Framework, TensorFlow v2.5.0, TensorFlow Lite.
  • Xử lý hình ảnh biên: OpenCV v4.5.1-dev, Python v3.8.
  • Ảo hóa & Điều phối: Docker Engine Community v20.10.x, K3s (Lightweight Kubernetes) v1.21.x-k3s1.
  • Hạ tầng Edge: Raspberry Pi 3 Model B+ (Broadcom BCM2837B0 Quad-Core 1.4GHz, 1GB LPDDR2 SDRAM, OS: Raspberry Pi OS Lite 32-bit).
  • Hạ tầng Cloud: Microsoft Azure Virtual Machine (Ubuntu Server 20.04 LTS, 2 vCPUs, 4GB RAM), Docker Hub Container Registry.
  • Backend & Database: Node.js v14.17.x, Express.js v4.17.x, MongoDB Atlas Cluster v4.4 (M0 Free Tier).
  • Frontend: HTML5, CSS3, JavaScript ES6, Bootstrap 4.6.

Thiết kế Cơ sở dữ liệu (MongoDB Schema):

Hệ thống sử dụng cơ sở dữ liệu phi quan hệ MongoDB Atlas gồm 3 collections chính:

// Collection: vehicles
{
  "_id": ObjectId("607d2f9a1c9d440000a1b2c3"),
  "license_plate": "59P1-12345",
  "vehicle_type": "Motorcycle",
  "owner_name": "Nguyen Van A",
  "registration_date": "2020-05-12T00:00:00Z",
  "status": "STOLEN", // NORMAL, STOLEN, SUSPICIOUS, WANTED
  "color": "Red-Black",
  "brand": "Honda AirBlade"
}

// Collection: detections
{
  "_id": ObjectId("607d30aa1c9d440000a1b2c4"),
  "license_plate": "59P1-12345",
  "edge_node_id": "rpi-edge-node-01",
  "location": "Nga tu Thu Duc, TP. Thu Duc",
  "timestamp": "2021-04-19T08:30:15.123Z",
  "confidence_score": 0.8958,
  "image_url": "https://storage.azure.com/detections/20210419_59P112345.jpg",
  "is_alert_triggered": true
}

Thiết kế API Endpoints:

Method Endpoint Mô tả Payload / Response
POST /api/v1/edge/detection Tiếp nhận kết quả phân tích từ Edge Node { node_id, plate, timestamp, image_base64 } $\rightarrow$ 201 Created
GET /api/v1/vehicles/:plate Truy vấn thông tin đăng kiểm và cảnh báo phương tiện Trả về thông tin chủ sở hữu và trạng thái vi phạm
GET /api/v1/detections/latest Lấy danh sách 20 phương tiện vừa phát hiện Dữ liệu render dashboard thời gian thực
POST /api/v1/vehicles/manual-check Tra cứu thủ công qua biển số do CSGT nhập { plate_number } $\rightarrow$ JSON chi tiết xe

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

Dự án áp dụng mô hình Agile/Scrum rút gọn chia làm 5 Sprint (mỗi Sprint 2 tuần):

  • Sprint 1: Nghiên cứu tổng quan Edge Computing, thu thập và gán nhãn 3,000+ ảnh dataset biển số xe (LabelImg).
  • Sprint 2: Huấn luyện mô hình YOLOv4 trên Darknet/Google Colab; lượng tử hóa mô hình sang TFLite.
  • Sprint 3: Phát triển pipeline xử lý ảnh OpenCV tại biên; đóng gói Docker Container cho kiến trúc ARMv7.
  • Sprint 4: Thiết lập K3s Master (Azure VM) và K3s Agent (Raspberry Pi 3B+); xây dựng Node.js API và MongoDB Atlas.
  • Sprint 5: Tích hợp Web Dashboard, kiểm thử trên kịch bản video thực tế, đo lường benchmark và tối ưu hóa hệ thống.

Implementation và kết quả

Quy trình phát triển và Huấn luyện AI

1. Huấn luyện mô hình YOLOv4 trên Google Colab

Quá trình huấn luyện sử dụng cấu hình Darknet chuyên dụng cho bài toán 1 class (license_plate). Tệp cấu hình yolov4-custom.cfg được điều chỉnh:

  • batch=64, subdivisions=16, max_batches=6000, steps=4800,5400
  • width=416, height=416, classes=1, filters=18 (tính theo công thức $(classes + 5) \times 3$)
# Trích xuất từ log huấn luyện Darknet trên Google Colab
v3 (iou loss, Normalizer: (iou: 0.07, obj: 1.00, cls: 1.00))
6000: 0.124560, 0.118945 avg loss, 0.000100 rate, 7.854321 seconds, 384000 images
Loaded: 0.000045 seconds
v3 (iou loss, Normalizer: (iou: 0.07, obj: 1.00, cls: 1.00)) Avg IOU: 0.895859, count: 6558
Saving weights to /content/drive/MyDrive/weights/yolov4-custom_final.weights

2. Lượng tử hóa và chuyển đổi sang TensorFlow Lite

Mô hình .weights từ Darknet được chuyển sang TensorFlow SavedModel, sau đó tối ưu hóa thành định dạng .tflite để giảm kích thước từ 245 MB xuống còn xấp xỉ 23 MB, tối ưu cho tập lệnh NEON trên vi xử lý ARM của Raspberry Pi 3B+:

import tensorflow as tf

# Convert SavedModel to TensorFlow Lite format with post-training quantization
converter = tf.lite.TFLiteConverter.from_saved_model('/content/drive/MyDrive/saved_model')
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]  # FP16 Quantization
tflite_quant_model = converter.convert()

with open('/content/drive/MyDrive/yolov4_plate_detect.tflite', 'wb') as f:
    f.write(tflite_quant_model)

3. Thuật toán trích xuất và xử lý hình ảnh tại Edge Node

Quy trình phân tích luồng video tại biên được hiện thực qua các bước:

  1. Load Interpreter TFLite: Nạp mô hình .tflite và cấp phát tensors.
  2. Object Detection: Trích xuất bounding boxes $(ymin, xmin, ymax, xmax)$ với ngưỡng tin cậy $Confidence \ge 0.7$.
  3. Cắt và tiền xử lý (Cropping & Adaptive Preprocessing): Sử dụng OpenCV chuyển đổi vùng biển số sang ảnh xám (Grayscale), áp dụng Gaussian Blur để khử nhiễu và Adaptive Thresholding (Otsu binarization) nhằm tách nền ký tự.
  4. Phân đoạn ký tự (Contour Extraction): Tìm đường bao các ký tự, lọc bỏ các khối nhiễu dựa trên tỷ lệ khung hình (aspect ratio $0.2 \le \frac{w}{h} \le 0.8$) và nhận dạng chuỗi ký tự.
# Trích đoạn xử lý ảnh tại Edge (Python 3 / OpenCV)
import cv2
import numpy as np

def extract_plate_characters(plate_img):
    # Chuyển ảnh xám
    gray = cv2.cvtColor(plate_img, cv2.COLOR_BGR2GRAY)
    # Khử nhiễu
    blur = cv2.GaussianBlur(gray, (5, 5), 0)
    # Nhị phân hóa thích nghi
    thresh = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]
    
    # Tìm contours ký tự
    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    character_boxes = []
    
    for cnt in contours:
        x, y, w, h = cv2.boundingRect(cnt)
        aspect_ratio = w / float(h)
        # Lọc contours thỏa mãn kích thước chữ số
        if 0.2 < aspect_ratio < 0.8 and h > (plate_img.shape[0] * 0.4):
            character_boxes.append((x, y, w, h))
            
    # Sắp xếp ký tự từ trái sang phải
    character_boxes = sorted(character_boxes, key=lambda b: b[0])
    return thresh, character_boxes

4. Đóng gói Container và Điều phối K3s Cluster

Ứng dụng biên được đóng gói bằng Dockerfile tối ưu trên nền tảng arm32v7/python:3.8-slim-buster:

FROM arm32v7/python:3.8-slim-buster

WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends \
    libgl1-mesa-glx libglib2.0-0 libatlas-base-dev && \
    rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .
CMD ["python3", "edge_inference_stream.py"]

Thiết lập K3s Deployment triển khai trực tiếp từ Azure Master xuống Raspberry Pi Worker Node:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: edge-camera-inference
  labels:
    app: alpr-edge
spec:
  replicas: 1
  selector:
    matchLabels:
      app: alpr-edge
  template:
    metadata:
      labels:
        app: alpr-edge
    spec:
      nodeSelector:
        kubernetes.io/hostname: raspberrypi
      containers:
      - name: license-plate-analyzer
        image: truongnguyen/alpr-edge-arm:v1.0
        resources:
          limits:
            memory: "600Mi"
            cpu: "800m"
          requests:
            memory: "300Mi"
            cpu: "400m"
        securityContext:
          privileged: true

Thử nghiệm và đánh giá hệ thống

Kịch bản thử nghiệm

  • Tập kiểm thử tĩnh (Static Test): 300 ảnh chụp xe máy và ô tô ngẫu nhiên tại các bãi giữ xe và đường giao thông trong điều kiện: ban ngày đủ sáng, trời mưa, ban đêm có đèn đường, biển số bị nghiêng góc 15-30 độ, biển số bị bám bụi mờ.
  • Tập kiểm thử động (Video Stream Test): Luồng video 720p@30fps giả lập camera giám sát gắn trên xe tuần tra CSGT và camera cố định tại nút giao lộ.

Kết quả thử nghiệm chi tiết:

Kịch bản thử nghiệm Số mẫu Phát hiện vùng biển số chính xác Đọc đúng ký tự hoàn toàn Tỷ lệ chính xác tổng thể
Ánh sáng ban ngày (Đầy đủ) 120 118 (98.3%) 114 (95.0%) 95.0%
Ánh sáng ban đêm / Ngược sáng 80 72 (90.0%) 65 (81.25%) 81.25%
Biển số nghiêng góc / Rung lắc 60 54 (90.0%) 49 (81.67%) 81.67%
Biển số mờ / Dính bùn đất 40 33 (82.5%) 26 (65.0%) 65.0%
Tổng kết nghiệm thu 300 ảnh 300 277 (92.33%) 254 (84.67%) 84.67%

Benchmark hiệu năng phần cứng trên Raspberry Pi 3B+:

  • Thời gian phân tích trung bình: ~280ms – 340ms / khung hình (đáp ứng xử lý 3 khung hình/giây - đủ cho bài toán phát hiện xe di chuyển qua khung hình camera).
  • Mức tiêu thụ tài nguyên CPU: Trung bình 68% trên 4 lõi Broadcom 1.4GHz.
  • Chiếm dụng RAM: 420MB / 1GB RAM (ổn định, không phát sinh memory leak).
  • Độ trễ truyền tải dữ liệu về Cloud: 45ms – 80ms (gói tin JSON + ảnh thumbnail cắt gọn ~15KB so với luồng video gốc > 2MB/s).

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

Đổi mới công nghệ

  1. Kiến trúc Edge-to-Cloud phân cấp tối ưu: Thay vì sử dụng mô hình truyền dữ liệu nguyên khối, hệ thống thực hiện giải thuật Computing Offloading, chuyển toàn bộ tác vụ tính toán thị giác máy tính nặng (heavy CV computation) về thiết bị biên, chỉ gửi kết quả phân tích (metadata) về Cloud.
  2. Ứng dụng K3s trong quản trị hệ thống nhúng IoT: Áp dụng phiên bản rút gọn của Kubernetes (K3s) với footprint nhị phân < 100MB, mang lại khả năng quản trị tập trung hàng loạt trạm camera phân tán địa lý mà trước đây chỉ áp dụng cho máy chủ Enterprise.
  3. Pipeline suy luận AI siêu nhẹ: Kết hợp giữa YOLOv4 và kỹ thuật lượng tử hóa TensorFlow Lite FP16, cho phép một vi máy tính có giá thành thấp ($35-$45) như Raspberry Pi 3B+ thực thi tốt các mạng nơ-ron tích chập (CNN).
+-----------------------------------------------------------------------------------+
|               HIỆU QUẢ TIẾT KIỆM TÀI NGUYÊN SO VỚI MÔ HÌNH CLOUD TRUYỀN THỐNG       |
+-----------------------------------------------------------------------------------+
| Băng thông truyền thông:     [█████████████████████████████████████] Giảm 85.5%   |
| Độ trễ phản hồi cảnh báo:   [████████████████████████████]         Giảm 72.0%    |
| Chi phí lưu trữ Cloud/tháng: [██████████████████████████████████]   Giảm 65.0%    |
+-----------------------------------------------------------------------------------+

Đóng góp thực tiễn và học thuật

  • Cung cấp kiến trúc tham chiếu (reference architecture) hoàn chỉnh, từ khâu thiết kế pipeline dữ liệu, huấn luyện mô hình, đóng gói container đến điều phối K3s cho sinh viên và kỹ sư ngành Mạng máy tính & Truyền thông.
  • Chứng minh tính khả thi của giải pháp bảo vệ an ninh trật tự thông minh tại Việt Nam với chi phí phần cứng cực kỳ tiết kiệm nhưng vẫn đảm bảo độ tin cậy vận hành.

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

Tình huống triển khai thực tế (Use Cases)

  1. Gắn trên xe tuần tra của Lực lượng Cảnh sát Giao thông (CSGT): Camera gắn phía trước xe tuần tra tự động quét biển số các phương tiện đang lưu thông trên tuyến đường. Khi phát hiện biển số nằm trong danh sách "Xe bị mất cắp" hoặc "Xe đang bị truy tìm", hệ thống ngay lập tức phát tín hiệu cảnh báo trên màn hình điều khiển để CSGT dừng xe kiểm tra.
  2. Hệ thống giám sát tại các nút giao thông trọng điểm (Phạt nguội): Camera tĩnh tại ngã tư tự động ghi nhận biển số và thời gian lưu thông, hỗ trợ trích xuất lịch trình phục vụ điều tra án hình sự hoặc xử phạt vi phạm hành chính.
  3. Bãi đỗ xe thông minh và Trạm thu phí không dừng: Tự động đối chiếu thông tin vé tháng, kiểm soát xe ra vào không cần nhân viên gác cổng, nâng cao tốc độ giải phóng lưu lượng tại các cổng kiểm soát.
                    +------------------------------------+
                    |  Camera ghi hình phương tiện      |
                    +------------------------------------+
                                      │
                                      ▼
                    +------------------------------------+
                    |  Raspberry Pi 3B+ phân tích biên   |
                    |  - Bounding Box Plate              |
                    |  - Character OCR                   |
                    +------------------------------------+
                                      │
                                      ▼
                    +------------------------------------+
                    |  Gửi JSON metadata lên Azure Cloud |
                    +------------------------------------+
                                      │
                         ┌────────────┴────────────┐
                         ▼                         ▼
            +------------------------+ +------------------------+
            |  Trùng khớp XE MẤT CẮP | |  Phương tiện BÌNH THƯỜNG|
            +------------------------+ +------------------------+
                         │                         │
                         ▼                         ▼
            +------------------------+ +------------------------+
            | CẢNH BÁO ĐỎ TỨC THÌ    | | Ghi nhật ký lưu thông  |
            | Đến Web CSGT / Còi hú  | | vào MongoDB Atlas      |
            +------------------------+ +------------------------+

Hướng dẫn triển khai từng bước

  1. Cấu hình Edge Node (Raspberry Pi 3B+):
    • Cài đặt hệ điều hành Raspberry Pi OS Lite (32-bit), cấu hình SSH và kết nối mạng Wi-Fi/4G.
    • Cài đặt Docker Engine: curl -fsSL https://get.docker.com -o get-docker.sh && sh get-docker.sh.
    • Cài đặt K3s Agent kết nối về Azure Master: 
      curl -sfL https://get.k3s.io | K3S_URL=https://<AZURE_MASTER_IP>:6443 K3S_TOKEN=<CLUSTER_SECRET_TOKEN> sh -
  2. Khởi tạo Master Node trên Microsoft Azure VM:
    • Tạo VM Ubuntu 20.04 LTS, mở cổng 6443 (K3s API), 80/443 (Web App), 27017 (MongoDB).
    • Cài đặt K3s Server: curl -sfL https://get.k3s.io | sh -
    • Lấy token xác thực tại /var/lib/rancher/k3s/server/node-token.
  3. Triển khai ứng dụng qua Kubernetes Manifest:
    • Thực thi lệnh kubectl apply -f edge-deployment.yaml từ Master Node để tự động pull image từ Docker Hub và khởi chạy Pod trên Raspberry Pi.

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

Hạn chế kỹ thuật hiện tại

  • Năng lực phần cứng Raspberry Pi 3B+: Vi xử lý ARM Cortex-A53 thế hệ cũ không có bộ tăng tốc phần cứng NPU (Neural Processing Unit), dẫn đến tốc độ khung hình xử lý bị giới hạn ở 3–4 FPS, chưa đáp ứng tốt phương tiện di chuyển ở vận tốc cao (> 60 km/h).
  • Bộ dữ liệu huấn luyện: Dữ liệu thu thập chủ yếu từ camera bãi xe và ngã tư ban ngày; tỷ lệ nhận diện giảm khi gặp điều kiện thời tiết khắc nghiệt (mưa lớn, sương mù, biển số cong vênh hoặc mất nét sơn).
  • Góc chụp camera: Độ chính xác suy giảm khi góc nghiêng camera so với mặt phẳng biển số vượt quá 35 độ.

Lộ trình nâng cấp và mở rộng

  • Nâng cấp phần cứng: Chuyển đổi sang Raspberry Pi 4 Model B (RAM 4GB/8GB) hoặc NVIDIA Jetson Nano / Raspberry Pi AI Kit để tăng tốc độ suy luận lên 15–25 FPS thông qua GPU CUDA / TensorRT.
  • Tự động hóa CI/CD: Xây dựng pipeline CI/CD tự động bằng GitHub Actions: khi cập nhật mã nguồn hoặc retraining mô hình AI mới, hệ thống tự động build Docker Image đa kiến trúc (ARMv7/ARM64/AMD64), push lên Docker Hub và thực hiện rolling update trên toàn bộ K3s cluster.
  • Tích hợp Mobile App: Phát triển ứng dụng di động cho CSGT tuần tra trên nền tảng Flutter/React Native, nhận thông báo đẩy tức thì (Push Notifications qua Firebase Cloud Messaging) kèm tọa độ GPS của xe nghi vấn.

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

1. Sinh viên và Giảng viên ngành Mạng & IoT

  • Giá trị học tập: Tài liệu tham khảo toàn diện về việc kết hợp giữa 3 trụ cột: IoT – AI – Cloud/Edge Computing.
  • Minh họa thực tế: Bộ source code mẫu về việc tích hợp K3s điều phối thiết bị nhúng và chuyển đổi mô hình học sâu sang thiết bị biên.

2. Kỹ sư và Lập trình viên hệ thống nhúng (Embedded & DevOps Engineers)

  • Kỹ thuật thực chiến: Kinh nghiệm tối ưu hóa Dockerfile cho kiến trúc ARMv7, giải quyết bài toán cấp phát bộ nhớ giới hạn và kỹ thuật xử lý ảnh OpenCV không đồng bộ.

3. Doanh nghiệp và Đơn vị quản lý Giao thông đô thị

  • Lợi ích kinh tế: Tiết kiệm hàng tỷ đồng chi phí hạ tầng mạng và máy chủ đám mây nhờ cắt giảm 85% lưu lượng băng thông truyền dẫn.
  • Tối ưu vận hành: Nâng cao hiệu quả phát hiện phương tiện vi phạm và phục hồi phương tiện bị mất cắp cho người dân.

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

1. Yêu cầu phần cứng tối thiểu để triển khai một trạm camera thông minh tại biên là gì?

Hệ thống yêu cầu tối thiểu một vi máy tính Raspberry Pi 3 Model B+ (Broadcom Quad-Core 1.4GHz, 1GB RAM) hoặc các bo mạch tương đương có hỗ trợ Docker (ARMv7 trở lên), một thẻ nhớ microSD tối thiểu 16GB Class 10 (tốc độ đọc $\ge 80MB/s$), nguồn cấp ổn định 5V/2.5A và một Camera Module USB/CSI độ phân giải tối thiểu 720p.

2. Tại sao lại chọn K3s thay vì Kubernetes (K8s) tiêu chuẩn của Google?

Kubernetes tiêu chuẩn yêu cầu tài nguyên phần cứng lớn (tối thiểu 2GB RAM cho control-plane và nhiều thành phần phụ thuộc), không thể chạy ổn định trên các thiết bị nhúng 1GB RAM như Raspberry Pi 3B+. K3s là bản phân phối Kubernetes được CNCF chứng nhận, đã lược bỏ các driver đám mây dư thừa, gói gọn trong một file nhị phân duy nhất với dung lượng RAM yêu cầu chỉ khoảng 512MB, cực kỳ lý tưởng cho Edge Computing.

3. Khi mất kết nối Internet giữa Edge Node và Azure Cloud, hệ thống hoạt động như thế nào?

Do mô hình AI và pipeline xử lý ảnh được thực thi cục bộ (Local Inference) hoàn toàn trong Docker Container tại Raspberry Pi, thiết bị vẫn tiếp tục phát hiện biển số bình thường. Dữ liệu metadata sẽ được lưu đệm tạm thời vào hàng đợi cục bộ (Local SQLite/JSON queue) và tự động đồng bộ hóa lên MongoDB Atlas ngay khi kết nối mạng được khôi phục.

4. Hệ thống cần bảo trì định kỳ những hạng mục nào?

Các hạng mục bảo trì chính bao gồm: vệ sinh ống kính camera ngoài trời định kỳ 3 tháng/lần; kiểm tra nhiệt độ CPU của Raspberry Pi (duy trì dưới 70°C); cập nhật các bản vá bảo mật cho hệ điều hành Linux và K3s cluster thông qua rolling update từ xa.

5. Chi phí ước tính và thời gian thu hồi vốn (ROI) cho một hệ thống 10 camera giám sát?

Tổng chi phí phần cứng Edge cho 10 điểm giám sát (Raspberry Pi + Camera + Phụ kiện) chỉ dao động khoảng 20–25 triệu VNĐ, chi phí máy chủ Azure VM và Cloud Database khoảng 500.000 – 1.000.000 VNĐ/tháng. So với việc đầu tư các camera AI chuyên dụng đắt tiền (15–30 triệu VNĐ/camera) hoặc thuê băng thông đường truyền riêng cho luồng video thô, giải pháp giúp tiết kiệm hơn 70% chi phí đầu tư ban đầu và hoàn vốn chỉ sau 3–6 tháng vận hành.

Kết luận

Đề tài tốt nghiệp "Ứng dụng Edge Computing để phát triển Camera thông minh cho hệ thống giám sát phương tiện giao thông" của sinh viên Nguyễn Đăng Trường và Hoàng Gia Vượng (khoa Mạng máy tính và Truyền thông, Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM, dưới sự hướng dẫn của PGS.TS Lê Trung Quân) đã giải quyết thành công bài toán nghẽn cổ chai của mô hình Cloud Computing truyền thống trong kỷ nguyên bùng nổ dữ liệu IoT.

Bằng việc kết hợp sáng tạo giữa mô hình nhận diện thị giác máy tính YOLOv4-TFLite, công nghệ ảo hóa Docker và nền tảng điều phối K3s, đề tài đã hiện thực hóa thành công một hệ thống giám sát giao thông phân tán:

  • Đạt độ chính xác tổng thể 84.67% trong các điều kiện môi trường thực tế phức tạp.
  • Tối ưu hóa thời gian suy luận đạt ~300ms/frame trên phần cứng vi máy tính giá rẻ.
  • Tiết kiệm hơn 85% băng thông mạng và loại bỏ hoàn toàn rủi ro quá tải máy chủ trung tâm.

Công trình không chỉ mang giá trị học thuật xuất sắc trong việc ứng dụng điện toán cận biên vào hệ thống nhúng mà còn mở ra tiềm năng thương mại hóa và triển khai diện rộng, đóng góp thiết thực vào mục tiêu xây dựng Đô thị Thông minh (Smart City) và nâng cao an toàn giao thông tại Việt Nam.