Ứng dụng Machine Learning vào phát hiện gian lận và bất thường dữ liệu

Trong các hệ thống thanh toán FinTech, ngân hàng số, ví điện tử và sàn thương mại điện tử quy mô lớn năm 2026, một giao dịch chuyển tiền hoặc quẹt thẻ quốc tế chỉ có ngân sách thời gian vỏn vẹn từ 10 ms đến 25 ms để đi qua bộ máy đánh giá rủi ro (Real-Time Risk & Fraud Scoring Engine) trước khi trả về quyết định phê duyệt hay từ chối. Hệ thống quy tắc tĩnh truyền thống (Rule-Based Engine với hàng trăm mệnh đề IF amount > 50_000_000 AND country != 'VN') ngày càng bộc lộ sự bất lực: hoặc chặn nhầm hàng loạt khách hàng VIP hợp lệ đi công tác nước ngoài gây thiệt hại doanh thu (False Positives / Customer Insult Rate), hoặc bị các nhóm tội phạm mạng dễ dàng lách qua bằng cách chia nhỏ giao dịch dưới ngưỡng kiểm soát (Smurfing / Structuring Attacks).

Để xây dựng lá chắn phòng vệ thích ứng theo thời gian thực, giải pháp chuẩn công nghiệp là triển khai kiến trúc phát hiện gian lận bằng Machine Learning Isolation Forest XGBoost kết hợp hai tầng học máy bổ trợ lẫn nhau. Bài viết chuyên sâu này hướng dẫn từ gốc rễ toán học đến mã nguồn Production trên Python 3.13+: giải quyết nghịch lý độ chính xác trên tập dữ liệu mất cân bằng cực đoan (0.05% – 0.2% tỷ lệ gian lận) bằng PR-AUC (aucpr), thiết kế Feast + Redis Online Feature Store chống lệch dữ liệu huấn luyện – suy luận (Training-Serving Skew), kết hợp thuật toán không giám sát Isolation Forest (PyOD / scikit-learn 1.6+) với Cost-Sensitive XGBoost 2.1+, giải thích lý do từ chối giao dịch bằng SHAP TreeExplainer, biên dịch mô hình sang ONNX Runtime (< 2ms inference) và giám sát trôi dạt phân phối bằng chỉ số Population Stability Index (PSI).

---

1. Thách thức Cốt lõi của Bài toán Fraud Detection: Dữ liệu Mất cân bằng Cực đoan và Dịch chuyển Hành vi (Concept Drift)

Khác hoàn toàn với bài toán phân loại ảnh hay phân tích cảm xúc văn bản thông thường nơi các lớp dữ liệu có tỷ lệ cân bằng (50% / 50%), bài toán phát hiện gian lận tài chính và bất thường nhật ký bảo mật luôn đối mặt với hai đặc tính khắc nghiệt: Sự mất cân bằng lớp cực đoan (Extreme Class Imbalance) và Đối thủ tiến hóa liên tục (Adversarial Concept Drift).

flowchart LR
    TxEvent["Sự kiện Giao dịch (Kafka KRaft / Payment API)"] --> OnlineFS["Feast + Redis 7.4+ Online Feature Store (Velocity 5m/1h, Geo-Distance < 3ms)"]
    OnlineFS --> ONNXHybrid["ONNX Runtime Hybrid Engine: Isolation Forest Score + Cost-Sensitive XGBoost 2.1+"]
    ONNXHybrid --> Policy{"Chính sách Ngưỡng Chi phí 3 Tầng (tau_low, tau_high)"}
    Policy -->|"p < tau_low (An toàn)"| Approve["Auto-Approve (< 12ms SLA)"]
    Policy -->|"tau_low <= p < tau_high (Nghi vấn)"| StepUp["Yêu cầu Xác thực 3DS / Sinh trắc học + SHAP Reason Codes"]
    Policy -->|"p >= tau_high (Gian lận cao)"| Block["Auto-Block + Ghi Audit Log & Cảnh báo SOC"]
    Block --> DriftLoop["Giám sát PSI Drift & Cập nhật Nhãn Chargeback Trễ (30-60 ngày)"]

1.1. Nghịch lý độ chính xác (Accuracy Paradox) khi tỷ lệ gian lận chỉ chiếm 0.05% – 0.2% tổng giao dịch

Giả sử hệ thống thanh toán của bạn xử lý 1,000,000 giao dịch mỗi ngày, trong đó có 999,000 giao dịch hợp lệ ($y = 0$, lớp đa số âm tính) và đúng 1,000 giao dịch gian lận chiếm đoạt tài khoản ($y = 1$, tỷ lệ dương tính 0.1%). Nếu một lập trình viên thiếu kinh nghiệm viết một hàm giả (Dummy Classifier) luôn trả về y_pred = 0 (phê duyệt tất cả mọi giao dịch), mô hình vô dụng đó vẫn đạt Độ chính xác tổng thể (Accuracy) lên tới 99.90%, trong khi để lọt 100% thiệt hại gian lận!

Nguy hiểm hơn, ngay cả chỉ số ROC-AUC (Area Under the Receiver Operating Characteristic Curve) — vốn vẽ đường cong giữa $text{TPR} = frac{TP}{TP + FN}$ và $text{FPR} = frac{FP}{FP + TN}$ — cũng đánh lừa kỹ sư dữ liệu trên tập dữ liệu lệch:

• Giả sử mô hình bắt được $TP = 800$ vụ gian lận nhưng lại báo động giả tới $FP = 9,990$ khách hàng hợp lệ.
• Khi đó, mẫu số $FP + TN = 999,000$ quá khổng lồ khiến tỷ lệ báo động giả $text{FPR} = frac{9,990}{999,000} = 0.01$ (1%) trông cực kỳ nhỏ, đẩy điểm ROC-AUC lên trên 0.96!
• Nhưng nếu nhìn vào Độ chuẩn xác dương tính (Precision = $frac{TP}{TP + FP}$), giá trị thực tế chỉ đạt $frac{800}{800 + 9,990} = mathbf{7.41%}$ — tức là cứ 100 khách hàng bị khóa thẻ thì có tới hơn 92 người là khách hàng thật bị oan!

Chính như chứng minh toán học kinh điển của Saito & Rehmsmeier, khi thực hiện phát hiện gian lận bằng Machine Learning Isolation Forest XGBoost, thước đo đánh giá bắt buộc phải là PR-AUC (Area Under the Precision-Recall Curve / average_precision_score / eval_metric="aucpr") kết hợp chỉ số Recall tại mức Precision hoặc FPR cố định (ví dụ: Recall @ Precision >= 80%).

1.2. Kiến trúc Hybrid Ensemble 2 tầng: Kết hợp Unsupervised (Isolation Forest) và Supervised (XGBoost)

Tại sao không chỉ dùng một mô hình học có giám sát (Supervised Learning như XGBoost hay LightGBM) hoặc chỉ dùng một mô hình không giám sát (Unsupervised Anomaly Detection như Isolation Forest)?

1. Điểm mù của Supervised GBDT đơn lẻ: Mô hình có giám sát học rất giỏi các mẫu gian lận đã từng xảy ra trong quá khứ (dựa trên nhãn khiếu nại hoàn tiền Chargeback). Tuy nhiên, nhãn Chargeback trong ngân hàng thường có độ trễ từ 15 đến 60 ngày, và khi kẻ tấn công tung ra một kịch bản tấn công mới chưa từng có tiền lệ (Zero-Day Fraud Pattern hoặc bot tấn công khai thác lỗ hổng đã nêu trong bài bảo mật Web API theo tiêu chuẩn OWASP API Security Top 10), mô hình có giám sát chưa có nhãn dương tính để học nên sẽ bỏ lọt.
2. Điểm mù của Unsupervised Anomaly Detection đơn lẻ: Các thuật toán phát hiện ngoại lai không cần nhãn nhưng lại không phân biệt được giữa "bất thường độc hại" (tội phạm rút trộm tiền lúc 3 giờ sáng) và "bất thường hợp pháp" (khách hàng mua sắm đột biến dịp Black Friday), dẫn đến tỷ lệ báo động giả (False Positive) quá cao nếu dùng làm bộ quyết định trực tiếp.
3. Sức mạnh cộng hưởng của Kiến trúc Hybrid 2 tầng:
   • Tầng 1 (Unsupervised Outlier Detector): Cho tập vector đặc trưng đi qua mô hình Isolation Forest (hoặc tổ hợp ECOD/COPOD trong thư viện PyOD 2.0+) để tính ra điểm số dị biệt cấu trúc liên tục iforest_anomaly_score.
   • Tầng 2 (Supervised Cost-Sensitive Meta-Classifier): Nối cột iforest_anomaly_score này như một đặc trưng đầu vào bổ sung (Engineered Meta-Feature) cùng với các đặc trưng vận tốc giao dịch vào mô hình XGBoost 2.1+ có trọng số phạt chi phí. Nhờ đó, XGBoost vừa tận dụng được tri thức lịch sử chính xác, vừa có khả năng nhạy bén trước các điểm dữ liệu nằm lệch khỏi phân phối bình thường!

---

2. Kỹ thuật Feature Engineering Thời gian thực và Xử lý Imbalanced Data Không Rò rỉ (Zero Data Leakage)

Một giao dịch đơn lẻ chỉ chứa amount = 5,000,000 VND và merchant_category = "Electronics" hoàn toàn không đủ thông tin để kết luận gian lận. Tín hiệu phát hiện gian lận mạnh nhất luôn nằm ở bối cảnh lịch sử và vận tốc biến thiên theo thời gian thực (Real-Time Velocity & Behavioral Deviation Features).

2.1. Thiết kế nhóm đặc trưng Velocity, Behavioral Deviation và Graph/Device Fingerprint trên cửa sổ trượt

Để cung cấp đặc trưng đồng nhất giữa môi trường huấn luyện ngoại tuyến (Offline Training trên Parquet/PostgreSQL) và môi trường chấm điểm trực tuyến (Online Serving < 5ms trên Redis Cluster) mà không bị lệch công thức (Training-Serving Skew), các hệ thống MLOps hiện đại sử dụng kiến trúc Feature Store (Feast v0.40+) kết hợp luồng sự kiện từ kiến trúc Event-Driven với Apache Kafka và RabbitMQ để tính sẵn 4 nhóm đặc trưng cốt lõi:

Nhóm Đặc trưng (Feature Family)	Các Biến Kỹ thuật Điển hình	Cơ chế Lưu trữ & Truy xuất Thời gian thực (< 3ms)
1. Transaction Velocity (Vận tốc Giao dịch)	tx_count_5m, tx_count_1h, tx_amount_sum_1h, failed_pin_attempts_15m	Bộ đếm cửa sổ trượt nguyên tử trên Redis Sorted Set (ZADD / ZREMRANGEBYSCORE) hoặc Feast Online Store.
2. Behavioral Deviation (Độ lệch Hành vi Cá nhân)	amount_zscore_user_30d = (amt - mean_30d) / std_30d, ratio_to_max_historical_tx	Đối chiếu số tiền hiện tại với trung bình và độ lệch chuẩn 30 ngày của chính chủ thẻ đó.
3. Impossible Travel / Geo-Velocity (Vận tốc Địa lý)	geo_velocity_kmh (Khoảng cách Haversine $Delta d$ chia cho $Delta t$ giữa 2 giao dịch liên tiếp)	Nếu quẹt thẻ tại Hà Nội rồi 10 phút sau quẹt tại TP.HCM ($text{vận tốc} > 6,000text{ km/h}$ $>$ tốc độ máy bay) $implies$ Rủi ro cực đại!
4. Entity Link / Device Cardinality (Độ bội Thực thể)	distinct_cards_per_device_24h, distinct_accounts_per_ip_1h	Phát hiện một thiết bị giả lập hoặc một địa chỉ IP đang thử quẹt hàng chục thẻ tín dụng ăn cắp khác nhau.

# file: realtime_fraud_feature_extractor.py
# Runtime: Python 3.13+ | Tính toán Geo-Velocity (Haversine) & Z-Score lệch hành vi
from __future__ import annotations

from dataclasses import dataclass
import math

@dataclass(slots=True, frozen=True)
class TransactionContext:
    tx_id: str
    user_id: str
    amount_vnd: float
    timestamp_epoch: float
    lat: float
    lon: float
    # Thống kê lịch sử 30 ngày lấy từ Feast / Redis Online Feature Store
    user_mean_amount_30d: float
    user_std_amount_30d: float
    tx_count_last_5m: int
    distinct_cards_on_device_24h: int
    prev_tx_timestamp_epoch: float | None
    prev_tx_lat: float | None
    prev_tx_lon: float | None

def compute_haversine_km(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
    """Tính khoảng cách đường chim bay trên mặt cầu Trái Đất (km) bằng công thức Haversine."""
    earth_radius_km = 6371.0088
    phi1, phi2 = math.radians(lat1), math.radians(lat2)
    d_phi = math.radians(lat2 - lat1)
    d_lambda = math.radians(lon2 - lon1)

    a = (
        math.sin(d_phi / 2.0) ** 2
        + math.cos(phi1) * math.cos(phi2) * math.sin(d_lambda / 2.0) ** 2
    )
    return 2.0 * earth_radius_km * math.atan2(math.sqrt(a), math.sqrt(1.0 - a))

def build_realtime_feature_vector(ctx: TransactionContext) -> dict[str, float]:
    """Trích xuất vector đặc trưng thời gian thực trong < 0.2ms CPU."""
    # 1. Độ lệch chuẩn Z-Score so với thói quen chi tiêu 30 ngày của chính chủ tài khoản
    safe_std = max(ctx.user_std_amount_30d, 10_000.0)
    amount_zscore = (ctx.amount_vnd - ctx.user_mean_amount_30d) / safe_std

    # 2. Vận tốc di chuyển địa lý (km/h) kể từ giao dịch liền trước ("Impossible Travel")
    geo_velocity_kmh = 0.0
    if (
        ctx.prev_tx_timestamp_epoch is not None
        and ctx.prev_tx_lat is not None
        and ctx.prev_tx_lon is not None
    ):
        dist_km = compute_haversine_km(ctx.prev_tx_lat, ctx.prev_tx_lon, ctx.lat, ctx.lon)
        elapsed_hours = max((ctx.timestamp_epoch - ctx.prev_tx_timestamp_epoch) / 3600.0, 1.0 / 3600.0)
        geo_velocity_kmh = dist_km / elapsed_hours

    return {
        "amount_log1p": math.log1p(max(ctx.amount_vnd, 0.0)),
        "amount_zscore_30d": round(amount_zscore, 4),
        "tx_count_5m": float(ctx.tx_count_last_5m),
        "distinct_cards_device_24h": float(ctx.distinct_cards_on_device_24h),
        "geo_velocity_kmh": round(geo_velocity_kmh, 2),
    }

2.2. Chống rò rỉ dữ liệu (Data Leakage) với Temporal Split, SMOTETomek nội tuyến và Cost-Sensitive scale_pos_weight

Khi huấn luyện mô hình chống gian lận, có hai lỗi Rò rỉ Dữ liệu (Data Leakage) phổ biến làm điểm kiểm thử trong phòng thí nghiệm cao giả tạo nhưng mô hình sập hoàn toàn khi đưa lên Production:

1. Lỗi 1 — Dùng train_test_split ngẫu nhiên thay vì chia theo trục thời gian (Out-of-Time / Temporal Split): Nếu chia ngẫu nhiên, tập huấn luyện (Train) sẽ chứa các giao dịch gian lận diễn ra vào ngày 15/10 để dự đoán giao dịch trong tập kiểm thử (Test) diễn ra vào ngày 10/10 (du hành thời gian!). Bắt buộc phải chia theo mốc thời gian nghiêm ngặt: ví dụ dữ liệu tháng 1–8 làm Train, tháng 9 làm Validation (chọn ngưỡng), và tháng 10 làm Out-of-Time Test.
2. Lỗi 2 — Chạy SMOTE (Oversampling) trên toàn bộ tập dữ liệu trước khi chia Cross-Validation: Thuật toán SMOTE nội suy tạo điểm gian lận nhân tạo giữa các điểm láng giềng gần nhau. Nếu chạy SMOTE trước khi chia tách, các điểm nhân tạo trong tập Train sẽ được tổng hợp trực tiếp từ các điểm nằm trong tập Validation, làm rò rỉ thông tin nhãn sang tập đánh giá!
   • Giải pháp chuẩn: Đối với cây quyết định tăng cường độ dốc (XGBoost 2.1+), phương pháp hiệu quả và bảo toàn xác suất hiệu chỉnh (Probability Calibration) tốt nhất là không làm méo phân phối bằng SMOTE tràn lan, mà sử dụng tham số học nhạy chi phí scale_pos_weight = count(Negative) / count(Positive) kết hợp max_delta_step = 1 (giúp ổn định bước cập nhật Newton-Raphson khi tỷ lệ lớp quá lệch). Nếu sử dụng SMOTETomek, bắt buộc phải nhốt nó bên trong đối tượng imblearn.pipeline.Pipeline để chỉ áp dụng riêng trên từng Fold huấn luyện.

---

3. Giải phẫu Thuật toán Isolation Forest và Huấn luyện Mô hình Hybrid XGBoost 2.1+

3.1. Cơ sở toán học của Isolation Forest: Chiều dài đường đi trung bình $E(h(x))$ trên cây phân hoạch ngẫu nhiên (iTrees)

Khác với các thuật toán phát hiện bất thường dựa trên khoảng cách (k-NN, LOF) hay mật độ phải tính khoảng cách giữa mọi cặp điểm với độ phức tạp $O(N^2)$, thuật toán Isolation Forest (Liu, Ting & Zhou — IEEE ICDM) dựa trên một nguyên lý cực kỳ sắc sảo: Các điểm dữ liệu gian lận/bất thường có số lượng rất ít (Few) và có giá trị đặc trưng khác biệt (Different), do đó chúng bị "cô lập" rất nhanh chỉ sau vài nhát cắt ngẫu nhiên!

Một rừng cô lập bao gồm $T$ cây nhị phân ngẫu nhiên (Isolation Trees — iTrees, thường chọn n_estimators = 300), mỗi cây được xây dựng trên một mẫu con ngẫu nhiên kích thước $psi = 256$ (max_samples = 256) bằng cách chọn ngẫu nhiên một đặc trưng $q$ và một giá trị chia cắt $p$ nằm giữa $[min(q), max(q)]$:

• Một giao dịch bình thường nằm sâu trong đám đông dày đặc cần rất nhiều lần chia cắt mới bị tách riêng (chiều dài đường đi từ gốc tới lá $h(x)$ lớn).
• Một giao dịch gian lận nằm trơ trọi ở rìa không gian bị cô lập ngay gần nút gốc ($h(x)$ rất nhỏ).
• Điểm số bất thường chuẩn hóa $s(x, psi) in (0, 1]$ được định nghĩa chính xác bởi công thức:
  $$s(x, psi) = 2^{-frac{E(h(x))}{c(psi)}}, quad text{với } c(psi) = 2 H(psi - 1) - frac{2(psi - 1)}{psi}$$
  trong đó $H(i) approx ln(i) + 0.5772156649$ (hằng số Euler). Khi $E(h(x)) to 0$, điểm bất thường $s(x, psi) to 1.0$ (nghi ngờ gian lận cực cao); khi $s(x, psi) le 0.5$, điểm dữ liệu hoàn toàn bình thường.

3.2. Huấn luyện Hybrid Pipeline (Isolation Forest Anomaly Feature + Cost-Sensitive XGBoost hist) tối ưu hóa aucpr

Đoạn mã dưới đây triển khai toàn bộ pipeline huấn luyện kết hợp Isolation Forest (scikit-learn 1.6+) và Cost-Sensitive XGBoost 2.1+ (tree_method="hist", eval_metric="aucpr"), kèm bộ tối ưu hóa ngưỡng quyết định 3 tầng theo Ma trận Chi phí Tài chính thực tế:

# file: train_hybrid_iforest_xgboost_fraud.py
# Runtime: Python 3.13+ | Dependencies: scikit-learn>=1.6.0, xgboost>=2.1.0, numpy>=2.1.0
from __future__ import annotations

import numpy as np
from sklearn.ensemble import IsolationForest
from sklearn.metrics import average_precision_score, precision_recall_curve
from xgboost import XGBClassifier

def augment_with_isolation_forest_score(
    X_train: np.ndarray,
    X_val: np.ndarray,
) -> tuple[IsolationForest, np.ndarray, np.ndarray]:
    """
    Huấn luyện Isolation Forest CHỈ trên X_train (Zero Data Leakage),
    sau đó trích xuất điểm bất thường làm đặc trưng thứ (D+1) cho XGBoost.
    """
    iforest = IsolationForest(
        n_estimators=300,
        max_samples=256,
        contamination="auto",
        n_jobs=-1,
        random_state=2026,
    )
    iforest.fit(X_train)

    # Đảo dấu decision_function để điểm càng cao = mức độ bất thường càng lớn
    train_anom_score = (-iforest.score_samples(X_train)).reshape(-1, 1)
    val_anom_score = (-iforest.score_samples(X_val)).reshape(-1, 1)

    X_train_hybrid = np.hstack([X_train, train_anom_score])
    X_val_hybrid = np.hstack([X_val, val_anom_score])
    return iforest, X_train_hybrid, X_val_hybrid

def find_optimal_financial_threshold(
    y_true: np.ndarray,
    y_prob: np.ndarray,
    tx_amounts: np.ndarray,
    false_positive_insult_cost: float = 15.0,
    chargeback_fee: float = 25.0,
) -> tuple[float, float]:
    """
    Tìm ngưỡng xác suất p* tối thiểu hóa Tổng Thiệt Hại Tài Chính Bằng Tiền:
    - False Negative (Bỏ lọt gian lận): Mất 100% giá trị giao dịch + phí phạt Chargeback.
    - False Positive (Chặn nhầm khách thật): Mất chi phí hỗ trợ CSKH & lợi nhuận đơn hàng.
    """
    candidate_thresholds = np.linspace(0.05, 0.95, 181)
    best_threshold = 0.50
    min_total_cost = float("inf")

    for tau in candidate_thresholds:
        preds = (y_prob >= tau).astype(int)
        fn_mask = (y_true == 1) & (preds == 0)
        fp_mask = (y_true == 0) & (preds == 1)

        fn_loss = float(np.sum(tx_amounts[fn_mask]) + np.sum(fn_mask) * chargeback_fee)
        fp_loss = float(np.sum(fp_mask) * false_positive_insult_cost)
        total_cost = fn_loss + fp_loss

        if total_cost < min_total_cost:
            min_total_cost = total_cost
            best_threshold = float(tau)

    return round(best_threshold, 4), round(min_total_cost, 2)

def train_hybrid_fraud_pipeline(
    X_train: np.ndarray,
    y_train: np.ndarray,
    X_val: np.ndarray,
    y_val: np.ndarray,
    val_amounts: np.ndarray,
) -> tuple[IsolationForest, XGBClassifier, float]:
    iforest, X_tr_hyb, X_va_hyb = augment_with_isolation_forest_score(X_train, X_val)

    # Tính tỷ lệ mất cân bằng lớp để cấu hình Cost-Sensitive Gradient Boosting
    neg_count = int(np.sum(y_train == 0))
    pos_count = max(int(np.sum(y_train == 1)), 1)
    imbalance_ratio = neg_count / pos_count

    xgb_model = XGBClassifier(
        n_estimators=600,
        max_depth=6,
        learning_rate=0.03,
        subsample=0.8,
        colsample_bytree=0.8,
        tree_method="hist",
        scale_pos_weight=imbalance_ratio,
        max_delta_step=1,          # Ổn định hội tụ Newton step khi dữ liệu lệch 1:1000
        eval_metric="aucpr",       # Tối ưu trực tiếp diện tích dưới đường cong Precision-Recall
        early_stopping_rounds=40,
        n_jobs=-1,
        random_state=2026,
    )

    xgb_model.fit(
        X_tr_hyb,
        y_train,
        eval_set=[(X_va_hyb, y_val)],
        verbose=False,
    )

    val_probs = xgb_model.predict_proba(X_va_hyb)[:, 1]
    pr_auc = average_precision_score(y_val, val_probs)
    opt_tau, min_cost = find_optimal_financial_threshold(y_val, val_probs, val_amounts)

    print(f"[Validation] PR-AUC = {pr_auc:.4f} | Optimal Cost Threshold tau* = {opt_tau} (Min Loss = ${min_cost:,.2f})")
    return iforest, xgb_model, opt_tau

---

4. Tối ưu Ngưỡng Quyết định theo Ma trận Chi phí Tài chính và Giải thích Mô hình với SHAP

sequenceDiagram
    autonumber
    participant PaymentGW as Payment Gateway (REST API)
    participant RiskAPI as Fraud Scoring Service (FastAPI 0.115+)
    participant RedisFeat as Redis 7.4+ Velocity Store
    participant ONNXEngine as ONNX Runtime (IForest + XGBoost)
    participant CaseQueue as SOC / Step-Up Auth Queue

    PaymentGW->>RiskAPI: POST /v1/risk/evaluate (tx_id, user_id, amount, lat/lon)
    RiskAPI->>RedisFeat: Pipeline GET stats_30d + ZCOUNT tx_5m (< 1.5ms)
    RedisFeat-->>RiskAPI: Trả về các bộ đếm cửa sổ trượt & tọa độ giao dịch trước
    RiskAPI->>ONNXEngine: Chấm điểm Hybrid Feature Vector trên CPU (< 1.2ms)
    ONNXEngine-->>RiskAPI: Trả về xác suất gian lận p = 0.84
    RiskAPI->>RiskAPI: Tính SHAP TreeExplainer Reason Codes (< 1.8ms)
    RiskAPI->>CaseQueue: Đẩy sự kiện cảnh báo kèm Top-3 SHAP Reasons (GEO_VELOCITY, ZSCORE)
    RiskAPI-->>PaymentGW: HTTP 200 OK {decision: "BLOCK", risk_score: 0.84, reasons: [...]}

4.1. Tìm ngưỡng xác suất tối ưu ($p^*$) cực tiểu hóa Tổng thiệt hại Tài chính (Chargeback Loss vs False Decline Friction)

Một sai lầm phổ biến là dùng cứng ngưỡng mặc định 0.50 của hàm .predict(). Trong hệ thống ngân hàng và thương mại điện tử thực tế, chi phí của hai loại sai lầm hoàn toàn bất đối xứng:

• Bỏ lọt 1 giao dịch gian lận (False Negative): Ngân hàng mất trắng giá trị giao dịch (ví dụ $800) cộng thêm phí phạt Chargeback từ tổ chức thẻ Visa/Mastercard ($25).
• Chặn nhầm 1 giao dịch hợp lệ (False Positive): Mất phí hoa hồng giao dịch và gây ức chế cho khách hàng (~$10 – $20).

Do đó, thay vì trả kết quả nhị phân cứng nhắc, kiến trúc Risk Engine chuẩn doanh nghiệp thiết lập Chính sách Quyết định 3 Dải (3-Band Risk Policy):

1. Dải Xanh (p < tau_low, ví dụ p < 0.18 — ~96% lưu lượng): Phê duyệt tự động tức thì (AUTO_APPROVE) không gây bất kỳ ma sát nào cho người dùng.
2. Dải Vàng (tau_low <= p < tau_high, ví dụ 0.18 <= p < 0.72 — ~3.5% lưu lượng): Kích hoạt xác thực bổ sung thích ứng (Step-Up Authentication như yêu cầu quét khuôn mặt sinh trắc học eKYC, mã Smart OTP / 3D-Secure 2.2) hoặc đẩy vào hàng đợi thẩm định nhanh.
3. Dải Đỏ (p >= tau_high, ví dụ p >= 0.72 — ~0.5% lưu lượng): Từ chối giao dịch tự động (AUTO_BLOCK) và đóng băng tạm thời phiên giao dịch.

4.2. Trích xuất mã lý do từ chối (Reason Codes) bằng SHAP TreeExplainer tuân thủ quy định kiểm toán ngân hàng

Theo quy định kiểm toán rủi ro của Ngân hàng Nhà nước và các tiêu chuẩn tài chính quốc tế, khi hệ thống AI từ chối một giao dịch hoặc khóa thẻ của khách hàng, bạn không được phép chỉ trả lời "Mô hình báo điểm 0.89" (Black-Box Decision). Hệ thống bắt buộc phải xuất ra Mã lý do giải thích (Adverse Action Reason Codes) chỉ rõ những đặc trưng nào đã đẩy điểm rủi ro của giao dịch đó tăng vọt.

Thuật toán SHAP TreeExplainer (Lundberg & Lee) tính toán chính xác giá trị Shapley lý thuyết trò chơi trên cây quyết định XGBoost trong thời gian đa thức (< 2 ms cho một giao dịch đơn lẻ), cho biết chính xác mức đóng góp $phi_i$ (theo đơn vị log-odds) của từng đặc trưng vào quyết định cuối cùng:

# file: shap_fraud_reason_codes.py
# Runtime: Python 3.13+ | Dependencies: shap>=0.46.0, xgboost>=2.1.0
from __future__ import annotations

import numpy as np
import shap
from xgboost import XGBClassifier

FEATURE_REASON_CODE_MAP: dict[str, str] = {
    "amount_log1p": "HIGH_TRANSACTION_VALUE",
    "amount_zscore_30d": "ABNORMAL_SPENDING_SPIKE_VS_30D_HISTORY",
    "tx_count_5m": "EXCESSIVE_TRANSACTION_VELOCITY_5M",
    "distinct_cards_device_24h": "MULTIPLE_CARDS_ON_SINGLE_DEVICE",
    "geo_velocity_kmh": "IMPOSSIBLE_GEO_TRAVEL_VELOCITY",
    "iforest_anomaly_score": "ZERO_DAY_STRUCTURAL_OUTLIER_DETECTED",
}

class FraudExplainabilityEngine:
    def __init__(self, model: XGBClassifier, feature_names: list[str]) -> None:
        self._explainer = shap.TreeExplainer(model)
        self._feature_names = feature_names

    def explain_single_transaction(
        self,
        feature_row: np.ndarray,
        top_k: int = 3,
    ) -> list[dict[str, object]]:
        """
        Trích xuất Top-K lý do đẩy xác suất gian lận tăng cao nhất cho 1 giao dịch.
        Thực thi trong ~1.5ms phục vụ trực tiếp phản hồi API và SOC Dashboard.
        """
        shap_values = self._explainer.shap_values(feature_row.reshape(1, -1))[0]
        # Sắp xếp các đặc trưng có đóng góp dương lớn nhất vào nguy cơ gian lận
        top_indices = np.argsort(shap_values)[::-1][:top_k]

        reasons: list[dict[str, object]] = []
        for idx in top_indices:
            impact = float(shap_values[idx])
            if impact <= 0:
                continue
            fname = self._feature_names[int(idx)]
            reasons.append({
                "reason_code": FEATURE_REASON_CODE_MAP.get(fname, fname.upper()),
                "feature_name": fname,
                "observed_value": round(float(feature_row[int(idx)]), 4),
                "shap_log_odds_impact": round(impact, 4),
            })
        return reasons

---

5. Kiến trúc Chấm điểm Thời gian thực (< 15ms SLA) với ONNX Runtime, Redis và Giám sát Data Drift (PSI)

Khi đưa dịch vụ chấm điểm gian lận vào luồng thanh toán trực tuyến — kết hợp cùng hợp đồng thiết kế RESTful API chuẩn Enterprise và quản lý phiên bản API và chốt chặn chống trừ tiền kép tại bài thiết kế kiến trúc Distributed Locking và Idempotency Key với Redis và PostgreSQL — việc gọi trực tiếp scikit-learn và xgboost qua lớp vỏ Python cho từng giao dịch đơn lẻ (batch_size = 1) thường chịu chi phí kiểm tra kiểu của Pandas/NumPy và khóa GIL.

5.1. Biên dịch mô hình sang ONNX Runtime và kết nối Redis Online Feature Store phục vụ hàng chục nghìn TPS

Giải pháp chuẩn Production để giảm độ trễ suy luận từ ~15ms xuống dưới 1.0 ms là xuất đồ thị cây quyết định sang chuẩn mở ONNX (Open Neural Network Exchange) bằng onnxmltools / skl2onnx và thực thi trên nhân C++ của onnxruntime 1.20+ (nhả hoàn toàn GIL và tận dụng tập lệnh vector hóa AVX-512):

# file: onnx_low_latency_fraud_scorer.py
# Runtime: Python 3.13+ | Dependencies: onnxruntime>=1.20.0, fastapi>=0.115.0
from __future__ import annotations

import time
import numpy as np
import onnxruntime as ort

class ONNXRealtimeFraudScorer:
    """
    Bộ chấm điểm gian lận độ trễ siêu thấp (< 1ms) trên ONNX Runtime C++ Execution Provider.
    """

    def __init__(self, onnx_model_path: str, tau_low: float = 0.18, tau_high: float = 0.72) -> None:
        sess_options = ort.SessionOptions()
        sess_options.intra_op_num_threads = 2
        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

        self._session = ort.InferenceSession(
            onnx_model_path,
            sess_options=sess_options,
            providers=["CPUExecutionProvider"],
        )
        self._input_name = self._session.get_inputs()[0].name
        self._tau_low = tau_low
        self._tau_high = tau_high

    def evaluate_transaction(self, features_fp32: np.ndarray) -> dict[str, object]:
        t0 = time.perf_counter_ns()
        input_tensor = features_fp32.astype(np.float32).reshape(1, -1)
        outputs = self._session.run(None, {self._input_name: input_tensor})

        # outputs[1] chứa mảng xác suất lớp [prob_legit, prob_fraud]
        fraud_prob = float(outputs[1][0][1])
        latency_ms = (time.perf_counter_ns() - t0) / 1_000_000.0

        if fraud_prob >= self._tau_high:
            decision = "AUTO_BLOCK"
        elif fraud_prob >= self._tau_low:
            decision = "STEP_UP_3DS_AUTH"
        else:
            decision = "AUTO_APPROVE"

        return {
            "decision": decision,
            "fraud_probability": round(fraud_prob, 5),
            "inference_latency_ms": round(latency_ms, 3),
        }

5.2. Phát hiện suy thoái mô hình (Model Decay) bằng chỉ số Population Stability Index (PSI) và Feedback Loop

Hành vi tiêu dùng của khách hàng và thủ đoạn của kẻ gian thay đổi theo từng tuần (dịp Tết, mùa du lịch, chiến dịch khuyến mãi lớn). Nếu phân phối điểm dự đoán hoặc phân phối đặc trưng đầu vào trôi dạt (Data / Concept Drift) mà không được phát hiện, tỷ lệ chặn nhầm sẽ tăng đột biến.

Chỉ số tiêu chuẩn trong ngành tài chính ngân hàng để đo lường mức độ dịch chuyển phân phối giữa tập dữ liệu chuẩn lúc huấn luyện ($P$ — Expected Baseline) và dữ liệu thực tế trên Production ($Q$ — Actual Production) chia theo $B = 10$ khoảng phân vị (Decile Bins) là Population Stability Index (PSI):

$$text{PSI} = sum_{i=1}^{B} left( P_i - Q_i right) times lnleft( frac{P_i}{Q_i} right)$$

• PSI < 0.10: Phân phối ổn định, mô hình hoạt động bình thường.
• 0.10 <= PSI < 0.25: Cảnh báo dịch chuyển nhẹ, cần theo dõi sát tỷ lệ Step-Up Auth.
• PSI >= 0.25: Báo động đỏ (Critical Drift) — Phân phối dữ liệu đã thay đổi căn bản; hệ thống MLOps phải tự động kích hoạt đường ống huấn luyện lại (Automated Retraining Pipeline) trên tập dữ liệu mới nhất!

# file: psi_drift_monitor.py
# Runtime: Python 3.13+ | Giám sát độ trôi phân phối Population Stability Index (PSI)
from __future__ import annotations

import numpy as np

def calculate_psi(
    expected_baseline: np.ndarray,
    actual_production: np.ndarray,
    num_bins: int = 10,
    eps: float = 1e-4,
) -> dict[str, object]:
    """
    Tính chỉ số Population Stability Index (PSI) trên 10 phân vị (Deciles)
    để phát hiện sớm hiện tượng Data Drift / Concept Drift trên Production.
    """
    quantiles = np.linspace(0, 100, num_bins + 1)
    bin_edges = np.percentile(expected_baseline, quantiles)
    bin_edges[0] = -np.inf
    bin_edges[-1] = np.inf

    expected_counts, _ = np.histogram(expected_baseline, bins=bin_edges)
    actual_counts, _ = np.histogram(actual_production, bins=bin_edges)

    p = np.clip(expected_counts / max(len(expected_baseline), 1), eps, 1.0)
    q = np.clip(actual_counts / max(len(actual_production), 1), eps, 1.0)

    psi_value = float(np.sum((p - q) * np.log(p / q)))
    if psi_value >= 0.25:
        status = "CRITICAL_DRIFT_RETRAIN_REQUIRED"
    elif psi_value >= 0.10:
        status = "MODERATE_DRIFT_WARNING"
    else:
        status = "STABLE"

    return {"psi": round(psi_value, 4), "status": status}

if __name__ == "__main__":
    rng = np.random.default_rng(2026)
    baseline_scores = rng.beta(a=1.2, b=15.0, size=50_000)
    drifted_scores = rng.beta(a=2.0, b=10.0, size=10_000)
    print(calculate_psi(baseline_scores, drifted_scores))

---

6. Checklist Nghiệm thu Hệ thống Chống Gian lận & Tài liệu Tham khảo Chuẩn Kỹ thuật

6.1. Bảng kiểm toán 8 tiêu chí cho hệ thống Fraud & Anomaly Detection trước khi đưa vào vận hành

STT	Hạng mục Kiểm toán	Tiêu chuẩn Nghiệm thu Production (Pass Criteria)
1	Phân tách Tập dữ liệu	Bắt buộc dùng Temporal Split (Out-of-Time); cấm tuyệt đối dùng train_test_split ngẫu nhiên.
2	Chống Rò rỉ Đặc trưng	Sử dụng Point-in-Time Join (AS OF timestamp) trong Feast; không để lọt thông tin tương lai vào vector huấn luyện.
3	Thước đo Đánh giá	Tối ưu hóa theo PR-AUC (aucpr) và Recall @ FPR <= 0.5%, không bao giờ đánh giá bằng Accuracy đơn thuần.
4	Kiến trúc Mô hình Lai	Kết hợp điểm bất thường không giám sát (IsolationForest / PyOD) với XGBoost nhạy chi phí (scale_pos_weight).
5	Tối ưu Ngưỡng Tài chính	Chọn ngưỡng $(tau{text{low}}, tau{text{high}})$ cực tiểu hóa hàm tổng chi phí Chargeback + False Decline.
6	Khả năng Giải thích (XAI)	Mọi giao dịch bị chặn (AUTO_BLOCK) đều đính kèm Top-3 mã lý do trích xuất từ SHAP TreeExplainer.
7	Độ trễ Suy luận Trực tuyến	Biên dịch sang ONNX Runtime kết hợp Redis Online Store đảm bảo độ trễ p99 < 15 ms.
8	Giám sát Trôi dạt Mô hình	Tính toán tự động chỉ số PSI hàng ngày; kích hoạt cảnh báo huấn luyện lại khi PSI >= 0.25.

6.2. Chiến lược triển khai Shadow Mode và Champion-Challenger trước khi bật chặn tự động

Khi phát hành một phiên bản mô hình chống gian lận mới (Challenger Model), không bao giờ thay thế trực tiếp mô hình đang chạy (Champion Model) ngay lập tức. Hãy chạy mô hình mới ở chế độ Shadow Mode (nhận bản sao lưu lượng giao dịch thật theo thời gian thực, ghi điểm dự đoán vào Kafka/ClickHouse nhưng không tác động đến quyết định thanh toán) trong tối thiểu 14 ngày để kiểm chứng độ trễ p99 và tỷ lệ báo động giả trước khi chuyển dần 5% -> 25% -> 100% lưu lượng.

6.3. Tài liệu tham khảo & Nguồn chuẩn kỹ thuật (Primary Technical References)

1. Liu, Ting & Zhou — Isolation Forest (IEEE International Conference on Data Mining / ICDM Official Paper)
2. Chen & Guestrin — XGBoost: A Scalable Tree Boosting System (ACM SIGKDD / arXiv:1603.02754)
3. Saito & Rehmsmeier — The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE)
4. Lundberg & Lee — A Unified Approach to Interpreting Model Predictions (SHAP Official Paper, NeurIPS / arXiv:1705.07874)
5. Scikit-Learn Official Documentation — Novelty and Outlier Detection (sklearn.ensemble.IsolationForest)
6. XGBoost Official Documentation — Handle Imbalanced Dataset (scale_pos_weight, max_delta_step, aucpr)
7. Feast Official Documentation — Point-in-Time Joins & Redis Online Feature Store Architecture