adversarial attacks pytorch
v3.5.1
Torchattacks est une bibliothèque Pytorch qui fournit des attaques contradictoires pour générer des exemples contradictoires.
Il contient une interface et des fonctions de type Pytorch qui facilitent les utilisateurs de Pytorch d'implémenter les attaques adversaires.
import torchattacks
atk = torchattacks . PGD ( model , eps = 8 / 255 , alpha = 2 / 255 , steps = 4 )
# If inputs were normalized, then
# atk.set_normalization_used(mean=[...], std=[...])
adv_images = atk ( images , labels )Packages recommandés supplémentaires .
Citation. Si vous utilisez ce package, veuillez citer le bibtex suivant (Googlescholar):
@article{kim2020torchattacks,
title={Torchattacks: A pytorch repository for adversarial attacks},
author={Kim, Hoki},
journal={arXiv preprint arXiv:2010.01950},
year={2020}
}
Exigences
Installation
# pip
pip install torchattacks
# source
pip install git+https://github.com/Harry24k/adversarial-attacks-pytorch.git
# git clone
git clone https://github.com/Harry24k/adversarial-attacks-pytorch.git
cd adversarial-attacks-pytorch/
pip install -e .
Précautions
(N, C) où C = number of classes . Compte tenu de la plupart des modèles dans TorchVision.Models renvoie un vecteur de (N,C) , où N est le nombre d'entrées et C est alors le nombre de classes, les torchattapes ne prennent également en charge que des formes de sortie limitées. Veuillez vérifier attentivement la forme de la sortie du modèle.torch.backends.cudnn.deterministic = True pour obtenir les mêmes exemples adversaires avec des graines aléatoires fixes . Certaines opérations sont non déterministes avec les tenseurs flottants sur GPU [Discussion]. Si vous souhaitez obtenir les mêmes résultats avec les mêmes entrées, veuillez exécuter torch.backends.cudnn.deterministic = True [Ref].Démos
Mode ciblé
# random labels as target labels.
atk . set_mode_targeted_random () # labels with the k-th smallest probability as target labels.
atk . set_mode_targeted_least_likely ( kth_min ) # labels obtained by mapping function as target labels.
# shift all class loops one to the right, 1=>2, 2=>3, .., 9=>0
atk . set_mode_targeted_by_function ( target_map_function = lambda images , labels :( labels + 1 ) % 10 ) atk . set_mode_targeted_by_label ( quiet = True )
# shift all class loops one to the right, 1=>2, 2=>3, .., 9=>0
target_labels = ( labels + 1 ) % 10
adv_images = atk ( images , target_labels ) atk . set_mode_default ()Enregistrer les images contradictoires
# Save
atk . save ( data_loader , save_path = "./data.pt" , verbose = True )
# Load
adv_loader = atk . load ( load_path = "./data.pt" )Formation / évaluation pendant l'attaque
# For RNN-based models, we cannot calculate gradients with eval mode.
# Thus, it should be changed to the training mode during the attack.
atk . set_model_training_mode ( model_training = False , batchnorm_training = False , dropout_training = False )Faire un ensemble d'attaques
atk1 = torchattacks . FGSM ( model , eps = 8 / 255 )
atk2 = torchattacks . PGD ( model , eps = 8 / 255 , alpha = 2 / 255 , iters = 40 , random_start = True )
atk = torchattacks . MultiAttack ([ atk1 , atk2 ]) atk1 = torchattacks . CW ( model , c = 0.1 , steps = 1000 , lr = 0.01 )
atk2 = torchattacks . CW ( model , c = 1 , steps = 1000 , lr = 0.01 )
atk = torchattacks . MultiAttack ([ atk1 , atk2 ]) atk1 = torchattacks . PGD ( model , eps = 8 / 255 , alpha = 2 / 255 , iters = 40 , random_start = True )
atk2 = torchattacks . PGD ( model , eps = 8 / 255 , alpha = 2 / 255 , iters = 40 , random_start = True )
atk = torchattacks . MultiAttack ([ atk1 , atk2 ])La mesure de distance entre parenthèses.
| Nom | Papier | Remarque |
|---|---|---|
| FGSM (Linf) | Expliquer et exploiter des exemples contradictoires (Goodfellow et al., 2014) | |
| Bim (Linf) | Exemples adversaires dans le monde physique (Kurakin et al., 2016) | Méthode itérative de base ou itérative-FSGM |
| Cw (L2) | Vers l'évaluation de la robustesse des réseaux de neurones (Carlini et al., 2016) | |
| RFGSM (Linf) | Tranage adversaire de l'ensemble: attaques et défenses (Tramèr et al., 2017) | Initialisation aléatoire + FGSM |
| DPI (Linf) | Vers des modèles d'apprentissage en profondeur résistants aux attaques contradictoires (Mardry et al., 2017) | Méthode de gradient projetée |
| Pgdl2 (L2) | Vers des modèles d'apprentissage en profondeur résistants aux attaques contradictoires (Mardry et al., 2017) | Méthode de gradient projetée |
| Mifgsm (Linf) | Boosting des attaques contradictoires avec Momentum (Dong et al., 2017) | ? Contributeur Zhuangzi926, Huitailangyz |
| Tpgd (Linf) | Compromis théoriquement fondé sur des principes entre robustesse et précision (Zhang et al., 2019) | |
| Eotpgd (Linf) | Commentaire sur "ADV-BNN: une défense adversaire améliorée par le biais d'un réseau neuronal bayésien robuste" (Zimmermann, 2019) | EOT + PGD |
| APGD (Linf, L2) | Évaluation fiable de la robustesse adversaire avec un ensemble de diverses attaques sans paramètres (Croce et al., 2020) | |
| Apgdt (Linf, L2) | Évaluation fiable de la robustesse adversaire avec un ensemble de diverses attaques sans paramètres (Croce et al., 2020) | APGD ciblé |
| Fabuleux (Linf, L2, L1) | Exemples adversaires mini-déformés avec une attaque limite adaptative rapide (Croce et al., 2019) | |
| Carré (Linf, L2) | Attaque carrée: une attaque adversaire à boîte noire économe en question via une recherche aléatoire (Andriushchenko et al., 2019) | |
| Attaque automatiquement (Linf, L2) | Évaluation fiable de la robustesse adversaire avec un ensemble de diverses attaques sans paramètres (Croce et al., 2020) | Apgd + apgdt + fab + carré |
| De profondeur (L2) | Deepfool: une méthode simple et précise pour tromper les réseaux de neurones profonds (Moosavi-Dezfooli et al., 2016) | |
| OnePixel (L0) | Une attaque de pixels pour avoir trompé des réseaux de neurones profonds (Su et al., 2019) | |
| Mâtain (L0) | Sparsefool: quelques pixels font une grande différence (Modas et al., 2019) | |
| Difgsm (Linf) | Amélioration de la transférabilité des exemples contradictoires avec la diversité des entrées (Xie et al., 2019) | ? Contributeur Taobai |
| TIFGSM (Linf) | Échantillonnant les défenses à des exemples adversaires transférables par des attaques invariantes de traduction (Dong et al., 2019) | ? Contributeur Taobai |
| Nifgsm (Linf) | Nesterov a accéléré le gradient et l'invariance d'échelle pour les attaques adversares (Lin, et al., 2022) | ? Contributeur zhijin-ge |
| SINIFGSM (Linf) | Nesterov a accéléré le gradient et l'invariance d'échelle pour les attaques adversares (Lin, et al., 2022) | ? Contributeur zhijin-ge |
| Vmifgsm (Linf) | Amélioration de la transférabilité des attaques contradictoires par le réglage de la variance (Wang et al., 2022) | ? Contributeur zhijin-ge |
| Vnifgsm (Linf) | Amélioration de la transférabilité des attaques contradictoires par le réglage de la variance (Wang et al., 2022) | ? Contributeur zhijin-ge |
| Giron (Linf) | Explorer les classifications erronées des réseaux de neurones robustes pour améliorer les attaques contradictoires (Schwinn, Leo, et al., 2021) | |
| Pixle (L0) | Pixle: une attaque de boîte noire rapide et efficace basée sur le réarrangement des pixels (Pomponi, Jary et al., 2022) | |
| LGV (Linf, L2, L1, L0) | LGV: augmentation de la transférabilité des exemples adversaires à partir de grands voisins géométriques (Gubri, et al., 2022) | ? Contributeur Martin Gubri |
| SPSA (Linf) | Risque contradictoire et dangers de l'évaluation contre les attaques faibles (Uesato, Jonathan, et al., 2018) | ? Contributeur Riko Naka |
| JSMA (L0) | Les limites de l'apprentissage en profondeur dans les contextes contradictoires (Papernot, Nicolas et al., 2016) | ? Contributeur Riko Naka |
| Eadl1 (L1) | EAD: Elastic-Net Attacks to Deep Neural Networks (Chen, Pin-Yu, et al., 2018) | ? Contributeur Riko Naka |
| Eaden (L1, L2) | EAD: Elastic-Net Attacks to Deep Neural Networks (Chen, Pin-Yu, et al., 2018) | ? Contributeur Riko Naka |
| PIFGSM (PIM) (Linf) | Attaque patch pour un réseau neuronal profond (Gao, Lianli, et al., 2020) | ? Contributeur Riko Naka |
| PIFGSM ++ (PIM ++) (Linf) | Patch-sage ++ perturbation pour les attaques ciblées adversaires (Gao, Lianli, et al., 2021) | ? Contributeur Riko Naka |
Quant aux packages de comparaison, les méthodes actuellement mises à jour et les plus citées ont été sélectionnées:
Une précision robuste contre chaque attaque et un temps écoulé sur les 50 premières images de CIFAR10. Pour les attaques L2, les distances moyennes de L2 entre les images contradictoires et les images originales sont enregistrées. Toutes les expériences ont été réalisées sur GeForce RTX 2080. Pour la dernière version, veuillez vous référer à ici (code, NBViewer).
| Attaque | Emballer | Standard | Wong2020fast | Rice2020Overfitting | Remarque |
|---|---|---|---|---|---|
| FGSM (LINF) | Coiffures | 34% (54 ms) | 48% (5 ms) | 62% (82 ms) | |
| Foolbox * | 34% (15 ms) | 48% (8 ms) | 62% (30 ms) | ||
| ART | 34% (214 ms) | 48% (59 ms) | 62% (768 ms) | ||
| PGD (LINF) | Coiffures | 0% (174 ms) | 44% (52 ms) | 58% (1348 ms) | ? Le plus rapide |
| Foolbox * | 0% (354 ms) | 44% (56 ms) | 58% (1856 ms) | ||
| ART | 0% (1384 ms) | 44% (437 ms) | 58% (4704 ms) | ||
| CW † (L2) | Coiffures | 0% / 0,40 (2596 ms) | 14% / 0,61 (3795 ms) | 22% / 0,56 (43484ms) | ? Taux de réussite le plus élevé ? Le plus rapide |
| Foolbox * | 0% / 0,40 (2668 ms) | 32% / 0,41 (3928 ms) | 34% / 0,43 (44418 ms) | ||
| ART | 0% / 0,59 (196738 ms) | 24% / 0,70 (66067 ms) | 26% / 0,65 (694972 ms) | ||
| PGD (L2) | Coiffures | 0% / 0,41 (184 ms) | 68% / 0,5 (52 ms) | 70% / 0,5 (1377 ms) | ? Le plus rapide |
| Foolbox * | 0% / 0,41 (396 ms) | 68% / 0,5 (57 ms) | 70% / 0,5 (1968 ms) | ||
| ART | 0% / 0,40 (1364 ms) | 68% / 0,5 (429 ms) | 70% / 0,5 (4777 ms) |
* Notez que Foolbox renvoie la précision et les images contradictoires simultanément, donc le temps réel pour générer des images contradictoires pourrait être plus court que les enregistrements.
† Étant donné que l'algorithme de recherche binaire de const c peut prendre du temps, Torchattacks prend en charge Mutliattack pour la recherche de grille c .
De plus, je recommande également d'utiliser un package récemment proposé, Rai-Toolbox .
| Attaque | Emballer | Temps / pas (précision) |
|---|---|---|
| FGSM (LINF) | rai-toolbox | 58 ms (0%) |
| Coiffures | 81 ms (0%) | |
| Imbécile | 105 ms (0%) | |
| ART | 83 ms (0%) | |
| PGD (LINF) | rai-toolbox | 58 ms (44%) |
| Coiffures | 79 ms (44%) | |
| Imbécile | 82 ms (44%) | |
| ART | 90 ms (44%) | |
| PGD (L2) | rai-toolbox | 58 ms (70%) |
| Coiffures | 81 ms (70%) | |
| Imbécile | 82 ms (70%) | |
| ART | 89 ms (70%) |
Le Rai-Toolbox adopte une approche unique des perturbations basées sur le gradient: elles sont implémentées en termes d'optimisateurs et de modèles de perturbation de transformatrice de paramètres. Cela permet aux utilisateurs de mettre en œuvre divers algorithmes (comme les perturbations universelles et le sondage conceptuel avec des gradients clairsemés) en utilisant le même paradigme qu'une attaque PGD standard.
