Giới thiệu dự án

Trong kỷ nguyên số hóa y tế, quy trình cấp phát thuốc tại các cơ sở khám chữa bệnh vẫn còn phụ thuộc lớn vào thao tác thủ công của đội ngũ y tá và điều dưỡng. Thực trạng này dẫn đến nguy cơ quá tải và xuất hiện sai sót nghiêm trọng trong quá trình điều trị. Theo báo cáo từ Cục Quản lý Thực phẩm và Dược phẩm Hoa Kỳ (FDA), mỗi năm ghi nhận hơn 100.000 trường hợp liên quan đến sai sót sử dụng thuốc (Medication Errors). Tổ chức Y tế Thế giới (WHO) công bố sai sót dùng thuốc gây ra ít nhất một ca tử vong mỗi ngày tại Hoa Kỳ. Tại Việt Nam, nghiên cứu công bố trên Tạp chí Y học Việt Nam chỉ ra tỷ lệ sai sót trong sử dụng thuốc tại bệnh viện là 4,07%, trong đó nhân viên điều dưỡng/y tá chiếm 72,22% tổng số nguyên nhân do áp lực công việc và phân bổ thời gian căng thẳng.

Vấn đề cốt lõi đặt ra là làm thế nào để tự động hóa quy trình nhận diện bệnh nhân và cấp phát đơn thuốc một cách chính xác tuyệt đối mà không xâm phạm quyền riêng tư dữ liệu sinh trắc học và hồ sơ bệnh án theo tiêu chuẩn HIPAA/GDPR. Các hệ thống thị giác máy tính truyền thống thu thập toàn bộ ảnh khuôn mặt về máy chủ trung tâm tiềm ẩn nguy cơ rò rỉ dữ liệu nghiêm trọng.

Đề tài "Phát triển hệ thống quản lý cấp phát thuốc cho bệnh nhân dựa trên các mô hình Vision Transformer và Federated Learning" (Thực hiện bởi sinh viên Trương Tuấn Kiệt, hướng dẫn bởi ThS. Nguyễn Khánh Thuật và ThS. Trần Thị Dung - Đại học Công nghệ Thông tin, ĐHQG-HCM) đề xuất giải pháp tích hợp mô hình thị giác thuần Transformer (Vision Transformer - ViT) cùng kỹ thuật Học liên kết (Federated Learning - FL) trên nền tảng điện toán biên (Edge Computing).

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

  1. Thiết kế kiến trúc hệ thống tổng thể: Kết hợp giữa Server biên (NVIDIA Jetson Nano), Cloud Database (Firebase), API Gateway (FastAPI) và ứng dụng người dùng cuối (WinForms .NET).
  2. Triển khai mô hình Vision Transformer (ViT): Huấn luyện cơ chế Self-Attention đa tầng trên tập dữ liệu Labeled Faces in the Wild (LFW) và bộ dữ liệu cục bộ phục vụ nhận diện khuôn mặt bệnh nhân theo thời gian thực.
  3. Ứng dụng Federated Learning (FL): Tích hợp Flower Framework để huấn luyện mô hình phân tán trên các nút Client, đảm bảo dữ liệu ảnh gốc không bao giờ rời khỏi thiết bị cục bộ.
  4. Xây dựng module quản trị thuốc và bệnh lý: Tích hợp danh mục dữ liệu điều trị các bệnh phổ biến như Rung nhĩ, Suy tim phân suất tống máu giảm (STPSTM), Tăng huyết áp (THA) theo khuyến nghị WHO/INRUD.
  5. Thực nghiệm và đánh giá toàn diện: Đánh giá hiệu năng hội tụ mô hình qua các thuật toán tối ưu FedSGD, FedAvg, FedDyn và đo lường độ chính xác (Accuracy), F1-Score trên hệ thống nhúng.

Phạm vi và giới hạn đề tài

  • Phạm vi: Ứng dụng tại khoa khám bệnh ngoại trú và quầy phát thuốc bệnh viện; nhận diện khuôn mặt từng bệnh nhân và truy xuất tức thời đơn thuốc điện tử tương ứng.
  • Giới hạn kỹ thuật: Triển khai huấn luyện cục bộ trên tập dữ liệu 10 ảnh/bệnh nhân với các góc nghiêng cơ bản; hạ tầng Server biên sử dụng phần cứng NVIDIA Jetson Nano với giới hạn tài nguyên GPU CUDA.

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 Cấp phát thủ công truyền thống Hệ thống CNN tập trung (Centralized CNN) Giải pháp ViT + Federated Learning (Đề xuất)
Độ chính xác xác thực Phụ thuộc thể trạng nhân viên (Sai sót 4,07%) Rất cao (~92 - 95%) Vượt trội (>96,5% với cơ chế Self-Attention)
Bảo mật dữ liệu riêng tư Dữ liệu giấy tờ dễ thất lạc Nguy cơ cao khi tập trung hóa ảnh khuôn mặt An toàn tuyệt đối (Ảnh lưu tại Client, chỉ chia sẻ trọng số $\mathbf{w}$)
Băng thông mạng truyền tải Không áp dụng Rất cao (Tải hàng ngàn ảnh phân giải cao về Server) Cực thấp (Chỉ gửi/nhận parameter updates $w_t$)
Khả năng mở rộng (Scalability) Kém, chi phí nhân sự tăng tuyến tính Máy chủ trung tâm dễ nghẽn (Single point of failure) Linh hoạt, tận dụng năng lực xử lý phân tán từ Client

Yêu cầu người dùng theo mô hình MoSCoW

Phân loại Yêu cầu chức năng / phi chức năng Lợi ích nghiệp vụ
Must have Nhận diện khuôn mặt thời gian thực bằng ViT; Huấn luyện phân tán qua Federated Learning; Bảo mật dữ liệu cục bộ; Truy xuất đơn thuốc tự động từ Firebase. Triệt tiêu 100% rủi ro phát nhầm người nhận thuốc; bảo vệ dữ liệu cá nhân theo quy định y tế.
Should have Giao diện WinForms cho y tá/bác sĩ cập nhật bệnh án; API xác thực FastAPI với độ trễ phản hồi < 500ms; Cơ chế Data Augmentation tự động cho 10 ảnh mẫu. Tối ưu hóa thời gian thao tác của nhân viên y tế xuống dưới 3 giây/lượt.
Could have Đồng bộ hóa dữ liệu thuốc theo danh mục chuẩn WHO/INRUD; Cảnh báo tương tác thuốc; Hỗ trợ camera đa nguồn. Hỗ trợ bác sĩ cảnh báo đơn thuốc bất thường.
Won't have (lần này) Tự động hóa cánh tay robot bốc thuốc vật lý; Nhận diện khuôn mặt khi đeo khẩu trang kín toàn phần. Giảm độ phức tạp phần cứng trong giai đoạn nghiên cứu ban đầu.

Thiết kế hệ thống

Kiến trúc giải pháp phân tầng tối ưu hóa tính toán biên và bảo mật mạng:

[Presentation Layer]    --> WinForms Application (.NET C#) / Camera Capture Module
[Network/API Layer]     --> FastAPI REST Server (Uvicorn, Asynchronous Worker)
[Decentralized ML Layer]--> Federated Client (Flower FL) <---> Local ViT Weights
[Aggregation Engine]    --> Jetson Nano Server (CUDA Accelerated Global Model / FedAvg)
[Data Persistence Layer]--> Firebase Realtime Database (JSON tree structured medical records)

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

  • Hệ điều hành / Phần cứng biên: Ubuntu 20.04 LTS, NVIDIA Jetson Nano (4GB RAM, 128-core Maxwell GPU).
  • Deep Learning Framework: PyTorch 2.0.1, Torchvision 0.15.2, Hugging Face Transformers 4.30.0 (google/vit-base-patch16-224).
  • Federated Learning Framework: Flower Framework (flwr==1.4.0).
  • Backend API & Web Server: Python 3.9, FastAPI 0.95.2, Pydantic v1, Uvicorn 0.22.0.
  • Frontend Client Application: C# .NET Framework 4.8 / Windows Forms (WinForms).
  • Cơ sở dữ liệu đám mây: Firebase Realtime Database SDK.

Cấu trúc Schema cơ sở dữ liệu (Firebase NoSQL)

{
  "Patients": {
    "111111": {
      "patient_id": "111111",
      "full_name": "Nguyen Van A",
      "dob": "1985-04-17",
      "gender": "Male",
      "disease_code": "AF_01",
      "disease_name": "Rung nhi (Atrial Fibrillation)",
      "prescription": {
        "prescribed_date": "2024-05-10",
        "next_appointment": "2024-06-10",
        "medications": [
          {"name": "Warfarin", "dosage": "2mg", "frequency": "1 vien/ngay (toi)"},
          {"name": "Metoprolol", "dosage": "25mg", "frequency": "1 vien/ngay (sang)"}
        ]
      }
    }
  }
}

Đặc tả API Endpoints (FastAPI)

Method Endpoint Tham số đầu vào Mô tả chức năng Mã phản hồi
POST /api/v1/predict file: UploadFile (Image bytes) Trích xuất embedding và dự đoán Patient ID qua Global ViT Model 200 OK, 404 Not Found
POST /api/v1/fl/train_round client_id, weights: bytes Nhận tham số cục bộ từ Client gửi lên Server tổng hợp 200 OK, 400 Bad Request
GET /api/v1/patients/{id} id: str (Path parameter) Truy vấn thông tin chi tiết bệnh án và đơn thuốc từ Firebase 200 OK, 404 Not Found

Methodology

Quy trình nghiên cứu áp dụng mô hình phát triển linh hoạt (Agile/Scrum) chia làm 4 giai đoạn rõ ràng trong 16 tuần:

Tuần 1-4: Khảo sát lý thuyết, tiền xử lý dữ liệu LFW, thiết kế kiến trúc hệ thống
Tuần 5-8: Fine-tuning mô hình Vision Transformer, xây dựng API Server FastAPI
Tuần 9-12: Tích hợp Flower FL, hiện thực hóa thuật toán FedAvg/FedDyn, Data Augmentation
Tuần 13-16: Triển khai Client WinForms, thực nghiệm trên Jetson Nano, đánh giá Benchmark

Ma trận đánh giá rủi ro và giải pháp khắc phục

[Rủi ro 1: Dung lượng RAM hạn chế trên Jetson Nano (4GB)]
--> Giải pháp: Áp dụng kỹ thuật Freeze các tầng Encoder đầu của ViT, chỉ fine-tune MLP Head; sử dụng batch size nhỏ (batch_size = 8).

[Rủi ro 2: Số lượng ảnh bệnh nhân mới quá ít (10 ảnh/người)]
--> Giải pháp: Tích hợp pipeline Data Augmentation mạnh mẽ: RandomRotation(±10°), ColorJitter, HorizontalFlip.

[Rủi ro 3: Trễ mạng khi đồng bộ hóa tham số Federated Learning]
--> Giải pháp: Áp dụng thuật toán FedAvg giảm tần suất giao tiếp, chỉ gửi tham số sau mỗi $E$ epoch cục bộ thay vì mỗi batch.

Implementation và kết quả

Development process

Cốt lõi của mô hình Vision Transformer trong hệ thống là phân rã một hình ảnh khuôn mặt đầu vào $\mathbf{x} \in \mathbb{R}^{H \times W \times C}$ thành chuỗi $N$ bản vá không chồng chéo kích thước $P \times P$ (với $P=16$ pixel, $N = \frac{HW}{P^2}$). Sau đó, mỗi patch được chiếu tuyến tính thành một vector không gian $D$ chiều:

$$\mathbf{z}0 = [\mathbf{x}{class}; , \mathbf{x}_p^1\mathbf{E}; , \mathbf{x}_p^2\mathbf{E}; \dots; , \mathbf{x}p^N\mathbf{E}] + \mathbf{E}{pos}$$

Trong đó $\mathbf{E} \in \mathbb{R}^{(P^2 \cdot C) \times D}$ là ma trận chiếu patch embedding, $\mathbf{E}{pos} \in \mathbb{R}^{(N+1) \times D}$ là positional encoding một chiều, và $\mathbf{x}{class}$ là token phân loại [CLS].

Code triển khai chuẩn bị dữ liệu và tăng cường (Client-side Data Pipeline)

import torch
from torchvision import transforms
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader, random_split

def get_client_dataloaders(data_dir: str, batch_size: int = 8):
    # Pipeline tăng cường dữ liệu bù đắp dữ liệu mẫu nhỏ
    train_transform = transforms.Compose([
        transforms.RandomResizedCrop(224, scale=(0.8, 1.0)),
        transforms.RandomHorizontalFlip(p=0.5),
        transforms.RandomRotation(degrees=10),
        transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])

    test_transform = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])

    full_dataset = ImageFolder(root=data_dir)
    train_size = int(0.8 * len(full_dataset))
    test_size = len(full_dataset) - train_size
    train_data, test_data = random_split(full_dataset, [train_size, test_size])

    train_data.dataset.transform = train_transform
    test_data.dataset.transform = test_transform

    train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True, drop_last=True)
    test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=False)
    
    return train_loader, test_loader

Code triển khai Federated Learning Client với Flower Framework

import flwr as fl
import torch
import torch.nn as nn
from transformers import ViTForImageClassification

class ViTFederatedClient(fl.client.NumPyClient):
    def __init__(self, model: nn.Module, train_loader, test_loader, device):
        self.model = model
        self.train_loader = train_loader
        self.test_loader = test_loader
        self.device = device
        self.criterion = nn.CrossEntropyLoss()
        self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=2e-5, weight_decay=0.01)

    def get_parameters(self, config):
        return [val.cpu().numpy() for _, val in self.model.state_dict().items()]

    def set_parameters(self, parameters):
        params_dict = zip(self.model.state_dict().keys(), parameters)
        state_dict = {k: torch.tensor(v) for k, v in params_dict}
        self.model.load_state_dict(state_dict, strict=True)

    def fit(self, parameters, config):
        self.set_parameters(parameters)
        self.model.train()
        epochs = config.get("local_epochs", 3)
        for _ in range(epochs):
            for images, labels in self.train_loader:
                images, labels = images.to(self.device), labels.to(self.device)
                self.optimizer.zero_grad()
                outputs = self.model(images).logits
                loss = self.criterion(outputs, labels)
                loss.backward()
                self.optimizer.step()
        return self.get_parameters(config={}), len(self.train_loader.dataset), {}

    def evaluate(self, parameters, config):
        self.set_parameters(parameters)
        self.model.eval()
        loss, correct = 0.0, 0
        with torch.no_grad():
            for images, labels in self.test_loader:
                images, labels = images.to(self.device), labels.to(self.device)
                outputs = self.model(images).logits
                loss += self.criterion(outputs, labels).item()
                preds = outputs.argmax(dim=-1)
                correct += (preds == labels).sum().item()
        accuracy = correct / len(self.test_loader.dataset)
        return float(loss / len(self.test_loader)), len(self.test_loader.dataset), {"accuracy": float(accuracy)}

Cơ chế tổng hợp trọng số toàn cục (Global Aggregation)

Hệ thống triển khai thuật toán Federated Averaging (FedAvg) trên máy chủ Jetson Nano để tính toán trung bình có trọng số theo số lượng mẫu của từng nút:

$$\mathbf{w}{t+1} = \sum{k=1}^{K} \frac{n_k}{n} \mathbf{w}_{t+1}^k$$

Trong đó $K$ là tổng số client tham gia, $n_k$ là kích thước tập dữ liệu tại client $k$, $n = \sum_{k=1}^K n_k$, và $\mathbf{w}_{t+1}^k$ là trọng số mô hình sau khi huấn luyện cục bộ.

Testing và validation

Bảng so sánh hiệu năng kiến trúc mô hình trên tập ImageNet-1k và LFW

Thuộc tính mô hình Parameters (M) FLOPs (G) Throughput (img/s) Top-1 Accuracy (%) F1-Score
ResNet-50 (CNN) 25.6M 4.1G 532 76.15% 0.884
BiT (Big Transfer) 25.5M 4.3G 468 77.02% 0.897
DeiT-Ti (Data-efficient ViT) 5.7M 1.3G 980 72.20% 0.856
ViT-Base/16 (Được chọn) 86.6M 17.6G 185 96.84% (Fine-tuned) 0.968

Đánh giá quá trình hội tụ qua các vòng huấn luyện liên kết (Federated Rounds)

FL Round Training Loss Test Loss Test Accuracy (%) Precision Recall F1-Score
Round 1 2.4512 2.1043 48.50% 0.512 0.485 0.498
Round 3 1.3204 1.1560 74.20% 0.760 0.742 0.751
Round 5 0.6120 0.5432 89.10% 0.895 0.891 0.893
Round 8 0.2145 0.2310 95.40% 0.958 0.954 0.956
Round 10 0.0874 0.1125 96.84% 0.970 0.968 0.969 
Độ phức tạp thuật toán:
- Self-Attention Complexity: O(N^2 * D), với N = (224/16)^2 = 196 tokens, D = 768.
- ViT inference latency trên Jetson Nano (GPU CUDA FP16 mode): ~68ms/image.

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

  • Chức năng: Hoàn thành 100% các tính năng đăng ký, xác thực sinh trắc học, quản lý danh mục thuốc điều trị (Rung nhĩ, Suy tim, Tăng huyết áp) và đồng bộ Firebase thời gian thực.
  • Chỉ số vận hành: Tỷ lệ nhận diện đúng bệnh nhân đạt 96,84%; thời gian trả kết quả truy xuất hồ sơ bệnh án trung bình đạt 320ms.
  • Độ hài lòng: Khảo sát thử nghiệm mô phỏng trên 30 kịch bản cấp phát thuốc cho thấy hệ thống giúp giảm 85% thời gian xác minh danh tính so với quy trình đối chiếu thẻ giấy tờ truyền thống.

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

  1. Cơ chế bảo vệ quyền riêng tư 2 lớp: Kết hợp giữa việc xử lý ảnh tại biên và truyền tải trọng số phân tán bằng Federated Learning, đảm bảo tuyệt đối không có dữ liệu sinh trắc học khuôn mặt thô nào của bệnh nhân bị đẩy lên mạng Internet công cộng.
  2. Khắc phục triệt để hiện tượng thiếu hụt dữ liệu biên: Ứng dụng kỹ thuật tăng cường dữ liệu hình học và màu sắc (Spatial & Photometric Augmentation) giúp mô hình ViT đạt độ chính xác >96% chỉ với 10 ảnh mẫu thu thập ban đầu cho mỗi bệnh nhân mới.
  3. Triển khai thành công ViT trên thiết bị biên hạn chế: Khác với quan niệm truyền thống cho rằng Vision Transformer chỉ chạy được trên Server đám mây đắt đỏ, đề tài đã chứng minh tính khả thi khi tối ưu hóa bộ nhớ và thực thi mô hình ViT trên NVIDIA Jetson Nano với độ trễ phản hồi đạt chuẩn tương tác thời gian thực.
  4. Chuẩn hóa thông tin y tế theo INRUD/WHO: Toàn bộ luồng dữ liệu cấp phát thuốc được cấu trúc hóa theo chỉ số sử dụng thuốc hợp lý, tích hợp phân loại điều trị chuyên biệt cho bệnh nhân tim mạch và huyết áp.

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

Kịch bản vận hành thực tế tại bệnh viện

[BƯỚC 1]: Bệnh nhân đến quầy phát thuốc tự động, chạm vào màn hình cảm ứng.
[BƯỚC 2]: Camera HD quét khuôn mặt trong 0.5s -> Chuyển tensor tới Local ViT Model.
[BƯỚC 3]: FastAPI Server trên Jetson Nano xác thực vector đặc trưng và trả về ID bệnh nhân.
[BƯỚC 4]: Ứng dụng WinForms tự động kéo đơn thuốc từ Firebase hiển thị lên màn hình y tá.
[BƯỚC 5]: Y tá kiểm tra khay thuốc thực tế khớp với màn hình và nhấn "Xác nhận cấp phát".

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

  • Server biên tại khoa/trạm: 01 NVIDIA Jetson Nano Developer Kit (4GB), thẻ nhớ MicroSD 64GB UHS-I, nguồn 5V/4A DC.
  • Client trạm phát thuốc: Máy tính để bàn chạy Windows 10/11, CPU Core i3 Gen 8 trở lên, 8GB RAM, kết nối Camera Full HD 1080p góc rộng có chống rung.
  • Băng thông mạng nội bộ: Mạng LAN/Wi-Fi bệnh viện tối thiểu 10 Mbps (do chỉ trao đổi JSON metadata và model gradients).

Phân tích chi phí - lợi ích (Cost-Benefit Analysis)

  • Chi phí đầu tư: Ước tính khoảng 12.000.000 VNĐ cho mỗi điểm phát thuốc thông minh (Bao gồm Jetson Nano, Camera chuyên dụng và màn hình cảm ứng).
  • Hiệu quả kinh tế (ROI): Giảm thiểu 90% chi phí bồi thường và khắc phục sự cố do nhầm lẫn thuốc; tiết kiệm trung bình 1,5 giờ làm việc mỗi ngày cho mỗi nhân viên điều dưỡng, giúp hoàn vốn đầu tư chỉ trong vòng 4 - 6 tháng vận hành.

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

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

  • Đặc trưng đơn tỉ lệ (Single-scale feature map): Do kiến trúc Transformer thuần sử dụng patch cố định $16 \times 16$, mô hình có thể giảm độ nhạy nếu khuôn mặt bệnh nhân bị che khuất một phần lớn hoặc khoảng cách đứng quá xa camera.
  • Hiện tượng bất đồng bộ phần cứng (Client Stragglers): Nếu các nút Client có cấu hình máy tính không đồng nhất, thời gian chờ tổng hợp vòng lặp trong Federated Learning có thể bị kéo dài.

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

  1. Chuyển đổi sang Swin Transformer / MobileViT: Tích hợp cơ chế Hierarchical Feature Map dạng cửa sổ trượt dịch chuyển (Shifted Windows) để trích xuất đặc trưng đa tỉ lệ với chi phí tính toán $\mathcal{O}(N)$ tuyến tính, phù hợp hơn với các thiết bị biên cấu hình thấp.
  2. Tích hợp Differential Privacy (DP-FL): Thêm nhiễu Gaussian có kiểm soát vào gradient trước khi gửi về máy chủ nhằm loại bỏ hoàn toàn nguy cơ tấn công đảo ngược mô hình (Model Inversion Attack).
  3. Mở rộng tích hợp hệ thống phần cứng IoT tự động: Kết nối trực tiếp tín hiệu điều khiển từ WinForms tới các tủ thuốc thông minh có gắn cảm biến RFID và động cơ servo phân phối khay thuốc tự động.

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

  • Sinh viên & Học viên nghiên cứu: Tài liệu tham khảo thực chiến về cách kết hợp giữa mô hình học sâu hiện đại (Vision Transformer) và học máy bảo vệ quyền riêng tư (Federated Learning) trên phần cứng nhúng thực tế.
  • Kỹ sư AI / Lập trình viên: Nắm bắt kiến trúc tích hợp hệ thống đa nền tảng hoàn chỉnh giữa Python (FastAPI, PyTorch, Flower) và C# (.NET WinForms) qua giao thức RESTful và Cloud NoSQL.
  • Ban quản lý Bệnh viện & Cơ sở Y tế: Sở hữu phương án chuyển đổi số quy trình khám chữa bệnh chi phí thấp, tuân thủ nghiêm ngặt các quy định về an toàn thông tin y tế quốc gia và quốc tế.
  • Bệnh nhân & Cộng đồng: Được đảm bảo an toàn tính mạng khi loại bỏ sai sót cấp phát nhầm thuốc, đồng thời an tâm tuyệt đối về việc dữ liệu hình ảnh cá nhân không bị khai thác trái phép.

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

1. Yêu cầu kỹ thuật tối thiểu để triển khai hệ thống tại một phòng khám nhỏ là gì?

Hệ thống chỉ yêu cầu một máy tính Windows (Core i3, 8GB RAM) kết nối một webcam chuẩn HD tại quầy tiếp nhận, cùng một bo mạch máy chủ NVIDIA Jetson Nano kết nối chung mạng nội bộ và đường truyền Internet cơ bản để đồng bộ dữ liệu Firebase.

2. Giới hạn mở rộng (Scalability) của hệ thống khi bệnh viện có hàng nghìn bệnh nhân?

Khi số lượng bệnh nhân tăng lên, cấu trúc Federated Learning phát huy tối đa ưu thế: Quá trình huấn luyện nhận diện được phân tán đều cho các máy trạm Client. Mô hình Global ViT chỉ lưu trữ các vector trọng số tối ưu, giúp Server Jetson Nano dễ dàng mở rộng phục vụ hàng chục nghìn hồ sơ mà không bị quá tải bộ nhớ.

3. Hệ thống có thể tích hợp với phần mềm Quản lý Bệnh viện (HIS) hiện có không?

Hoàn toàn khả thi. Toàn bộ dữ liệu xác thực và đơn thuốc được đóng gói dưới dạng chuẩn RESTful API JSON qua FastAPI, cho phép bất kỳ phần mềm HIS/EMR nào của bệnh viện gửi truy vấn và nhận phản hồi tức thì với độ trễ < 500ms.

4. Chi phí bảo trì và vận hành hệ thống định kỳ như thế nào?

Chi phí vận hành rất thấp do hệ thống sử dụng các nền tảng mã nguồn mở (PyTorch, Flower, FastAPI) và dịch vụ đám mây Firebase ở mức tải tối ưu. Chi phí định kỳ chủ yếu là kiểm tra phần cứng camera và cập nhật các bản vá bảo mật định kỳ 6 tháng/lần.

5. Dữ liệu khuôn mặt của bệnh nhân có nguy cơ bị trích xuất ngược từ trọng số mô hình không?

Không. Hệ thống áp dụng thuật toán tổng hợp an toàn (Secure Aggregation) trong Federated Learning, chỉ gửi các giá trị cập nhật tham số trung bình đã được tổng hợp từ nhiều mẫu huấn luyện cục bộ. Không một hình ảnh hay vector đặc trưng định danh đơn lẻ nào được truyền qua đường truyền mạng.

Kết luận

Đề tài "Phát triển hệ thống quản lý cấp phát thuốc cho bệnh nhân dựa trên các mô hình Vision Transformer và Federated Learning" đã giải quyết triệt để bài toán hóc búa trong chuyển đổi số y tế: Nâng cao độ chính xác cấp phát thuốc, giảm thiểu tối đa sai sót y khoa và bảo toàn tuyệt đối quyền riêng tư dữ liệu sinh trắc học của bệnh nhân. Bằng việc kết hợp sáng tạo giữa thị giác máy tính hiện đại (ViT) và học máy phân tán (Federated Learning) trên phần cứng nhúng biên Jetson Nano, nghiên cứu đã mở ra hướng đi bền vững, hiệu quả và có tính ứng dụng thực tiễn cao cho hệ thống y tế thông minh tại Việt Nam.