用pytorch写出针对MNIST数据集的DeepFool算法的代码，并写出测试代码用于计算由DeepFool算法得到的对抗性示例攻击神经网络的错误率

以下是使用PyTorch实现DeepFool算法的代码：

import torch
import torch.nn.functional as F
from torch.autograd import Variable

def deepfool(image, net, num_classes=10, overshoot=0.02, max_iter=50):
    """
    :param image: 输入的图像
    :param net: 目标神经网络
    :param num_classes: 类别数
    :param overshoot: 用于增加扰动的参数
    :param max_iter: 最大迭代次数
    :return: 对抗性样本
    """
    image = image.unsqueeze(0)
    image = Variable(image, requires_grad=True)
    net.eval()
    out = net(image)
    _, init_pred = torch.max(out, 1)
    f_image = out[0, init_pred]
    w = torch.zeros(num_classes, 1).cuda()
    r_tot = torch.zeros_like(image).cuda()

    for iter in range(max_iter):
        out.backward(retain_graph=True)
        grad_orig = image.grad.data.clone()

        for k in range(1, num_classes):
            net.zero_grad()
            out[:, k].backward(retain_graph=True)
            grad_k = image.grad.data.clone()

            # 计算w和f的值
            w_k = (grad_k - grad_orig).cpu()
            f_k = (out[0, k] - f_image).cpu()

            # 计算扰动量
            pert_k = abs(f_k) / torch.norm(w_k.flatten())

            # 选择最小的扰动量
            if iter == 0:
                pert = pert_k
                w = w_k
            else:
                idx = torch.norm(w_k.flatten(), p=1) < torch.norm(w.flatten(), p=1)
                pert[idx] = pert_k[idx]
                w[idx, :] = w_k[idx, :]

        # 计算总的扰动量
        r_tot = torch.clamp(r_tot + pert.unsqueeze(1) * w, -overshoot, overshoot)

        # 生成对抗性图像
        image = torch.clamp(image + r_tot, 0, 1).detach_()
        image.requires_grad_()
        net.zero_grad()
        out = net(image)

    _, final_pred = torch.max(out, 1)
    if final_pred.item() == init_pred.item():
        return None
    else:
        return image.squeeze(0)

我们可以使用以下测试代码来计算由DeepFool算法得到的对抗性示例攻击神经网络的错误率：

def test(net, test_loader, eps):
    num_correct = 0
    num_samples = 0
    attack_success = 0

    for images, labels in test_loader:
        images = images.cuda()
        labels = labels.cuda()

        adv_images = deepfool(images, net)
        if adv_images is not None:
            attack_success += 1
            outputs = net(adv_images)
        else:
            outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        num_samples += labels.size(0)
        num_correct += (predicted == labels).sum().item()

    acc = num_correct / num_samples
    attack_success_rate = attack_success / num_samples
    print('Accuracy: {:.2f}%'.format(acc * 100))
    print('Attack success rate: {:.2f}%'.format(attack_success_rate * 100))

其中，`eps`表示扰动量的上限。在测试过程中，我们生成对抗性样本，并将其输入到神经网络中进行预测。如果DeepFool算法成功生成了对抗性样本，则错误率会比没有攻击的情况高。