adversarial attacks pytorch
v3.5.1
Torchattacks é uma biblioteca Pytorch que fornece ataques adversários para gerar exemplos contraditórios.
Ele contém interface e funções semelhantes a pytorch que facilitam a implementação de ataques adversários para os usuários do Pytorch.
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 )Pacotes recomendados adicionais .
Citação. Se você usar este pacote, cite o seguinte Bibtex (Googlescholar):
@article{kim2020torchattacks,
title={Torchattacks: A pytorch repository for adversarial attacks},
author={Kim, Hoki},
journal={arXiv preprint arXiv:2010.01950},
year={2020}
}
Requisitos
Instalação
# 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 .
Precauções
(N, C) onde C = number of classes . Considerando a maioria dos modelos em Torchvision.Models Retorna um vetor de (N,C) , onde N é o número de entradas e C é o número de classes, os Torchattacks também suportam apenas formas limitadas de saída. Verifique cuidadosamente a forma da saída do modelo.torch.backends.cudnn.deterministic = True para obter os mesmos exemplos adversários com sementes aleatórias fixa . Algumas operações não são determinísticas com tensores de flutuação na GPU [discuta]. Se você deseja obter os mesmos resultados com as mesmas entradas, execute torch.backends.cudnn.deterministic = True [Ref].Demos
Modo direcionado
# 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 ()Salve imagens adversárias
# Save
atk . save ( data_loader , save_path = "./data.pt" , verbose = True )
# Load
adv_loader = atk . load ( load_path = "./data.pt" )Treinamento/avaliação durante o 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 )Fazer um 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 ])A medida da distância entre parênteses.
| Nome | Papel | Observação |
|---|---|---|
| FGSM (Linf) | Explicando e aproveitando exemplos adversários (Goodfellow et al., 2014) | |
| Bim (Linf) | Exemplos adversários no mundo físico (Kurakin et al., 2016) | Método iterativo básico ou iterativo-fsgm |
| Cw (L2) | Para avaliar a robustez das redes neurais (Carlini et al., 2016) | |
| RFGSM (Linf) | Traning adversário de conjunto: ataques e defesas (Tramèr et al., 2017) | Inicialização aleatória + FGSM |
| PGD (Linf) | Rumo a modelos de aprendizado profundo resistentes a ataques adversários (Mardry et al., 2017) | Método de gradiente projetado |
| PGDL2 (L2) | Rumo a modelos de aprendizado profundo resistentes a ataques adversários (Mardry et al., 2017) | Método de gradiente projetado |
| Mifgsm (Linf) | Aumentar ataques adversários com momento (Dong et al., 2017) | ? Colaborador Zhuangzi926, Huitailangyz |
| Tpgd (Linf) | Teoricamente, troca de princípios entre robustez e precisão (Zhang et al., 2019) | |
| Eotpgd (Linf) | Comente sobre "Adv-Bnn: Defesa Adversária Melhorada através de Rede Neural Bayesiana robusta" (Zimmermann, 2019) | EOT+PGD |
| APGD (Linf, L2) | Avaliação confiável da robustez adversária com um conjunto de diversos ataques livres de parâmetros (Croce et al., 2020) | |
| Apgdt (Linf, L2) | Avaliação confiável da robustez adversária com um conjunto de diversos ataques livres de parâmetros (Croce et al., 2020) | APGD direcionado |
| Fab (Linf, L2, L1) | Exemplos adversários minimamente distorcidos com um ataque limite adaptativo rápido (Croce et al., 2019) | |
| Quadrado (Linf, L2) | Ataque quadrado: um ataque adversário de caixa preta eficiente em consulta via pesquisa aleatória (Andriushchenko et al., 2019) | |
| Autoattack (Linf, L2) | Avaliação confiável da robustez adversária com um conjunto de diversos ataques livres de parâmetros (Croce et al., 2020) | Apgd+apgdt+fab+quadrado |
| DeepFool (L2) | DeepFool: Um método simples e preciso para enganar as redes neurais profundas (Moosavi-dezfooli et al., 2016) | |
| OnePixel (L0) | Um ataque de pixel para enganar as redes neurais profundas (Su et al., 2019) | |
| Sparsefool (L0) | Sparsefool: Alguns pixels fazem uma grande diferença (Modas et al., 2019) | |
| Difgsm (Linf) | Melhorando a transferibilidade dos exemplos adversários com a diversidade de insumos (Xie et al., 2019) | ? Colaborador Taobai |
| TIFGSM (Linf) | Evitando as defesas para exemplos adversários transferíveis por ataques invariantes à tradução (Dong et al., 2019) | ? Colaborador Taobai |
| NIFGSM (Linf) | Nesterov acelerou o gradiente e a invariância em escala para ataques adversários (Lin, et al., 2022) | ? Colaborador Zhijin-Ge |
| Sinifgsm (Linf) | Nesterov acelerou o gradiente e a invariância em escala para ataques adversários (Lin, et al., 2022) | ? Colaborador Zhijin-Ge |
| Vmifgsm (Linf) | Melhorando a transferibilidade dos ataques adversários por meio do ajuste da variação (Wang, et al., 2022) | ? Colaborador Zhijin-Ge |
| VNIFGSM (Linf) | Melhorando a transferibilidade dos ataques adversários por meio do ajuste da variação (Wang, et al., 2022) | ? Colaborador Zhijin-Ge |
| Jitter (Linf) | Explorando classificações incorretas de redes neurais robustas para aprimorar ataques adversários (Schwinn, Leo, et al., 2021) | |
| Pixle (L0) | Pixle: um ataque de caixa preta rápida e eficaz com base em pixels reorganizados (Pomponi, Jary, et al., 2022) | |
| LGV (Linf, L2, L1, L0) | LGV: aumentando a transferibilidade do exemplo adversário da grande vizinhança geométrica (Gubri, et al., 2022) | ? Colaborador Martin Gubri |
| SPSA (Linf) | Risco adversário e os perigos de avaliar contra ataques fracos (Uesato, Jonathan, et al., 2018) | ? Colaborador Riko Naka |
| JSMA (L0) | As limitações do aprendizado profundo em ambientes adversários (Papernot, Nicolas, et al., 2016) | ? Colaborador Riko Naka |
| EADL1 (L1) | EAD: Ataques de rede elástica a redes neurais profundas (Chen, Pin-Yu, et al., 2018) | ? Colaborador Riko Naka |
| Eaden (L1, L2) | EAD: Ataques de rede elástica a redes neurais profundas (Chen, Pin-Yu, et al., 2018) | ? Colaborador Riko Naka |
| PIFGSM (PIM) (Linf) | Ataque de remendo por enganar a rede neural profunda (Gao, Lianli, et al., 2020) | ? Colaborador Riko Naka |
| PIFGSM ++ (PIM ++) (Linf) | Perturbação de remendo ++ para ataques direcionados adversários (Gao, Lianli, et al., 2021) | ? Colaborador Riko Naka |
Quanto aos pacotes de comparação, atualmente atualizados e os métodos mais citados foram selecionados:
Precisão robusta contra cada ataque e tempo decorrido nas 50 primeiras imagens do CIFAR10. Para ataques de L2, as distâncias médias de L2 entre imagens adversárias e as imagens originais são gravadas. Todas as experiências foram feitas no GeForce RTX 2080. Para a versão mais recente, consulte aqui (código, NBViewer).
| Ataque | Pacote | Padrão | Wong2020Fast | RICE202030OVERFITTION | Observação |
|---|---|---|---|---|---|
| FGSM (LINF) | Torchattacks | 34% (54ms) | 48% (5ms) | 62% (82ms) | |
| Foolbox * | 34% (15ms) | 48% (8ms) | 62% (30ms) | ||
| ARTE | 34% (214ms) | 48% (59ms) | 62% (768ms) | ||
| PGD (LINF) | Torchattacks | 0% (174ms) | 44% (52ms) | 58% (1348ms) | ? Mais rápido |
| Foolbox * | 0% (354ms) | 44% (56ms) | 58% (1856ms) | ||
| ARTE | 0% (1384 ms) | 44% (437ms) | 58% (4704ms) | ||
| CW † (L2) | Torchattacks | 0% / 0,40 (2596ms) | 14% / 0,61 (3795ms) | 22% / 0,56 (43484ms) | ? Maior taxa de sucesso ? Mais 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) | Torchattacks | 0% / 0,41 (184ms) | 68% / 0,5 (52ms) | 70% / 0,5 (1377ms) | ? Mais rápido |
| Foolbox * | 0% / 0,41 (396ms) | 68% / 0,5 (57ms) | 70% / 0,5 (1968ms) | ||
| ARTE | 0% / 0,40 (1364ms) | 68% / 0,5 (429ms) | 70% / 0,5 (4777ms) |
* Observe que o FoolBox retorna a precisão e as imagens adversárias simultaneamente, portanto, o tempo real para gerar imagens adversárias pode ser mais curto que os registros.
† Considerando que o algoritmo de pesquisa binária para const c pode ser demorado, os Torchattacks suportam o MutliatTack para a pesquisa da grade c .
Além disso, também recomendo usar um pacote recentemente proposto, o Rai-Toolbox .
| Ataque | Pacote | Hora/etapa (precisão) |
|---|---|---|
| FGSM (LINF) | Rai-Toolbox | 58 ms (0%) |
| Torchattacks | 81 ms (0%) | |
| Foolbox | 105 ms (0%) | |
| ARTE | 83 ms (0%) | |
| PGD (LINF) | Rai-Toolbox | 58 ms (44%) |
| Torchattacks | 79 ms (44%) | |
| Foolbox | 82 ms (44%) | |
| ARTE | 90 ms (44%) | |
| PGD (L2) | Rai-Toolbox | 58 ms (70%) |
| Torchattacks | 81 ms (70%) | |
| Foolbox | 82 ms (70%) | |
| ARTE | 89 ms (70%) |
O Rai-Toolbox adota uma abordagem única para perturbações baseadas em gradiente: elas são implementadas em termos de otimizadores e modelos de perturbação que transformam parâmetros. Isso permite que os usuários implementem algoritmos diversos (como perturbações universais e investigação de conceito com gradientes escassos) usando o mesmo paradigma que um ataque de PGD padrão.
