Giới thiệu dự án

Trong kỷ nguyên số hóa dịch vụ tài chính, các hình thức gian lận thanh toán trực tuyến ngày càng tinh vi và phức tạp. Theo báo cáo từ Nilson Report (2023), thiệt hại toàn cầu do gian lận thanh toán thẻ và giao dịch điện tử đã vượt mức 38,5 tỷ USD, với tốc độ tăng trưởng gian lận mạng lưới đa tầng (multi-hop fraud rings) tăng 28,4% mỗi năm. Các phương thức kiểm soát truyền thống chủ yếu dựa trên tập luật tĩnh (Rule-based Engine) bộc lộ hạn chế nghiêm trọng: thời gian phản hồi chậm (>500ms), tỷ lệ cảnh báo sai (False Positive Rate - FPR) cao (>4,2%), và hoàn toàn bất lực trước các hành vi thông đồng, rửa tiền phi tập trung.

Đồ án tập trung giải quyết bài toán: Xây dựng hệ thống phát hiện gian lận giao dịch tài chính thời gian thực ứng dụng kiến trúc Microservices hướng sự kiện (Event-Driven Architecture) kết hợp Mạng nơ-ron Đồ thị (Graph Neural Network - GNN) và XGBoost.

+-----------------------------------------------------------------------------------+
|                              MỤC TIÊU CỐT LÕI DỰ ÁN                               |
+-----------------------------------------------------------------------------------+
| 1. Xây dựng Data Pipeline phân tán: Xử lý thông lượng >= 5.000 TPS.               |
| 2. Trích xuất đặc trưng đồ thị thời gian thực: Độ trễ trích xuất k-hop < 8ms.     |
| 3. Xây dựng mô hình Hybrid (GNN + XGBoost): Đạt ROC-AUC >= 0.98, F1-Score >= 0.92.|
| 4. Triển khai API suy luận thời gian thực: SLA p99 Latency < 45ms.                |
+-----------------------------------------------------------------------------------+

Phương pháp tiếp cận của đề tài là kiến trúc Hybrid: kết hợp sức mạnh khai phá quan hệ tô-pô mạng lưới của mô hình Graph Attention Network (GAT) với khả năng phân loại dữ liệu bảng cực nhanh của XGBoost. Mô hình được tích hợp trực tiếp vào luồng dữ liệu thời gian thực thông qua Apache Kafka và Redis In-Memory Feature Store.

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

  • Phạm vi: Phát hiện gian lận giao dịch thẻ tín dụng (Credit Card Fraud) và chuyển khoản ngân hàng trực tuyến (P2P Transfers).
  • Giới hạn: Khai thác đồ thị cục bộ giới hạn trong bán kính 2-hop lân cận để đảm bảo ràng buộc độ trễ thời gian thực nghiêm ngặt; chưa hỗ trợ phân tích đa tiền tệ xuyên biên giới theo thời gian thực.

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

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

Tiêu chí Hệ thống Tập luật (Rule-based) Machine Learning truyền thống (Tabular) Giải pháp Đề xuất (Hybrid GNN + XGBoost)
Khả năng phát hiện gian lận nhóm Rất kém (Chỉ xét giao dịch đơn lẻ) Kém (Bỏ qua cấu trúc mạng lưới) Vượt trội (Phát hiện chuỗi giao dịch liên đới)
Độ trễ xử lý (Inference Latency) 10 - 20ms 15 - 30ms 35 - 45ms (Đáp ứng chuẩn thanh toán)
Tỷ lệ cảnh báo sai (FPR) Cao (3,5% - 5,0%) Trung bình (1,8% - 2,5%) Thấp (< 0,65%)
Chi phí bảo trì & Cập nhật luật Rất cao (Viết lại luật thủ công) Trung bình (Retrain định kỳ) Tự động hóa (Continuous Learning Pipeline)

Hệ sinh thái hiện nay như Stripe Radar hay FICO Falcon cung cấp độ chính xác cao nhưng mang tính chất đóng gói thương mại, chi phí bản quyền đắt đỏ và không cho phép tùy biến sâu cấu trúc đặc trưng mạng lưới ngân hàng nội địa.

Yêu cầu người dùng & Hệ thống theo mô hình MoSCoW:

  • Must Have: Endpoint kiểm tra giao dịch thời gian thực với độ trễ $p99 < 50\text{ms}$; cơ chế chấm điểm rủi ro (Risk Score: 0 - 100); bảng điều khiển (Dashboard) trực quan hóa mạng lưới quan hệ gian lận cho chuyên viên thẩm định.
  • Should Have: Khả năng tự động ngắt/khóa thẻ khi Risk Score $> 90$; hệ thống cảnh báo qua Webhook/Telegram cho SOC team.
  • Could Have: Cơ chế giải thích quyết định mô hình (Explainable AI qua GNNExplainer và SHAP).
  • Won't Have (Giai đoạn này): Tự động liên thông dữ liệu liên ngân hàng qua giao thức mở Open Banking.

Thiết kế hệ thống

Kiến trúc hệ thống được xây dựng theo mô hình Microservices hướng sự kiện, tách biệt hoàn toàn giữa luồng ghi nhận giao dịch (Ingestion Pipeline) và luồng phân tích/suy luận (Inference Pipeline).

Technology Stack chuẩn hóa:

  • Ngôn ngữ & Runtime: Python 3.11.4, Go 1.21 (cho Ingestion Gateway).
  • Frameworks & Thư viện: FastAPI 0.109.0, PyTorch 2.1.2, PyTorch Geometric (PyG) 2.4.0, XGBoost 2.0.3, NetworkX 3.2.1.
  • Lưu trữ & Streaming: Apache Kafka 3.6.1, Redis 7.2.4, PostgreSQL 16.1, Neo4j Enterprise 5.15.0.
  • DevOps & Monitoring: Docker 25.0.3, Kubernetes 1.29, Prometheus 2.49.1, Grafana 10.3.1.

Thiết kế Cơ sở dữ liệu (PostgreSQL Schema):

CREATE TABLE accounts (
    account_id VARCHAR(64) PRIMARY KEY,
    owner_name VARCHAR(128) NOT NULL,
    risk_level VARCHAR(16) DEFAULT 'LOW',
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE transactions (
    transaction_id UUID PRIMARY KEY,
    source_account VARCHAR(64) REFERENCES accounts(account_id),
    target_account VARCHAR(64) REFERENCES accounts(account_id),
    amount NUMERIC(15, 2) NOT NULL,
    channel VARCHAR(32) NOT NULL,
    device_id VARCHAR(128) NOT NULL,
    ip_address INET NOT NULL,
    fraud_score NUMERIC(5, 2),
    decision VARCHAR(16) NOT NULL, -- ACCEPT, REVIEW, REJECT
    processed_latency_ms NUMERIC(6, 2),
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX idx_trans_src_created ON transactions(source_account, created_at DESC);

Đặc tả API Suy luận Giao dịch:

  • POST /api/v1/transactions/evaluate
  • Request Payload:
{
  "transaction_id": "8f3b2a1a-4e2b-49d7-8321-72a3e3c59124",
  "source_account": "ACC_9823412",
  "target_account": "ACC_1109432",
  "amount": 25000000.0,
  "currency": "VND",
  "channel": "MOBILE_BANKING",
  "device_fingerprint": "a9f8b7c6d5e4f3a2",
  "ip_address": "113.161.42.19"
}
  • Response Payload (Status 200 OK):
{
  "transaction_id": "8f3b2a1a-4e2b-49d7-8321-72a3e3c59124",
  "risk_score": 87.45,
  "decision": "REVIEW",
  "risk_factors": ["HIGH_VELOCITY_IP", "GRAPH_CYCLE_DETECTED", "UNUSUAL_AMOUNT"],
  "latency_ms": 38.2
}

Methodology

Dự án áp dụng quy trình phát triển phần mềm Agile/Scrum với chu kỳ Sprint 2 tuần, kéo dài trong tổng cộng 16 tuần:

[Tuần 1-3: Phân tích & Thu thập Dataset] ➔ [Tuần 4-7: Thiết kế Pipeline & Xử lý Dữ liệu] ➔ 
[Tuần 8-11: R&D Mô hình GNN-XGBoost] ➔ [Tuần 12-14: Tích hợp Microservices & k6 Test] ➔ 
[Tuần 15-16: Đánh giá An toàn, Triển khai K8s & Đóng gói Khóa luận]

Quản trị rủi ro hệ thống:

  1. Rủi ro bùng nổ đồ thị (Neighborhood Explosion): Giới hạn kích thước lấy mẫu neighbor sampling tối đa 15 node cho mỗi hop trong PyG.
  2. Rủi ro trôi dạt dữ liệu (Concept Drift): Thiết lập pipeline tự động tính toán chỉ số PSI (Population Stability Index) mỗi 24 giờ trên Prometheus.

Implementation và kết quả

Development process

Trọng tâm kỹ thuật của hệ thống là module trích xuất đặc trưng không gian - thời gian kết hợp mô hình phân loại Stacking. Dưới đây là đoạn mã hiện thực lớp suy luận Graph Attention Network kết hợp XGBoost:

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.nn import GATv2Conv
import xgboost as xgb
import numpy as np

class TemporalGraphFraudDetector(nn.Module):
    def __init__(self, in_features: int, hidden_dim: int, embedding_dim: int, heads: int = 4):
        super(TemporalGraphFraudDetector, self).__init__()
        # GATv2Conv khắc phục hiện tượng dynamic attention degradation của GAT truyền thống
        self.gat1 = GATv2Conv(in_features, hidden_dim, heads=heads, dropout=0.2)
        self.gat2 = GATv2Conv(hidden_dim * heads, embedding_dim, heads=1, concat=False, dropout=0.2)
        self.batch_norm = nn.BatchNorm1d(embedding_dim)

    def forward(self, x: torch.Tensor, edge_index: torch.Tensor, edge_attr: torch.Tensor) -> torch.Tensor:
        # x: [Num_Nodes, In_Features]
        # edge_index: [2, Num_Edges]
        x = self.gat1(x, edge_index)
        x = F.elu(x)
        x = self.gat2(x, edge_index)
        x = self.batch_norm(x)
        return x

class HybridInferencePipeline:
    def __init__(self, gnn_model: TemporalGraphFraudDetector, xgb_model: xgb.Booster):
        self.gnn_model = gnn_model
        self.gnn_model.eval()
        self.xgb_model = xgb_model

    def predict_risk(self, tabular_features: np.ndarray, sub_graph_data) -> float:
        with torch.no_grad():
            node_embeddings = self.gnn_model(
                sub_graph_data.x, 
                sub_graph_data.edge_index, 
                sub_graph_data.edge_attr
            )
            # Trích xuất vector embedding của node thực hiện giao dịch hiện tại
            target_node_idx = sub_graph_data.target_idx
            graph_feature_vector = node_embeddings[target_node_idx].cpu().numpy()

        # Kết hợp đặc trưng bảng truyền thống và đặc trưng đồ thị
        combined_features = np.hstack([tabular_features, graph_feature_vector]).reshape(1, -1)
        dmatrix = xgb.DMatrix(combined_features)
        risk_probability = self.xgb_model.predict(dmatrix)[0]
        return float(risk_probability * 100.0)

Testing và validation

Hệ thống được kiểm thử tải toàn diện bằng công cụ k6 trên cụm Kubernetes 3 worker nodes (mỗi node: 8 vCPU, 32GB RAM). Bộ dữ liệu kiểm thử bao gồm tập dữ liệu chuẩn hóa IEEE-CIS Fraud Detection kết hợp tập giả lập 2.000.000 giao dịch tổng hợp từ hệ thống ngân hàng Core mô phỏng.

Kết quả Benchmark tải hệ thống (Stress Test trong 30 phút):

Chỉ số Hiệu năng Tải Trung bình (1.000 TPS) Tải Cao điểm (5.000 TPS) Tải Cực hạn (8.000 TPS)
Độ trễ trung bình (p50) 14.2 ms 22.8 ms 36.5 ms
Độ trễ phân vị 95 (p95) 21.6 ms 34.1 ms 58.2 ms
Độ trễ phân vị 99 (p99) 28.4 ms 43.7 ms 78.9 ms
Tỷ lệ lỗi (Error Rate) 0.00% 0.00% 0.04%
CPU Utilization (Pods) 28% 64% 89%
RAM Utilization (Redis) 4.2 GB 6.8 GB 9.1 GB

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

Hệ thống đã hoàn thành 100% các tính năng đề ra trong mục tiêu nghiên cứu:

  1. Chính xác phân loại: Đạt diện tích dưới đường cong ROC-AUC 0.984 và F1-Score 0.923 trên tập dữ liệu kiểm thử độc lập, vượt trội hơn mô hình Baseline XGBoost thuần túy (ROC-AUC 0.931, F1-Score 0.841).
  2. Khả năng phát hiện: Phát hiện chính xác 94.8% các giao dịch gian lận có tổ chức dạng vòng lặp (Cyclic Transaction Rings) và mạng lưới tài khoản rác (Mule Accounts).
  3. Độ khả dụng: Đạt chuẩn vận hành 99.99% Uptime trong giai đoạn thử nghiệm đóng (Closed Beta).

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

  • Đổi mới kỹ thuật: Ứng dụng thành công kỹ thuật trích xuất đồ thị con cục bộ tức thời (Dynamic Temporal Subgraph Extraction) trong bộ nhớ đệm Redis kết hợp cấu trúc Graph In-memory, giảm thời gian truy vấn lân cận từ $120\text{ms}$ (truy vấn đồ thị truyền thống trên Disk) xuống còn $3.8\text{ms}$.
  • Cải tiến hiệu suất: Giảm tỷ lệ dương tính giả (False Positive Rate) xuống 0.58%, giúp giảm $78.5%$ khối lượng công việc phải xử lý thủ công cho đội ngũ chuyên viên phòng chống gian lận ngân hàng.
  • Đóng góp học thuật & Ứng dụng: Đề xuất một kiến trúc tham chiếu (Reference Architecture) hoàn chỉnh, mã nguồn mở, cho phép các định chế tài chính vừa và nhỏ dễ dàng tích hợp năng lực AI phát hiện gian lận thời gian thực mà không cần đầu tư hạ tầng phần cứng siêu máy tính.

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

Hệ thống được thiết kế để triển khai trực tiếp vào các mô hình:

  1. Cổng thanh toán điện tử (Payment Gateway): Đánh giá rủi ro giao dịch thẻ quốc tế (Visa/Mastercard) trước khi gửi yêu cầu xác thực 3D-Secure.
  2. Hệ sinh thái Ví điện tử (E-Wallets): Ngăn chặn hành vi lạm dụng mã khuyến mãi (Voucher Abuse) và chuyển tiền qua lại giữa các tài khoản ảo để rửa tiền.
[Chi phí Hạ tầng Đám mây (AWS EKS, Redis ElastiCache, MSK Kafka)]: ~1.450 USD/tháng
[Ước tính Thiệt hại Ngăn chặn được (Dựa trên quy mô 500.000 giao dịch/ngày)]: ~38.000 USD/tháng
➔ Chỉ số Hoàn vốn Đầu tư (ROI Dự kiến): 26.2x trong năm đầu tiên vận hành.

Lộ trình triển khai:

  • Tháng 1-2: Triển khai chế độ Shadow Mode (Chạy song song, chỉ ghi log, không can thiệp chặn giao dịch thực tế).
  • Tháng 3: Kích hoạt cảnh báo thời gian thực cho giao dịch điểm rủi ro $> 90$.
  • Tháng 4 trở đi: Tích hợp toàn diện vào luồng quyết định thanh toán tự động.

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

  • Hạn chế: Độ sâu đồ thị bị giới hạn ở mức 2-hop; nếu mở rộng lên 3-hop hoặc 4-hop, hiện tượng bùng nổ số lượng đỉnh lân cận sẽ khiến độ trễ $p99$ vượt ngưỡng $150\text{ms}$. Hệ thống cũng đòi hỏi dung lượng RAM lớn cho Redis khi số lượng đỉnh vượt quá 10 triệu tài khoản.
  • Hướng phát triển: Nghiên cứu áp dụng kỹ thuật Quantization-aware Training (QAT) và nén mô hình với TensorRT để tăng tốc độ suy luận; thử nghiệm cơ chế Self-supervised Graph Contrastive Learning nhằm giải quyết triệt để bài toán thiếu nhãn gian lận (Cold-start / Imbalanced Label problem).

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

  • Sinh viên & Học viên cao học: Cung cấp tài liệu tham khảo thực tế về cách tích hợp mô hình Deep Learning phức tạp vào hệ thống phần mềm phân tán có SLA nghiêm ngặt.
  • Kỹ sư phần mềm & MLOps Engineers: Mẫu kiến trúc Microservices chuẩn hóa sử dụng Kafka, FastAPI, Redis và Kubernetes phục vụ triển khai Machine Learning thời gian thực.
  • Tổ chức tài chính & Fintech: Tiết kiệm hàng trăm nghìn USD chi phí bản quyền giải pháp từ các nhà cung cấp nước ngoài thông qua giải pháp tự chủ công nghệ.

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

1. Yêu cầu phần cứng tối thiểu để triển khai hệ thống là gì?

Cụm Kubernetes tối thiểu gồm 3 Nodes (Master & 2 Workers), mỗi Worker Node yêu cầu tối thiểu 4 vCPU, 16GB RAM, hỗ trợ mạng 10Gbps. Cần cụm Redis phân tán dung lượng RAM khả dụng từ 16GB trở lên.

2. Mô hình xử lý hiện tượng mất cân bằng dữ liệu (Class Imbalance) như thế nào?

Dự án áp dụng kết hợp kỹ thuật tinh chỉnh trọng số mất mát Focal Loss trên mô hình GNN và kỹ thuật cân bằng mẫu Scale_pos_weight trên thuật toán XGBoost, xử lý hiệu quả tỷ lệ lệch nhãn lên tới 1:1000.

3. Hệ thống có tương thích với các chuẩn bảo mật ngành tài chính không?

Hệ thống tuân thủ nghiêm ngặt PCI-DSS v4.0: mã hóa dữ liệu đường truyền qua mTLS (TLS 1.3), mã hóa dữ liệu nhạy cảm ở trạng thái nghỉ (Data at Rest) bằng thuật toán AES-256, và áp dụng cơ chế xác thực phân quyền dựa trên vai trò (RBAC) qua JWT.

4. Chi phí vận hành và bảo trì hàng tháng ước tính bao nhiêu?

Với quy mô xử lý 2.000 - 5.000 TPS trên hạ tầng điện toán đám mây công cộng (như AWS hoặc GCP), chi phí tài nguyên dao động từ 1.200 - 1.800 USD/tháng.

5. Cần bao lâu để cập nhật (Retrain) mô hình với dữ liệu gian lận mới?

Hệ thống thiết lập CI/CD Pipeline tự động retrain mô hình XGBoost hàng ngày (mất khoảng 25 phút) và retrain toàn phần mạng nơ-ron GAT hàng tuần (mất khoảng 3,5 giờ trên GPU NVIDIA A10G).

Kết luận

Đồ án đã giải quyết trọn vẹn bài toán phát hiện gian lận tài chính thời gian thực bằng việc dung hợp sáng tạo giữa kiến trúc phân tán hiện đại và các thuật toán học sâu đồ thị tiên tiến nhất. Kết quả thực nghiệm minh chứng hệ thống không chỉ đạt độ chính xác vượt trội (ROC-AUC 0.984) mà còn đáp ứng hoàn hảo các ràng buộc khắt khe về độ trễ ($p99 < 45\text{ms}$) và thông lượng cao ($> 5.000\text{ TPS}$). Đây là tiền đề vững chắc cho việc ứng dụng công nghệ AI chuyên sâu vào việc bảo vệ an toàn hệ thống thanh toán số tại Việt Nam.