Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số giáo dục (EdTech) và tự động hóa không gian thông minh, việc tích hợp Trí tuệ nhân tạo (AI) vào quản lý lớp học đóng vai trò then chốt nhằm nâng cao chất lượng dạy và học. Theo các nghiên cứu thực nghiệm sư phạm quốc tế, giáo viên thường tiêu tốn từ 12% đến 18% thời lượng tiết dạy cho các tương tác gián đoạn phi học thuật như học sinh phát biểu ngắt lời, xin phép ra ngoài (đi vệ sinh, uống nước), hoặc cần trợ giúp cá nhân. Đề tài "Xây dựng ứng dụng trí tuệ nhân tạo nhận dạng cử chỉ bàn tay người" (Tác giả: Trần Hồng Thu, GVHD: TS. Mai Xuân Tráng – Trường Đại học Phenikaa) được nghiên cứu và phát triển nhằm giải quyết triệt để bài toán giao tiếp phi ngôn ngữ (non-verbal communication) trong lớp học thông minh.

+-------------------------------------------------------------------------------+
|                             HỆ THỐNG GIAO TIẾP THÔNG MINH                     |
|                                                                               |
|   [ Học sinh thực hiện cử chỉ ] ---> [ Camera / Web App ]                     |
|                                             |                                 |
|                                             v                                 |
|   [ Giáo viên nhận tín hiệu Dashboard ] <-- [ AI Pipeline: YOLOv8 + VGG-16 ]  |
+-------------------------------------------------------------------------------+

Vấn đề thực tiễn (Problem Statement)

Trong các lớp học truyền thống và lớp học quy mô lớn (từ 40–80 sinh viên/học sinh), việc học sinh đồng loạt giơ tay và nói lớn để xin phép, phát biểu hoặc cần trợ giúp kỹ thuật thường gây ra các hệ quả tiêu cực:

  • Làm đứt gãy mạch giảng dạy: Giảng viên liên tục bị ngắt quãng tiến trình truyền đạt kiến thức.
  • Gây mất tập trung toàn diện: Các học sinh xung quanh bị ảnh hưởng bởi tiếng ồn và sự xao nhãng.
  • Thiếu hụt công cụ số hóa tương tác thầm lặng: Chưa có hệ thống thị giác máy tính tự động ghi nhận và phân loại nhu cầu học sinh theo thời gian thực mà không cần thiết bị cảm biến đeo đắt tiền.

Mục tiêu nghiên cứu cụ thể

  1. Thu thập và xây dựng tập dữ liệu chuẩn hóa: Thu thập 1.502 ảnh chất lượng cao ghi nhận 7 cử chỉ lớp học phổ biến: Đồng ý (agree), Không đồng ý (disagree), Hoàn thành bài (done), Uống nước (drink), Vệ sinh (restroom), Trợ giúp (help), và Đặt câu hỏi (question).
  2. Thiết kế kiến trúc AI kết hợp (Two-Stage AI Pipeline):
    • Huấn luyện mô hình YOLOv8 (State-of-the-Art Object Detection) nhằm định vị và khoanh vùng chính xác bàn tay (Hand Detection) trong môi trường nhiễu.
    • Ứng dụng VGG-16 Transfer Learning để phân loại tinh chỉnh (Fine-grained Classification) 7 trạng thái cử chỉ bàn tay từ vùng ảnh cắt (RoI - Region of Interest).
  3. Triển khai ứng dụng Web tương tác thời gian thực: Xây dựng hệ thống Web Application trên nền tảng Flask Framework, xử lý luồng video thời gian thực từ Webcam với độ trễ thấp ($< 35\text{ ms}$).

Phạm vi và giới hạn

  • Phạm vi: Ứng dụng trong lớp học, phòng tự học, hội thảo tương tác với các cử chỉ tĩnh (static gestures).
  • Giới hạn: Tối ưu hóa cho cử chỉ của một hoặc hai bàn tay chính trong khung hình camera cá nhân; chưa hỗ trợ chuỗi cử chỉ động phức tạp (dynamic gesture sequences) dạng video temporal.

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 giao tiếp và nhận dạng cử chỉ bàn tay trên thị trường chia làm 3 nhóm chính:

Tiêu chí Cảm biến phần cứng (Leap Motion / Găng tay) MediaPipe Hand Landmark Heuristic Hai giai đoạn: YOLOv8 + VGG-16 (Đề tài đề xuất)
Chi phí đầu tư Rất cao ($> 100\text{ USD}$/bàn) Thấp (Chỉ cần camera thường) Thấp (Chỉ cần camera/webcam có sẵn)
Độ phức tạp cài đặt Cần thiết bị ngoại vi chuyên dụng Cần tinh chỉnh thuật toán tọa độ 21 điểm Tích hợp Web/API tiêu chuẩn, triển khai linh hoạt
Độ bền vững với nền nhiễu Cao (dựa trên cảm biến chiều sâu) Kém khi bàn tay bị che khuất hoặc góc nghiêng Cao (YOLOv8 loại bỏ nền, VGG-16 trích xuất sâu)
Khả năng mở rộng lớp cử chỉ Khó lập trình lại Phức tạp khi cử chỉ ngón tay tương đồng Rất dễ dàng (chỉ cần fine-tune lại lớp phân loại)

Phân loại yêu cầu hệ thống theo mô hình MoSCoW

+-----------------------------------------------------------------------------------+
| MUST HAVE: Phát hiện bàn tay (YOLOv8), Phân loại 7 nhãn cử chỉ, Web UI webcam     |
| SHOULD HAVE: Cân bằng sáng CLAHE, Lọc nhiễu ảnh đầu vào, FPS > 25 trên GPU        |
| COULD HAVE: Lưu trữ lịch sử giơ tay vào CSDL, Tích hợp giao thức WebSocket        |
| WON'T HAVE (Hiện tại): Nhận dạng ngôn ngữ ký hiệu động dạng câu ghép liên tục     |
+-----------------------------------------------------------------------------------+

Thiết kế hệ thống

Kiến trúc hệ thống được xây dựng theo mô hình module hóa cao độ (Modular Architecture), phân tách độc lập giữa tầng tiền xử lý, tầng mô hình học sâu và tầng hiển thị:

flowchart TD
    A[Webcam Input Stream] --> B[Module Tiền Xử Lý: OpenCV CLAHE & Gaussian Filter]
    B --> C[Stage 1: YOLOv8n Hand Detection Model]
    C -->|Bounding Box Coordinates| D[Crop Region of Interest - RoI]
    D --> E[Resize & Normalize: 224x224x3]
    E --> F[Stage 2: VGG-16 Classifier Model]
    F -->|Softmax Probabilities| G[Gesture Label & Confidence Score]
    G --> H[Flask Backend Controller / API Route]
    H --> I[HTML5 / Bootstrap Dashboard UI]

Technology Stack và phiên bản cụ thể

  • Ngôn ngữ cốt lõi: Python 3.10.12
  • Thị giác máy tính & Xử lý ảnh: OpenCV 4.8.1.78, Pillow 10.1.0
  • Framework Học sâu (Deep Learning): PyTorch 2.1.2, Ultralytics 8.1.0 (YOLOv8), TensorFlow/Keras 2.15.0 (VGG-16)
  • Web Backend & REST API: Flask 3.0.0, Werkzeug 3.0.1
  • Frontend: HTML5, CSS3, JavaScript (Fetch API / Canvas streaming), Bootstrap 5.3.0
  • Công cụ gán nhãn: LabelImg 1.8.6

Thiết kế RESTful API

Hệ thống cung cấp các endpoint chuẩn hóa cho việc tích hợp:

POST /api/v1/predict_gesture
Content-Type: multipart/form-data

Payload:
  - image: [Binary image file / Base64 Data URI]

Response (200 OK):
{
  "status": "success",
  "detection": {
    "hand_detected": true,
    "bbox": [124, 85, 310, 420],
    "detection_confidence": 0.942
  },
  "classification": {
    "gesture": "question",
    "gesture_vn": "Có câu hỏi",
    "confidence": 0.968,
    "all_probabilities": {
      "agree": 0.002,
      "disagree": 0.001,
      "done": 0.005,
      "drink": 0.012,
      "help": 0.008,
      "question": 0.968,
      "restroom": 0.004
    }
  },
  "latency_ms": 28.5
}

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

Dự án được triển khai theo quy trình phát triển lặp nhanh (Agile/CRISP-DM) qua 4 giai đoạn chính:

[Khảo sát & Thu thập dữ liệu] -> [Huấn luyện mô hình Stage 1 & 2] -> [Tích hợp Flask API] -> [Đánh giá & Triển khai]
Mốc thời gian Nội dung công việc Deliverables Chiến lược kiểm soát rủi ro
Tuần 1 - 3 Khảo sát nhu cầu sư phạm, thu thập 1.502 ảnh bằng webcam, gán nhãn qua LabelImg Dataset chuẩn hóa định dạng YOLO (train/val/test) Đa dạng hóa góc chụp và ánh sáng phòng học
Tuần 4 - 6 Tiền xử lý ảnh (CLAHE, lọc nhiễu), Data Augmentation, Train YOLOv8n (100 epochs) Trọng số best.pt, đồ thị mAP & Loss Dùng early stopping chống Overfitting
Tuần 7 - 9 Cắt RoI bàn tay, Fine-tune mạng VGG-16 với Transfer Learning ImageNet Trọng số vgg16_hand_gesture.h5 Thêm lớp Dropout (0.5) và BatchNormalization
Tuần 10 - 12 Xây dựng Flask Web App, kết nối Webcam Real-time, kiểm thử End-to-End Hệ thống Web Demo hoàn chỉnh Tối ưu hóa pipeline xử lý luồng Frame OpenCV

Implementation và kết quả

Quy trình phát triển và thuật toán then chốt

1. Pipeline tiền xử lý và tăng cường dữ liệu (OpenCV & Augmentation)

Dữ liệu thô từ webcam được đưa qua bộ cân bằng biểu đồ mức xám cục bộ thích ứng (CLAHE) để cân bằng độ sáng và khử nhiễu bằng bộ lọc Gaussian trước khi đưa vào mô hình.

import cv2
import numpy as np

def preprocess_frame(frame: np.ndarray) -> np.ndarray:
    """
    Tiền xử lý ảnh đầu vào: Cân bằng ánh sáng và khử nhiễu.
    """
    # Chuyển sang không gian màu LAB để xử lý kênh độ sáng L
    lab = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)
    l_channel, a_channel, b_channel = cv2.split(lab)
    
    # Áp dụng CLAHE (Contrast Limited Adaptive Histogram Equalization)
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
    cl = clahe.apply(l_channel)
    
    # Hợp nhất các kênh và chuyển lại BGR
    limg = cv2.merge((cl, a_channel, b_channel))
    balanced_frame = cv2.cvtColor(limg, cv2.COLOR_LAB2BGR)
    
    # Khử nhiễu Gaussian nhẹ
    denoised_frame = cv2.GaussianBlur(balanced_frame, (3, 3), 0)
    return denoised_frame

2. Pipeline nhận diện YOLOv8 và phân loại VGG-16 tích hợp

Quá trình suy luận (Inference) hai giai đoạn được tích hợp chặt chẽ:

import torch
import cv2
import numpy as np
from tensorflow.keras.models import load_model
from ultralytics import YOLO

class TwoStageHandGestureRecognizer:
    def __init__(self, yolo_model_path: str, vgg_model_path: str):
        # Khởi tạo mô hình YOLOv8n phát hiện bàn tay
        self.detector = YOLO(yolo_model_path)
        # Khởi tạo mô hình VGG-16 phân loại cử chỉ
        self.classifier = load_model(vgg_model_path)
        self.labels = ['agree', 'disagree', 'done', 'drink', 'help', 'question', 'restroom']

    def predict(self, frame: np.ndarray):
        processed_frame = preprocess_frame(frame)
        results = self.detector(processed_frame, conf=0.5, verbose=False)
        
        detections = []
        for r in results:
            boxes = r.boxes
            for box in boxes:
                # Lấy tọa độ bounding box [x1, y1, x2, y2]
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                conf = float(box.conf[0])
                
                # Trích xuất và cắt vùng RoI bàn tay
                h, w, _ = frame.shape
                x1, y1 = max(0, x1), max(0, y1)
                x2, y2 = min(w, x2), min(h, y2)
                hand_roi = frame[y1:y2, x1:x2]
                
                if hand_roi.size == 0:
                    continue
                
                # Tiền xử lý chuẩn 224x224 cho VGG-16
                roi_resized = cv2.resize(hand_roi, (224, 224))
                roi_normalized = roi_resized.astype("float32") / 255.0
                roi_expanded = np.expand_dims(roi_normalized, axis=0)
                
                # Phân loại cử chỉ bằng VGG-16
                preds = self.classifier.predict(roi_expanded, verbose=0)[0]
                class_idx = np.argmax(preds)
                gesture_label = self.labels[class_idx]
                gesture_conf = float(preds[class_idx])
                
                detections.append({
                    "bbox": [x1, y1, x2, y2],
                    "det_conf": conf,
                    "gesture": gesture_label,
                    "gesture_conf": gesture_conf
                })
        return detections

Đánh giá và kiểm thử thực nghiệm

Phân chia tập dữ liệu huấn luyện

Tổng số lượng mẫu thu thập đạt 1.502 ảnh, được phân tách nghiêm ngặt:

  • Tập huấn luyện (Training Set - 70%): 1.051 ảnh
  • Tập kiểm định (Validation Set - 15%): 226 ảnh
  • Tập kiểm thử độc lập (Test Set - 15%): 225 ảnh
Tập dữ liệu: 1.502 ảnh
├── Training Set (70%): 1.051 ảnh ====> Huấn luyện trọng số mạng nơ-ron
├── Validation Set (15%): 226 ảnh ====> Tối ưu Hyperparameters & Early Stopping
└── Test Set (15%): 225 ảnh        ====> Đánh giá hiệu năng khách quan

Kết quả thực nghiệm mô hình (Benchmarks)

Thành phần mô hình Thông số cấu hình Metric chính đạt được Giá trị đo lường
YOLOv8n (Detection) 100 Epochs, Batch Size 16, Optimizer AdamW $\text{mAP@0.5}$ $96.4%$
Input: $640 \times 640$, Image Size $\text{mAP@0.5:0.95}$ $82.1%$
Precision / Recall $94.8% / 93.2%$
VGG-16 (Classifier) Transfer Learning, 50 Epochs, LR = 0.0001 Overall Accuracy $95.6%$
FC Layers: Dense(512, ReLU) + Dropout(0.5) + Dense(7, Softmax) Macro F1-Score $0.952$
Hệ thống End-to-End Video Stream $1280 \times 720$ qua Flask Web Độ trễ xử lý (Nvidia GTX 1650) $28.5\text{ ms}$ (~35 FPS)
Độ trễ xử lý (Intel Core i5-1135G7 CPU) $48.2\text{ ms}$ (~21 FPS)

Chi tiết độ chính xác theo từng cử chỉ lớp học

+-----------------+---------------+------------+----------+
| Cử chỉ (Class)  | Precision (%) | Recall (%) | F1-Score |
+-----------------+---------------+------------+----------+
| Agree (Đồng ý)  |     96.2      |    95.0    |   0.956  |
| Disagree (K.Đ.Ý)|     94.8      |    93.5    |   0.941  |
| Done (Xong bài) |     97.1      |    96.4    |   0.967  |
| Drink (Uống nc) |     95.5      |    97.0    |   0.962  |
| Help (Hỗ trợ)   |     93.9      |    94.2    |   0.940  |
| Question (Hỏi)  |     98.0      |    97.5    |   0.977  |
| Restroom (WC)   |     94.1      |    95.8    |   0.949  |
+-----------------+---------------+------------+----------+

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

  1. Kiến trúc phân tách đa tầng giải quyết triệt để nhiễu nền: Thay vì sử dụng một mạng End-to-End duy nhất vốn dễ nhầm lẫn giữa cử chỉ ngón tay và các vật thể nền phòng học (bảng đen, bàn ghế, quần áo), giải pháp tách biệt YOLOv8 (chuyên định vị không gian) và VGG-16 (chuyên biệt hóa trích xuất đặc trưng ngón tay) giúp giảm tỷ lệ phát hiện nhầm (False Positive) đến $38.4%$ so với các mô hình CNN phân loại toàn cảnh thông thường.

  2. Xây dựng Dataset cử chỉ học đường độc bản: Bộ dữ liệu 1.502 mẫu được gán nhãn chi tiết với độ bao phủ cao về sắc thái ánh sáng, kích thước bàn tay và góc nghiêng, tạo nguồn tài nguyên mở giá trị cho các nghiên cứu tiếp nối trong lĩnh vực AI giáo dục tại Việt Nam.

  3. Tối ưu hóa khả năng triển khai thực tế trên phần cứng đại trà: Mô hình được tối ưu để vận hành mượt mà ngay trên các dòng máy tính xách tay văn phòng sử dụng CPU thông thường (đạt mức xấp xỉ 21–25 FPS) mà không bắt buộc trang bị GPU chuyên dụng đắt tiền, mang lại tính khả thi cao khi ứng dụng rộng rãi tại các trường học.

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

Kịch bản vận hành thực tế trong lớp học thông minh

[ Học sinh: Giơ ký hiệu 'Done' ] 
          │
          ▼ (Webcam cá nhân / Lớp học)
[ Module AI: YOLOv8 phát hiện tay -> VGG-16 nhận diện nhãn 'Done' (97.1%) ]
          │
          ▼ (WebSocket / REST API)
[ Màn hình Giáo viên: Hiển thị icon xanh "Bàn 04 - Đã xong bài tập" ]
          │
          ▼
(Giáo viên nắm bắt tiến độ lớp học mà không cần học sinh gián đoạn bài giảng)
  1. Quản lý trật tự trong giờ tự học và thảo luận: Học sinh xin đi vệ sinh (restroom) hoặc uống nước (drink) chỉ cần giơ tay theo ký hiệu; giáo viên nhìn bảng thông báo trên Dashboard và gật đầu xác nhận mà không làm ngắt lời diễn giả hay các nhóm đang tập trung.
  2. Ghi nhận phản hồi nhanh (Instant Polling/Feedback): Giáo viên đặt câu hỏi trắc nghiệm/ý kiến, cả lớp phản hồi bằng cử chỉ agree hoặc disagree. Hệ thống tự động đếm và xuất biểu đồ tỷ lệ theo thời gian thực.
  3. Hỗ trợ học sinh khiếm thính và rụt rè: Tạo môi trường bình đẳng, khuyến khích học sinh ít nói tự tin tương tác và yêu cầu trợ giúp (help) một cách nhanh chóng.

Hướng dẫn cài đặt và triển khai hệ thống (Deployment Guide)

1. Yêu cầu hệ thống tối thiểu

  • Hệ điều hành: Linux (Ubuntu 20.04/22.04 LTS), Windows 10/11, macOS
  • Phần cứng: CPU Intel Core i3 thế hệ 8 trở lên (Khuyến nghị: Intel Core i5 hoặc GPU Nvidia GTX 1650 4GB để đạt hiệu năng tối đa)
  • RAM: Tối thiểu 8 GB
  • Thiết bị: Webcam chuẩn HD 720p trở lên

2. Các bước triển khai qua CLI

# Bước 1: Clone repository và tạo môi trường ảo
git clone https://github.com/phenikaa-it/hand-gesture-ai-classroom.git
cd hand-gesture-ai-classroom
python3 -m venv venv
source venv/bin/activate  # Trên Windows: venv\Scripts\activate

# Bước 2: Cài đặt các thư viện phụ thuộc
pip install --upgrade pip
pip install -r requirements.txt

# Bước 3: Kiểm tra cấu trúc thư mục trọng số mô hình
# models/
#   ├── best_yolov8n_hand.pt
#   └── vgg16_gesture_classifier.h5

# Bước 4: Khởi chạy Flask Web Server
python app.py --host=0.0.0.0 --port=5000 --device=cuda  # hoặc --device=cpu

Truy cập hệ thống tại: http://localhost:5000

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

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

  • Phụ thuộc vào điều kiện môi trường: Trong phòng học thiếu sáng nghiêm trọng ($< 50\text{ lux}$), độ chính xác của bước phát hiện bàn tay bị suy giảm khoảng $8 - 12%$.
  • Cử chỉ bị che khuất một phần (Occlusion): Khi các ngón tay bị đan xen vào nhau hoặc bị che bởi sách vở, mô hình VGG-16 đôi khi nhầm lẫn giữa nhãn agree và done.
  • Giới hạn cử chỉ tĩnh: Chưa phân biệt được các thao tác chuyển động động học (ví dụ: vẫy tay xin chào, xoay tròn cổ tay).

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

  1. Chuyển đổi sang mô hình không gian - thời gian (Spatiotemporal Models): Tích hợp mạng ConvLSTM hoặc Video Vision Transformer (ViViT) để nhận dạng trọn vẹn cả cử chỉ động và chuỗi ngôn ngữ ký hiệu liên tục (Continuous Sign Language Recognition).
  2. Nén mô hình phục vụ thiết bị biên (Edge AI): Lượng tử hóa mô hình (Quantization INT8) và tối ưu hóa qua TensorRT / ONNX Runtime để nạp trực tiếp lên các vi máy tính giá rẻ như Raspberry Pi 4/5 hoặc Jetson Nano phục vụ gắn cố định tại từng bàn học.
  3. Mở rộng tập nhãn đa ngôn ngữ: Gia tăng từ điển cử chỉ lên 30+ ký hiệu bao gồm bảng chữ cái và chữ số tiêu chuẩn.

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

+-----------------------------------------------------------------------------------------+
|                                    ĐỐI TƯỢNG HƯỞNG LỢI                                  |
|                                                                                         |
|  [Sinh viên & Người học]      [Lập trình viên & Kỹ sư AI]     [Nhà trường & Giáo viên]  |
|  - Tài liệu tham khảo chuẩn   - Source code mẫu 2-stage       - Giảm 15% thời gian chết |
|  - Nắm bắt pipeline AI thực   - Kiến trúc Web AI tinh gọn     - Lớp học số hóa kỷ luật  |
+-----------------------------------------------------------------------------------------+
  • Sinh viên & Học viên: Là tài liệu tham khảo chi tiết về quy trình hoàn thiện một đồ án tốt nghiệp chuẩn mực từ khâu thu thập dữ liệu, huấn luyện mô hình kết hợp (YOLO + VGG) đến triển khai Web application.
  • Kỹ sư AI & Lập trình viên: Cung cấp mẫu thiết kế (Design Pattern) thực tế để giải quyết các bài toán phân loại vùng đối tượng phức tạp mà các mô hình Single-stage đơn lẻ khó đạt độ chính xác cao.
  • Giáo viên & Cơ sở giáo dục: Sở hữu giải pháp chuyển đổi số không gian lớp học miễn phí, mã nguồn mở, vận hành ổn định trên cơ sở vật chất sẵn có.
  • Nhà nghiên cứu: Bổ sung phương pháp luận thực nghiệm về việc ghép nối các kiến trúc mạng nơ-ron tích chập đa nhiệm phục vụ Computer Vision ứng dụng.

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

1. Hệ thống cần cấu hình phần cứng tối thiểu như thế nào để vận hành mượt mà?

Hệ thống chỉ yêu cầu máy tính chạy CPU Intel Core i3 thế hệ thứ 8 trở lên, 8GB RAM và một webcam chuẩn 720p. Khi chạy trên CPU, hệ thống đạt tốc độ xử lý khoảng 20–25 khung hình/giây (FPS), hoàn toàn đáp ứng tốt nhu cầu tương tác trực tiếp trong lớp học mà không bắt buộc phải có card đồ họa rời.

2. Tại sao đồ án không phân loại trực tiếp bằng YOLOv8 mà phải kết hợp thêm VGG-16?

YOLOv8 xuất sắc trong việc quét toàn bộ khung hình để tìm tọa độ hộp bao (Bounding Box), tuy nhiên với các cử chỉ ngón tay có chi tiết nhỏ và khoảng cách cử chỉ giữa các ngón hẹp, việc sử dụng VGG-16 phân loại chuyên biệt trên vùng ảnh đã được cắt (Cropped RoI) và chuẩn hóa ($224 \times 224$) mang lại độ chính xác cao hơn $14.2%$ và hạn chế tối đa việc nhận diện nhầm các vật thể nền.

3. Hệ thống có thể tích hợp vào các phần mềm học trực tuyến như Zoom hoặc Microsoft Teams không?

Có. Nhờ thiết kế module hóa thông qua RESTful API và Flask Backend, hệ thống có thể hoạt động như một Virtual Camera Driver (sử dụng thư viện pyvirtualcam) hoặc một tiện ích mở rộng (Plugin/Sidecar) để gửi trực tiếp thông báo trạng thái cử chỉ của học sinh lên giao diện lớp học trực tuyến.

4. Chi phí triển khai và bảo trì hệ thống ước tính là bao nhiêu?

Chi phí phần mềm là 0 VNĐ do toàn bộ giải pháp được xây dựng trên nền tảng mã nguồn mở (Python, OpenCV, PyTorch, Flask). Chi phí phần cứng tận dụng hệ thống máy tính và webcam sẵn có của nhà trường. Chi phí bảo trì định kỳ chỉ bao gồm việc cập nhật tập dữ liệu để tái huấn luyện mô hình khi có thêm các cử chỉ mới.

5. Khả năng bảo mật và quyền riêng tư hình ảnh của học sinh được giải quyết như thế nào?

Toàn bộ luồng xử lý video (Frame Processing) diễn ra hoàn toàn cục bộ (On-Premise) trên bộ nhớ RAM của máy chủ lớp học hoặc máy cá nhân. Hệ thống chỉ trích xuất tọa độ và nhãn phân loại cử chỉ dưới dạng dữ liệu số; tuyệt đối không lưu trữ hay truyền tải hình ảnh khuôn mặt học sinh ra máy chủ bên ngoài, đảm bảo tuân thủ nghiêm ngặt các quy định về bảo vệ dữ liệu cá nhân.

Kết luận

Đồ án "Xây dựng ứng dụng trí tuệ nhân tạo nhận dạng cử chỉ bàn tay người" đã giải quyết thành công một thách thức thực tế trong quản lý lớp học hiện đại bằng việc phối hợp hai kiến trúc học sâu tiên tiến YOLOv8 và VGG-16. Với tập dữ liệu tự xây dựng gồm 1.502 ảnh, hệ thống đạt độ chính xác phát hiện bàn tay $\text{mAP@0.5}$ là $96.4%$, độ chính xác phân loại 7 cử chỉ đạt $95.6%$, và độ trễ xử lý thực tế chỉ $28.5\text{ ms}$.

Ứng dụng Web hoàn chỉnh trên nền tảng Flask chứng minh tính khả thi cao, mở ra tiềm năng to lớn trong việc số hóa tương tác sư phạm, hỗ trợ học sinh khiếm thính và xây dựng các lớp học thông minh trong tương lai. Đây là minh chứng rõ nét cho giá trị ứng dụng của Trí tuệ nhân tạo trong việc giải quyết các bài toán thiết thực của đời sống xã hội.