Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và công nghệ tương tác giữa người và máy (Human-Computer Interaction - HCI), phương thức nhập liệu truyền thống thông qua chuột, bàn phím hay màn hình cảm ứng đang dần được mở rộng sang các giao diện phi tiếp xúc (Touchless Interfaces). Các báo cáo thị trường công nghệ giao diện cử chỉ toàn cầu ghi nhận tốc độ tăng trưởng kép hàng năm (CAGR) đạt trên 22.5%, thúc đẩy mạnh mẽ việc ứng dụng Computer Vision và Deep Learning vào các thiết bị thông minh, xe tự hành (điển hình như hệ thống BMW Gesture Control) và y tế thông minh.

Đề tài "Tìm hiểu học sâu và xây dựng ứng dụng dự đoán hình ảnh được vẽ bằng cử chỉ" do sinh viên Nguyễn Đức Thuận (Ngành Kỹ thuật Dữ liệu, Đại học Sư phạm Kỹ thuật TP.HCM) thực hiện dưới sự hướng dẫn khoa học của TS. Trần Nhật Quang. Nghiên cứu giải quyết bài toán tương tác trực quan bằng cách nhận dạng cử chỉ bàn tay theo thời gian thực để vẽ nét trong không gian ảo, đồng thời tự động phân loại và dự đoán nội dung hình vẽ thông qua mạng nơ-ron tích chập (Convolutional Neural Network - CNN).

+------------------+      +-------------------+      +---------------------+
|  Video Capture   | ---> | Hand Tracking &   | ---> | Real-time Canvas    |
|  (RGB Camera)    |      | Gesture Classify  |      | Trajectory Buffer   |
+------------------+      +-------------------+      +---------------------+
                                                                |
+------------------+      +-------------------+                 v
|  Predicted Class | <--- | CNN Inference     | <--- +---------------------+
|  & Visual Output |      | (Adam Optimizer)  |      | Image Preprocessing |
+------------------+      +-------------------+      | (28x28 Bitmap, ROI) |
                                                     +---------------------+

Vấn đề thực tiễn và thách thức kỹ thuật

Phương thức vẽ tự do trong không gian (Air-drawing) đối mặt với các rào cản kỹ thuật lớn:

  • Thiếu phản hồi xúc giác (Haptic Feedback): Người dùng không có điểm tựa vật lý, khiến nét vẽ dễ biến dạng, rung giật và ngắt quãng không đồng đều.
  • Nhiễu chuyển động và tốc độ biến thiên: Tốc độ di chuyển tay dao động từ $25\text{ cm/s}$ đến hơn $30\text{ cm/s}$ gây ra hiện tượng mất dấu nét (trajectory loss) và trễ khung hình (frame latency).
  • Phân tách trạng thái vẽ: Khó khăn trong việc nhận diện chính xác thời điểm bắt đầu nét vẽ (Draw state) và ngưng vẽ (Hover/Idle state) mà không cần thiết bị ngoại vi gắn trên tay.

Mục tiêu của đề tài

  1. Nghiên cứu cơ sở lý thuyết về Computer Vision, kiến trúc mạng nơ-ron tích chập (CNN), cơ chế lan truyền ngược và các thuật toán tối ưu hóa tham số.
  2. Xây dựng module trích xuất đặc trưng và nhận diện cử chỉ tay dựa trên 2 trạng thái: Open Hand (Mở bàn tay - Ngưng bắt nét vẽ) và Close Hand (Nắm bàn tay/Trỏ ngón - Kích hoạt đầu bút vẽ).
  3. Tiền xử lý, tăng cường dữ liệu (Data Augmentation) và huấn luyện mô hình phân loại hình vẽ trên tập dữ liệu bitmap chuẩn hóa (Google Quick, Draw! Dataset).
  4. Đóng gói và tối ưu hóa pipeline ứng dụng khép kín từ camera đầu vào đến giao diện dự đoán theo thời gian thực với độ trễ thấp ($< 40\text{ ms}$).

Phạm vi và giới hạn nghiên cứu

  • Phạm vi: Nhận dạng cử chỉ bàn tay đơn (Single-hand tracking) qua webcam RGB thông thường, phân loại tập bản vẽ sketch thuộc các danh mục định sẵn (ngôi sao, quả táo, cái quần, chiếc lá, con mèo,...).
  • Giới hạn: Ứng dụng hoạt động tối ưu trong điều kiện ánh sáng ổn định, phông nền ít nhiễu động phức tạp và góc quay trực diện camera.

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

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

Tiêu chí so sánh Bảng vẽ / Chuột máy tính Cảm biến chuyên dụng (Leap Motion / Kinect) Giải pháp Vision + Deep Learning (Đề tài)
Thiết bị phần cứng Bắt buộc có phần cứng tiếp xúc vật lý Cảm biến hồng ngoại/chiều sâu đắt tiền Webcam chuẩn RGB thông dụng
Chi phí triển khai Trung bình ($50 - $300) Cao ($150 - $1000+) Rất thấp ($0 nếu tận dụng camera sẵn có)
Độ linh hoạt không gian Gò bó trên mặt phẳng 2D Giới hạn trong vùng quét hẹp của cảm biến Tự do tương tác trong không gian trước camera
Độ trễ xử lý $< 5\text{ ms}$ $10 - 20\text{ ms}$ $25 - 40\text{ ms}$ (Real-time inference)
Khả năng mở rộng AI Chỉ thu thập tọa độ thô Cần API chuyên biệt theo hãng Tích hợp trực tiếp các kiến trúc Deep Learning mở

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

  • Must-have: Bắt tọa độ bàn tay thời gian thực ($\ge 25\text{ FPS}$); Phân loại chuẩn xác 2 cử chỉ Open/Close; Lưu trữ buffer nét vẽ; Phân loại hình vẽ bằng CNN với Top-1 Accuracy $\ge 88%$.
  • Should-have: Pipeline tăng cường dữ liệu tự động (Rotation, Scaling, Noise Addition); Visual Dashboard trực quan hóa ma trận huấn luyện bằng TensorBoard.
  • Could-have: Nhận diện đa cử chỉ tùy biến màu nét vẽ và kích thước bút; Hỗ trợ xuất file ảnh bitmap hoặc vector.
  • Won't-have (Hiện tại): Tái tạo cử chỉ bàn tay 3D đa chiều (Mesh Reconstruction) và nhận dạng bản vẽ liên tục không cần ngắt nét.

Thiết kế kiến trúc hệ thống

Hệ thống hoạt động theo kiến trúc luồng dữ liệu 4 tầng độc lập:

graph TD
    A[Video Stream Input - Webcam RGB] --> B[Module Vision: Hand Tracking & ROI Detection]
    B --> C{Gesture State Classifier}
    C -- "Close Hand (Draw)" --> D[Trajectory Canvas Buffer]
    C -- "Open Hand (Pause)" --> E[Hold Canvas State]
    D --> F[Image Preprocessing & Downsampling 28x28]
    F --> G[Deep Learning Inference Engine - CNN]
    G --> H[Output Visualization: Top Predictions & Confidence Scores]

Thông số Technology Stack

Tech Stack:
├── Ngôn ngữ lập trình: Python v3.8.10
├── Framework Deep Learning: TensorFlow v2.8.0 / Keras API
├── Xử lý ảnh & Thị giác máy tính: OpenCV (cv2) v4.5.5
├── Tính toán đại số tuyến tính: NumPy v1.21.6
├── Giám sát & Trực quan hóa: TensorBoard v2.8.0
├── Môi trường thực thi: Ubuntu 20.04 LTS x86_64
└── Bộ tăng tốc phần cứng: NVIDIA CUDA Toolkit v11.2 / cuDNN v8.1

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

Dự án áp dụng mô hình phát triển Agile 15 tuần với các mốc kiểm soát kỹ thuật nghiêm ngặt:

[Tuần 1-3]  Khảo sát bài toán, xác lập tập dataset QuickDraw & cấu trúc môi trường Linux/CUDA.
     │
[Tuần 4-6]  Xây dựng module Computer Vision tracking tay và phân tách cử chỉ Open/Close.
     │
[Tuần 7-9]  Thiết kế kiến trúc CNN, triển khai Data Augmentation, cấu hình Adam Optimizer.
     │
[Tuần 10-12] Huấn luyện mô hình, tinh chỉnh siêu tham số (Hyperparameters), đánh giá loss/accuracy.
     │
[Tuần 13-15] Tích hợp end-to-end pipeline, kiểm thử thực địa theo vận tốc tay và hoàn thiện báo cáo.

Implementation và kết quả

Chi tiết giải thuật và mô hình toán học

1. Cơ chế phép tích chập (Convolution Operation)

Cho ma trận ảnh đầu vào $X \in \mathbb{R}^{m \times n}$ và bộ lọc (kernel) $F \in \mathbb{R}^{k \times k}$ ($k$ là số nguyên lẻ). Với bước sải (stride) $s$ và vùng đệm (padding) $p$, kích thước ma trận đầu ra $Y$ được xác định theo công thức chuẩn:

$$Y_{\text{dim}} = \left( \left\lfloor \frac{m - k + 2p}{s} \right\rfloor + 1 \right) \times \left( \left\lfloor \frac{n - k + 2p}{s} \right\rfloor + 1 \right)$$

Sau mỗi tầng tích chập, hàm kích hoạt phi tuyến tính ReLU ($f(x) = \max(0, x)$) được áp dụng nhằm loại bỏ các giá trị âm, kích hoạt các đặc trưng biên (edges) và góc (corners).

2. Thuật toán tối ưu hóa Adam (Adaptive Moment Estimation)

Thuật toán Adam kết hợp ưu điểm của Momentum (gia tốc gradient theo quán tính) và RMSprop (điều chỉnh learning rate thích ứng theo phương sai bậc 2 của gradient):

  • Khởi tạo vector moment bậc 1 ($m_t$) và moment bậc 2 ($v_t$): $$m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t$$ $$v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2$$

  • Hiệu chỉnh sai số độ lệch (Bias Correction): $$\hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \quad \hat{v}_t = \frac{v_t}{1 - \beta_2^t}$$

  • Cập nhật trọng số tham số $\theta$: $$\theta_{t+1} = \theta_t - \frac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t$$

Siêu tham số thực nghiệm thiết lập: $\alpha = 0.001$, $\beta_1 = 0.9$, $\beta_2 = 0.999$, $\epsilon = 10^{-8}$.

Hiện thực hóa mã nguồn (Code Implementation)

Mã nguồn xây dựng kiến trúc mạng CNN và pipeline huấn luyện trên TensorFlow:

import tensorflow as tf
from tensorflow.keras import layers, models, optimizers

def build_sketch_classifier(input_shape=(28, 28, 1), num_classes=10):
    """
    Xây dựng kiến trúc CNN phân loại ảnh vẽ nét sketch.
    Bao gồm các tầng Conv2D, MaxPooling, BatchNormalization, Dropout và Dense.
    """
    model = models.Sequential([
        # Tầng tích chập khối 1
        layers.Conv2D(32, (3, 3), padding='same', activation='relu', input_shape=input_shape),
        layers.BatchNormalization(),
        layers.MaxPooling2D(pool_size=(2, 2), strides=2),
        layers.Dropout(0.25),

        # Tầng tích chập khối 2
        layers.Conv2D(64, (3, 3), padding='same', activation='relu'),
        layers.BatchNormalization(),
        layers.MaxPooling2D(pool_size=(2, 2), strides=2),
        layers.Dropout(0.25),

        # Tầng tích chập khối 3
        layers.Conv2D(128, (3, 3), padding='same', activation='relu'),
        layers.BatchNormalization(),
        layers.MaxPooling2D(pool_size=(2, 2), strides=2),
        layers.Dropout(0.3),

        # Tầng phẳng hóa và Fully Connected
        layers.Flatten(),
        layers.Dense(256, activation='relu'),
        layers.BatchNormalization(),
        layers.Dropout(0.4),
        layers.Dense(num_classes, activation='softmax')
    ])
    
    # Cấu hình bộ tối ưu Adam với các siêu tham số chuẩn hóa
    opt = optimizers.Adam(
        learning_rate=0.001,
        beta_1=0.9,
        beta_2=0.999,
        epsilon=1e-08
    )
    
    model.compile(
        optimizer=opt,
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )
    return model

# Khởi tạo mô hình
classifier = build_sketch_classifier(num_classes=10)
classifier.summary()

Mã nguồn điều khiển canvas vẽ thời gian thực bằng OpenCV:

import cv2
import numpy as np

class AirCanvasTracker:
    def __init__(self, canvas_size=(480, 640)):
        self.canvas = np.zeros((*canvas_size, 3), dtype=np.uint8)
        self.prev_point = None
        self.draw_color = (255, 255, 255) # Nét vẽ trắng trên nền đen
        self.thickness = 8

    def process_frame(self, frame, hand_state, current_point):
        """
        hand_state: 1 nếu Close Hand (vẽ), 0 nếu Open Hand (ngưng vẽ)
        """
        if hand_state == 1 and current_point is not None:
            if self.prev_point is not None:
                cv2.line(self.canvas, self.prev_point, current_point, self.draw_color, self.thickness)
            self.prev_point = current_point
        else:
            self.prev_point = None # Ngắt nét khi mở bàn tay

    def extract_inference_roi(self):
        """Tiền xử lý vùng canvas để đưa vào CNN inference (28x28 Grayscale)"""
        gray = cv2.cvtColor(self.canvas, cv2.COLOR_BGR2GRAY)
        resized = cv2.resize(gray, (28, 28), interpolation=cv2.INTER_AREA)
        normalized = resized.astype('float32') / 255.0
        return np.expand_dims(normalized, axis=(0, -1)) # Shape: (1, 28, 28, 1)

Kết quả kiểm thử và đánh giá hiệu năng

1. Đánh giá khả năng tracking theo vận tốc cử chỉ

Kịch bản kiểm thử Vận tốc di chuyển tay Tỷ lệ bắt nét chuẩn xác Tỷ lệ mất dấu (Loss tracking) FPS trung bình
Kịch bản A $25 - 26\text{ cm/s}$ $96.4%$ $3.6%$ $29.8\text{ FPS}$
Kịch bản B $29 - 30\text{ cm/s}$ $88.2%$ $11.8%$ $28.4\text{ FPS}$
Kịch bản C $> 35\text{ cm/s}$ $74.5%$ $25.5%$ $26.1\text{ FPS}$

Nhận xét: Ở dải vận tốc tiêu chuẩn từ $25 - 26\text{ cm/s}$, thuật toán bám dính quỹ đạo cực tốt, nét vẽ liền mạch và giữ nguyên tỷ lệ hình học của vật thể.

2. Độ chính xác nhận diện trên các lớp đối tượng thực tế

========================================================================
Lớp đối tượng (Class)      Số mẫu test    Độ chính xác (Accuracy)   Top-2 Confidence
------------------------------------------------------------------------
Ngôi sao (Star)            120            94.17%                    98.33%
Quả táo (Apple)            120            93.33%                    96.67%
Cái quần (Pants)           120            91.67%                    95.83%
Chiếc lá (Leaf)            120            90.83%                    95.00%
Con mèo (Cat)              120            89.17%                    93.33%
------------------------------------------------------------------------
Trung bình toàn hệ thống:  600 mẫu        91.83%                    95.83%
========================================================================

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

  1. Kiến trúc tương tác phi tiếp xúc giá thành $0$ đồng: Loại bỏ hoàn toàn sự phụ thuộc vào các cảm biến hồng ngoại chuyên dụng (như Leap Motion controller có giá hàng triệu đồng), cho phép ứng dụng chạy trực tiếp trên các webcam 720p tiêu chuẩn của laptop phổ thông.
  2. Cơ chế tách nét thông minh (State Decoupling): Phân định rành mạch giữa chế độ vẽ (Close Hand) và di chuyển con trỏ tự do (Open Hand), khắc phục triệt để lỗi "nét thừa" (drawing artifacts) vốn là vấn đề nan giải trong các ứng dụng Air-drawing truyền thống.
  3. Tối ưu hóa thời gian hội tụ với Adam Optimizer: Giảm số lượng epochs cần thiết để đạt điểm hội tụ từ $45\text{ epochs}$ (khi dùng SGD tiêu chuẩn) xuống còn $18\text{ epochs}$, đồng thời triệt tiêu hiện tượng dao động quanh cực tiểu cục bộ (Local Minima).
  4. Pipeline tăng cường dữ liệu đa dạng: Áp dụng kết hợp Rotation ($\pm 15^\circ$), Random Crop và Color/Noise Inversion giúp mô hình có khả năng tổng quát hóa cao, không bị ảnh hưởng bởi độ dày mỏng của nét vẽ tay người dùng.

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

Kịch bản ứng dụng thực tiễn

  • Giáo dục mầm non và tiểu học: Bảng vẽ tương tác không chạm thông minh giúp học sinh học vẽ, luyện chữ và đoán đồ vật qua trò chơi trực quan mà không cần bảng điện tử đắt tiền.
  • Y tế và phòng phẫu thuật vô trùng: Hỗ trợ bác sĩ phẫu thuật phác thảo ghi chú hoặc tra cứu tài liệu y khoa trên màn hình điều khiển mà không cần chạm tay vào thiết bị, đảm bảo tiêu chuẩn vô trùng tuyệt đối.
  • Kiosk thông tin công cộng: Hệ thống tra cứu tại sân bay, nhà ga, bảo tàng hoạt động hoàn toàn bằng cử chỉ tay, ngăn ngừa nguy cơ lây nhiễm vi khuẩn/virus qua màn hình cảm ứng công cộng.

Yêu cầu phần cứng và triển khai

Thông số phần cứng đề xuất:
├── CPU: Intel Core i3 thế hệ 8 hoặc AMD Ryzen 3 trở lên
├── RAM: Tối thiểu 4GB (Khuyến nghị 8GB DDR4)
├── Camera: Webcam chuẩn USB RGB độ phân giải tối thiểu 720p @ 30FPS
└── GPU (Tùy chọn cho Inference nhanh): NVIDIA GeForce GT 1030 hoặc Intel UHD Graphics 620

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

  • Chi phí đầu tư phần cứng: Giảm $95%$ so với việc trang bị màn hình cảm ứng điện dung cỡ lớn hoặc cảm biến quang học chuyên dụng.
  • Chi phí bảo trì: Giảm thiểu $80%$ hư hỏng vật lý do người dùng không tác động lực cơ học lên bề mặt phần cứng hiển thị.

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

Hạn chế hiện tại

  • Độ nhạy sáng: Khi môi trường có ánh sáng quá yếu ($< 50\text{ lux}$) hoặc bị ngược sáng mạnh, tỷ lệ phát hiện bàn tay giảm khoảng $14.5%$.
  • Tập danh mục lớp: Số lượng nhãn phân loại đang dừng lại ở các nhóm đối tượng đại diện cơ bản, chưa mở rộng ra toàn bộ hơn 300 danh mục của bộ Google QuickDraw.
  • Tracking đơn điểm: Chưa tận dụng đầy đủ 21 tọa độ khớp bàn tay (Hand Landmarks) để tạo ra các thao tác phức tạp như phóng to, thu nhỏ, xóa vùng vẽ bằng 2 ngón tay.

Hướng phát triển tiếp theo

  • Nâng cấp module Computer Vision sang MediaPipe Hand Landmark Pipeline để trích xuất 21 điểm 3D khớp ngón tay với độ chính xác cao hơn.
  • Triển khai mô hình nén nhẹ TensorFlow Lite (TFLite) với kỹ thuật lượng tử hóa trọng số (Quantization int8/float16), phục vụ nhúng trực tiếp lên các vi máy tính biên như Raspberry Pi 4 hoặc NVIDIA Jetson Nano.
  • Mở rộng kiến trúc mạng sang các mô hình Vision Transformer (ViT) hoặc MobileNetV3 nhằm hỗ trợ phân loại đồng thời hơn 345 lớp đồ vật sketch phức tạp.

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

  • Sinh viên & Học viên CNTT: Nắm vững giáo trình thực hành về Computer Vision, hiểu sâu bản chất toán học của phép Convolution, Pooling và cơ chế tối ưu hóa Adam.
  • Kỹ sư AI / Lập trình viên: Tham khảo mô hình kiến trúc hoàn chỉnh từ khâu bắt luồng video camera, trích xuất ROI, đưa qua buffer canvas đến thực hiện inference theo thời gian thực.
  • Doanh nghiệp & Startup EdTech: Sở hữu giải pháp công nghệ nền tảng chi phí thấp để tích hợp vào các phòng học thông minh, bảng tương tác và ứng dụng giải trí không chạm.
  • Nhà nghiên cứu HCI: Dữ liệu thực nghiệm về mối tương quan giữa tốc độ vung tay ($25 - 30\text{ cm/s}$) và độ chính xác của nét vẽ cung cấp tham số giá trị cho các nghiên cứu giao diện người - máy tương lai.

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

1. Hệ thống có yêu cầu GPU rời đắt tiền để chạy suy luận không?

Không. Mạng CNN được thiết kế tối ưu với kích thước đầu vào chỉ $28 \times 28$ pixel và số tầng tích chập tinh gọn. Do đó, CPU thông thường của laptop (như Intel Core i3/i5) hoàn toàn có thể chạy suy luận thời gian thực với tốc độ xử lý đạt trên $28\text{ FPS}$.

2. Sự khác biệt cốt lõi giữa Adam Optimizer và SGD truyền thống trong bài toán này là gì?

Stochastic Gradient Descent (SGD) sử dụng một tốc độ học (learning rate) cố định cho tất cả các trọng số, dẫn đến tốc độ hội tụ chậm và dễ mắc kẹt tại các điểm yên ngựa (saddle points). Adam tính toán tốc độ học thích ứng riêng cho từng tham số thông qua moment bậc 1 và moment bậc 2, giúp mô hình hội tụ nhanh hơn gấp $2.5$ lần trên tập dữ liệu QuickDraw.

3. Làm thế nào để ứng dụng phân biệt được giữa lúc người dùng đang vẽ và lúc di chuyển tay vị trí khác?

Hệ thống sử dụng bộ phân loại trạng thái cử chỉ bàn tay: khi bàn tay ở trạng thái nắm/trỏ ngón (Close Hand), hệ thống kích hoạt chế độ ghi nhận tọa độ điểm ảnh liên tục trên canvas; khi bàn tay mở rộng (Open Hand), luồng bắt nét lập tức ngắt quãng, cho phép người dùng di chuyển tay tự do trong không gian mà không làm lem nét vẽ.

4. Tập dữ liệu Quick, Draw! Bitmap được xử lý như thế nào trước khi huấn luyện?

Dữ liệu gốc gồm hàng triệu tệp vector/bitmap được trích xuất, chuẩn hóa kích thước về ma trận $28 \times 28$ điểm ảnh xám (Grayscale), chia giá trị pixel cho $255.0$ để đưa về đoạn $[0, 1]$, sau đó được phân bổ thành 2 tập riêng biệt: $80%$ dành cho Training và $20%$ dành cho Validation.

5. Ứng dụng có thể mở rộng để nhận diện chữ viết tay trong không trung (Air-writing) được không?

Hoàn toàn khả thi. Bằng cách thay thế tập dữ liệu QuickDraw bằng bộ dữ liệu chữ số MNIST hoặc chữ viết EMNIST/VN-OnDB và giữ nguyên pipeline AirCanvasTracker, hệ thống có thể dễ dàng chuyển đổi thành ứng dụng nhận dạng chữ viết tay bằng cử chỉ.

Kết luận

Đề tài "Tìm hiểu học sâu và xây dựng ứng dụng dự đoán hình ảnh được vẽ bằng cử chỉ" của tác giả Nguyễn Đức Thuận đã hoàn thành xuất sắc các mục tiêu đề ra: từ việc làm chủ nền tảng lý thuyết mạng nơ-ron tích chập (CNN), thuật toán tối ưu hóa Adam, đến việc hiện thực hóa thành công một sản phẩm ứng dụng có tính tương tác cao. Hệ thống đạt độ chính xác phân loại trung bình $91.83%$ trên các lớp bản vẽ thực nghiệm, duy trì tốc độ xử lý mượt mà $\sim 30\text{ FPS}$ trên phần cứng phổ thông.

Đây là minh chứng rõ nét cho tiềm năng ứng dụng của Trí tuệ nhân tạo và Thị giác máy tính trong việc nâng cao trải nghiệm giao tiếp người - máy, mở ra cánh cửa cho các giải pháp tương tác không chạm thông minh, tiện ích và tiết kiệm chi phí trong tương lai.