Giới thiệu dự án
Tai nạn giao thông (TNGT) đường bộ là một trong những thách thức an toàn công cộng nghiêm trọng nhất trên toàn cầu cũng như tại Việt Nam. Theo thống kê từ Ủy ban An toàn Giao thông Quốc gia và Báo Tuyên Giáo trong Quý I năm 2023, cả nước đã ghi nhận 2.343 vụ tai nạn giao thông, làm tử vong 1.434 người và khiến 1.578 người bị thương. Phân tích dữ liệu từ Cục Cảnh sát Giao thông chỉ ra rằng có tới 70% số vụ tai nạn đặc biệt nghiêm trọng xảy ra trong khung giờ từ 12h00 đến 24h00 — thời điểm đồng hồ sinh học của tài xế dễ rơi vào trạng thái mệt mỏi, suy giảm nhận thức hoặc xuất hiện các cơn buồn ngủ thoáng qua (micro-sleep).
+---------------------------------------------------------------------------------------------------+
| THỰC TRẠNG TNGT ĐƯỜNG BỘ & NGUY CƠ TÀI XẾ BUỒN NGỦ (NGUỒN: CỤC CSGT 2023) |
+------------------------------------+--------------------------------------------------------------+
| 2.343 vụ tai nạn (Quý I/2023) | 70% tai nạn rơi vào khung giờ 12h - 24h (tài xế kiệt sức) |
| 1.434 người tử vong | Micro-sleep (ngủ gật 3-5s): Xe di chuyển 80-130m mất kiểm soát|
| Vận tải đường dài & container | Nguyên nhân cốt lõi: Mệt mỏi thị giác & giảm phản xạ |
+------------------------------------+--------------------------------------------------------------+
Vấn đề thực tiễn và điểm nghẽn kỹ thuật (Problem Statement & Pain Points)
- Thời gian phản hồi trễ (Latency Delay): Khi xe đang di chuyển ở vận tốc cao tốc 100 km/h, chỉ cần tài xế nhắm mắt 3 giây, phương tiện đã tự hành trong vô thức hơn 83 mét, biến mọi hệ thống phanh khẩn cấp thành vô hiệu nếu không có cảnh báo phòng ngừa từ trước.
- Hạn chế của phương pháp thủ công và cảm biến đeo (Wearable Sensors): Các cảm biến điện não đồ (EEG) hay vòng đeo nhịp tim gây vướng víu, khó chịu cho tài xế và không thực tế khi vận hành liên tục.
- Độ nhạy sáng và nhiễu ngoại cảnh của các thuật toán thị giác cổ điển: Thuật toán Haar-Cascade truyền thống dễ mất dấu vùng mắt khi tài xế đeo kính thuốc, thay đổi góc nhìn (nghiêng đầu, cúi đầu) hoặc trong môi trường ánh sáng phức tạp.
Mục tiêu của đồ án (Project Objectives)
- Nghiên cứu & Thiết kế: Xây dựng pipeline thị giác máy tính phát hiện khuôn mặt và tách lọc vùng mắt theo thời gian thực (Real-time Computer Vision Pipeline).
- Mô hình hóa Học sâu: Thiết kế và tối ưu mạng nơ-ron tích chập (Convolutional Neural Network - CNN) tùy chỉnh trên framework PyTorch để phân loại nhị phân trạng thái mắt (Closed vs. Open).
- Tích hợp logic cảnh báo thời gian thực: Triển khai cơ chế cửa sổ trượt (Temporal Sliding Window) phát hiện trạng thái nhắm mắt liên tục trong ngưỡng 3 – 5 giây hoặc khi phát hiện khuôn mặt bị che khuất để kích hoạt chuông báo động âm thanh và giao diện trực quan.
- Đánh giá đa kịch bản: Kiểm thử độ chính xác (Accuracy), tỷ lệ khung hình trên giây (FPS), và độ bền vững trước các điều kiện thực tế (đeo kính, đội mũ, thay đổi góc nghiêng đầu, thiếu sáng).
Giải pháp kỹ thuật và kết quả kỳ vọng
Dự án áp dụng mô hình lai: Sử dụng thư viện MediaPipe Face Mesh để định vị 468 điểm mốc khuôn mặt (Facial Landmarks) với độ trễ siêu thấp nhằm trích xuất chính xác vùng quan tâm (Region of Interest - ROI) của hai mắt; sau đó chuyển tiếp tensor ROI qua mạng Custom CNN (PyTorch) để phân loại trạng thái.
- Kết quả kỳ vọng: Đạt độ chính xác $\ge 95%$ trên tập kiểm thử thực nghiệm, tốc độ xử lý $\ge 30\text{ FPS}$ trên phần cứng CPU tiêu chuẩn, độ trễ phát hiện và kích hoạt âm thanh $< 200\text{ ms}$ sau khi chạm ngưỡng thời gian buồn ngủ.
- Phạm vi và giới hạn: Hệ thống thử nghiệm demo thông qua Webcam RGB tiêu chuẩn (độ phân giải 720p/1080p), hoạt động tối ưu trong điều kiện ánh sáng tự nhiên/nhân tạo không quá tối (không dùng cảm biến hồng ngoại IR chuyên dụng), tài xế không đeo kính râm tối màu hoàn toàn.
Phân tích và thiết kế giải pháp
Phân tích hiện trạng và so sánh giải pháp
Trước khi thiết kế kiến trúc, đồ án tiến hành đánh giá ưu - nhược điểm của các hướng tiếp cận phát hiện buồn ngủ phổ biến hiện nay:
| Phương pháp |
Công nghệ cốt lõi |
Ưu điểm |
Nhược điểm |
Chi phí & Khả thi |
| Cảm biến sinh học (Physiological) |
Điện não đồ (EEG), Điện tâm đồ (ECG), Cảm biến mạch |
Độ chính xác rất cao (>98%), phát hiện từ giai đoạn mệt mỏi tiềm ẩn |
Gây khó chịu, xâm lấn (intrusive), dây cáp rườm rà, khó áp dụng thực tế |
Chi phí cao ($500 - $2000), tính khả thi thương mại thấp |
| Thị giác cổ điển (EAR / Haar-Cascade) |
Haar-Cascade + Dlib 68 points + Tỷ lệ khung mắt (EAR) |
Thuật toán nhẹ, tính toán nhanh trên vi điều khiển yếu |
Dễ vỡ khung nhận diện khi quay đầu lệch góc, nhạy cảm với ánh sáng |
Chi phí thấp ($20 - $50), độ ổn định thực tế trung bình |
| Giải pháp đề xuất (MediaPipe + Custom CNN) |
MediaPipe Mesh 468 pts + PyTorch CNN Binary Classifier |
Định vị mốc mặt cực nhanh, bất biến góc xoay/nghiêng đầu, phân loại mắt sâu, chính xác cao |
Yêu cầu tinh chỉnh kiến trúc để tối ưu FPS trên CPU |
Chi phí rất thấp ($30 - $70), độ ổn định và tính khả thi thương mại vượt trội |
Yêu cầu hệ thống theo mô hình MoSCoW
+---------------------------------------------------------------------------------------------------+
| PHÂN LOẠI YÊU CẦU THEO MÔ HÌNH MOSCOW |
+---------------------------------------------------------------------------------------------------+
| [M] MUST HAVE: |
| - Trích xuất luồng video thời gian thực từ Webcam (>= 25 FPS). |
| - Định vị khuôn mặt và cắt ROI hai mắt độc lập bằng MediaPipe. |
| - Phân loại chính xác trạng thái Mắt Nhắm / Mắt Mở bằng mạng CNN. |
| - Đếm thời gian nhắm mắt liên tục: Kích hoạt cảnh báo âm thanh/visual khi vượt ngưỡng 3-5s. |
| - Bật cảnh báo khi tài xế cúi gập mặt/mất dấu khuôn mặt (Occlusion Warning). |
+---------------------------------------------------------------------------------------------------+
| [S] SHOULD HAVE: |
| - Ghi đè thông tin trạng thái trực tiếp lên khung hình (OpenCV Text & Bounding Box Overlay). |
| - Xử lý mượt mà khi tài xế đeo kính thuốc có gọng và đội mũ lưỡi trai. |
+---------------------------------------------------------------------------------------------------+
| [C] COULD HAVE: |
| - Ghi log lịch sử buồn ngủ theo mốc thời gian phục vụ giám sát hành trình. |
| - Xuất mô hình sang định dạng ONNX Runtime nhằm tối ưu hóa trên thiết bị nhúng. |
+---------------------------------------------------------------------------------------------------+
| [W] WON'T HAVE (Hiện tại): |
| - Tích hợp camera hồng ngoại quan sát ban đêm không cần đèn. |
| - Phân tích ngáp (Yawn detection) và cử động đầu phức tạp (Head Pose Estimation 3D). |
+---------------------------------------------------------------------------------------------------+
Kiến trúc tổng thể hệ thống (System Architecture)
Hệ thống hoạt động theo mô hình xử lý phân lớp theo thời gian thực khép kín:
flowchart TD
A["Camera / Webcam Stream (RGB Video Input)"] --> B["Khung hình Frame (OpenCV Frame Processing)"]
B --> C{"MediaPipe Face Mesh Detector"}
C -- "Không thấy mặt / Bị che khuất" --> D["Phát cảnh báo: Mất dấu tài xế / Che khuất"]
C -- "Phát hiện khuôn mặt (468 Landmarks)" --> E["Trích xuất vùng ROI Mắt Trái & Mắt Phải"]
E --> F["Tiền xử lý: Resize (64x64) + Grayscale/Norm"]
F --> G["Mô hình PyTorch Custom CNN Inference"]
G --> H{"Dự đoán trạng thái mắt"}
H -- "Mắt Mở (Open)" --> I["Reset Timer / Bộ đếm khung hình nhắm"]
H -- "Mắt Nhắm (Closed)" --> J["Tăng Bộ đếm Frame / Timer (t = t + dt)"]
J --> K{"Thời gian nhắm t >= 3.0s?"}
K -- "Đúng" --> L["Kích hoạt Cảnh Báo Buồn Ngủ (Loa Âm Thanh + Visual GUI)"]
K -- "Chưa đủ ngưỡng" --> M["Hiển thị trạng thái theo dõi trên màn hình"]
I --> M
L --> M
D --> M
M --> B
Chi tiết Technology Stack và phiên bản sử dụng
- Ngôn ngữ lập trình chính: Python 3.9.x (Đảm bảo tương thích cao nhất với các thư viện Deep Learning và bindings C++).
- Thị giác máy tính (Computer Vision): OpenCV (opencv-python
v3.4.x / v4.7.x) thực hiện đọc luồng I/O từ camera, chuyển đổi không gian màu, vẽ bounding box, hiển thị text overlay cv2.putText().
- Trích xuất điểm đặc trưng: Google MediaPipe
v0.9.x (Module Face Mesh trích xuất 468 điểm tọa độ $x, y, z$ chuẩn hóa).
- Deep Learning Framework: PyTorch
v1.13.1 / v2.0.1 + Torchvision xây dựng kiến trúc mạng CNN, tính toán lan truyền thuận/ngược (Forward/Backward propagation) và quản lý tensor.
- Môi trường phát triển & Quản trị gói: Anaconda 3 (Conda Environment Management) và Visual Studio Code (IDE chính cùng tiện ích mở rộng Python/Pylance).
Implementation và kết quả
Quy trình phát triển và tiền xử lý dữ liệu (Data Pipeline & Augmentation)
Dữ liệu huấn luyện gồm hơn 3.000 mẫu ảnh mắt (Closed Eyes & Open Eyes) được thu thập từ Kaggle, Roboflow và tập dữ liệu thực nghiệm ghi hình qua webcam từ các cá nhân khác nhau.
TIỀN XỬ LÝ DỮ LIỆU ĐẦU VÀO
+--------------------+ +-----------------------+ +------------------------+
| Ảnh thô từ Camera | ---> | Cắt ROI Vùng Mắt | ---> | Chuyển Grayscale / RGB |
| (Raw Video Frames) | | (MediaPipe Landmarks) | | (Color Normalization) |
+--------------------+ +-----------------------+ +------------------------+
|
v
+--------------------+ +-----------------------+ +------------------------+
| Tensor (Batch, C, | <--- | Chuẩn hóa pixel | <--- | Resize cố định |
| H, W) cho CNN | | ([0, 1] hoặc [-1, 1]) | | (64 x 64 pixels) |
+--------------------+ +-----------------------+ +------------------------+
Nhằm chống hiện tượng quá khớp (Overfitting) và tăng cường tính bất biến không gian (Spatial Invariance), các kỹ thuật tăng cường dữ liệu (Data Augmentation) được áp dụng:
- Lật ảnh ngẫu nhiên (Random Horizontal Flip): Xác suất $p = 0.5$.
- Xoay góc ngẫu nhiên (Random Rotation): Dao động góc từ $-15^\circ$ đến $+15^\circ$.
- Biến đổi độ sáng & độ tương phản (Color Jitter): Thay đổi độ sáng ngẫu nhiên $\pm 20%$ để mô phỏng ánh sáng ngày/đêm.
- Chuẩn hóa phân phối (Normalization): Đưa ma trận điểm ảnh về khoảng giá trị có kỳ vọng $\mu = 0.5$, độ lệch chuẩn $\sigma = 0.5$.
import torch
import torch.nn as nn
from torchvision import transforms
# Pipeline tăng cường và chuẩn hóa dữ liệu đầu vào
train_transforms = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((64, 64)),
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomRotation(degrees=15),
transforms.ColorJitter(brightness=0.2, contrast=0.2),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5], std=[0.5])
])
Kiến trúc mạng nơ-ron tích chập tùy chỉnh (Custom CNN Architecture)
Mô hình phân loại trạng thái mắt được xây dựng với 3 khối tích chập liên tiếp (Convolutional Blocks), xen kẽ bởi hàm phi tuyến ReLU (giúp khắc phục triệt để hiện tượng Vanishing Gradient và tăng tốc độ hội tụ gấp 6 lần so với Sigmoid) cùng các tầng Max-Pooling (giảm kích thước không gian, trích xuất đặc trưng bậc cao). Cuối mạng là các tầng Fully Connected kèm Dropout (p=0.5) để triệt tiêu phụ thuộc đồng thời giữa các nơ-ron.
class EyeStateClassifierCNN(nn.Module):
def __init__(self):
super(EyeStateClassifierCNN, self).__init__()
# Block 1: Input (1, 64, 64) -> Output (32, 32, 32)
self.conv_block1 = nn.Sequential(
nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2)
)
# Block 2: Input (32, 32, 32) -> Output (64, 16, 16)
self.conv_block2 = nn.Sequential(
nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1),
nn.BatchNorm2d(64),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2)
)
# Block 3: Input (64, 16, 16) -> Output (128, 8, 8)
self.conv_block3 = nn.Sequential(
nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2)
)
# Fully Connected Classifier
self.classifier = nn.Sequential(
nn.Dropout(p=0.5),
nn.Linear(128 * 8 * 8, 128),
nn.ReLU(inplace=True),
nn.Dropout(p=0.3),
nn.Linear(128, 2) # Output: [Logits_Open, Logits_Closed]
)
def forward(self, x):
x = self.conv_block1(x)
x = self.conv_block2(x)
x = self.conv_block3(x)
x = x.view(x.size(0), -1) # Flatten tensor
logits = self.classifier(x)
return logits
Thuật toán phân tích chuỗi thời gian và kích hoạt cảnh báo (Inference & Alert Trigger Logic)
Trong quá trình suy luận trực tiếp, thuật toán tính toán trạng thái đóng/mở của cả 2 mắt đồng thời. Khi cả 2 mắt được phân loại là Closed, bộ đếm thời gian thực closed_start_time sẽ tích lũy. Nếu thời lượng vượt mốc ngưỡng $\Delta t \ge 3.0\text{s}$, còi báo động qua module âm thanh sẽ liên tục phát tín hiệu tần số cao.
import cv2
import time
import torch
import numpy as np
def run_drowsiness_detection_pipeline(model, device, alert_threshold_sec=3.0):
cap = cv2.VideoCapture(0)
eye_closed_start_time = None
alert_active = False
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break
# 1. Trích xuất ROI mắt thông qua MediaPipe Face Mesh
# (left_eye_roi, right_eye_roi, face_detected) = extract_eye_roi(frame)
face_detected = True # Minh họa giả định luồng xử lý
left_eye_closed = True # Kết quả phân loại từ CNN cho mắt trái
right_eye_closed = True # Kết quả phân loại từ CNN cho mắt phải
if not face_detected:
cv2.putText(frame, "CANH BAO: KHONG TIM THAY MAT!", (30, 50),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
else:
# 2. Logic kiểm tra trạng thái cả hai mắt
if left_eye_closed and right_eye_closed:
if eye_closed_start_time is None:
eye_closed_start_time = time.time()
elapsed_closed_time = time.time() - eye_closed_start_time
cv2.putText(frame, f"Nham mat: {elapsed_closed_time:.1f}s", (30, 50),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 255), 2)
# 3. Kích hoạt chuông báo động khi vượt ngưỡng 3s - 5s
if elapsed_closed_time >= alert_threshold_sec:
alert_active = True
cv2.putText(frame, "CANH BAO NGU GAT (BUON NGU)!", (30, 100),
cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 3)
# trigger_sound_alarm() # Kích hoạt còi âm thanh qua loa
else:
eye_closed_start_time = None
alert_active = False
cv2.putText(frame, "Trang thai: Tinh tao (Mat Mo)", (30, 50),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
cv2.imshow("Driver Drowsiness Monitor", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
Kết quả thực nghiệm và đánh giá hiệu năng (Experimental Results & Benchmarks)
Mô hình được huấn luyện trên 20 Epochs sử dụng thuật toán tối ưu hóa SGD kết hợp Momentum và Cross-Entropy Loss.
+---------------------------------------------------------------------------------------------------+
| QUÁ TRÌNH HỘI TỤ MÔ HÌNH QUA 20 EPOCHS (TRAINING DYNAMICS) |
+------------------------------------+--------------------------------------------------------------+
| Epoch 01 -> Loss: 0.684, Acc: 58.2% | Bắt đầu học đặc trưng biên cơ bản (Low-level edge filters) |
| Epoch 05 -> Loss: 0.342, Acc: 86.4% | Phân biệt cấu trúc mí mắt và đồng tử |
| Epoch 10 -> Loss: 0.185, Acc: 93.1% | Tỷ lệ nhận diện sai giảm mạnh trên tập validation |
| Epoch 20 -> Loss: 0.082, Acc: 96.5% | Mô hình đạt điểm cực tiểu toàn cục, không có dấu hiệu Overfit|
+------------------------------------+--------------------------------------------------------------+
Đồ án đã tiến hành thử nghiệm nghiệm thu hệ thống trong 8 kịch bản vận hành thực tế khác nhau:
| STT |
Kịch bản thử nghiệm thực tế |
Độ chính xác (Accuracy) |
Tốc độ xử lý (FPS) |
Đánh giá & Hiện tượng ghi nhận |
| 1 |
Ánh sáng bình thường + Có đeo kính cận có gọng |
95.8% |
32.4 FPS |
Nhận diện chính xác, không bị đánh lừa bởi gọng kính |
| 2 |
Ánh sáng bình thường + Không đeo kính |
97.6% |
33.1 FPS |
Trạng thái mí mắt rõ nét, độ tin cậy phân loại tối ưu |
| 3 |
Ánh sáng bình thường + Đội mũ lưỡi trai |
95.2% |
31.8 FPS |
Vành mũ tạo bóng đổ nhẹ nhưng MediaPipe vẫn bắt chuẩn mốc |
| 4 |
Ánh sáng chiếu rọi xung quanh (chói sáng) |
93.4% |
32.0 FPS |
Tăng cường độ tương phản giúp lọc nhiễu vùng lóa |
| 5 |
Ánh sáng yếu / Môi trường tối vừa phải |
91.8% |
30.5 FPS |
Vùng ROI mắt mờ hơn nhưng CNN vẫn trích xuất được rãnh mí |
| 6 |
Tư thế tài xế cúi đầu thấp |
92.5% |
31.2 FPS |
Nhận diện tốt khi góc cúi $\le 35^\circ$; quá sâu sẽ kích hoạt cảnh báo che khuất |
| 7 |
Tư thế tài xế ngẩng đầu lên trên |
94.1% |
31.5 FPS |
Không gian mắt giãn rộng, tỷ lệ phát hiện mở mắt chính xác |
| 8 |
Nghiêng đầu sang trái / sang phải ($15^\circ - 30^\circ$) |
93.7% |
31.0 FPS |
Nhờ tính bất biến vị trí của CNN và mốc 3D của MediaPipe |
Đổi mới và đóng góp
- Kiến trúc phân tầng kết hợp Hybrid (MediaPipe + Lightweight PyTorch CNN): Thay vì sử dụng toàn bộ mô hình Object Detection cồng kềnh (như YOLOv5/YOLOv8) tiêu tốn nhiều tài nguyên GPU, hệ thống tách biệt bài toán: MediaPipe chịu trách nhiệm định vị mốc tọa độ siêu nhẹ trên CPU, và Custom CNN chỉ xử lý ma trận ảnh mắt siêu nhỏ ($64 \times 64$). Giải pháp này giúp hệ thống đạt tốc độ xử lý >30 FPS mượt mà ngay trên laptop hoặc vi xử lý thông thường.
- Khắc phục triệt để nhược điểm của phương pháp đo ngưỡng EAR (Eye Aspect Ratio): Các phương pháp truyền thống dựa trên ngưỡng hình học EAR cố định rất dễ báo động giả khi hình dạng mắt của từng người khác nhau (mắt một mí, mắt híp tự nhiên). Mạng CNN học sâu tự trích xuất đặc trưng vân bề mặt (texture features) và hình thái mí mắt, giúp giảm 38% tỷ lệ báo động giả (False Alarm Rate) so với phương pháp EAR.
- Cơ chế phòng ngừa rủi ro mất dấu tài xế (Occlusion Resilience): Khi tài xế gục đầu hẳn xuống vô lăng hoặc tay che mặt, hệ thống ngay lập tức kích hoạt cảnh báo mất nhận diện, giải quyết triệt để "vùng mù" mà các hệ thống theo dõi mắt thuần túy thường bỏ qua.
+---------------------------------------------------------------------------------------------------+
| BẢNG SO SÁNH ĐỐI CHỨNG VỚI CÁC GIẢI PHÁP THỰC NGHIỆM KHÁC |
+--------------------------------+--------------------+---------------------+-----------------------+
| Tiêu chí kỹ thuật | Haar-Cascade + SVM | Dlib 68 + EAR Ratio | Đề tài nghiên cứu |
+--------------------------------+--------------------+---------------------+-----------------------+
| Tốc độ khung hình (CPU) | 18 - 22 FPS | 20 - 25 FPS | **30 - 33 FPS** |
| Độ chính xác tổng thể | 82.4% | 89.1% | **95.2%** |
| Khả năng chịu nghiêng đầu | Rất kém (dễ mất) | Trung bình | **Tốt (Mesh 3D 468)** |
| Xử lý tài xế đeo kính cận | Kém | Trung bình | **Rất tốt (CNN)** |
| Khả năng báo động che khuất | Không có | Không có | **Có tích hợp sẵn** |
+--------------------------------+--------------------+---------------------+-----------------------+
Ứng dụng thực tế và triển khai
Kịch bản ứng dụng thực tế (Real-world Use Cases)
- Vận tải logistics và xe tải đường dài (Long-haul Trucking): Hỗ trợ tài xế container chạy xuyên đêm trên các tuyến quốc lộ và cao tốc, giảm thiểu nguy cơ tai nạn liên hoàn do ngủ gật.
- Xe khách liên tỉnh và xe buýt đô thị: Tích hợp vào hệ thống giám sát an toàn cabin (DMS - Driver Monitoring System), truyền dữ liệu cảnh báo về trung tâm điều hành đội xe (Fleet Management Telematics).
- Ô tô cá nhân và gia đình: Triển khai như một ứng dụng độc lập trên màn hình Android ô tô (Android Auto) kết hợp camera hành trình gắn trong xe.
+---------------------------------------------------------------------------------------------------+
| MÔ HÌNH TRIỂN KHAI PHẦN CỨNG TRÊN XE (HARDWARE DEPLOYMENT ON-BOARD) |
+---------------------------------------------------------------------------------------------------+
| [Camera Module RGB/IR] ---> [Bộ vi xử lý nhúng / Mini PC] ---> [Màn hình Taplo & Còi Buzzer 85dB] |
| (Góc quét 60-80 độ, (Raspberry Pi 4 / Jetson Nano (Phát chuông + Giao diện cảnh báo |
| đặt trên cột A / Vô lăng) chạy ONNX / PyTorch Engine) ngay lập tức khi t >= 3s) |
+---------------------------------------------------------------------------------------------------+
Yêu cầu phần cứng và hướng dẫn triển khai (Deployment Specifications)
- Phần cứng tối thiểu:
- CPU: Intel Core i3 thế hệ 6 trở lên hoặc ARM Cortex-A72 (Raspberry Pi 4 Model B 4GB / NVIDIA Jetson Nano 4GB).
- Camera: USB Webcam chuẩn UVC độ phân giải tối thiểu 720p @ 30 FPS.
- Audio: Loa cảnh báo âm thanh mini hoặc còi Buzzer $5\text{V}$ / $85\text{dB}$.
- Môi trường phần mềm:
- Hệ điều hành: Ubuntu Linux 20.04/22.04 LTS hoặc Windows 10/11.
- Python Runtime: Python 3.8+ kèm các thư viện phụ thuộc (
torch, torchvision, opencv-python, mediapipe, numpy).
Phân tích chi phí và hiệu quả đầu tư (Cost-Benefit & ROI Analysis)
| Hạng mục thiết bị |
Chi phí ước tính (VNĐ) |
Giá trị mang lại |
| Camera module góc rộng HD |
350.000 VNĐ |
Thu nhận hình ảnh độ nét cao trong cabin |
| Bo mạch xử lý nhúng (Orange Pi / Pi 4) |
1.200.000 – 1.800.000 VNĐ |
Chạy mô hình suy luận độc lập, ổn định |
| Module còi cảnh báo & Phụ kiện nguồn |
150.000 VNĐ |
Phát âm thanh tức thì khi phát hiện rủi ro |
| TỔNG CHI PHÍ PHẦN CỨNG CHO 1 XE |
~ 1.700.000 – 2.300.000 VNĐ |
Bảo vệ an toàn cho phương tiện hàng tỷ đồng |
Ước tính ROI: Chi phí đầu tư dưới 2,5 triệu VNĐ/phương tiện giúp ngăn ngừa các vụ va chạm có thể gây thiệt hại từ hàng trăm triệu đến hàng tỷ đồng chi phí sửa chữa phương tiện, đền bù hàng hóa và đặc biệt là bảo vệ tính mạng con người.
Hạn chế và hướng phát triển
+---------------------------------------------------------------------------------------------------+
| HẠN CHẾ HIỆN TẠI VÀ LỘ TRÌNH NÂNG CẤP KỸ THUẬT |
+---------------------------------------------------------------------------------------------------+
| [Hạn chế 1] Ánh sáng ban đêm: Webcam RGB thường suy giảm độ nhạy sáng trong cabin tối hoàn toàn. |
| ==> Hướng khắc phục: Tích hợp Camera cảm biến hồng ngoại chủ động (Near-Infrared NIR + IR LED).|
+---------------------------------------------------------------------------------------------------+
| [Hạn chế 2] Kính râm đen: Mắt kính màu đen đậm ngăn cản camera quang học thu nhận mí mắt. |
| ==> Hướng khắc phục: Bổ sung module phân tích hành vi gián tiếp (Độ gật đầu, Ngáp, Đảo vô lăng)|
+---------------------------------------------------------------------------------------------------+
| [Hạn chế 3] Bộ tiêu chí cảnh báo: Mới chỉ tập trung vào trạng thái nhắm mắt 3-5s. |
| ==> Hướng khắc phục: Mở rộng mạng học sâu phát hiện ngáp (Yawn), Tần suất chớp mắt (Blink Rate)|
+---------------------------------------------------------------------------------------------------+
- Tối ưu hóa phần mềm: Chuyển đổi mô hình PyTorch (
.pt) sang định dạng ONNX Runtime hoặc TensorRT để tối ưu hóa bộ nhớ đệm (Quantization INT8/FP16), giúp nâng tốc độ xử lý lên $>60\text{ FPS}$ trên các chip nhúng giá rẻ.
Đối tượng hưởng lợi
- Sinh viên & Người học ngành Công nghệ Thông tin/AI: Tài liệu tham khảo toàn diện, chuẩn mực từ thu thập dữ liệu, tiền xử lý, thiết kế mạng CNN bằng PyTorch đến tích hợp pipeline thị giác máy tính với OpenCV và MediaPipe.
- Kỹ sư & Lập trình viên hệ thống nhúng (Embedded/AI Developers): Cung cấp mô hình tham chiếu giải quyết bài toán cân bằng giữa độ chính xác học sâu (Deep Learning Accuracy) và tốc độ thời gian thực (Real-time Latency).
- Doanh nghiệp vận tải & Logistics: Cơ sở khoa học để nghiên cứu, phát triển và lắp đặt các thiết bị an toàn hành trình nội bộ với chi phí hợp lý, nâng cao chỉ số an toàn của đội xe.
- Nhà nghiên cứu khoa học: Khung dữ liệu thực nghiệm về hành vi tài xế trong các điều kiện ngoại cảnh phức tạp (đeo kính, đội mũ, thay đổi góc đầu) tại môi trường giao thông Việt Nam.
Câu hỏi thường gặp
1. Hệ thống có yêu cầu phần cứng GPU đắt tiền để chạy thời gian thực không?
Không. Nhờ kiến trúc tối ưu kết hợp giữa MediaPipe (định vị điểm mốc khuôn mặt cực nhẹ) và mô hình Custom CNN kích thước đầu vào chỉ $64 \times 64$ pixels, hệ thống có thể chạy mượt mà ở mức 30 – 33 FPS trực tiếp trên CPU máy tính xách tay thông thường hoặc các bo mạch nhúng như Raspberry Pi 4 mà không bắt buộc phải có card đồ họa rời GPU.
2. Khi tài xế chớp mắt tự nhiên thì hệ thống có phát chuông báo động nhầm không?
Không. Một cái chớp mắt tự nhiên của con người thường chỉ diễn ra trong khoảng $0.1 - 0.4$ giây. Hệ thống áp dụng bộ đếm thời gian thực (Temporal Sliding Window) và chỉ kích hoạt cảnh báo khi hai mắt nhắm liên tục vượt ngưỡng an toàn được cài đặt từ 3.0 đến 5.0 giây. Do đó, hiện tượng chớp mắt thông thường sẽ tự động reset bộ đếm và không gây phiền toái cho tài xế.
3. Hệ thống hoạt động ra sao nếu tài xế đeo kính cận hoặc đội mũ?
Mô hình đã được huấn luyện với tập dữ liệu đa dạng bao gồm người đeo kính có gọng và đội mũ lưỡi trai, kết hợp kỹ thuật tăng cường dữ liệu (Data Augmentation). Kết quả thực nghiệm cho thấy độ chính xác đạt 95.8% khi đeo kính và 95.2% khi đội mũ, đảm bảo khả năng nhận diện ổn định trong điều kiện thực tế.
4. Giải pháp này có thể tích hợp với các hệ thống quản lý hạm đội (Fleet Management) hiện có không?
Hoàn toàn khả thi. Ứng dụng được viết trên nền tảng Python hướng module, dễ dàng xuất tín hiệu cảnh báo qua giao thức mạng (RESTful API, MQTT, WebSockets) hoặc giao tiếp phần cứng (UART/CAN bus) để truyền dữ liệu trạng thái tài xế tức thời về máy chủ trung tâm điều hành.
5. Chi phí triển khai và thời gian hoàn vốn (ROI) của hệ thống như thế nào?
Tổng chi phí phần cứng cho một bộ thiết bị độc lập trên xe dao động từ 1.700.000 đến 2.300.000 VNĐ. Chỉ cần ngăn chặn được một vụ va chạm giao thông tiềm ẩn, hệ thống đã giúp doanh nghiệp và chủ xe tiết kiệm hàng chục đến hàng trăm triệu đồng chi phí thiệt hại vật chất và bảo vệ tính mạng con người.
Kết luận
Đồ án tốt nghiệp "Nghiên cứu ứng dụng mạng nơ ron trong việc cảnh báo tài xế buồn ngủ khi đang lái xe" của sinh viên Trần Thị Phương Nhi (Trường Đại học Sư phạm Kỹ thuật – Đại học Đà Nẵng, hướng dẫn bởi TS. Hoàng Thị Mỹ Lệ) đã giải quyết thành công một bài toán mang tính thời sự và cấp thiết cao trong xã hội.
Bằng việc kết hợp sáng tạo giữa thư viện mã nguồn mở MediaPipe và mô hình Convolutional Neural Network (CNN) tự xây dựng trên nền tảng PyTorch, đồ án đã chứng minh tính khả thi vượt trội với độ chính xác nhận diện đạt 95.2% – 97.6% cùng tốc độ xử lý thời gian thực >30 FPS. Hệ thống vận hành ổn định qua 8 kịch bản kiểm thử thực tế, mở ra tiềm năng ứng dụng to lớn trong việc xây dựng hệ sinh thái giao thông an toàn và đô thị thông minh (Smart City) tại Việt Nam.
