4.1.2 Gradiens alapú támadások matematikája

Képzeld el, hogy egy ismeretlen, ködös hegyoldalon állsz, és a lehető leggyorsabban szeretnél feljutni a csúcsra. Mit tennél? Valószínűleg minden lépésnél megvizsgálnád a talajt magad körül, és abba az irányba indulnál, amerre a legmeredekebb az emelkedő. A gépi tanulási modellek elleni gradiens alapú támadások pontosan ugyanezt a logikát követik. A „hegy” a modell veszteségfüggvénye (loss function), a „csúcs” pedig a maximális hiba állapota. A támadó a gradiens segítségével „tapogatja ki” a legmeredekebb utat a tévesztés felé.

Az előző fejezetben láttuk, hogy az ellenséges támadás egy optimalizációs probléma. Most megnézzük, hogyan oldható meg ez a probléma a leghatékonyabb eszközzel, amit a neurális hálók világa kínál: a gradienssel.

A gradiens mint a sebezhetőség térképe

A neurális hálók tanítása során a gradiens azt mutatja meg, hogyan kell módosítani a modell súlyait (paramétereit) a veszteség csökkentése érdekében. Ez a visszaterjesztés (backpropagation) alapja. Egy támadó szempontjából azonban a gradiensnek egy másik olvasata is van. Ha a veszteségfüggvényt nem a súlyok, hanem a bemeneti adatok (pl. egy kép pixeljei) szerint deriváljuk, akkor a kapott gradiens megmutatja, hogy a bemenet melyik részének megváltoztatására reagál a legérzékenyebben a modell.

Formálisan, a keresett gradiens a következő:
∇x J(θ, x, y)
ahol:

• J a modell veszteségfüggvénye (pl. kereszt-entrópia).
• θ a modell paraméterei (súlyai), amelyeket a támadás során fixnek tekintünk.
• x a bemeneti adatpont (pl. egy kép pixelértékeinek vektora).
• y a helyes címke.
• ∇x a gradiens operátor az x bemenet szerint.

Ez a vektor, ∇x J, minden egyes eleme megadja, hogy az adott bemeneti jellemző (pl. egy pixel) értékének apró növelése mennyivel növeli a veszteséget. Más szavakkal, ez a vektor a veszteségfüggvény „legmeredekebb emelkedőjének” irányába mutat a bemeneti térben. Egy támadónak pontosan erre van szüksége.

A klasszikus: Fast Gradient Sign Method (FGSM)

Az egyik legegyszerűbb és legnépszerűbb gradiens alapú támadás az Ian Goodfellow és kollégái által 2014-ben bemutatott Fast Gradient Sign Method (FGSM). 

A neve mindent elárul: gyors, a gradiens előjelét használja, és ez egy módszer. Az alapötlet az, hogy egyetlen, jól irányzott lépést teszünk a gradiens által kijelölt irányba.

A módosított, ellenséges bemenet (x') előállítása a következő képlettel történik:

# Pszeudokód az FGSM támadásra
def fgsm_attack(image, epsilon, data_grad):
 # image: az eredeti kép (pl. egy tenzor)
 # epsilon: a perturbáció maximális mértéke
 # data_grad: a veszteség gradiense a bemeneti képre nézve

 # Gyűjtsük össze a gradiens elemeinek előjelét
 sign_data_grad = sign(data_grad)

 # Hozzuk létre az ellenséges képet a képlet alapján
 perturbed_image = image + epsilon * sign_data_grad
 
 # Opcionális: Biztosítsuk, hogy az értékek a valid tartományban maradjanak
 # (pl. [0,1] vagy [0,255] a képeknél)
 perturbed_image = clip(perturbed_image, 0, 1)
 
 # Térjünk vissza a módosított képpel
 return perturbed_image

A támadás vizualizációja

Hogy jobban megértsük a folyamatot, képzeljük el a modell döntési felületét egy egyszerű, kétdimenziós térben. A cél az, hogy egy adatpontot (x) átjuttassunk a döntési határon egy másik osztály területére, miközben a lehető legkisebb módosítást hajtjuk végre.

_x J (gradiens)

ε-gömb (max. perturbáció)


x’ (ellenséges)

A diagramon az x pont az „A” osztályba tartozik. A gradiens (∇x J) jobbra mutat, a magasabb veszteség (a „B” osztály) felé. Az FGSM támadás egy lépést tesz ebben az irányban. Az új pont, x', már a döntési határ túloldalán van, de még az ε-gömbön (a megengedett maximális változtatás sugarán) belül. A modellt sikeresen megtévesztettük.

Iteratív módszerek: A finomhangolás

Az FGSM egy nagy, durva lépést tesz. De mi van, ha egy finomabb, óvatosabb megközelítés hatékonyabb? Az iteratív módszerek, mint a Basic Iterative Method (BIM) vagy a Projected Gradient Descent (PGD), ezen az elven alapulnak. Ahelyett, hogy egyetlen nagy lépést tennének ε mérettel, sok apró lépést tesznek α lépésközzel, ahol α < ε.

A folyamat a következőképpen néz ki:

1. Indulj az eredeti bemenetről: x'0 = x.
2. Ismételd N-szer:
   • Számítsd ki a gradienst az aktuális pontban: ∇x' J(θ, x't, y).
   • Tégy egy kis lépést a gradiens irányába: x't+1 = x't + α ⋅ sign(∇x' J).
   • Gondoskodj róla, hogy az új pont ne legyen túl messze az eredeti x-től. Ezt egy „vetítési” (projection) vagy „vágási” (clipping) lépéssel érik el, ami biztosítja, hogy x't+1 mindig az eredeti x körüli ε-sugarú gömbön belül maradjon.

Ezek a módszerek általában erősebb támadásokat eredményeznek, mert finomabban tudják feltérképezni a döntési határ közeli, sebezhető pontokat. Cserébe számításigényesebbek, hiszen többször kell a gradienst kiszámítani.

A White-Box feltételezés kritikája

Fontos hangsúlyozni, hogy minden eddig tárgyalt gradiens alapú támadás ún. white-box (fehér dobozos) forgatókönyvet feltételez. Ez azt jelenti, hogy a támadó teljes hozzáféréssel rendelkezik a modellhez:

• Ismeri az architektúrát (rétegek, aktivációs függvények).
• Ismeri az összes tanított paramétert (súlyokat és torzításokat).
• Képes a veszteségfüggvény gradiensét kiszámítani bármely bemenetre.

A valóságban ez egy nagyon erős feltételezés. Gyakran a támadónak csak korlátozott, fekete dobozos (black-box) hozzáférése van a modellhez (pl. egy API-n keresztül). 

A white-box támadások azonban kritikus fontosságúak a Red Teaming folyamatban, mert megmutatják a modell elméleti sebezhetőségének felső határát. Ha egy modell egy ilyen erős támadással szemben is ellenálló, akkor valószínűleg a gyengébb, black-box támadásokkal szemben is robusztusabb lesz.