6.1.5 Gyakorlati példák és kód

Az elmélet után merüljünk is bele a kódba. A leggyakoribb kérdés, ami az ART megismerése után felmerül, az az, hogy „hogyan is néz ki ez a valóságban?”. Pontosan ezt fogjuk most lépésről lépésre, a leggyakoribb felhasználási eseteken keresztül megvizsgálni. A cél, hogy a fejezet végére magabiztosan tudj elindítani egy alapvető támadást és egy védekezési mechanizmust is.

Oké, elméletben értem. De hogyan néz ki egy egyszerű FGSM támadás a gyakorlatban?

Kezdjük a legalapvetőbb esettel: van egy előtanított képfelismerő modelled, és szeretnéd megtéveszteni egyetlen, jól célzott támadással. A Fast Gradient Sign Method (FGSM) tökéletes erre a célra, mert gyors és könnyen érthető. A folyamat lényege, hogy a modell gradienseit használjuk fel egy olyan minimális zaj generálására, ami maximalizálja a veszteséget, ezzel „eltolva” a predikciót a rossz irányba.

Lássuk a medvét! Tegyük fel, hogy van egy előtanított ResNet-18 modelled, amit a PyTorch-csal töltöttél be.

# 1. Szükséges importok
import torch
import torchvision.models as models
from art.estimators.classification import PyTorchClassifier
from art.attacks.evasion import FastGradientMethod

# 2. Modell betöltése és becslő (estimator) létrehozása
model = models.resnet18(pretrained=True).eval()
# Az ART-nak szüksége van egy wrapper-re, ami egységes interfészt biztosít
classifier = PyTorchClassifier(
 model=model,
 loss=torch.nn.CrossEntropyLoss(),
 input_shape=(3, 224, 224),
 nb_classes=1000,
)

# 3. Támadás inicializálása
# Az epsilon (eps) a zaj mértékét szabályozza
attack = FastGradientMethod(estimator=classifier, eps=0.01)

# 4. Adversarial példa generálása
# Tegyük fel, hogy 'x_test' egy teszt kép (numpy array)
x_test_adversarial = attack.generate(x=x_test)

# 5. Eredmények összehasonlítása
original_pred = classifier.predict(x_test)
adversarial_pred = classifier.predict(x_test_adversarial)
print(f"Eredeti predikció: {original_pred.argmax()}")
print(f"Megtámadott predikció: {adversarial_pred.argmax()}")

Ebben a kódban a kulcsmozzanat a PyTorchClassifier wrapper létrehozása. Az ART így tudja, hogyan kommunikáljon a te specifikus modelleddel, függetlenül attól, hogy az PyTorch, TensorFlow vagy más keretrendszerben készült. Az eps paraméter finomhangolásával szabályozhatod a támadás „erősségét”: a nagyobb érték nagyobb vizuális torzítást, de valószínűleg sikeresebb támadást eredményez.

Ez eddig egyetlen képre működött. Hogyan tesztelhetem a modell teljesítményét egy egész adathalmazon?

Az AI Red Teaming során ritkán elégszünk meg egyetlen példával. A modell valódi sebezhetőségének felméréséhez egy teljes adathalmazon (vagy annak egy reprezentatív részén) kell lefuttatnunk a támadást, és mérnünk a teljesítménycsökkenést. Ez segít megérteni, hogy a modell általánosan gyenge-e egy adott támadástípussal szemben, vagy csak egy-egy speciális bemenetre érzékeny.

A folyamat lényegében az előző kód kibővítése egy ciklussal, ami végigmegy a teszt adathalmazon, és számolja a sikeres megtévesztéseket.

# Feltételezzük, hogy a classifier és az attack már létezik
import numpy as np

successful_attacks = 0
total_samples = len(test_loader.dataset)

for (images, labels) in test_loader: # 'test_loader' egy PyTorch DataLoader
 images_np = images.numpy()
 labels_np = labels.numpy()

 # Eredeti predikciók lekérdezése a batch-re
 preds_original = classifier.predict(images_np)
 
 # Támadás generálása a teljes batch-re
 x_adv = attack.generate(x=images_np)
 
 # Új predikciók a megtámadott adatokon
 preds_adv = classifier.predict(x_adv)
 
 # Sikeres támadások számolása
 # Egy támadás sikeres, ha az eredeti predikció helyes volt, de az új már nem
 for i in range(len(images_np)):
 if np.argmax(preds_original[i]) == labels_np[i] and np.argmax(preds_adv[i]) != labels_np[i]:
 successful_attacks += 1

accuracy_under_attack = 1 - (successful_attacks / total_samples)
print(f"A modell pontossága FGSM támadás alatt: {accuracy_under_attack:.2%}")

Ez a metrika – a modell pontossága támadás alatt – az egyik legfontosabb, amit az előző, 6.1.4-es fejezetben tárgyaltunk. Ez a „kemény szám” mutatja meg a vezetőség vagy a fejlesztőcsapat számára a probléma súlyosságát.

Láttuk a támadást. Hogyan védekezhetek ellene az ART eszköztárával?

A támadások detektálása után a következő logikus lépés a védekezés. Az egyik legelterjedtebb és leghatékonyabb módszer az „Adversarial Training”, vagyis az ellenséges tanítás. A koncepció egyszerű: ha a modell gyenge a generált zajos képeken, tanítsuk meg neki, hogyan ismerje fel őket helyesen. Gyakorlatilag a tanító adathalmazt kibővítjük a támadások által generált példákkal.

Az ART ezt a folyamatot rendkívül leegyszerűsíti az AdversarialTrainer osztállyal.

# 1. Szükséges importok
from art.defences.trainer import AdversarialTrainer

# 2. Új, még nem tanított modell létrehozása
# Fontos, hogy a védekezést egy "tiszta" modellen kezdjük
model_to_defend = models.resnet18(pretrained=False)
classifier_to_defend = PyTorchClassifier(
 model=model_to_defend,
 loss=torch.nn.CrossEntropyLoss(),
 optimizer=torch.optim.Adam(model_to_defend.parameters(), lr=0.01),
 input_shape=(3, 224, 224),
 nb_classes=1000,
)

# 3. Adversarial Trainer létrehozása
# Megadjuk a modellt és a támadás(oka)t, amivel tanítani szeretnénk
trainer = AdversarialTrainer(classifier=classifier_to_defend, attacks=attack, ratio=0.5)

# 4. A modell tanítása
# A ratio=0.5 azt jelenti, hogy a tanító batch-ek fele eredeti, fele adversarial
trainer.fit(x_train, y_train, nb_epochs=10, batch_size=128)

# 5. Értékelés a robusztus modellen
# Most futtassuk le ugyanazt a kiértékelő ciklust, mint korábban,
# de már a 'classifier_to_defend' (a megerősített) modellen.
# Az eredmény drámaian jobb lesz!