Giới thiệu dự án

Trong bối cảnh chuyển đổi số và tự động hóa các giao dịch tài chính, việc xử lý tiền mặt nhanh chóng và chính xác vẫn là mắt xích thiết yếu tại các thị trường đang phát triển. Theo thống kê từ Ngân hàng Nhà nước Việt Nam, mặc dù thanh toán không dùng tiền mặt tăng trưởng mạnh, lưu lượng tiền mặt trong lưu thông tại các chợ truyền thống, chuỗi bán lẻ vừa và nhỏ, và các điểm dịch vụ vẫn chiếm tỷ trọng đáng kể. Quá trình kiểm đếm tiền mặt thủ công tiềm ẩn nhiều rủi ro về sai sót định danh mệnh giá, tiêu tốn thời gian giao dịch, và nguy cơ lây nhiễm vi khuẩn qua tiếp xúc vật lý.

Đề tài "Hệ thống đếm tiền Việt Nam Đồng" do sinh viên Võ Thanh Hưng thực hiện dưới sự hướng dẫn của ThS. Huỳnh Quang Đức tại Khoa Công nghệ Thông tin, Robot và Trí tuệ Nhân tạo – Trường Đại học Bình Dương (07/2022) tập trung giải quyết bài toán tự động hóa nhận diện mệnh giá và tính toán tổng giá trị tiền polymer Việt Nam Đồng (VND) thông qua công nghệ Thị giác Máy tính (Computer Vision) và Học sâu (Deep Learning).

┌─────────────────────────────────────────────────────────────┐
│                   HỆ THỐNG ĐẾM TIỀN VND                     │
│                                                             │
│  [ Camera Mobile ] ──(Ảnh chụp)──> [ API Gateway Flask ]    │
│                                           │                 │
│                                           ▼                 │
│  [ Flutter UI ] <──(JSON kết quả)── [ YOLOv6 / ResNet50 ]   │
│         │                                 │                 │
│         └────────(Quản lý gói/Tỷ giá)─────┴─> [ MySQL DB ]  │
└─────────────────────────────────────────────────────────────┘

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

  • Tốc độ và sai sót của con người: Việc đếm thủ công các cọc tiền lẫn lộn nhiều mệnh giá (10.000đ, 20.000đ, 50.000đ, 100.000đ, 200.000đ, 500.000đ) dễ dẫn đến nhầm lẫn, đặc biệt giữa các tờ có tông màu tương đồng (như 20.000đ và 500.000đ trong điều kiện thiếu sáng).
  • Chi phí thiết bị chuyên dụng cao: Các máy đếm tiền cơ học có cảm biến quang học hiện đại trên thị trường có giá thành từ 5.000.000đ đến 20.000.000đ, kích thước cồng kềnh, không linh hoạt để triển khai di động.
  • Rào cản tiếp cận cho người khiếm thị và người nước ngoài: Khách du lịch quốc tế và người khuyết tật thị giác gặp nhiều khó khăn khi phân biệt mệnh giá tiền VND, dẫn đến bất tiện trong sinh hoạt và thanh toán hàng ngày.

Mục tiêu dự án

  1. Xây dựng mô hình Học sâu (Deep Learning) có khả năng định vị (localization) và phân loại (classification) chính xác các mệnh giá tiền Việt Nam Đồng từ hình ảnh thu thập qua camera.
  2. Thiết kế và phát triển ứng dụng di động đa nền tảng (Cross-platform) với giao diện người dùng trực quan, tối ưu trải nghiệm thao tác một chạm.
  3. Xây dựng hệ thống máy chủ phụ trợ (Backend Server) xử lý suy luận (inference) thời gian thực với độ trễ thấp và tích hợp cơ sở dữ liệu quản lý người dùng, giao dịch, tỷ giá ngoại tệ.
  4. Đóng gói giải pháp hoàn chỉnh, có khả năng triển khai linh hoạt trên môi trường đám mây và thiết bị di động cá nhân.

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

Dự án kết hợp giữa mô hình nhận diện vật thể tiên tiến YOLOv6 (You Only Look Once version 6) và mạng nơ-ron tích chập ResNet50 (Deep Residual Network 50 layers), kết nối với ứng dụng giao diện Flutter thông qua RESTful API xây dựng trên nền tảng Python Flask. Hệ thống hướng đến mục tiêu đạt thời gian phản hồi suy luận dưới 1.5 giây mỗi khung hình, độ chính xác nhận diện trên 95%, và hỗ trợ đếm cùng lúc nhiều tờ tiền trong một góc chụp.

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

  • Phạm vi nghiên cứu: Nhận diện 6 mệnh giá tiền polymer Việt Nam Đồng đang lưu hành phổ biến (10.000 VND, 20.000 VND, 50.000 VND, 100.000 VND, 200.000 VND, 500.000 VND).
  • Giới hạn hệ thống: Hình ảnh đầu vào yêu cầu bề mặt tờ tiền không bị che khuất quá 40%; hệ thống chưa tích hợp cảm biến từ tính (MG) hoặc tia cực tím (UV) để phân biệt tiền giả chuyên sâu.

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

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

Tiêu chí Máy đếm tiền cơ học truyền thống Xử lý ảnh cổ điển (OpenCV / SIFT) Hệ thống Deep Learning Đề xuất
Tính di động Kém (thiết bị cố định, cồng kềnh) Trung bình (cần máy tính xách tay) Cao (chạy trên Smartphone qua Flutter)
Chi phí triển khai 5.000.000đ – 20.000.000đ/máy Thấp (phần mềm mã nguồn mở) Rất thấp (tận dụng smartphone có sẵn)
Xử lý tiền lẫn mệnh giá Chỉ có trên dòng máy cao cấp Rất kém, dễ sai sót do góc nghiêng Tốt, xử lý đa vật thể đồng thời qua YOLO
Khả năng mở rộng Phải thay đổi phần cứng Khó mở rộng thêm mệnh giá mới Dễ dàng retrain model và cập nhật qua OTA
Tính năng phụ trợ Chỉ đếm và cộng dồn Giới hạn xử lý ảnh thô Quy đổi ngoại tệ, lưu lịch sử, quản trị gói

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

┌─────────────────────────────────────────────────────────────┐
│                     MÔ HÌNH MOSCOW                          │
│                                                             │
│  [MUST HAVE]                                                │
│  - Chụp ảnh từ Camera / Thư viện                            │
│  - Nhận diện 6 mệnh giá VND                                 │
│  - Tính tổng số tờ và tổng tiền                             │
│                                                             │
│  [SHOULD HAVE]                                              │
│  - Quy đổi VND sang USD/EUR                                 │
│  - Đăng ký / Đăng nhập tài khoản                            │
│                                                             │
│  [COULD HAVE]                                               │
│  - Quản lý gói cước dịch vụ Admin                           │
│  - Bounding Box hiển thị trực quan                          │
│                                                             │
│  [WON'T HAVE (Phase 1)]                                     │
│  - Quét tiền giả bằng tia cực tím (UV)                      │
│  - Xử lý video stream 60 FPS cục bộ                         │
└─────────────────────────────────────────────────────────────┘
  • Must Have (Bắt buộc): Chụp ảnh từ camera; nhận diện 6 mệnh giá tiền VND; hiển thị số lượng từng loại và tổng tiền.
  • Should Have (Nên có): Tính năng quy đổi ngoại tệ tức thời; xác thực đăng nhập/đăng ký người dùng; lưu trữ lịch sử kiểm đếm.
  • Could Have (Có thể có): Phân quyền quản trị viên (Admin) để quản lý gói người dùng; hiển thị khung bao (Bounding Box) trực quan của từng tờ tiền.
  • Won't Have (Chưa thực hiện ở giai đoạn này): Kiểm tra cấu trúc sợi phát quang chống tiền giả qua cảm biến quang phổ.

Thiết kế hệ thống

Kiến trúc giải pháp được thiết kế theo mô hình Khách - Chủ (Client - Server) phân lớp độc lập:

  1. Client Layer (Mobile App): Xây dựng bằng Flutter Engine, đảm nhiệm chụp ảnh, tiền xử lý kích thước ảnh phía client, gửi HTTP POST request và render kết quả phân tích.
  2. Gateway & Application Layer (REST Server): Nền tảng Flask Web Framework tiếp nhận payload ảnh, thực hiện kiểm tra tính hợp lệ và chuyển tiếp ma trận điểm ảnh (Tensor) đến mô hình AI.
  3. Inference Engine (AI Pipeline):
    • YOLOv6: Chịu trách nhiệm Object Detection, phân chia hình ảnh thành lưới $S \times S$, dự đoán tọa độ Bounding Box $(x, y, w, h)$, Objectness Score và Class Probabilities.
    • ResNet50: Đóng vai trò mạng phân loại trích xuất đặc trưng sâu (Deep Feature Extractor) gồm 48 lớp Convolution, 1 lớp MaxPool và 1 lớp AveragePool kết hợp cơ chế Residual Skip Connection $F(x) + x$.
  4. Data Persistence Layer (Database): Hệ quản trị cơ sở dữ liệu MySQL lưu trữ thực thể tài khoản, thông tin gói cước và log kiểm đếm.

Danh mục công nghệ và phiên bản chuẩn hóa

  • Hệ điều hành máy chủ: Ubuntu Server 20.04 LTS (triển khai qua SSH/PuTTY 0.77).
  • Backend Framework: Python 3.7.12, Flask 2.1.2, Werkzeug 2.1.2.
  • Computer Vision & AI: PyTorch 1.11.0, Torchvision 0.12.0, OpenCV 4.5.5, YOLOv6 Engine, ResNet50 (Transfer Learning từ ImageNet weights).
  • Frontend Framework: Flutter 3.0.x (Dart SDK 2.17.x), HTTP Package, Camera Plugin.
  • Cơ sở dữ liệu: MySQL Community Server 8.0.29 (kết nối qua PyMySQL / SQLAlchemy).
  • Công cụ gán nhãn & xử lý Dataset: LabelImg v1.8.6, Roboflow Annotation Platform.

Thiết kế cơ sở dữ liệu (Database Schema)

-- Bảng tài khoản người dùng
CREATE TABLE `users` (
  `id` INT AUTO_INCREMENT PRIMARY KEY,
  `username` VARCHAR(50) NOT NULL UNIQUE,
  `password_hash` VARCHAR(255) NOT NULL,
  `fullname` VARCHAR(100),
  `role` ENUM('admin', 'user') DEFAULT 'user',
  `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- Bảng quản lý gói cước dịch vụ
CREATE TABLE `service_packages` (
  `package_id` INT AUTO_INCREMENT PRIMARY KEY,
  `user_id` INT NOT NULL,
  `package_name` VARCHAR(50) NOT NULL,
  `expired_date` DATE NOT NULL,
  `status` TINYINT(1) DEFAULT 1,
  FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- Bảng lưu trữ lịch sử nhận diện và kiểm đếm
CREATE TABLE `counting_logs` (
  `log_id` INT AUTO_INCREMENT PRIMARY KEY,
  `user_id` INT NOT NULL,
  `image_path` VARCHAR(255),
  `total_amount` BIGINT NOT NULL,
  `details_json` JSON NOT NULL,
  `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  FOREIGN KEY (`user_id`) REFERENCES `users`(`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Thiết kế API Endpoints

┌─────────────────────────────────────────────────────────────┐
│                    API GATEWAY ENDPOINTS                    │
│                                                             │
│  [POST] /api/v1/auth/login        ──> Xác thực JWT          │
│  [POST] /api/v1/detect-money      ──> Nhận diện & Đếm tiền  │
│  [POST] /api/v1/currency-convert  ──> Quy đổi ngoại tệ      │
│  [GET]  /api/v1/admin/packages    ──> Quản lý gói cước      │
└─────────────────────────────────────────────────────────────┘
HTTP Method Endpoint Tham số đầu vào (Payload) Phản hồi (JSON Response)
POST /api/v1/auth/login {"username": "...", "password": "..."} {"status": "success", "token": "...", "role": "..."}
POST /api/v1/detect-money Multipart: file (Image binary) {"total_amount": 680000, "breakdown": {"500k": 1, "100k": 1, "50k": 1, "20k": 1, "10k": 1}, "latency_ms": 320}
POST /api/v1/currency-convert {"amount_vnd": 500000, "target": "USD"} {"amount_vnd": 500000, "converted": 21.35, "rate": 23415}
GET /api/v1/admin/packages Header: Authorization: Bearer <token> [{"user": "...", "package": "VIP_Monthly", "expired": "2022-12-31"}]

Methodology

Dự án áp dụng phương pháp phát triển linh hoạt (Agile-based Iteration) kéo dài từ ngày 29/03/2022 đến ngày 11/07/2022, chia làm 5 mốc tiến độ chính:

  1. Khảo sát & Thu thập dữ liệu (29/03/2022 - 01/05/2022): Thu thập mẫu ảnh tiền tệ đa góc chụp, điều kiện sáng phức tạp; gán nhãn dữ liệu chuẩn PASCAL VOC/YOLO format qua LabelImg.
  2. Cấu hình môi trường & Pipeline AI (02/05/2022 - 18/06/2022): Cài đặt Python, PyTorch, YOLOv6, ResNet50; huấn luyện trên Google Colab GPU (Tesla T4) và Roboflow cloud; tinh chỉnh siêu tham số (Hyperparameter Tuning).
  3. Tích hợp Backend & API (19/06/2022 - 01/07/2022): Xây dựng Flask API, kết nối cơ sở dữ liệu MySQL, triển khai cấu hình bảo mật máy chủ từ xa qua PuTTY.
  4. Phát triển giao diện Flutter (02/07/2022 - 05/07/2022): Hiện thực hóa màn hình Đăng ký, Đăng nhập, Chụp ảnh, Thống kê chi tiết từng tờ tiền và Tổng tiền tệ.
  5. Kiểm thử hệ thống & Hoàn thiện báo cáo (08/07/2022 - 11/07/2022): Chạy thử nghiệm tổng thể (End-to-End Testing), tối ưu hóa thời gian phản hồi và hoàn thiện tài liệu kỹ thuật.

Implementation và kết quả

Development process

1. Quy trình xử lý dữ liệu và Data Augmentation

Bộ dữ liệu gồm 480 hình ảnh gốc được gán nhãn thủ công qua công cụ LabelImg và đồng bộ lên Roboflow. Để khắc phục hiện tượng Overfitting và nâng cao khả năng khái quát hóa trong điều kiện chụp thực tế, các kỹ thuật tăng cường dữ liệu (Data Augmentation) được áp dụng:

  • Xoay ngẫu nhiên (Random Rotation): $\pm 15^\circ$.
  • Thay đổi độ sáng (Brightness Adjustment): từ $-20%$ đến $+20%$.
  • Cắt và co giãn tỷ lệ (Random Crop & Resize): Chuẩn hóa về kích thước $640 \times 640$ pixels.
  • Tỷ lệ phân chia tập dữ liệu: 70% Train (336 ảnh), 20% Validation (96 ảnh), 10% Test (48 ảnh).

2. Xây dựng dịch vụ nhận diện Backend (Flask + Deep Learning)

Đoạn mã nguồn dưới đây minh họa cách thức dịch vụ Flask tiếp nhận ảnh nhị phân từ ứng dụng di động, thực thi mô hình suy luận và tổng hợp mệnh giá tiền:

import os
import io
import torch
import numpy as np
from PIL import Image
from flask import Flask, request, jsonify

app = Flask(__name__)

# Tải mô hình YOLOv6 tùy biến đã huấn luyện cho tiền VND
MODEL_PATH = "weights/yolov6_vnd_custom.pt"
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = torch.load(MODEL_PATH, map_location=device)['model'].float().eval()

DENOMINATIONS = {
    0: 10000,
    1: 20000,
    2: 50000,
    3: 100000,
    4: 200000,
    5: 500000
}

def preprocess_image(image_bytes):
    img = Image.open(io.BytesIO(image_bytes)).convert("RGB")
    img_resized = img.resize((640, 640))
    img_array = np.array(img_resized) / 255.0
    img_tensor = torch.from_numpy(img_array).float().permute(2, 0, 1).unsqueeze(0)
    return img_tensor.to(device)

@app.route('/api/v1/detect-money', methods=['POST'])
def detect_money():
    if 'file' not in request.files:
        return jsonify({'error': 'No file uploaded'}), 400
    
    file = request.files['file']
    img_tensor = preprocess_image(file.read())
    
    with torch.no_grad():
        predictions = model(img_tensor)
        # Áp dụng Non-Maximum Suppression (NMS) với threshold IoU = 0.45, Conf = 0.5
        detections = non_max_suppression(predictions, conf_thres=0.5, iou_thres=0.45)[0]
    
    breakdown = {f"{val:,} VND": 0 for val in DENOMINATIONS.values()}
    total_amount = 0
    
    if detections is not None and len(detections):
        for *box, conf, cls_id in detections:
            denom_value = DENOMINATIONS.get(int(cls_id), 0)
            if denom_value > 0:
                breakdown[f"{denom_value:,} VND"] += 1
                total_amount += denom_value
                
    return jsonify({
        'status': 'success',
        'total_amount': total_amount,
        'total_notes': int(len(detections)) if detections is not None else 0,
        'breakdown': breakdown
    }), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=False)

3. Xử lý phía Client bằng Flutter (Dart)

import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;

class MoneyDetectionService {
  static const String apiUrl = 'http://52.135.xx.xx:5000/api/v1/detect-money';

  Future<Map<String, dynamic>> uploadAndDetect(File imageFile) async {
    var request = http.MultipartRequest('POST', Uri.parse(apiUrl));
    request.files.add(await http.MultipartFile.fromPath('file', imageFile.path));

    try {
      var streamedResponse = await request.send();
      var response = await http.Response.fromStream(streamedResponse);

      if (response.statusCode == 200) {
        return jsonDecode(response.body) as Map<String, dynamic>;
      } else {
        throw Exception('Server error: ${response.statusCode}');
      }
    } catch (e) {
      throw Exception('Failed to connect to AI server: $e');
    }
  }
}

Testing và validation

Ma trận kịch bản kiểm thử (Test Matrix)

Kịch bản kiểm thử Điều kiện môi trường Số lượng mẫu thử Tỷ lệ nhận diện đúng Thời gian suy luận trung bình
Đơn tờ tiền phẳng Ánh sáng tiêu chuẩn (500 lux), góc vuông $90^\circ$ 120 98.3% 240 ms
Đa tờ tiền tách biệt 2 - 5 tờ trải trên mặt phẳng, không đè lấp 100 95.0% 310 ms
Đa tờ tiền xếp chồng Chồng lấn một phần ($< 25%$ diện tích) 80 88.7% 340 ms
Tiền nhàu / gập mép Tờ tiền cũ, nếp gấp ngang dọc 100 91.2% 290 ms
Thiếu sáng / Bóng mờ Ánh sáng yếu ($< 100$ lux), có bóng che 80 86.2% 360 ms 
┌─────────────────────────────────────────────────────────────┐
│              HIỆU NĂNG NHẬN DIỆN THEO MỆNH GIÁ              │
│                                                             │
│  500.000 VND  ████████████████████████████  97.5%           │
│  200.000 VND  ██████████████████████████    94.2%           │
│  100.000 VND  ████████████████████████████  96.8%           │
│   50.000 VND  █████████████████████████     92.1%           │
│   20.000 VND  ████████████████████████      90.5%           │
│   10.000 VND  ██████████████████████████    93.8%           │
└─────────────────────────────────────────────────────────────┘
  • Độ chính xác trung bình (mAP@0.5): Đạt 94.18% trên toàn bộ tập kiểm thử.
  • Tốc độ xử lý Pipeline:
    • Network Upload Latency: ~180 ms (qua mạng 4G/WiFi).
    • Model Inference (GPU Tesla T4): ~45 ms (hoặc ~320 ms trên CPU Server tiêu chuẩn).
    • Response Rendering: ~25 ms.
    • Tổng thời gian hoàn tất một giao dịch: $\approx 0.55 - 0.85$ giây.

Kết quả đạt được

┌─────────────────────────────────────────────────────────────┐
│                    KẾT QUẢ TRIỂN KHAI                      │
│                                                             │
│  - Dataset: 480+ ảnh chuẩn hóa qua Roboflow                 │
│  - Training: Đạt mAP@0.5 = 94.18% sau 150 epochs            │
│  - Latency: < 1s/giao dịch kiểm đếm                         │
│  - Client: Hoàn thiện 5 màn hình Flutter                    │
│  - Server: Flask RESTful API chạy nền qua PuTTY             │
└─────────────────────────────────────────────────────────────┘
  1. Về mặt công nghệ: Xây dựng thành công quy trình khép kín từ thu thập, chuẩn hóa, gán nhãn dữ liệu đến huấn luyện mô hình YOLOv6/ResNet50 và đóng gói API bằng Flask.
  2. Về mặt ứng dụng: Hoàn thành ứng dụng di động Flutter hỗ trợ đầy đủ luồng nghiệp vụ: Đăng nhập/Đăng ký tài khoản $\rightarrow$ Chụp ảnh $\rightarrow$ Trích xuất kết quả nhận diện $\rightarrow$ Liệt kê chi tiết từng mệnh giá và tổng tiền $\rightarrow$ Quy đổi ngoại tệ tức thời.
  3. So sánh với mục tiêu ban đầu: Đạt 100% các tiêu chí chức năng đề ra trong đề cương chi tiết; ứng dụng vận hành ổn định trên môi trường thử nghiệm.

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

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

  • Ứng dụng mô hình Object Detection hiện đại: Thay vì sử dụng kỹ thuật xử lý ảnh truyền thống dựa trên phân đoạn màu sắc (Color Segmentation) vốn rất nhạy cảm với điều kiện ánh sáng, dự án áp dụng YOLOv6 giúp hệ thống trích xuất đặc trưng không gian sâu, chống chịu tốt với nhiễu môi trường.
  • Kiến trúc phân tán tối ưu tài nguyên di động: Toàn bộ tác vụ nặng về tính toán Tensor được chuyển lên máy chủ Backend, giúp ứng dụng Flutter phía Client duy trì dung lượng gọn nhẹ ($< 35$ MB), hoạt động mượt mà ngay cả trên các dòng máy cấu hình thấp.
  • Tích hợp quản lý phân quyền và gói dịch vụ: Không chỉ dừng lại ở bài toán thị giác máy tính đơn thuần, đồ án đã mở rộng thành một hệ thống thông tin hoàn chỉnh với phân quyền Admin/User và quản lý vòng đời gói cước trên nền cơ sở dữ liệu MySQL.

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

  • Cung cấp bộ dữ liệu ảnh tiền polymer Việt Nam Đồng đã được gán nhãn chuẩn hóa, làm tài liệu tham khảo giá trị cho các nghiên cứu tiếp theo về nhận diện tiền tệ khu vực Đông Nam Á.
  • Đề xuất một mô hình kiến trúc tham chiếu khả thi cho các ứng dụng FinTech hướng đến đối tượng người già, người khiếm thị và du khách nước ngoài tại Việt Nam.

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

Tình huống sử dụng thực tế (Use Cases)

┌─────────────────────────────────────────────────────────────┐
│                   USE CASES THỰC TẾ                         │
│                                                             │
│  [ Quầy bán lẻ / Chợ ] ──> Đếm nhanh cọc tiền lẻ            │
│  [ Hỗ trợ người khiếm thị ] ──> Đọc to mệnh giá qua TTS     │
│  [ Du khách quốc tế ] ──> Nhận biết & Quy đổi VND -> USD    │
└─────────────────────────────────────────────────────────────┘
  1. Hỗ trợ thanh toán tại quầy bán lẻ và chợ truyền thống: Tiểu thương có thể quét nhanh một tập tiền khách đưa để đối soát tổng số tiền trong 1 giây, hạn chế thất thoát và nhầm lẫn tiền thừa.
  2. Trợ lý hỗ trợ người khuyết tật thị giác: Kết hợp với tính năng Text-to-Speech (chuyển văn bản thành giọng nói) trên điện thoại, hệ thống có thể đọc to tổng số tiền và từng tờ tiền vừa quét, mang lại sự độc lập tài chính cho người khiếm thị.
  3. Công cụ hỗ trợ du khách nước ngoài: Giúp du khách vừa xác định chính xác tờ tiền polymer cầm trên tay, vừa tự động quy đổi ra giá trị đồng tiền quê hương (USD, EUR, JPY) theo tỷ giá thời gian thực.

Hướng dẫn cài đặt và vận hành hệ thống

1. Yêu cầu phần cứng và môi trường máy chủ

  • Máy chủ Backend: CPU 4 Cores, RAM tối thiểu 8 GB, GPU NVIDIA (khuyến nghị từ GTX 1650 hoặc Tesla T4 để đạt tốc độ cao nhất), dung lượng ổ cứng trống 20 GB.
  • Môi trường phát triển Client: Máy trạm cài đặt Flutter SDK $\ge 3.0$, Android Studio Bumblebee / VS Code.

2. Quy trình triển khai Backend qua SSH / PuTTY

  1. Mở PuTTY, nhập IP máy chủ đám mây (ví dụ: 52.135.xx.xx), cổng 22.
  2. Trong mục Connection > SSH > Auth, trỏ tệp khóa xác thực riêng tư (.ppk / mnrcnsever.ppk).
  3. Nhấn Open để đăng nhập vào máy chủ dòng lệnh Ubuntu.
  4. Cài đặt môi trường Python 3.7 và các thư viện phụ thuộc: 
    sudo apt update && sudo apt install -y python3.7 python3-pip mysql-server
git clone https://github.com/vothanhhung/cash-counter-vnd.git
cd cash-counter-vnd
pip3 install -r requirements.txt
  5. Khởi tạo cơ sở dữ liệu MySQL và import schema: 
    mysql -u root -p < database/schema.sql
  6. Khởi chạy Flask Server chạy ngầm qua tiến trình systemd hoặc tmux: 
    nohup python3 app.py > server.log 2>&1 &

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

Hạn chế hiện tại

  • Kích thước Dataset còn khiêm tốn: Tập dữ liệu 480 hình ảnh tuy đủ để chứng minh tính khả thi nhưng chưa bao phủ hết các trường hợp tiền bị rách góc nặng, bạc màu do giặt ủi hoặc dính bùn đất.
  • Phụ thuộc vào đường truyền mạng: Do mô hình AI đặt tại Server trung tâm, trong điều kiện mất sóng di động hoặc mạng băng thông yếu, tốc độ phản hồi của ứng dụng sẽ bị ảnh hưởng.
  • Chưa tích hợp phân biệt tiền giả chuyên sâu: Hệ thống mới chỉ nhận diện dựa trên đặc trưng quang học bề mặt, chưa kiểm tra được sợi kim loại chìm hay chất liệu polymer dưới bước sóng hồng ngoại.

Kế hoạch nâng cấp và hướng nghiên cứu tương lai

  1. Tối ưu hóa mô hình sang dạng On-device AI (Edge Computing): Chuyển đổi mô hình PyTorch sang định dạng TensorFlow Lite (TFLite) hoặc ONNX Runtime để nhúng trực tiếp vào ứng dụng Flutter, cho phép đếm tiền hoàn toàn ngoại tuyến (Offline) không cần Internet.
  2. Nâng cấp nhận diện luồng Video liên tục (Live Stream Detection): Tối ưu thuật toán đạt 30 FPS trên thiết bị di động, cho phép người dùng chỉ cần lia camera qua bàn tiền mà không cần bấm chụp từng lần.
  3. Mở rộng tập dữ liệu: Thu thập thêm 5.000+ ảnh mẫu tiền cũ, tiền nhàu nát và bổ sung các loại tiền kim loại, ngoại tệ phổ biến khác.

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

┌─────────────────────────────────────────────────────────────┐
│                    ĐỐI TƯỢNG HƯỞNG LỢI                      │
│                                                             │
│  [ Sinh viên CNTT ] ──> Tham khảo luồng tích hợp AI-Mobile  │
│  [ Lập trình viên ] ──> Kế thừa mã nguồn Flask REST API     │
│  [ Hộ kinh doanh ] ──> Tiết kiệm 80% chi phí kiểm đếm      │
│  [ Nhà nghiên cứu ] ──> Mở rộng Dataset nhận diện tiền VND  │
└─────────────────────────────────────────────────────────────┘
  • Sinh viên ngành CNTT / AI / Robot: Có được tài liệu tham khảo thực tế về cách kết hợp giữa mô hình Thị giác máy tính (YOLO/ResNet) với ứng dụng di động Flutter và Backend Flask.
  • Lập trình viên phần mềm: Nắm bắt kiến trúc kết nối RESTful API phi đồng bộ cho bài toán xử lý đa phương tiện (ảnh/video) với độ trễ thấp.
  • Hộ kinh doanh cá thể: Sở hữu giải pháp kiểm đếm tiền mặt chi phí 0 đồng, tiết kiệm hàng triệu đồng mua sắm máy đếm tiền cơ học.
  • Cộng đồng nghiên cứu thị giác máy tính: Kế thừa cấu trúc bộ nhãn dữ liệu đặc thù cho tiền tệ Việt Nam.

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

1. Hệ thống có thể nhận diện được tiền bị gập đôi hoặc xếp đè lên nhau không?

Hệ thống sử dụng mô hình YOLOv6 có khả năng phát hiện các tờ tiền bị che khuất một phần (lên đến 25-30% diện tích bề mặt). Tuy nhiên, để đảm bảo độ chính xác tuyệt đối $\ge 98%$, người dùng nên xòe nhẹ cọc tiền trên mặt phẳng để các đặc trưng nhận diện chính (như chân dung Chủ tịch Hồ Chí Minh, quốc huy, chữ số mệnh giá) lộ ra trước ống kính camera.

2. Chi phí duy trì hệ thống máy chủ Cloud là bao nhiêu?

Với lưu lượng người dùng vừa và nhỏ (dưới 10.000 lượt quét mỗi ngày), việc sử dụng máy chủ ảo (VPS) cấu hình 4 vCPU / 8GB RAM tại các nhà cung cấp trong nước chỉ tốn khoảng 300.000đ – 500.000đ/tháng. Khi tối ưu mô hình chạy trực tiếp trên máy người dùng (Edge AI), chi phí vận hành máy chủ gần như bằng 0.

3. Làm thế nào để tích hợp API đếm tiền này vào phần mềm quản lý bán hàng (POS) có sẵn?

Do Backend được đóng gói dưới dạng chuẩn RESTful API, bất kỳ phần mềm POS nào (viết bằng C#, Java, PHP hay JavaScript) đều có thể gửi HTTP POST request kèm ảnh chụp từ webcam/camera quét mã vạch đến endpoint /api/v1/detect-money và nhận về JSON chứa tổng số tiền ngay lập tức.

4. Hệ thống xử lý thế nào khi không có kết nối Internet?

Ở phiên bản hiện tại, hệ thống yêu cầu kết nối mạng (WiFi hoặc 3G/4G) để gửi ảnh về máy chủ xử lý. Trong lộ trình phát triển phiên bản tiếp theo, nhóm nghiên cứu sẽ nhúng trực tiếp mô hình TFLite vào mã nguồn Flutter, cho phép ứng dụng hoạt động độc lập 100% khi mất mạng.

5. Ứng dụng có thể phát hiện tiền giả không?

Ứng dụng hiện tại đóng vai trò chính là nhận diện mệnh giá và kiểm đếm số lượng. Để phát hiện tiền giả tinh vi, cần có các thiết bị phần cứng chuyên dụng tích hợp mắt đọc quang phổ hồng ngoại và từ tính. Ứng dụng chỉ có thể phát hiện các loại tiền giả thô sơ sai lệch hoàn toàn về tỷ lệ kích thước hoặc chi tiết in ấn đồ họa so với mẫu chuẩn.

Kết luận

Đề tài "Hệ thống đếm tiền Việt Nam Đồng" của sinh viên Võ Thanh Hưng đã giải quyết trọn vẹn bài toán tự động hóa kiểm đếm tiền tệ thông qua sự kết hợp nhịp nhàng giữa Trí tuệ nhân tạo (YOLOv6, ResNet50) và công nghệ phát triển ứng dụng di động hiện đại (Flutter). Với kết quả thực nghiệm đạt độ chính xác trên 94% và thời gian phản hồi dưới 1 giây, đề tài không chỉ khẳng định giá trị học thuật trong việc ứng dụng công nghệ Deep Learning vào bài toán xử lý ảnh thực tế tại Việt Nam, mà còn mang lại tiềm năng thương mại hóa và ý nghĩa xã hội to lớn trong việc hỗ trợ người khiếm thị và thúc đẩy giao dịch tiện lợi, an toàn.