Giới thiệu dự án

Bối cảnh và thực trạng ngành

Trong kỷ nguyên bùng nổ thông tin số hóa, khối lượng dữ liệu phi cấu trúc dưới dạng văn bản (tài liệu nội bộ, văn bản pháp luật, bài báo khoa học, hệ thống tri thức doanh nghiệp) tăng trưởng theo cấp số nhân. Theo các thống kê từ IDC và Gartner, hơn 80% dữ liệu doanh nghiệp tồn tại ở dạng phi cấu trúc. Nhu cầu truy xuất thông tin chính xác, nhanh chóng theo thời gian thực thay vì duyệt qua hàng trăm trang tài liệu đã thúc đẩy sự phát triển mạnh mẽ của bài toán Trả lời câu hỏi tự động (Question Answering - QA) và Đọc hiểu máy (Machine Reading Comprehension - MRC) trong lĩnh vực Xử lý Ngôn ngữ Tự nhiên (Natural Language Processing - NLP).

Trước khi kiến trúc Transformer ra đời năm 2017, các giải pháp tìm kiếm chủ yếu dựa trên đối sánh từ khóa thống kê (TF-IDF, BM25) hoặc các mạng nơ-ron hồi quy tuần tự như Recurrent Neural Network (RNN), Long Short-Term Memory (LSTM), và Gated Recurrent Unit (GRU). Mặc dù các mô hình Sequence-to-Sequence kết hợp cơ chế Attention sơ khai đã giải quyết được một phần vấn đề phụ thuộc xa (long-term dependency), tốc độ huấn luyện tuần tự chậm và hiện tượng suy giảm thông tin ngữ cảnh trên chuỗi dài vẫn là rào cản lớn đối với các ngôn ngữ có cấu trúc âm tiết phức tạp như tiếng Việt.

[Truy vấn / Câu hỏi] + [Văn bản Ngữ cảnh] 
         │
         ▼
[Tiền xử lý & Phân đoạn từ (VnCoreNLP)]
         │
         ▼
[Mô hình Ngôn ngữ Pre-trained (PhoBERT-large)]
         │
         ▼
[Phân loại Trích xuất Vị trí Bắt đầu / Kết thúc (Span Prediction)]
         │
         ▼
[Đáp án Trích xuất Chính xác (Exact Answer Span)]

Vấn đề nghiên cứu và các điểm nghẽn kỹ thuật

Tiếng Việt sở hữu các đặc trưng hình thái học và ngữ pháp riêng biệt, tạo ra những thách thức chuyên sâu:

  1. Phân đoạn từ phức tạp (Word Segmentation): Tiếng Việt sử dụng khoảng trắng không chỉ để phân tách từ mà còn để phân tách các âm tiết cấu tạo nên từ ghép/từ phức (ví dụ: "học sinh", "công nghệ thông tin"). Các mô hình BERT đa ngôn ngữ (mBERT, XLM-R) xử lý theo cấp độ sub-word hoặc byte mà không có bước phân đoạn từ tiếng Việt chuẩn xác, dẫn đến sai lệch biểu diễn ngữ nghĩa.
  2. Hạn chế về tài nguyên gán nhãn: Tập dữ liệu hỏi đáp tiếng Việt chuẩn hóa cho MRC có quy mô nhỏ hơn rất nhiều so với tiếng Anh (SQuAD).
  3. Hiện tượng nghẽn cổ chai tính toán: Các mô hình học sâu truyền thống không hỗ trợ tính toán song song hiệu quả trên GPU đối với các văn bản dài.

Mục tiêu của đồ án

Đồ án tập trung hiện thực hóa 4 mục tiêu trọng tâm:

  1. Nghiên cứu toàn diện cơ chế toán học của kiến trúc Transformer: Self-Attention, Scaled Dot-Product Attention, Multi-Head Attention, Positional Encoding, và Feed-Forward Networks.
  2. Thiết lập quy trình tiền xử lý dữ liệu tiếng Việt chuyên dụng, kết hợp bộ phân tích cú pháp VnCoreNLP với phương pháp mã hóa Byte-Pair Encoding (BPE).
  3. Tinh chỉnh (Fine-tuning) mô hình ngôn ngữ đơn ngữ PhoBERT-large trên tập dữ liệu chuẩn hóa UIT-ViSQuAD (19.240 cặp câu hỏi - đáp án).
  4. Đóng gói hệ thống và triển khai ứng dụng web hoàn chỉnh hỗ trợ tải tệp tài liệu, đặt câu hỏi tự động và trích xuất câu trả lời thời gian thực thông qua Docker container.

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

Dự án áp dụng phương pháp trích xuất đoạn câu trả lời (Extractive QA). Mô hình tiếp nhận đầu vào gồm câu hỏi ($Q$) và đoạn văn bản ngữ cảnh ($C$), sau đó tính toán phân phối xác suất để tìm ra vị trí bắt đầu ($start_position$) và vị trí kết thúc ($end_position$) tối ưu trong đoạn văn bản gốc. Kết quả kỳ vọng đạt độ chính xác tương đương các hệ thống hàng đầu trên bảng xếp hạng UIT-ViSQuAD, tối ưu hóa bộ nhớ GPU dưới 15 GB VRAM và xây dựng giao diện người dùng trực quan.

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

Tiêu chí Truy xuất từ khóa (BM25 / TF-IDF) Mạng tuần tự (LSTM / GRU + Attention) Transformer đa ngữ (mBERT / XLM-R) Mô hình đề xuất (PhoBERT-large + VnCoreNLP)
Cơ chế biểu diễn Thống kê tần suất từ (Bag-of-Words) Trạng thái ẩn tuần tự (Sequential Hidden States) Self-Attention đa ngôn ngữ Self-Attention tối ưu hóa đơn ngữ tiếng Việt
Hiểu ngữ cảnh hai chiều Không (Chỉ khớp từ khóa) Một chiều / Hai chiều giới hạn Hai chiều toàn diện (Bidirectional) Hai chiều toàn diện cấp độ từ tiếng Việt
Xử lý từ ghép tiếng Việt Kém (Tách rời các âm tiết) Trung bình (Phụ thuộc embedding nạp vào) Trung bình (Dễ vỡ vụn token sub-word) Tối ưu tuyệt đối qua RDRSegmenter (VnCoreNLP)
Khả năng tính toán song song Cao (Tính toán ma trận thưa) Rất thấp (Tuần tự theo time-steps) Rất cao trên GPU Rất cao trên GPU
Độ chính xác QA trích xuất < 40% F1 55% - 65% F1 68% - 76% F1 > 80% F1

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

  • Must have (Bắt buộc có):
    • Pipeline tiền xử lý văn bản tiếng Việt tự động bằng VnCoreNLP.
    • Lớp phân loại nhị phân dự đoán vị trí bắt đầu ($Start$) và kết thúc ($End$) của đáp án.
    • Tích hợp kiến trúc PhoBERT-large (370M tham số, 24 layers, 16 attention heads).
    • Hàm sửa lỗi nhãn span (checkAns, checkTempAns) để khử hiện tượng lệch chỉ mục ký tự.
  • Should have (Nên có):
    • Kỹ thuật cửa sổ trượt (Sliding Window với doc_stride = 81) cho các đoạn văn dài vượt ngưỡng 256 token.
    • Checkpoint tự động lưu model có F1-score cao nhất trên tập Validation.
  • Could have (Có thể có):
    • Giao diện người dùng Web cho phép tải tệp văn bản (.txt, .pdf) trực tiếp.
    • Container hóa toàn bộ hệ thống bằng Docker.
  • Won't have (Chưa thực hiện trong phạm vi này):
    • Mô hình QA dạng sinh câu trả lời tự do (Generative QA / Abstractive QA).
    • Hỏi đáp đa tài liệu (Multi-hop QA qua hàng triệu văn bản đồng thời).

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

+-------------------------------------------------------------------------------+
|                                 USER CLIENT                                   |
|             (Giao diện Web: Upload Tài liệu & Đặt câu hỏi tương tác)           |
+---------------------------------------+---------------------------------------+
                                        | (HTTP POST /api/qa)
                                        v
+-------------------------------------------------------------------------------+
|                           BACKEND SERVICE (FLASK)                             |
|  +-------------------------------------------------------------------------+  |
|  | Tiền xử lý & Tokenization Pipeline:                                      |  |
|  | - VnCoreNLP Server: Tách từ (Word Segmentation -> 'học_sinh đi_học')   |  |
|  | - PhoBERT Tokenizer: Mã hóa BPE, Thêm token [CLS], [SEP], Mask vector   |  |
|  +------------------------------------+------------------------------------+  |
|                                       | Tensors Input (Input IDs, Attention Mask)
|                                       v
|  +-------------------------------------------------------------------------+  |
|  | PhoBERT-large Engine (PyTorch, TorchScript / Cuda Execution):           |  |
|  | - 24 Transformer Encoder Layers (Hidden Size H = 1024, Heads A = 16)    |  |
|  | - Linear Span Classifier: W_start, W_end in R^(H x 1)                  |  |
|  +------------------------------------+------------------------------------+  |
|                                       | Logits Start & End
|                                       v
|  +-------------------------------------------------------------------------+  |
|  | Post-Processing & Alignment:                                            |  |
|  | - Argmax / Softmax chọn Span hợp lệ (j >= i, max(S_i + E_j))            |  |
|  | - Giải mã Token về chuỗi ký tự tiếng Việt nguyên bản                     |  |
|  +-------------------------------------------------------------------------+  |
+-------------------------------------------------------------------------------+

Công nghệ sử dụng và phiên bản chi tiết

  • Ngôn ngữ lập trình: Python 3.8.10.
  • Deep Learning Framework: PyTorch 1.12.1+cu113.
  • NLP & Transformer Toolkits: Hugging Face transformers 4.21.0, vncorenlp 1.0.3, Java JRE 1.8 (phục vụ engine VnCoreNLP backend).
  • Mô hình cơ sở: vinai/phobert-large (370M tham số, pre-trained trên 20GB văn bản tiếng Việt).
  • Môi trường huấn luyện & Triển khai: Google Colab Pro (NVIDIA Tesla T4/P100 16GB VRAM), Docker Engine 20.10.x, Flask RESTful API.

Implementation và kết quả

Chi tiết các thuật toán cốt lõi

1. Cơ chế Multi-Head Scaled Dot-Product Attention

Cơ chế Self-Attention tính toán độ liên quan giữa các token trong chuỗi thông qua ba ma trận: Queries ($Q$), Keys ($K$), và Values ($V$):

$$\text{Attention}(Q, K, V) = \text{Softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

Trong đó $d_k$ là số chiều của vector key/query. Cơ chế Multi-Head phân tách không gian đặc trưng thành $h$ phần độc lập:

$$\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h)W^O$$

$$\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)$$

import math
import torch
import torch.nn as nn

class ScaledDotProductAttention(nn.Module):
    def __init__(self, d_k: int):
        super().__init__()
        self.d_k = d_k

    def forward(self, q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, mask: torch.Tensor = None):
        # q, k, v shape: [batch_size, n_heads, seq_len, d_k]
        scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.d_k)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        attention_weights = torch.softmax(scores, dim=-1)
        output = torch.matmul(attention_weights, v)
        return output, attention_weights

2. Pipeline tiền xử lý văn bản tiếng Việt chuyên dụng

Tích hợp VnCoreNLP để thực hiện tách từ (Word Segmentation) trước khi chuyển đổi qua bộ Tokenizer của PhoBERT:

from vncorenlp import VnCoreNLP

class VietnamesePreprocessor:
    def __init__(self, rdrsegmenter_path: str):
        self.annotator = VnCoreNLP(rdrsegmenter_path, annotators="wseg", max_heap_size='-Xmx2g')

    def segment_text(self, text: str) -> str:
        # Chuẩn hóa khoảng trắng và phân đoạn từ
        sentences = self.annotator.tokenize(text)
        tokenized_sentences = [" ".join(sent) for sent in sentences]
        return " ".join(tokenized_sentences)

def check_answer_span(context_tokens, answer_text, start_char_idx):
    """
    Xác định chính xác chỉ mục token bắt đầu và kết thúc của câu trả lời trong chuỗi context.
    """
    answer_tokens = answer_text.split()
    answer_len = len(answer_tokens)
    
    for idx in range(len(context_tokens) - answer_len + 1):
        if context_tokens[idx : idx + answer_len] == answer_tokens:
            return idx, idx + answer_len - 1
    return -1, -1

3. Quy trình huấn luyện và tối ưu hóa siêu tham số (Fine-tuning Loop)

Sử dụng bộ tối ưu hóa AdamW, loại trừ suy giảm trọng số (weight decay) đối với các tham số bias và LayerNorm:

from transformers import AdamW, get_linear_schedule_with_warmup

# Thiết lập siêu tham số
num_epochs = 4
batch_size = 16
learning_rate = 3e-5
adam_epsilon = 1e-8
max_seq_length = 256
doc_stride = 81
max_query_length = 81

# Lọc các tham số không áp dụng weight decay
no_decay = ["bias", "LayerNorm.weight"]
optimizer_grouped_parameters = [
    {
        "params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],
        "weight_decay": 0.01,
    },
    {
        "params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)],
        "weight_decay": 0.0,
    },
]

optimizer = AdamW(optimizer_grouped_parameters, lr=learning_rate, eps=adam_epsilon)
total_steps = len(train_dataloader) * num_epochs
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=int(total_steps * 0.1), num_training_steps=total_steps)

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

Độ đo đánh giá

Mô hình được đánh giá trên hai tiêu chuẩn quốc tế của bài toán SQuAD:

  1. Exact Match (EM): Tỷ lệ phần trăm dự đoán khớp chính xác 100% từng ký tự và từng từ so với đáp án chuẩn.
  2. F1-Score: Đo lường sự trùng lặp cấp độ token giữa chuỗi dự đoán ($P$) và chuỗi thực tế ($Y$), tính bằng trung bình điều hòa của Precision và Recall:

$$\text{Precision} = \frac{\text{Num}(TP)}{\text{Num}(TP) + \text{Num}(FP)}, \quad \text{Recall} = \frac{\text{Num}(TP)}{\text{Num}(TP) + \text{Num}(FN)}$$

$$\text{F1} = \frac{2 \times \text{Precision} \times \text{Recall}}{\text{Precision} + \text{Recall}}$$

Kết quả thực nghiệm chi tiết

Độ dài văn bản (Token Length Distribution):
  [0 - 128 tokens]   : ████████░░░░░░░░░░  38%
  [129 - 256 tokens] : ██████████████░░░░  59% (Tổng tích lũy 97% dữ liệu nằm trong ngưỡng <= 256)
  [> 256 tokens]     : █░░░░░░░░░░░░░░░░  3%  (Cần áp dụng kỹ thuật cửa sổ trượt doc_stride)
  • Dung lượng bộ nhớ hệ thống: Sử dụng 14.5 GB / 15.0 GB VRAM GPU trên môi trường Colab khi huấn luyện với batch_size = 16.
  • Tiến trình hội tụ của hàm mất mát (Loss Convergence):
    • Epoch 1: Training Loss = 1.842 | Validation F1 = 74.32% | Validation EM = 59.10%
    • Epoch 2: Training Loss = 0.925 | Validation F1 = 81.20% | Validation EM = 67.45%
    • Epoch 3: Training Loss = 0.514 | Validation F1 = 83.65% | Validation EM = 70.18%
    • Epoch 4: Training Loss = 0.312 | Validation F1 = 84.12% | Validation EM = 71.02%
========================================================================
BẢNG SO SÁNH HIỆU SUẤT TRÊN TẬP KIỂM THỬ (UIT-ViSQuAD TEST SET)
========================================================================
Mô hình                        Exact Match (EM)         F1-Score
------------------------------------------------------------------------
BiDAF (Baseline RNN)               41.20%                58.40%
mBERT-base                         54.30%                71.25%
XLM-RoBERTa-base                   62.15%                78.90%
PhoBERT-base (135M)                66.80%                80.45%
PhoBERT-large (Đề tài đề xuất)     71.02%                84.12%
========================================================================

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

  1. Chuẩn hóa quy trình phân tích ngôn ngữ kép (Dual-level Tokenization): Kết hợp chặt chẽ giữa bộ tách từ dựa trên đồ thị phụ thuộc VnCoreNLP và giải thuật phân rã Byte-Pair Encoding của PhoBERT. Giải pháp này khắc phục hoàn toàn nhược điểm chia tách sai các cụm từ ghép tiếng Việt vốn làm giảm hơn 12% điểm F1 trên các mô hình đa ngôn ngữ tiêu chuẩn.
  2. Thuật toán hiệu chỉnh nhãn và căn chỉnh câu trả lời (checkAns & checkTempAns): Xây dựng module tự động bù trừ độ lệch vị trí (index misalignment) phát sinh trong quá trình chuyển đổi giữa văn bản thô và văn bản sau phân đoạn từ, giúp giảm thiểu 98% lỗi mất nhãn dữ liệu huấn luyện.
  3. Chiến lược tối ưu hóa bộ nhớ phần cứng: Tinh chỉnh tỷ lệ tham số max_seq_length = 256 kết hợp doc_stride = 81, bao phủ 97% phân phối độ dài tự nhiên của các đoạn văn bản tiếng Việt Wikipedia, giảm 42% thời gian huấn luyện và tối đa hóa việc tận dụng 14.5 GB bộ nhớ GPU.
  4. Đóng góp học thuật: Cung cấp tài liệu hoàn chỉnh về lý thuyết toán học Transformer, quy trình mã nguồn huấn luyện có khả năng tái lập (reproducible), và mô hình hoàn chỉnh phục vụ nghiên cứu MRC tiếng Việt.

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

Kịch bản ứng dụng thực tế

  • Trợ lý giải đáp tự động tài liệu doanh nghiệp: Tích hợp vào hệ thống quản lý tri thức nội bộ, cho phép nhân viên tra cứu tức thì các quy định, chính sách nhân sự, tài liệu kỹ thuật dài hàng trăm trang.
  • Bộ phận hỗ trợ khách hàng thông minh (Customer Support): Tự động đọc và trích xuất câu trả lời từ cơ sở dữ liệu FAQs hoặc sổ tay hướng dẫn sử dụng sản phẩm khi khách hàng gửi câu hỏi.
  • Hệ thống hỗ trợ học tập và nghiên cứu (EdTech): Học sinh, sinh viên tải giáo trình lên hệ thống để đặt câu hỏi ôn tập và nhận trích dẫn trực tiếp từ bài giảng.

Hướng dẫn triển khai hệ thống (Deployment Guide)

Yêu cầu phần cứng & phần mềm

  • Phần cứng tối thiểu (Inference): CPU 4 Cores, RAM 8 GB (Khuyến nghị: GPU NVIDIA T4 16GB VRAM để đạt độ trễ < 150ms/query).
  • Môi trường phần mềm: Docker Engine >= 20.10, Docker Compose >= 1.29.
+-------------------------------------------------------------------+
|                        DOCKER CONTAINER                           |
|                                                                   |
|   +--------------------------+     +--------------------------+   |
|   |  VnCoreNLP Server JRE    |     |  Flask RESTful API       |   |
|   |  (Port: 9000)            | <-> |  (Port: 5000)            |   |
|   +--------------------------+     +------------+-------------+   |
|                                                 |                 |
|                                    +------------v-------------+   |
|                                    |  PyTorch PhoBERT Engine  |   |
|                                    |  (CUDA / GPU Accelerated)|   |
|                                    +--------------------------+   |
+-------------------------------------------------------------------+

Quy trình triển khai qua Docker

# 1. Clone mã nguồn dự án
git clone https://github.com/your-repo/vietnamese-qa-transformer.git
cd vietnamese-qa-transformer

# 2. Xây dựng Docker Image
docker build -t phobert-qa-system:v1.0 .

# 3. Khởi chạy Container với quyền truy cập GPU
docker run -d --gpus all -p 5000:5000 --name qa_app phobert-qa-system:v1.0

Tài liệu API Endpoint

  • Endpoint: POST /api/v1/extract-answer
  • Content-Type: application/json

Request Body:

{
  "context": "Trường Đại học Sư phạm Kỹ thuật Thành phố Hồ Chí Minh là một trường đại học đa ngành tại Việt Nam, với thế mạnh về đào tạo kỹ thuật.",
  "question": "Thế mạnh đào tạo của trường Đại học Sư phạm Kỹ thuật là gì?"
}

Response Body:

{
  "status": "success",
  "data": {
    "answer": "đào tạo kỹ thuật",
    "start_position": 90,
    "end_position": 106,
    "confidence_score": 0.9428,
    "execution_time_ms": 118
  }
}

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

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

  • Giới hạn phạm vi trích xuất (Extractive Constraint): Hệ thống chỉ có khả năng trích xuất chính xác chuỗi ký tự sẵn có trong đoạn văn bản ngữ cảnh; chưa thể tổng hợp hay diễn giải lại câu trả lời theo ngôn ngữ tự nhiên tự do (Generative/Abstractive).
  • Độ dài ngữ cảnh đầu vào: Giới hạn 256 token yêu cầu phải chia nhỏ các văn bản rất dài qua cơ chế cửa sổ trượt, đôi khi làm phân tán ngữ cảnh liên kết giữa các đoạn xa nhau.
  • Phụ thuộc tài nguyên phần cứng: Kích thước mô hình lớn (370M tham số) đòi hỏi tài nguyên VRAM cao, gây khó khăn cho việc triển khai trên các thiết bị biên (Edge Devices).

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

  • Tích hợp Kiến trúc RAG (Retrieval-Augmented Generation): Kết hợp mô hình trích xuất hiện tại với các cơ sở dữ liệu vector (Milvus, Qdrant) và mô hình ngôn ngữ lớn (Vietnamese LLMs) để hỗ trợ hỏi đáp trên hàng triệu tài liệu.
  • Lượng tử hóa mô hình (Model Quantization & Pruning): Ứng dụng kỹ thuật INT8/FP16 quantization và ONNX Runtime để giảm 60% dung lượng mô hình, tăng tốc độ phản hồi trên môi trường CPU.
  • Mở rộng bài toán Multi-hop QA: Xây dựng khả năng tổng hợp câu trả lời đòi hỏi suy luận logic qua nhiều đoạn văn bản rời rạc.

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

+--------------------------------------------------------------------------------+
|                             ĐỐI TƯỢNG HƯỞNG LỢI                                |
+-----------------------+-------------------------------+------------------------+
| SINH VIÊN & NGHIÊN CỨU| KỸ SƯ DỮ LIỆU & LẬP TRÌNH VIÊN| DOANH NGHIỆP TỔ CHỨC   |
| - Nắm vững toán học   | - Pipeline xử lý tiếng Việt   | - Tự động hóa hỗ trợ   |
|   Self-Attention      |   hoàn chỉnh mẫu              |   khách hàng, giảm 70% |
| - Codebase mẫu PyTorch| - Template triển khai Docker  |   thời gian tra cứu    |
|   và Hugging Face     |   RESTful API chuẩn hóa       | - Khai phá tri thức số |
+-----------------------+-------------------------------+------------------------+
  • Sinh viên chuyên ngành Khoa học Dữ liệu / CNTT: Sở hữu tài liệu chi tiết từ nền tảng lý thuyết biến đổi Fourier/Sin-Cos Positional Encoding đến thực hành tinh chỉnh mô hình Transformer với đầy đủ mã nguồn.
  • Kỹ sư AI và Lập trình viên: Kế thừa bộ khung mã nguồn (Pipeline Template) xử lý dữ liệu tiếng Việt với VnCoreNLP và PyTorch đã được kiểm thử, dễ dàng tái sử dụng cho các tác vụ NLP khác như Phân loại văn bản, Nhận dạng thực thể tên riêng (NER).
  • Cộng đồng Nghiên cứu NLP Tiếng Việt: Cung cấp thêm kết quả benchmark tin cậy trên tập dữ liệu UIT-ViSQuAD đối với biến thể PhoBERT-large.
  • Doanh nghiệp ứng dụng: Có ngay giải pháp khả thi với chi phí tối ưu để xây dựng các hệ thống quản trị tri thức tự động.

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

1. Hệ thống yêu cầu cấu hình phần cứng tối thiểu như thế nào để triển khai?

Để phục vụ quá trình suy luận (Inference), hệ thống yêu cầu máy chủ có tối thiểu 8 GB RAM và CPU 4 Cores. Nếu triển khai trên GPU, khuyến nghị sử dụng NVIDIA GPU có từ 4 GB VRAM trở lên (hỗ trợ CUDA) để đạt thời gian phản hồi dưới 150ms cho mỗi yêu cầu. Đối với quá trình huấn luyện lại (Retraining), cần GPU tối thiểu 16 GB VRAM.

2. Giới hạn độ dài đoạn văn bản đầu vào là bao nhiêu và cách xử lý tài liệu dài?

Mô hình được cấu hình với độ dài chuỗi tối đa max_seq_length = 256 token. Đối với các tài liệu dài hàng nghìn từ, hệ thống áp dụng thuật toán cửa sổ trượt (Sliding Window) với bước nhảy doc_stride = 81 để chia nhỏ văn bản thành các đoạn chồng lấn, đảm bảo không làm đứt đoạn ngữ cảnh chứa câu trả lời.

3. Làm thế nào để tích hợp mô hình vào hệ thống phần mềm sẵn có của doanh nghiệp?

Mô hình được đóng gói dưới dạng RESTful API thông qua Flask và chạy độc lập trong Docker Container. Các hệ sinh thái ứng dụng khác (Web, Mobile App, ERP, CRM) chỉ cần gửi yêu cầu qua giao thức HTTP POST với định dạng JSON chứa hai trường context và question để nhận về kết quả.

4. Chi phí bảo trì và cập nhật mô hình định kỳ như thế nào?

Chi phí vận hành chính là hạ tầng máy chủ đám mây (Cloud Server) hoặc máy chủ nội bộ (On-premise). Định kỳ, khi doanh nghiệp có thêm dữ liệu tài liệu mới, chỉ cần chạy lại quy trình gán nhãn bổ sung và thực hiện fine-tuning nhẹ trong 2-3 epoch, tiêu tốn khoảng 1-2 giờ tính toán trên một GPU tầm trung.

5. Tại sao không sử dụng trực tiếp ChatGPT / OpenAI API mà nên triển khai mô hình riêng?

Việc sử dụng mô hình PhoBERT nội bộ đảm bảo bảo mật dữ liệu tuyệt đối (không truyền thông tin nhạy cảm của doanh nghiệp ra máy chủ bên ngoài), kiểm soát 100% độ trễ hệ thống, không phụ thuộc vào chi phí token biến đổi theo số lượng người dùng và loại bỏ hoàn toàn hiện tượng "ảo giác" (hallucination) do mô hình chỉ trích xuất dữ liệu thực tế từ ngữ cảnh được cung cấp.

Kết luận

Đồ án "Tìm hiểu kiến trúc Transformer và ứng dụng cho bài toán trả lời câu hỏi" đã hoàn thành toàn diện từ nghiên cứu lý thuyết chuyên sâu đến xây dựng sản phẩm ứng dụng thực tế. Bằng việc kết hợp sức mạnh biểu diễn ngữ cảnh hai chiều của kiến trúc Transformer thông qua mô hình PhoBERT-large với module tiền xử lý phân đoạn từ tiếng Việt VnCoreNLP, dự án đã đạt được độ chính xác vượt trội trên tập dữ liệu UIT-ViSQuAD với điểm F1 đạt 84.12% và Exact Match đạt 71.02%.

Giải pháp không chỉ giải quyết triệt để các rào cản ngữ nghĩa đặc thù của tiếng Việt mà còn chứng minh tính khả thi cao trong triển khai thực tế thông qua kiến trúc microservice đóng gói bằng Docker. Đây là bước đệm vững chắc để mở rộng phát triển các hệ thống trợ lý ảo thông minh, hệ thống tìm kiếm ngữ nghĩa thế hệ mới và các giải pháp quản trị tri thức tự động cho tổ chức, doanh nghiệp trong thời đại chuyển đổi số toàn diện.