one pixel attack keras

Um ataque de pixel

Quão simples é fazer com que uma rede neural profunda classifique incorretamente uma imagem se um invasor só puder modificar a cor de um pixel e ver apenas a probabilidade de previsão? Acontece que é muito simples. Em muitos casos, um invasor pode até fazer com que a rede retorne qualquer resposta que desejar.

O projeto a seguir é uma reimplementação de Keras e um tutorial de "um ataque de pixels por enganar redes neurais profundas". O código oficial do artigo pode ser encontrado aqui.

Como funciona

Para este ataque, usaremos o conjunto de dados CIFAR10. A tarefa do conjunto de dados é classificar corretamente uma imagem de 32x32 pixels em 1 de 10 categorias (por exemplo, pássaro, veado, caminhão). O ataque de caixa preta requer apenas os rótulos de probabilidade (o valor de probabilidade de cada categoria) que é emitido pela rede neural. Geramos imagens adversárias selecionando um pixel e modificando -as para uma certa cor.

Usando um algoritmo evolutivo chamado evolução diferencial (DE), podemos gerar iterativamente imagens adversárias para tentar minimizar a confiança (probabilidade) da classificação da rede neural.

_{^{Crédito: Blog de Pablo R. Mier}}

Primeiro, gerar várias amostras adversárias que modificam um pixel aleatório e executam as imagens através da rede neural. Em seguida, combine as posições e cores dos pixels anteriores, gerar várias outras amostras adversárias e execute as novas imagens através da rede neural. Se houve pixels que reduziram a confiança da rede a partir da última etapa, substitua -os como as soluções mais conhecidas atuais. Repita essas etapas para algumas iterações; Então, na última etapa, retorne a imagem adversária que reduziu mais a confiança da rede. Se bem -sucedido, a confiança seria reduzida tanto que uma nova categoria (incorreta) agora tem a maior confiança de classificação.

Veja abaixo alguns exemplos de ataques bem -sucedidos:

Começando

Precisa de uma GPU ou apenas quer ler? Veja o primeiro caderno do tutorial com o Google Colab.

Para executar o código no tutorial localmente, recomenda-se uma GPU dedicada para executar com Keras ( tensorflow-gpu ). Python 3.5+ necessário.

1. Clone o repositório.

git clone https://github.com/Hyperparticle/one-pixel-attack-keras
cd ./one-pixel-attack-keras

2. Instale os pacotes python nos requisitos.txt se você ainda não os possui.

pip install -r ./requirements.txt

3. Execute o Caderno do Tutorial do Ipython com Jupyter.

jupyter notebook ./one-pixel-attack.ipynb

Treinamento e teste

Para treinar um modelo, execute train.py O modelo será posicionado (salvo) após cada época no diretório networks/models .

Por exemplo, para treinar uma resnet com 200 épocas e um tamanho de lote de 128:

python train.py --model resnet --epochs 200 --batch_size 128

Para realizar ataques, execute attack.py . Por padrão, isso executará todos os modelos com parâmetros padrão. Para especificar os tipos de modelos para testar, use --model .

python attack.py --model densenet capsnet

Os modelos disponíveis atualmente são:

• lenet - LeNet, primeiro modelo CNN
• pure_cnn - um nn com apenas camadas convolucionais
• net_in_net - rede na rede
• resnet - aprendizado residual profundo para reconhecimento de imagem
• densenet - redes convolucionais densamente conectadas
• wide_resnet - redes residuais amplas
• capsnet - roteamento dinâmico entre cápsulas

Resultados

Resultados preliminares depois de executar vários experimentos em vários modelos. Cada experimento gera 100 imagens adversárias e calcula a taxa de sucesso de ataque, ou seja, a proporção de imagens que causaram com sucesso o modelo a classificar incorretamente uma imagem sobre o número total de imagens. Para um determinado modelo, vários experimentos são executados com base no número de pixels que podem ser modificados em uma imagem (1,3 ou 5). O algoritmo diferencial foi executado com um tamanho de população de 400 e uma contagem máxima de iteração de 75.

Ataque em 1,3,5 perturbações de pixels (100 amostras)

modelo	parâmetros	precisão do teste	pixels	Sucesso de ataque (não direcionado)	Sucesso de ataque (direcionado)
LENET	62k	74,9%	1	63,0%	34,4%
			3	92,0%	64,4%
			5	93,0%	64,4%
CNN puro	1.4m	88,8%	1	13,0%	6,67%
			3	58,0%	13,3%
			5	63,0%	18,9%
Rede em rede	970K	90,8%	1	34,0%	10,0%
			3	73,0%	24,4%
			5	73,0%	31,1%
Resnet	470K	92,3%	1	34,0%	14,4%
			3	79,0%	21,1%
			5	79,0%	22,2%
Densenet	850k	94,7%	1	31,0%	4,44%
			3	71,0%	23,3%
			5	69,0%	28,9%
Ampla resnet	11m	95,3%	1	19,0%	1,11%
			3	58,0%	18,9%
			5	65,0%	22,2%
Capsnet	12m	79,8%	1	19,0%	0,00%
			3	39,0%	4,44%
			5	36,0%	4,44%

Parece que a rede de cápsulas CapsNet, embora mais resistente ao ataque de um pixel do que todas as outras CNNs, ainda é vulnerável.

Conquistas

• Conjunto de dados CIFAR10
• Notebook tutorial
• LENET, Rede em Rede, Rede Residual, Modelos Densenet
• Modelo CapsNet (Rede Capsule)
• Interface da linha de comando configurável
• Implementação eficiente de evolução da evolução
• DataSet ImageNet