ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Huấn luyện & Alignment

AI Researcher

Bền vững trước tấn công — AI không dễ bị lừa

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Khả năng của mô hình AI duy trì hiệu suất chính xác khi đối mặt với dữ liệu đầu vào bị thao túng có chủ đích.

lesson98 minHuấn luyện & AlignmentAI Researcher

Dự đoán

Bạn thêm nhiễu CỰC NHỎ (mắt người không thấy) vào ảnh con mèo. AI nhận dạng sẽ thế nào?

Nghe khó tin nhưng đúng! Adversarial perturbation nhỏ đến mức mắt người KHÔNG THỂ phân biệt, nhưng được thiết kế theo gradient để đẩy dự đoán lệch HOÀN TOÀN. Ảnh con mèo có thể bị nhận thành máy bay, chó, hoặc bất cứ gì kẻ tấn công muốn — và mô hình vẫn tự tin cao vào câu trả lời sai!

Công thức FGSM

Công thức: x′=x+ϵ⋅sign(∇xL)x' = x + \epsilon \cdot \text{sign}(\nabla_x \mathcal{L})

Nhiễu đối kháng được cộng vào ảnh gốc. Khi ε ≈ 0.01, mắt người hoàn toàn không phân biệt được x và x′, nhưng mô hình không có adversarial training thường đã bắt đầu lật nhãn từ ε ≈ 0.035.

Khoảnh khắc A-ha

Adversarial attack không phải thêm nhiễu ngẫu nhiên — nó là nhiễu được thiết kế có mục đích dựa trên gradient. AI nhìn theo hàng nghìn chiều trong không gian feature — nhiễu nhỏ ở mỗi chiều cộng lại đủ để đẩy quyết định vượt qua ranh giới phân loại. Với người, ảnh không đổi; với mô hình, feature vector đã dịch chuyển xa.

Hiểu FGSM

Nếu dùng gradient đầy đủ, nhiễu ở pixel có gradient lớn sẽ rất rõ (nhìn thấy được), còn pixel gradient nhỏ gần như không đổi. sign() chuẩn hoá tất cả về ±1 — mọi pixel đóng góp đều nhau, nhiễu phân bố đều và khó phát hiện hơn.

Về mặt tối ưu hoá: sign(∇) là nghiệm chính xác của bài toán cực đại hoá linear approximation của loss dưới ràng buộc L∞. Đó là lý do FGSM là attack L∞ "tự nhiên" nhất.

Nếu đổi sang L2 ball, ta dùng gradient đã chuẩn hoá L2 thay vì sign. Họ tấn công rộng lớn (FGM, PGD-L2, CW-L2) xoay quanh lựa chọn norm này.

Thử thách nhanh

Xe tự lái dùng camera nhận dạng biển báo giao thông. Kẻ xấu dán sticker nhỏ lên biển 'DỪNG LẠI' khiến AI đọc thành 'Tốc độ 120 km/h'. Hậu quả nguy hiểm nhất là gì?

Đây là ví dụ kinh điển về physical adversarial attack: sticker nhỏ (mắt người vẫn đọc được 'DỪNG LẠI') nhưng AI đọc sai hoàn toàn. Đây là lý do adversarial robustness là BẮT BUỘC cho AI safety-critical: xe tự lái, y tế, an ninh. Eykholt et al. (2018) đã chứng minh attack này hoạt động ngoài đời thực.

Lý thuyết

Adversarial Robustness là khả năng AI duy trì dự đoán chính xác khi đầu vào bị thao túng có chủ đích. Khái niệm liên quan chặt chẽ tới red-teaming (tìm lỗ hổng chủ động) và guardrails (hàng rào bảo vệ đầu ra), và là một mảnh ghép trung tâm của alignment.

Phương trình PGD nhìn như FGSM lặp lại:

xt+1=ΠB(x,ϵ)(xt+α⋅sign(∇xL(θ,xt,y)))x^{t+1} = \Pi_{\mathcal{B}(x, \epsilon)}\left(x^t + \alpha \cdot \text{sign}(\nabla_x \mathcal{L}(\theta, x^t, y))\right)

ΠB\Pi_{\mathcal{B}} là phép chiếu về epsilon-ball quanh x; α\alpha là step size (thường ε/10); sau K bước, nhiễu không vượt quá ε.

Adversarial training giải bài toán hai cấp:

min⁡θ  E(x,y)[max⁡∥δ∥∞≤ϵL(θ,x+δ,y)]\min_{\theta} \; \mathbb{E}_{(x,y)}\left[\max_{\|\delta\|_\infty \le \epsilon} \mathcal{L}(\theta, x+\delta, y)\right]

Vòng trong (max) là attack — tìm nhiễu tồi tệ nhất. Vòng ngoài (min) là training — cập nhật trọng số để robust với nhiễu đó. Xấp xỉ vòng trong bằng PGD K-bước → được gọi là PGD adversarial training.

Code và physical attacks

fgsm_pgd_with_cleverhans.py

"""Adversarial attacks & training — PyTorch + CleverHans.

CleverHans (https://github.com/cleverhans-lab/cleverhans) là thư viện
chuẩn cho adversarial ML. Ở đây ta kết hợp CleverHans cho attack +
PyTorch training loop cho defense.
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from cleverhans.torch.attacks.fast_gradient_method import fast_gradient_method
from cleverhans.torch.attacks.projected_gradient_descent import projected_gradient_descent


# ---------------------------------------------------------------------
# 1. Attacks
# ---------------------------------------------------------------------

def fgsm_attack(model: nn.Module, x: torch.Tensor, y: torch.Tensor, eps: float = 0.03):
    """1 bước FGSM — rẻ, hữu ích làm baseline."""
    model.eval()
    # CleverHans API: fast_gradient_method(model, x, eps, norm, ...)
    x_adv = fast_gradient_method(
        model_fn=model,
        x=x,
        eps=eps,
        norm=float("inf"),
        y=y,
        targeted=False,
    )
    return x_adv.detach()


def pgd_attack(model: nn.Module, x: torch.Tensor, y: torch.Tensor,
               eps: float = 0.03, alpha: float = 0.007, steps: int = 10):
    """PGD-K — attack chuẩn để đo robustness."""
    model.eval()
    x_adv = projected_gradient_descent(
        model_fn=model,
        x=x,
        eps=eps,
        eps_iter=alpha,
        nb_iter=steps,
        norm=float("inf"),
        y=y,
        targeted=False,
        rand_init=True,       # khởi tạo ngẫu nhiên trong ball → mạnh hơn
        sanitize=True,
    )
    return x_adv.detach()


# ---------------------------------------------------------------------
# 2. Adversarial training loop (Madry-style)
# ---------------------------------------------------------------------

def train_robust(
    model: nn.Module,
    loader: DataLoader,
    optimizer: torch.optim.Optimizer,
    device: torch.device,
    eps: float = 0.03,
    steps: int = 7,
    clean_weight: float = 0.5,
):
    model.train()
    for x, y in loader:
        x, y = x.to(device), y.to(device)

        # (a) Sinh adversarial batch — mỗi step train đều có attack mới
        x_adv = pgd_attack(model, x, y, eps=eps, alpha=eps/4, steps=steps)
        model.train()  # pgd_attack gọi model.eval()

        # (b) Loss kết hợp clean + adversarial
        logits_clean = model(x)
        logits_adv = model(x_adv)
        loss = (
            clean_weight * F.cross_entropy(logits_clean, y)
            + (1 - clean_weight) * F.cross_entropy(logits_adv, y)
        )

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()


# ---------------------------------------------------------------------
# 3. Đánh giá robustness
# ---------------------------------------------------------------------

@torch.no_grad()
def clean_accuracy(model, loader, device):
    model.eval()
    correct, total = 0, 0
    for x, y in loader:
        x, y = x.to(device), y.to(device)
        correct += (model(x).argmax(1) == y).sum().item()
        total += y.size(0)
    return correct / total


def pgd_accuracy(model, loader, device, eps=0.03, steps=20):
    """Robust accuracy — dùng PGD mạnh (nhiều bước) để đánh giá."""
    model.eval()
    correct, total = 0, 0
    for x, y in loader:
        x, y = x.to(device), y.to(device)
        x_adv = pgd_attack(model, x, y, eps=eps, alpha=eps/10, steps=steps)
        with torch.no_grad():
            correct += (model(x_adv).argmax(1) == y).sum().item()
        total += y.size(0)
    return correct / total


# Thông thường: clean_acc giảm 1-3%, robust_acc tăng từ ~0% → 45-60%.

Đoạn code dưới đây là demo tối thiểu: tải một mô hình CNN đã train, tấn công bằng FGSM + PGD từ CleverHans, và đo accuracy trước/sau.

demo_cleverhans_attack.py

"""Demo: Tấn công một mô hình CIFAR-10 đã train bằng CleverHans.

Chạy: python demo_cleverhans_attack.py
Kết quả mong đợi: clean_acc ≈ 0.92, fgsm_acc ≈ 0.15, pgd_acc ≈ 0.02
                  (nếu mô hình KHÔNG được adversarial training)
"""
import torch
import torchvision as tv
from cleverhans.torch.attacks.fast_gradient_method import fast_gradient_method
from cleverhans.torch.attacks.projected_gradient_descent import projected_gradient_descent

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 1. Tải CIFAR-10 test set
mean = torch.tensor([0.4914, 0.4822, 0.4465])
std = torch.tensor([0.2470, 0.2435, 0.2616])
transform = tv.transforms.Compose([
    tv.transforms.ToTensor(),
    tv.transforms.Normalize(mean, std),
])
testset = tv.datasets.CIFAR10(root="./data", train=False, download=True, transform=transform)
loader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False)

# 2. Tải mô hình — ví dụ ResNet-18 từ torchvision hub
model = torch.hub.load("chenyaofo/pytorch-cifar-models",
                       "cifar10_resnet20", pretrained=True).to(device)
model.eval()

# 3. Hàm đánh giá
def eval_attack(attack_fn, name: str):
    correct, total = 0, 0
    for x, y in loader:
        x, y = x.to(device), y.to(device)
        x_adv = attack_fn(x, y) if attack_fn is not None else x
        with torch.no_grad():
            pred = model(x_adv).argmax(1)
        correct += (pred == y).sum().item()
        total += y.size(0)
    acc = correct / total
    print(f"{name:>10s}  accuracy = {acc:.4f}")
    return acc

# 4. Clean
eval_attack(None, "clean")

# 5. FGSM — 1 bước
eval_attack(
    lambda x, y: fast_gradient_method(model, x, 8/255, float("inf"), y=y),
    "FGSM",
)

# 6. PGD-20 — chuẩn công bố
eval_attack(
    lambda x, y: projected_gradient_descent(
        model, x,
        eps=8/255, eps_iter=2/255, nb_iter=20,
        norm=float("inf"), y=y, rand_init=True,
    ),
    "PGD-20",
)

# 7. AutoAttack (nếu cài autoattack pip package)
# from autoattack import AutoAttack
# aa = AutoAttack(model, norm="Linf", eps=8/255, version="standard")
# x_adv = aa.run_standard_evaluation(x, y)

White-box, black-box và gray-box

Khi đánh giá robustness, ta phân loại theo mức quyền truy cập của kẻ tấn công:

  • White-box: kẻ tấn công biết toàn bộ kiến trúc, trọng số, và gradient. FGSM / PGD / CW đều là white-box. Kịch bản tệ nhất — dùng để đánh giá upper bound.
  • Black-box: chỉ truy vấn qua API, không biết nội tại mô hình. Dùng Square Attack, NES, transfer attack. Thực tế hơn nhưng vẫn hiệu quả đáng sợ.
  • Gray-box: biết kiến trúc nhưng không biết trọng số, hoặc có query limit. Tấn công qua transferability: train surrogate model, attack surrogate, transfer lên target.

Transferability là hiện tượng đáng lo ngại: adversarial examples tạo cho mô hình A thường lừa được cả mô hình B có kiến trúc khác. Đây là lý do ensemble đơn thuần không đủ — cần ensemble đa dạng (khác kiến trúc, khác data augmentation, khác training objective).

Obfuscated gradients

Athalye et al. (2018) đã phân tích 9 defense tại ICLR 2018 và phá 7 trong số đó. Nguyên nhân chung: các defense làm gradient khó tính (shattered, stochastic, vanishing) khiến white-box attack trông như thất bại — nhưng adaptive attack (BPDA, EOT) vượt qua được.

Bài học: khi báo cáo robust accuracy, phải dùng adaptive attack — attack biết defense là gì và tuỳ biến theo nó. Chuẩn đánh giá hiện tại: AutoAttack (Croce & Hein, 2020) — ensemble 4 attack mạnh.

Nếu defense của bạn chỉ đánh giá với FGSM default, con số có thể sai đến 50% (theo nguồn bài, chưa kiểm chứng). Luôn dùng PGD-50 + AutoAttack.

Trade-off và phòng thủ nhiều lớp

Thử thách phòng thủ

Một startup Việt Nam triển khai AI nhận dạng chữ ký cho ngân hàng. Họ đo clean accuracy 99%. Bạn là security reviewer — đâu là yêu cầu BẮT BUỘC?

Clean accuracy 99%, robust accuracy chưa đo. Bạn đề xuất gì trước khi triển khai?

Clean accuracy 99% vô nghĩa cho ứng dụng an ninh nếu robust accuracy = 0%. Kẻ xấu chỉ cần FGSM ε=0.01 là đã lật được dự đoán. Quy trình đúng: (1) đo robust accuracy với AutoAttack, (2) adversarial training với ngân sách tính toán phù hợp, (3) anomaly detection chặn input bất thường, (4) khi confidence <95% → chuyển human review. Defense in depth cho ứng dụng tài chính là bắt buộc.

Cách đánh giá đúng

Thông sốGiá trịGhi chú
Attack budgetε = 8/255 (L∞)Chuẩn CIFAR-10 / ImageNet. Nhiễu ≈ 3% mỗi pixel — mắt người không thấy.
Attack stepsPGD-50, 10 restarts50 bước gradient + 10 khởi tạo ngẫu nhiên. Số liệu tối thiểu để công bố.
Mục tiêu robust acc≥ 45% (CIFAR-10)Mô hình không phòng thủ thường ≈ 0%. SOTA robust ≈ 70% (theo nguồn bài, chưa kiểm chứng) nhưng tốn nhiều tài nguyên.

Tóm tắt

  • Adversarial attack = nhiễu CỰC NHỎ nhưng thiết kế theo gradient, đủ để lừa AI hoàn toàn.
  • FGSM: 1 bước, nhanh. PGD: nhiều bước + projection, mạnh hơn. CW: optimization-based, khó phát hiện nhất.
  • Physical attacks (sticker biển báo, kính, áo hoạ tiết) nguy hiểm hơn digital — hoạt động trong thế giới thực.
  • Adversarial training (min-max) hiệu quả nhất nhưng tốn 3-10x thời gian và giảm clean accuracy 1-3%.
  • Defense in depth: preprocessing + adversarial training + ensemble + fallback — không biện pháp đơn lẻ nào đủ.
  • BẮT BUỘC đánh giá bằng PGD-50 + AutoAttack + adaptive attack trước khi claim robustness cho production.

Đọc thêm

  • Goodfellow, Shlens, Szegedy (2014) — Explaining and Harnessing Adversarial Examples (FGSM gốc).
  • Madry et al. (2018) — Towards Deep Learning Models Resistant to Adversarial Attacks (PGD adversarial training).
  • Croce & Hein (2020) — Reliable evaluation of adversarial robustness with AutoAttack.
  • RobustBench (robustbench.github.io) — leaderboard chuẩn cho robust accuracy trên CIFAR / ImageNet.

Continue the module

Lesson 8 of 11