论文讲解参考对抗样本（五）DeepFool_Bai丁的博客-程序员宅基地

二、论文背景及简介
    目前，没有有效率的方法可以用来精确的计算深度模型对对抗扰动的鲁棒性。在这篇论文中，提出了DeepFool的算法来生成扰动，并且提出了一种量化分类器鲁棒性的方法。

三、论文内容总结
提出了一种计算分类器对对抗扰动的鲁棒性的评价方法
FGSM虽然快，但是它只是提供了最优扰动的一个粗略的估计，它执行的梯度的方法，经常得到的是局部最优解，DeepFool能够得到更小的扰动，甚至比FGSM小一个数量级
提出了一个新的对抗攻击方法DeepFool：

直接放pytorch代码吧

#Deepfool算法示例
from typing import Collection
import torch
import torchvision
from torchvision import datasets, transforms
from torch.autograd import Variable
# from torch.autograd.gradcheck import zero_gradients 这句话运行不了，改为下面这段函数
import torch.utils.data.dataloader as Data
import torch.nn as nn
from torchvision import models
import numpy as np
import cv2


def zero_gradients(x):
    if isinstance(x, torch.Tensor):
        if x.grad is not None:
            x.grad.detach_()
            x.grad.zero_()
    elif isinstance(x, Collection.abc.Iterable):
        for elem in x:
            zero_gradients(elem)

#对比展现原始图片和对抗样本图片
def show_images_diff(original_img,original_label,adversarial_img,adversarial_label):
    import matplotlib.pyplot as plt
    plt.figure()

    #归一化
    if original_img.any() > 1.0:
        original_img=original_img/255.0
    if adversarial_img.any() > 1.0:
        adversarial_img=adversarial_img/255.0

    plt.subplot(131)
    plt.title('Original')
    plt.imshow(original_img)
    plt.axis('off')

    plt.subplot(132)
    plt.title('Adversarial')
    plt.imshow(adversarial_img)
    plt.axis('off')

    plt.subplot(133)
    plt.title('Adversarial-Original')
    difference = adversarial_img - original_img
    #(-1,1)  -> (0,1)
    difference=difference / abs(difference).max()/2.0+0.5
    plt.imshow(difference,cmap=plt.cm.gray)
    plt.axis('off')
    plt.tight_layout()
    plt.show()

#获取计算设备 默认是CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

#图像加载以及预处理
image_path="../picture/test_im1.jpg"# 这里用的是一张鹦鹉的图片，所以输出的label应该是88
orig = cv2.imread(image_path)[..., ::-1]
orig = cv2.resize(orig, (224, 224))
img = orig.copy().astype(np.float32)

mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
img /= 255.0
img = (img - mean) / std
img = img.transpose(2, 0, 1)

img=np.expand_dims(img, axis=0)

img = Variable(torch.from_numpy(img).to(device).float())
print(img.shape)

#使用预测模式 主要影响droupout和BN层的行为
model = models.alexnet(pretrained=True).to(device).eval()

orig_label=np.argmax(model(img).data.cpu().numpy())
print("label={}".format(orig_label))

上面这些代码都可以复用的所以我直接用
 

下面这部分是非定向攻击的代码

#图像数据梯度可以获取
img.requires_grad = True

#设置为不保存梯度值 自然也无法修改
for param in model.parameters():
    param.requires_grad = False
    
#最大迭代次数
epochs=100
#used as a termination criterion to prevent vanishing updates
overshoot=0.02
#类别数
num_classes=1000

# forward 
output = model(img)
#detach()是一个常用的函数，其作用是从计算图中分离出一个张量，返回一个新的张量，新张量与原张量共享数据存储空间，但不再与计算图相连，即新张量不会被用于计算梯度。这样可以避免梯度在反向传播过程中回传到已经不需要梯度的张量上，从而减少计算量，提高训练效率。
input_shape = img.cpu().detach().numpy().shape
w=np.zeros(input_shape)
r_tot=np.zeros(input_shape)

for epoch in range(epochs):
    scores=model(img).data.cpu().numpy()[0]
    label=np.argmax(scores)
    print("epoch={},label={},score={}".format(epoch,label,scores[label])

# 如果无定向攻击成功
    if label!=orig_label:
        break
    pert=np.inf
    output[0,orig_label].backward(retain_graph=True)
    grad_orig=img.grad.data.cpu().numpy().copy()
    for k in range(1, num_classes):
        if k==orig_label:# 如果label不变
            continue
        zero_gradients(img)# 梯度清零
        output[0,k].backward(retain_graph=True)
        cur_grad=img.grad.data.cpu().numpy().copy()
        # set new w_k,f_k
        w_k=cur_grad-grad_orig
        f_k=(output[0,k]-output[0,orig_label]).data.cpu().numpy()
        pert_k=abs(f_k)/np.linalg.norm(wk.flatten())

        # 选择pert最小值
        if pert_k<pert:
            pert=pert_k
            w=w_k
    # 计算r_i和r_tot
    r_i = (pert+1e-8)*w/np.linalg.norm(w)
    r_tot=np.float32(r_tot+r_i)
    img.data=img.data+(1+overshoot)*torch.from_numpy(r_tot).to(device)
        
            

adv=img.data.cpu().numpy()[0]
print(adv.shape)
adv = adv.transpose(1, 2, 0)
adv = (adv * std) + mean
adv = adv * 255.0
adv = np.clip(adv, 0, 255).astype(np.uint8)

show_images_diff(orig,orig_label,adv,label)

下面这部分是定向攻击的代码

#图像数据梯度可以获取
img.requires_grad = True

#设置为不保存梯度值 自然也无法修改
for param in model.parameters():
    param.requires_grad = False

epochs=100
overshoot=0.02

#攻击目标
target_label=288
target=Variable(torch.Tensor([float(target_label)]).to(device).long())

input_shape = img.cpu().detach().numpy().shape
w = np.zeros(input_shape)
r_tot = np.zeros(input_shape)

loss_func = torch.nn.CrossEntropyLoss()

for epoch in range(epochs):
    
    # forward 
    output = model(img)
    
    label=np.argmax(output.data.cpu().numpy())
    loss = loss_func(output, target)
    print("epoch={} label={} loss={}".format(epoch,label,loss))
    
    #如果定向攻击成功
    if label == target_label:
        break
   
    #梯度清零
    zero_gradients(img)

    output[0, target_label].backward(retain_graph=True)
    w = img.grad.data.cpu().numpy().copy()

    f = output[0, target_label].data.cpu().numpy()

    pert = abs(f)/np.linalg.norm(w.flatten())

    # 计算 r_i 和 r_tot
    r_i =  (pert+1e-8) * w / np.linalg.norm(w)
        
    r_tot = np.float32(r_tot + r_i)
    
    img.data=img.data + (1+overshoot)*torch.from_numpy(r_tot).to(device)


adv=img.data.cpu().numpy()[0]
print(adv.shape)
adv = adv.transpose(1, 2, 0)
adv = (adv * std) + mean
adv = adv * 255.0
adv = np.clip(adv, 0, 255).astype(np.uint8)

show_images_diff(orig,orig_label,adv,target_label)