26.1.1. FGSM, PGD, C&W implementációk

Tévhit vs. Valóság

A tévhit: A képosztályozók elleni adverzális támadások csak véletlenszerű zajt adnak a képhez, amíg a modell meg nem zavarodik.

A valóság: A leghatékonyabb támadások matematikailag precízen kiszámított, a modell belső működését (a gradienseit) kihasználó, célzott perturbációk. Nem zajok, hanem a modell Achilles-sarkát célzó, láthatatlanul apró módosítások. Ebben a fejezetben három klasszikus, gradienalapú módszer implementációját nézzük meg.

FGSM: A gyors első lépés (Fast Gradient Sign Method)

Az FGSM a legegyszerűbb és leggyorsabb gradienalapú támadás. Lényege, hogy egyetlen lépésben módosítja a bemeneti képet. Kiszámolja a veszteségi függvény gradiensét a bemeneti képhez képest, majd veszi a gradiens előjelét. Ezt az előjel-mátrixot megszorozza egy kicsi ε (epszilon) értékkel, és hozzáadja az eredeti képhez. Gyors, de gyakran könnyen kivédhető.

A képlet egyszerű: x' = x + ε · sign(∇_xJ(θ, x, y)), ahol x' a perturbált kép, x az eredeti, ε a perturbáció mértéke, J a veszteségi függvény, θ a modell súlyai és y a valódi címke.


import torch
import torch.nn.functional as F

def fgsm_attack(image, epsilon, data_grad):
 # Gyűjtsük össze a gradiens előjelét
 sign_data_grad = data_grad.sign()
 
 # Hozzuk létre a perturbált képet a gradiens előjelének felhasználásával
 perturbed_image = image + epsilon * sign_data_grad
 
 # A pixelértékeket tartsuk a [0,1] tartományban
 perturbed_image = torch.clamp(perturbed_image, 0, 1)
 
 # Adjuk vissza a megtámadott képet
 return perturbed_image

# ... a modell előrecsatolása és a veszteség kiszámítása után ...
# image.requires_grad = True
# loss.backward()
# data_grad = image.grad.data
# perturbed_data = fgsm_attack(image, epsilon, data_grad)

PGD: Az iteratív erő (Projected Gradient Descent)

A PGD az FGSM iteratív, erősebb változata. Ahelyett, hogy egyetlen nagy lépést tenne, a PGD több apró lépést tesz. Minden lépés után „visszavetíti” (project) a perturbációt egy adott norma (általában L_∞) által definiált gömbbe. Ez biztosítja, hogy a teljes perturbáció ne lépje túl a megengedett ε értéket. Sokkal hatékonyabb, mint az FGSM, és gyakran használják a modellek robusztusságának tesztelésére.


import torch

def pgd_attack(model, images, labels, eps=0.3, alpha=2/255, iters=40):
 images = images.clone().detach()
 labels = labels.clone().detach()
 
 loss = torch.nn.CrossEntropyLoss()
 
 original_images = images.clone().detach()
 
 for i in range(iters):
 images.requires_grad = True
 outputs = model(images)

 model.zero_grad()
 cost = loss(outputs, labels).to(device)
 cost.backward()

 # Az FGSM lépés iteratív alkalmazása
 adv_images = images + alpha * images.grad.sign()
 
 # Visszavetítés az epszilon-környezetbe
 eta = torch.clamp(adv_images - original_images, min=-eps, max=eps)
 images = torch.clamp(original_images + eta, min=0, max=1).detach()
 
 return images

C&W: Az optimalizált precizitás (Carlini & Wagner)

A Carlini & Wagner támadás egy teljesen más megközelítést alkalmaz. Ez egy optimalizáció-alapú támadás, amelynek célja, hogy megtalálja a lehető legkisebb perturbációt, ami a modellt téves osztályozásra készteti, ráadásul nagy magabiztossággal. Sokkal lassabb, mint az FGSM vagy a PGD, de rendkívül hatékony és nehezen detektálható, mivel a létrehozott perturbációk minimálisak. Ahelyett, hogy a veszteséget maximalizálná, egy olyan célfüggvényt minimalizál, ami egyszerre bünteti a perturbáció nagyságát és a helyes osztály valószínűségét.

Az implementációja komplex, ezért a gyakorlatban általában meglévő keretrendszereket, mint az Adversarial Robustness Toolbox (ART), használunk a futtatásához.


# Példa az ART (Adversarial Robustness Toolbox) könyvtár használatával
from art.attacks.evasion import CarliniL2Method
from art.estimators.classification import PyTorchClassifier

# 1. Készítsünk egy ART-kompatibilis wrapper-t a PyTorch modellünkhöz
classifier = PyTorchClassifier(
 model=model,
 clip_values=(0, 1),
 loss=torch.nn.CrossEntropyLoss(),
 optimizer=optimizer,
 input_shape=(1, 28, 28),
 nb_classes=10,
)

# 2. Hozzunk létre egy C&W támadási objektumot
attack = CarliniL2Method(classifier=classifier, max_iter=100, confidence=0.0)

# 3. Generáljuk le az adverzális példákat
x_test_adv = attack.generate(x=x_test)

Gyors összehasonlítás

Az alábbi táblázat összefoglalja a három támadás legfontosabb tulajdonságait, hogy segítsen eldönteni, melyiket mikor érdemes használnod a red teaming feladatok során.

Támadás	Sebesség	Hatékonyság	Komplexitás	Fő jellemző
FGSM	Nagyon gyors	Alacsony	Alacsony	Egyetlen gradiens lépés. Jó kiindulási alap.
PGD	Mérsékelt	Magas	Mérsékelt	Iteratív, robusztus támadás. Standard benchmark.
C&W	Lassú	Nagyon magas	Magas	Optimalizáció-alapú, a legkisebb perturbációt keresi.

Melyiket mikor használd?

A red teaming során a sebesség és a hatékonyság közötti kompromisszum a döntő. Kezdj egy gyors FGSM támadással, hogy felmérd a modell alapvető sebezhetőségét. Ha ez sikertelen, vagy egy erősebb ellenállást feltételezel, a PGD a következő logikus lépés – ez egyfajta ipari sztenderd a robusztusság mérésére. Ha pedig a cél a modell abszolút korlátainak feltérképezése, és a lehető legészrevétlenebb támadás generálása, akkor a számításigényesebb C&W a megfelelő eszköz.