adversarial attacks pytorch
v3.5.1
TorchAttacks es una biblioteca de Pytorch que proporciona ataques adversos para generar ejemplos adversos.
Contiene una interfaz y funciones similares a Pytorch que facilitan a los usuarios de Pytorch implementar ataques adversos.
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 )Paquetes recomendados adicionales .
Citación. Si usa este paquete, cite el siguiente bibtex (GoogleScholar):
@article{kim2020torchattacks,
title={Torchattacks: A pytorch repository for adversarial attacks},
author={Kim, Hoki},
journal={arXiv preprint arXiv:2010.01950},
year={2020}
}
Requisitos
Instalación
# 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 .
Precauciones
(N, C) donde C = number of classes . Teniendo en cuenta la mayoría de los modelos en Vision de TorchVision. Modelos Devuelve un vector de (N,C) , donde N es el número de entradas y C es entonces un número de clases, los ataques de antorchas también solo admiten formas limitadas de salida. Verifique cuidadosamente la forma de la salida del modelo.torch.backends.cudnn.deterministic = True para obtener los mismos ejemplos adversos con semillas aleatorias fijas . Algunas operaciones no son deterministas con tensores flotantes en GPU [discutir]. Si desea obtener los mismos resultados con las mismas entradas, ejecute torch.backends.cudnn.deterministic = True [Ref].Población
Modo objetivo
# 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 ()Guardar imágenes adversas
# Save
atk . save ( data_loader , save_path = "./data.pt" , verbose = True )
# Load
adv_loader = atk . load ( load_path = "./data.pt" )Entrenamiento/evaluación durante el ataque
# 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 )Hacer un conjunto de ataques
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 medida de distancia entre paréntesis.
| Nombre | Papel | Observación |
|---|---|---|
| FGSM (LINF) | Explicando y aprovechando ejemplos adversos (Goodfellow et al., 2014) | |
| Bim (LINF) | Ejemplos adversos en el mundo físico (Kurakin et al., 2016) | Método iterativo básico o FSGM iterativo |
| CW (L2) | Hacia la evaluación de la robustez de las redes neuronales (Carlini et al., 2016) | |
| RFGSM (LINF) | Conjunto de transmisión congresiva: ataques y defensas (Tramèr et al., 2017) | Inicialización aleatoria + FGSM |
| PGD (LINF) | Hacia modelos de aprendizaje profundo resistentes a los ataques adversos (Mardry et al., 2017) | Método de gradiente proyectado |
| Pgdl2 (L2) | Hacia modelos de aprendizaje profundo resistentes a los ataques adversos (Mardry et al., 2017) | Método de gradiente proyectado |
| Mfgsm (LINF) | Aumentando ataques condenos con impulso (Dong et al., 2017) | ? Colaborador Zhuangzi926, Huitailangyz |
| TPGD (LINF) | Teóricamente compensación de principios entre robustez y precisión (Zhang et al., 2019) | |
| Eotpgd (LINF) | Comentario sobre "ADV-BNN: defensa adversaria mejorada a través de una robusta red neuronal bayesiana" (Zimmermann, 2019) | EOT+PGD |
| Apgd (Linf, L2) | Evaluación confiable de la robustez adversa con un conjunto de diversos ataques sin parámetros (Croce et al., 2020) | |
| Apgdt (Linf, L2) | Evaluación confiable de la robustez adversa con un conjunto de diversos ataques sin parámetros (Croce et al., 2020) | APGD dirigido |
| Fabuloso (Linf, L2, L1) | Ejemplos adversos mínimamente distorsionados con un ataque límite adaptativo rápido (Croce et al., 2019) | |
| Cuadrado (Linf, L2) | Ataque cuadrado: un ataque adversario de caja negra eficiente en consulta a través de una búsqueda aleatoria (Andriushchenko et al., 2019) | |
| Autoata (Linf, L2) | Evaluación confiable de la robustez adversa con un conjunto de diversos ataques sin parámetros (Croce et al., 2020) | APGD+APGDT+Fab+Square |
| Fool profundo (L2) | Deepfool: un método simple y preciso para engañar a las redes neuronales profundas (Moosavi-Dezfooli et al., 2016) | |
| Unpíxel (L0) | Ataque de un píxel para engañar a las redes neuronales profundas (Su et al., 2019) | |
| Sparsefool (L0) | Sparsefool: algunos píxeles hacen una gran diferencia (Modas et al., 2019) | |
| Difgsm (LINF) | Mejora de la transferibilidad de ejemplos adversos con diversidad de entrada (Xie et al., 2019) | ? Colaborador Taobai |
| Tifgsm (LINF) | Evadiendo las defensas a ejemplos adversos transferibles mediante ataques invariantes de traducción (Dong et al., 2019) | ? Colaborador Taobai |
| NIFGSM (LINF) | Nesterov aceleró la invariancia de gradiente y escala para ataques adversos (Lin, et al., 2022) | ? Colaborador Zhijin-Ge |
| Sinifgsm (LINF) | Nesterov aceleró la invariancia de gradiente y escala para ataques adversos (Lin, et al., 2022) | ? Colaborador Zhijin-Ge |
| Vmifgsm (LINF) | Mejora de la transferibilidad de los ataques adversos a través del ajuste de la varianza (Wang, et al., 2022) | ? Colaborador Zhijin-Ge |
| Vnifgsm (LINF) | Mejora de la transferibilidad de los ataques adversos a través del ajuste de la varianza (Wang, et al., 2022) | ? Colaborador Zhijin-Ge |
| Estar nervioso (LINF) | Explorando clasificaciones erróneas de redes neuronales robustas para mejorar los ataques adversos (Schwinn, Leo, et al., 2021) | |
| Píxle (L0) | Pixle: un ataque de caja negra rápida y efectiva basado en los píxeles de reorganización (Pomponi, Jary, et al., 2022) | |
| LGV (Linf, L2, L1, L0) | LGV: impulso de transferibilidad de ejemplo adversas de grandes proximidades geométricas (Gubri, et al., 2022) | ? Colaborador Martin Gubri |
| SPSA (LINF) | Riesgo adversario y los peligros de evaluar contra ataques débiles (Uesato, Jonathan, et al., 2018) | ? Colaborador Riko Naka |
| Jsma (L0) | Las limitaciones del aprendizaje profundo en entornos adversos (Papernot, Nicolas, et al., 2016) | ? Colaborador Riko Naka |
| EADL1 (L1) | EAD: ataques de red elástica a redes neuronales profundas (Chen, Pin-Yu, et al., 2018) | ? Colaborador Riko Naka |
| Eaden (L1, L2) | EAD: ataques de red elástica a redes neuronales profundas (Chen, Pin-Yu, et al., 2018) | ? Colaborador Riko Naka |
| PIFGSM (PIM) (LINF) | Ataque de parche para engañar a la red neuronal profunda (Gao, Lianli, et al., 2020) | ? Colaborador Riko Naka |
| PIFGSM ++ (PIM ++) (LINF) | Patch-Wise ++ Perturbación para ataques dirigidos adversos (Gao, Lianli, et al., 2021) | ? Colaborador Riko Naka |
En cuanto a los paquetes de comparación, se seleccionaron los métodos actualmente actualizados y más citados:
Precisión robusta contra cada ataque y transcurrió el tiempo en las primeras 50 imágenes de CIFAR10. Para los ataques L2, se registran las distancias promedio de L2 entre las imágenes adversas y las imágenes originales. Todos los experimentos se realizaron en GeForce RTX 2080. Para la última versión, consulte aquí (Code, NBViewer).
| Ataque | Paquete | Estándar | Wong2020fast | Rice2020 Overgingtitting | Observación |
|---|---|---|---|---|---|
| FGSM (LINF) | Ataques de torchos | 34% (54 ms) | 48% (5 ms) | 62% (82 ms) | |
| Foolbox * | 34% (15 ms) | 48% (8 ms) | 62% (30 ms) | ||
| ARTE | 34% (214 ms) | 48% (59ms) | 62% (768 ms) | ||
| PGD (LINF) | Ataques de torchos | 0% (174 ms) | 44% (52 ms) | 58% (1348 ms) | ? Más rápido |
| Foolbox * | 0% (354 ms) | 44% (56 ms) | 58% (1856 ms) | ||
| ARTE | 0% (1384 ms) | 44% (437 ms) | 58% (4704 ms) | ||
| CW † (L2) | Ataques de torchos | 0% / 0.40 (2596ms) | 14% / 0.61 (3795ms) | 22% / 0.56 (43484 ms) | ? Tasa de éxito más alta ? Lo más rápido |
| Foolbox * | 0% / 0.40 (2668ms) | 32% / 0.41 (3928ms) | 34% / 0.43 (44418ms) | ||
| ARTE | 0% / 0.59 (196738ms) | 24% / 0.70 (66067ms) | 26% / 0.65 (694972ms) | ||
| PGD (L2) | Ataques de torchos | 0% / 0.41 (184 ms) | 68% / 0.5 (52 ms) | 70% / 0.5 (1377ms) | ? Lo más rápido |
| Foolbox * | 0% / 0.41 (396 ms) | 68% / 0.5 (57ms) | 70% / 0.5 (1968ms) | ||
| ARTE | 0% / 0.40 (1364 ms) | 68% / 0.5 (429ms) | 70% / 0.5 (4777ms) |
* Tenga en cuenta que Foolbox devuelve la precisión y las imágenes adversas simultáneamente, por lo tanto, el tiempo real para generar imágenes adversas podría ser más corta que los registros.
† Teniendo en cuenta que el algoritmo de búsqueda binario para const c puede llevar mucho tiempo, los ataques de torches admiten Mutliattack para la búsqueda de cuadrícula c .
Además, también recomiendo usar un paquete recientemente propuesto, RAI-Toolbox .
| Ataque | Paquete | Tiempo/paso (precisión) |
|---|---|---|
| FGSM (LINF) | Rai-Toolbox | 58 ms (0%) |
| Ataques de torchos | 81 ms (0%) | |
| Tontería | 105 ms (0%) | |
| ARTE | 83 ms (0%) | |
| PGD (LINF) | Rai-Toolbox | 58 ms (44%) |
| Ataques de torchos | 79 ms (44%) | |
| Tontería | 82 ms (44%) | |
| ARTE | 90 ms (44%) | |
| PGD (L2) | Rai-Toolbox | 58 ms (70%) |
| Ataques de torchos | 81 ms (70%) | |
| Tontería | 82 ms (70%) | |
| ARTE | 89 ms (70%) |
El RAI-Toolbox adopta un enfoque único para las perturbaciones basadas en gradientes: se implementan en términos de optimizadores de transformación de parámetros y modelos de perturbación. Esto permite a los usuarios implementar diversos algoritmos (como perturbaciones universales y sondeo de concepto con gradientes dispersos) utilizando el mismo paradigma que un ataque PGD estándar.
