Giới thiệu dự án

Trong kỷ nguyên bùng nổ thông tin số hóa, khối lượng dữ liệu văn bản tiếng Việt được tạo ra mỗi ngày từ báo điện tử, trang tin tức và mạng xã hội đang tăng trưởng theo cấp số nhân. Theo các thống kê từ ngành truyền thông và dữ liệu số, hơn 70% dữ liệu doanh nghiệp tồn tại dưới dạng phi cấu trúc, trong đó văn bản chiếm tỷ trọng áp đảo. Việc phân loại thủ công khối lượng tin tức khổng lồ này gây lãng phí nguồn nhân lực, độ trễ xử lý cao và thiếu tính nhất quán. Do đó, bài toán phân loại văn bản tự động (Automated Text Classification) trở thành một mắt xích cốt lõi trong các hệ thống khai phá dữ liệu (Data Mining) và Xử lý Ngôn ngữ Tự nhiên (Natural Language Processing - NLP).

                      +------------------------------------------+
                      |   Dữ liệu bài báo / tin tức tiếng Việt   |
                      |          (Dữ liệu phi cấu trúc)          |
                      +------------------------------------------+
                                           |
                                           v
                      +------------------------------------------+
                      |  Tiền xử lý & Tách từ (VnCoreNLP/RDR)   |
                      +------------------------------------------+
                                           |
                                           v
                      +------------------------------------------+
                      |   Biểu diễn ngữ cảnh sâu (Deep Context)  |
                      |      PhoBERT / Longformer Architecture   |
                      +------------------------------------------+
                                           |
                                           v
                      +------------------------------------------+
                      |      Phân loại đa lớp & Dự đoán nhãn     |
                      |  (Chính trị, Kinh tế, Thể thao, Giải trí)|
                      +------------------------------------------+

Vấn đề nghiên cứu (Problem Statement)

Tiếng Việt sở hữu các đặc trưng hình thái học và ngữ nghĩa phức tạp: tính đơn âm tiết ghép từ, hiện tượng đa nghĩa phụ thuộc ngữ cảnh, cùng hệ thống 6 thanh điệu đặc thù. Các mô hình truyền thống (Bag-of-Words, TF-IDF kết hợp Machine Learning cổ điển) hay mạng nơ-ron hồi quy đơn luồng thường bộc lộ hạn chế nghiêm trọng trong việc nắm bắt sự phụ thuộc xa giữa các từ và không mô hình hóa được ngữ cảnh hai chiều. Hơn nữa, các bài báo tin tức thường có độ dài vượt qua ngưỡng 512 tokens — giới hạn cứng của kiến trúc Transformer tiêu chuẩn — dẫn đến việc mất mát thông tin quan trọng khi bị cắt ngắn chuỗi.

Mục tiêu dự án

  1. Khảo sát và làm chủ lý thuyết: Nghiên cứu sâu cơ chế hoạt động của các kiến trúc học sâu tiên tiến: Bi-LSTM (Bidirectional Long Short-Term Memory), Transformer, BERT (Bidirectional Encoder Representations from Transformers), PhoBERT và Longformer PhoBERT.
  2. Xây dựng quy trình tiền xử lý chuyên biệt cho tiếng Việt: Ứng dụng công cụ tách từ hình thái học (RDRSegmenter từ VnCoreNLP) kết hợp mã hóa Byte-Pair Encoding (BPE).
  3. Thực nghiệm và tối ưu mô hình: Triển khai huấn luyện, tinh chỉnh (Fine-tuning) và đánh giá đối chuẩn (Benchmark) giữa 3 kiến trúc: Bi-LSTM, PhoBERT-base và Longformer PhoBERT trên tập dữ liệu tin tức đa chủ đề.
  4. Giải quyết bài toán văn bản dài: Khắc phục giới hạn tính toán độ phức tạp bậc hai $O(N^2)$ của Self-Attention tiêu chuẩn bằng cơ chế Sparse Attention (Sliding Window Attention) trong Longformer.
  5. Xây dựng ứng dụng hoàn chỉnh: Phát triển Web Application trực quan bằng Streamlit và triển khai mô hình lên nền tảng Hugging Face Spaces.

Phương pháp tiếp cận

Dự án tiếp cận bài toán qua hai kỹ thuật chính của Transfer Learning:

  • Trích xuất đặc trưng (Feature Extraction): Đóng băng (Freeze) các tầng Transformer của mô hình tiền huấn luyện (Pre-trained Language Model), trích xuất trạng thái ẩn cuối cùng (Last Hidden States) làm vector đầu vào cho bộ phân loại tùy chỉnh.
  • Tinh chỉnh toàn diện (End-to-End Fine-Tuning): Cập nhật trọng số của toàn bộ mô hình ngôn ngữ kết hợp với lớp phân loại chuyên biệt (Classification Head) thông qua thuật toán tối ưu AdamW và hàm mất mát Cross-Entropy Loss.

Kết quả kỳ vọng và chỉ số đo lường

  • Đạt độ chính xác tổng thể (Accuracy) trên 95% và Macro F1-Score trên 94% với mô hình PhoBERT/Longformer PhoBERT.
  • Cải thiện tối thiểu 8-10% hiệu năng phân loại so với mô hình baseline Bi-LSTM.
  • Cho phép phân loại văn bản có độ dài lên tới 4.096 tokens mà không bị tràn bộ nhớ VRAM nhờ Longformer.

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

  • Phạm vi dữ liệu: Tập trung vào tập dữ liệu bài báo, tin tức tiếng Việt trực tuyến thuộc các chủ đề chính (Chính trị, Kinh tế, Xã hội, Thể thao, Giải trí, Công nghệ, Giáo dục).
  • Ngôn ngữ: Đơn ngữ tiếng Việt (Vietnamese Monolingual).
  • Giới hạn kỹ thuật: Tài nguyên huấn luyện dựa trên môi trường GPU điện toán đám mây (NVIDIA Tesla T4 / V100).

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 TF-IDF + SVM / Naive Bayes Bi-LSTM Baseline Pre-trained PhoBERT Longformer PhoBERT
Nắm bắt ngữ cảnh Không (Rời rạc từng từ) Tuần tự 2 chiều (Forward/Backward) Toàn cục sâu (Bidirectional Self-Attention) Cục bộ + Toàn cục phân tán (Sparse Attention)
Xử lý từ đồng âm khác nghĩa Rất kém Trung bình Xuất sắc Xuất sắc
Giới hạn độ dài chuỗi Không giới hạn (ma trận thưa) Gặp hiện tượng suy giảm Gradient ở chuỗi dài Tối đa 512 tokens Tối đa 4.096 tokens
Độ phức tạp tính toán $O(N \cdot V)$ $O(N \cdot d^2)$ $O(N^2 \cdot d)$ $O(N \cdot w \cdot d)$ (Tuyến tính theo độ dài)
Chi phí huấn luyện Rất thấp (CPU) Trung bình (GPU cơ bản) Cao (GPU chuyên dụng) Cao (GPU chuyên dụng)

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

  • Must Have: Module tách từ tiếng Việt tự động; mô hình trích xuất đặc trưng và phân loại đa lớp; module đánh giá Confusion Matrix, Precision, Recall, F1-Score; giao diện web demo dự đoán trực tiếp.
  • Should Have: Cơ chế xử lý tài liệu dài (>512 tokens) với Longformer PhoBERT; chức năng trích xuất xác suất tin cậy (Probability Confidence Score).
  • Could Have: Khả năng tải lên tệp tin văn bản (.txt, .csv) hàng loạt để phân loại theo lô (Batch Processing).
  • Won't Have (Giai đoạn này): Phân loại đa nhãn đồng thời (Multi-label classification) và hệ thống streaming real-time pipeline qua Kafka.

Thiết kế hệ thống

+-----------------------------------------------------------------------------------+
|                                  KIẾN TRÚC HỆ THỐNG                                |
+-----------------------------------------------------------------------------------+
|                                                                                   |
|  [ Client Layer ]          Streamlit Web Application (UI / Dashboard)             |
|                                         |                                         |
|                                         v                                         |
|  [ Preprocessing Layer ]   VnCoreNLP (RDRSegmenter) -> FastBPE Tokenizer         |
|                                         |                                         |
|                                         v                                         |
|  [ Deep Learning Layer ]   +---------------------------------------------------+  |
|                            | Pre-trained Backbone (PhoBERT / Longformer)       |  |
|                            |  - 12/24 Transformer Encoder Blocks               |  |
|                            |  - Sliding Window & Global Attention Mechanisms   |  |
|                            +---------------------------------------------------+  |
|                                         |                                         |
|                                         v                                         |
|  [ Classification Head ]   [CLS] Pooling Layer -> Dropout (0.3) -> Linear Layer   |
|                                         |                                         |
|                                         v                                         |
|  [ Output Layer ]          Softmax Probabilities -> Predicted Category Label     |
|                                                                                   |
+-----------------------------------------------------------------------------------+

Ngăn xếp công nghệ (Technology Stack)

  • Ngôn ngữ lập trình: Python v3.10.12
  • Deep Learning Framework: PyTorch v2.1.2 + CUDA 11.8 / 12.1
  • Transformers Ecosystem: Hugging Face transformers v4.38.2, tokenizers v0.15.2, accelerate v0.27.2
  • Xử lý ngôn ngữ tiếng Việt: vncorenlp v1.0.3, pyvi v0.1.1, fastBPE v0.1.0
  • Khoa học dữ liệu & Trực quan hóa: scikit-learn v1.4.1, pandas v2.2.1, numpy v1.26.4, seaborn v0.13.2, matplotlib v3.8.3
  • Triển khai giao diện: streamlit v1.32.2
  • Hosting & CI/CD: Hugging Face Spaces (Gradio/Streamlit runtime)

Thiết kế cấu trúc dữ liệu và Pipeline xử lý

  • Dữ liệu thô đầu vào: Dạng JSON/CSV chứa các trường title, content, category.
  • Tiền xử lý: Làm sạch ký tự đặc biệt, chuẩn hóa mã Unicode (NFC), loại bỏ HTML tags, chuyển chữ thường (lowercase) có kiểm soát.
  • Tokenization Pipeline: Chuỗi văn bản $\rightarrow$ Tách từ bằng RDRSegmenter $\rightarrow$ Mã hóa BPE Subwords $\rightarrow$ Thêm special tokens (<s>, </s>, hoặc [CLS], [SEP]) $\rightarrow$ Padding/Truncation thành Tensor định dạng input_ids và attention_mask.

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

Quy trình nghiên cứu và phát triển được xây dựng theo mô hình CRISP-DM (Cross-Industry Standard Process for Data Mining) kết hợp vòng lặp Agile:

[Hiểu bài toán] -> [Thu thập & Tiền xử lý] -> [Xây dựng mô hình] -> [Đánh giá & Benchmark] -> [Triển khai Web App]

Ma trận đánh giá rủi ro và biện pháp giảm thiểu

Rủi ro kỹ thuật Mức độ Biện pháp giảm thiểu
Tràn bộ nhớ GPU (OOM) khi train chuỗi dài Cao Áp dụng Gradient Accumulation, FP16 Mixed Precision, giảm Per-device Batch Size xuống 4 hoặc 8.
Mất cân bằng dữ liệu giữa các chủ đề Trung bình Sử dụng kỹ thuật Class Weighting trong hàm Cross-Entropy Loss hoặc phân tầng (Stratified Sampling).
Hiện tượng Catastrophic Forgetting khi fine-tune Trung bình Thiết lập Learning Rate nhỏ ($2e-5$ đến $3e-5$) kèm Warmup Scheduler và Weight Decay ($0.01$).

Implementation và kết quả

Quy trình phát triển (Development Process)

Quá trình thực thi dự án được chia làm 4 giai đoạn chính:

  1. Giai đoạn 1: Xây dựng baseline model với mạng nơ-ron hồi quy hai chiều Bi-LSTM.
  2. Giai đoạn 2: Tích hợp mô hình ngôn ngữ tiếng Việt tiền huấn luyện PhoBERT (vinai/phobert-base) thông qua Hugging Face.
  3. Giai đoạn 3: Triển khai kiến trúc Longformer PhoBERT với cơ chế Sliding Window Attention nhằm nâng kích thước cửa sổ ngữ cảnh lên $4.096$ tokens.
  4. Giai đoạn 4: Tinh chỉnh siêu tham số (Hyperparameter Tuning), đánh giá kết quả và đóng gói ứng dụng Streamlit.

Trích đoạn thuật toán tiền xử lý và tách từ tiếng Việt

import torch
from vncorenlp import VnCoreNLP
from transformers import AutoTokenizer, AutoModelForSequenceClassification

class VietnameseTextPreprocessor:
    def __init__(self, rdrsegmenter_path: str, model_name: str = "vinai/phobert-base"):
        # Khởi tạo công cụ tách từ VnCoreNLP RDRSegmenter
        self.rdrsegmenter = VnCoreNLP(rdrsegmenter_path, annotators="wseg", max_heap_size='-Xmx500m')
        self.tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=False)

    def preprocess_and_tokenize(self, text: str, max_length: int = 256):
        # Bước 1: Tách từ tiếng Việt (ví dụ: "học máy" -> "học_máy")
        segmented_sentences = self.rdrsegmenter.tokenize(text)
        segmented_text = " ".join([" ".join(sentence) for sentence in segmented_sentences])
        
        # Bước 2: Mã hóa sang Subword Token IDs và Attention Mask
        encoding = self.tokenizer(
            segmented_text,
            truncation=True,
            max_length=max_length,
            padding="max_length",
            return_tensors="pt"
        )
        return encoding

Xây dựng mô hình phân loại tùy biến với PhoBERT Backbone

import torch.nn as nn
from transformers import AutoModel

class PhoBERTClassifier(nn.Module):
    def __init__(self, model_name: str, num_classes: int, dropout_rate: float = 0.3):
        super(PhoBERTClassifier, self).__init__()
        self.phobert = AutoModel.from_pretrained(model_name)
        self.dropout = nn.Dropout(dropout_rate)
        # Sử dụng hidden_size = 768 từ PhoBERT-base
        self.classifier = nn.Linear(self.phobert.config.hidden_size, num_classes)

    def forward(self, input_ids, attention_mask):
        outputs = self.phobert(input_ids=input_ids, attention_mask=attention_mask)
        # Trích xuất vector đại diện tại vị trí token đầu tiên [CLS]
        cls_output = outputs[0][:, 0, :]
        x = self.dropout(cls_output)
        logits = self.classifier(x)
        return logits

Cấu hình siêu tham số huấn luyện (Training Configuration)

  • Optimizer: AdamW ($\beta_1 = 0.9, \beta_2 = 0.999, \epsilon = 1e-8$)
  • Learning Rate: $2 \times 10^{-5}$ với Linear Learning Rate Decay và $10%$ Warmup Steps
  • Batch Size: 16 (PhoBERT-base), 8 (Longformer PhoBERT)
  • Epochs: 5 - 10 epochs (Early Stopping với Patience = 3 dựa trên Validation Loss)
  • Loss Function: Categorical Cross-Entropy Loss

Đánh giá và kiểm thử (Testing & Validation)

Hệ thống được kiểm thử độc lập trên tập kiểm tra (Test Set) gồm hàng ngàn bài báo với phân bổ đồng đều giữa các thể loại.

                    MA TRẬN KẾT QUẢ ĐỐI CHUẨN (BENCHMARK RESULTS)
+------------------------------------------------------------------------------+
|   Mô hình               | Accuracy  | Precision | Recall    | Macro F1-Score |
+-------------------------+-----------+-----------+-----------+----------------+
| 1. Bi-LSTM Baseline     |   86.42%  |   85.90%  |   85.15%  |     85.52%     |
| 2. PhoBERT-base         |   94.85%  |   94.60%  |   94.48%  |     94.54%     |
| 3. Longformer PhoBERT   |   96.18%  |   96.05%  |   95.92%  |     95.98%     |
+------------------------------------------------------------------------------+

                     BIỂU ĐỒ SO SÁNH HIỆU NĂNG MACRO F1-SCORE
                     
  Bi-LSTM Baseline     [████████████████████████████░░░░░] 85.52%
  PhoBERT-base         [█████████████████████████████████░] 94.54%
  Longformer PhoBERT   [██████████████████████████████████] 95.98%
                       +---------+---------+---------+---+
                       0%       25%       50%       75% 100%

Đánh giá chi tiết theo từng lớp (Per-Class Performance - Longformer PhoBERT)

Nhãn chủ đề Precision (%) Recall (%) F1-Score (%) Support
Chính trị - Xã hội 95.40 96.10 95.75 450
Kinh tế - Tài chính 96.20 95.80 96.00 480
Khoa học - Công nghệ 97.10 96.50 96.80 420
Thể thao 98.50 98.20 98.35 500
Văn hóa - Giải trí 95.80 94.90 95.35 460
Giáo dục - Đời sống 93.90 94.00 93.95 390

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

  1. Khắc phục triệt để rào cản độ dài văn bản: Đa số các nghiên cứu phân loại văn bản tiếng Việt trước đây chỉ áp dụng PhoBERT tiêu chuẩn với giới hạn 512 tokens. Nghiên cứu này tích hợp thành công kiến trúc Longformer Attention vào backbone tiếng Việt, giảm độ phức tạp tính toán từ $O(N^2)$ xuống $O(N \cdot w)$, cho phép mô hình tiếp nhận trọn vẹn nội dung bài báo lên tới 4.096 tokens mà không bị mất ngữ cảnh phần kết luận.
  2. Cải tiến vượt bậc về độ chính xác: Longformer PhoBERT nâng cao Macro F1-Score thêm +10.46% so với baseline Bi-LSTM và +1.44% so với PhoBERT-base nguyên bản trên các bài báo dài.
  3. Đóng góp giải pháp thực thi mã nguồn mở: Cung cấp trọn vẹn pipeline tiền xử lý, cấu hình fine-tuning và web interface, tạo tài liệu tham khảo thực nghiệm chi tiết cho cộng đồng nghiên cứu Kỹ thuật Dữ liệu và Xử lý Ngôn ngữ Tự nhiên tại Việt Nam.

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

Kịch bản sử dụng thực tế (Real-World Use Cases)

  • Hệ thống tổng hợp và phân loại tin tức tự động (News Aggregators): Tự động gom nhóm các luồng tin từ hàng chục tờ báo điện tử vào các danh mục chuyên đề theo thời gian thực.
  • Hệ thống lắng nghe mạng xã hội (Social Media Monitoring): Phân tích và phân loại các bài đăng, bài phân tích dài trên các diễn đàn và mạng xã hội để phục vụ nghiên cứu thị trường và cảnh báo khủng hoảng truyền thông.
  • Quản lý tri thức doanh nghiệp (Enterprise Document Management): Tự động gắn nhãn (tagging) và lưu trữ văn bản hành chính, tài liệu báo cáo kỹ thuật vào các danh mục lưu trữ nội bộ.

Kiến trúc triển khai Web Application

Hệ thống được đóng gói và triển khai qua giao diện Web trực quan với luồng vận hành như sau:

[Người dùng nhập URL / Văn bản] 
            │
            ▼
[Giao diện Streamlit UI] 
            │ (HTTP Request)
            ▼
[Engine Tiền xử lý: VnCoreNLP] 
            │ (Segmented Text)
            ▼
[Inference Engine: PyTorch + Longformer PhoBERT] 
            │ (Softmax Computation)
            ▼
[Xuất kết quả: Chủ đề dự đoán + Thanh đo độ tin cậy %]

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

  • Tối ưu hóa nhân lực: Giảm 92% thời gian biên tập và gán nhãn bài viết thủ công tại các tòa soạn hoặc đơn vị tổng hợp tin.
  • Chi phí vận hành thấp: Nhờ kỹ thuật tối ưu hóa trọng số (Pruning / Quantization FP16), mô hình có thể chạy ổn định trên các instance GPU phổ thông (hoặc suy luận trên CPU đa nhân với độ trễ $<80\text{ ms/bài}$).

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

Hạn chế kỹ thuật

  • Thời gian trích xuất đặc trưng và suy luận của Transformer lớn hơn đáng kể so với các mô hình mạng nơ-ron cổ điển (Bi-LSTM / CNN).
  • Khâu tách từ tiếng Việt phụ thuộc nhiều vào chất lượng bộ công cụ VnCoreNLP; các từ ngữ mới xuất hiện, từ ghép phi chuẩn hoặc tiếng lóng trên mạng xã hội có thể bị phân đoạn sai lệch.

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

  • Nén mô hình (Knowledge Distillation & Quantization): Xây dựng phiên bản Distil-PhoBERT hoặc lượng tử hóa INT8/ONNX Runtime để tăng tốc độ suy luận gấp 3-4 lần, phục vụ triển khai trên thiết bị nhúng và hệ thống microservices tải cao.
  • Mở rộng bài toán: Nâng cấp từ phân loại đơn nhãn (Single-label) sang phân loại đa nhãn (Multi-label) và phân tích cảm xúc phân cấp (Hierarchical Multi-task Learning).

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

  • Sinh viên & Học viên chuyên ngành Kỹ thuật Dữ liệu/CNTT: Nguồn tài liệu học tập thực tế, cung cấp kiến thức toàn diện từ lý thuyết Deep Learning (LSTM, Attention, BERT, Longformer) đến kỹ năng lập trình mô hình PyTorch chuẩn mực.
  • Kỹ sư AI & NLP Developers: Cung cấp mẫu thiết kế (Design Pattern) hoàn chỉnh để xây dựng và triển khai các bài toán phân loại văn bản tiếng Việt trong môi trường công nghiệp.
  • Tòa soạn, Doanh nghiệp truyền thông & Phân tích dữ liệu: Giải pháp tự động hóa quy trình quản trị nội dung với chi phí tối ưu và độ tin cậy cao.
  • Nhà nghiên cứu: Dữ liệu đối chuẩn và bằng chứng thực nghiệm về tính hiệu quả của cơ chế Sparse Attention trên ngữ liệu tiếng Việt.

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

1. Cấu hình phần cứng tối thiểu để triển khai và huấn luyện mô hình là gì?

  • Huấn luyện (Training): Khuyến nghị sử dụng GPU tối thiểu có 12GB - 16GB VRAM (như NVIDIA Tesla T4, RTX 3060, hoặc Google Colab Pro).
  • Suy luận (Inference/Deployment): Có thể chạy tốt trên CPU 4 cores, 8GB RAM hoặc GPU giá rẻ (T4) với thời gian phản hồi trung bình $45 - 80\text{ ms}$ cho mỗi văn bản chuẩn.

2. Làm thế nào để Longformer PhoBERT xử lý được các văn bản vượt quá 512 tokens?

Mô hình tiêu chuẩn áp dụng Full Self-Attention tính toán mối tương quan giữa mọi cặp token, dẫn đến độ phức tạp $O(N^2)$ về bộ nhớ. Longformer thay thế bằng Sliding Window Attention với kích thước cửa sổ cố định $w$ kết hợp Global Attention tại các token đặc biệt ([CLS]), giảm chi phí bộ nhớ xuống mức tuyến tính $O(N \cdot w)$, cho phép nâng chiều dài chuỗi đầu vào lên $4.096$ tokens.

3. Có cần thiết phải tách từ tiếng Việt trước khi đưa vào PhoBERT không?

Có. Khác với tiếng Anh (ngôn ngữ biến hình, phân tách bằng dấu cách), tiếng Việt là ngôn ngữ đơn lập, ranh giới từ không trùng với ranh giới âm tiết (ví dụ: "học sinh", "công nghệ thông tin"). PhoBERT được huấn luyện trước trên dữ liệu đã qua tách từ hình thái học bằng RDRSegmenter (VnCoreNLP). Việc tách từ trước khi tokenize bằng BPE là bắt buộc để mô hình nhận diện chính xác ngữ nghĩa của từ.

4. Chi phí bản quyền và tính khả dụng của mã nguồn như thế nào?

Toàn bộ hệ thống được xây dựng dựa trên các công nghệ mã nguồn mở hoàn toàn miễn phí: Python, PyTorch, Hugging Face Transformers và PhoBERT (giấy phép MIT/Apache 2.0). Doanh nghiệp có thể tự do tùy biến và tích hợp vào hệ sinh thái sản phẩm thương mại mà không chịu chi phí bản quyền phần mềm.

5. Khả năng mở rộng (Scalability) của hệ thống khi khối lượng truy vấn tăng cao?

Mô hình có thể được chuyển đổi sang định dạng ONNX (Open Neural Network Exchange) hoặc sử dụng framework Triton Inference Server / FastAPI, kết hợp cơ chế Load Balancing trên Kubernetes (K8s) để xử lý đồng thời hàng ngàn requests/giây với khả năng mở rộng ngang (Horizontal Auto-scaling) linh hoạt.

Kết luận

Đồ án tốt nghiệp "Phân loại văn bản dùng mô hình BERT" của nhóm tác giả tại Trường Đại học Sư phạm Kỹ thuật TP.HCM (HCMUTE) đã giải quyết trọn vẹn và chuyên sâu bài toán phân loại tin tức tiếng Việt tự động. Thông qua việc nghiên cứu, triển khai và đối chuẩn nghiêm ngặt giữa các kiến trúc học sâu từ Bi-LSTM, PhoBERT đến Longformer PhoBERT, đề tài đã chứng minh tính ưu việt vượt trội của các mô hình ngôn ngữ ngữ cảnh sâu kết hợp cơ chế chú ý thưa (Sparse Attention).

Kết quả đạt được với độ chính xác 96.18% và Macro F1-Score 95.98% khẳng định tính khả thi cao trong triển khai ứng dụng thực tế, mở ra hướng đi bền vững cho việc tự động hóa xử lý văn bản quy mô lớn trong lĩnh vực truyền thông số và kỹ thuật dữ liệu tại Việt Nam.