基于梯度的黑盒迁移对抗攻击（附代码）

1 引言

 黑盒迁移攻击是对抗攻击中非常热门的一个研究方向，基于动量梯度的方法又是黑盒迁移攻击的一个主流方向。当前大部分研究主要通过在数据样本的尺寸，分布，规模，时序等方面来丰富梯度的多样性，使得生成的对抗样本在迁移到其它的模型攻击时，能够有更高的攻击成功率。本文会介绍最近几年有代表性的黑盒迁移攻击的论文，这些论文的方法经常会被当成论文比较的baseline。我对论文中涉及到一些数学结论进行补充证明，大部分论文中给出的源码是tensorflow的，我又根据论文的算法流程图用pytorch对论文的核心方法重新编程了一下，代码实例在文末所示。

2 注意力攻击（AOA）

2.1 论文简介

 在该论文中作者提出一种注意力攻击 (AoA)，注意显著图是深度学习模型共享的语义属性。作者发现当交叉熵损失被注意力损失取代时，AoA方法生成对抗样本的可迁移性会显着提高。除此之外由于AoA方法只改变了损失函数，它可以很容易地与其它对抗样本可迁移性增强技术相结合，从而实现更好的 SOTA 性能。作者应用AoA方法从ImageNet验证集中生成 50000个对抗样本并攻击成功许多神经网络模型，并将数据集命名为DAmageNet，该数据及是第一个通用对抗数据集。

论文链接：https://arxiv.org/abs/2001.06325
数据集链接：http://www.pami.sjtu.edu.cn/Show/56/122

2.2 论文方法

 令$h(x,y)$表示输入$x$和指定类$y$的注意力热力图。$h(x,y_{\mathrm{ori}})$是一个与输入$x$维度一致的张量。

• 抑制损失函数$L_{\mathrm{supp}}$： 其目的是抑制正确类别$h(x,y_{\mathrm{ori}})$的注意力热力图的大小。当正确类的网络注意力降低时，其他类的注意力会增加并最终超过正确的类，从而导致模型寻求获取有关其它类别的信息而不是正确类别的信息，从而做出不正确的预测，具体的损失函数如下所示：$$L_{\mathrm{supp}}=\Vert h(x,y_{\mathrm{ori}}){\Vert }_1$$其中$\Vert \cdot \Vert$表示${\ell }_1$范数。

• 分散损失函数$L_{\mathrm{dstc}}$： 当注意力从原始感兴趣区域分散时，模型可能会失去预测能力。 在这种情况下，不需要网络关注任何不正确类别的信息，而是引导它关注图像的不相关区域，具体的损失可以表示为以下形式：$$L_{\mathrm{dstc}}(x)=-{\Vert \frac{h(x,y_{\mathrm{ori}})}{\max (h(x,y_{\mathrm{ori}}))}-\frac{h(x_{\mathrm{ori}},y_{\mathrm{ori}})}{\max (h(x_{\mathrm{ori}},y_{\mathrm{ori}}))}\Vert }_1$$其中通过进行自归一化以消除注意力大小的影响。

• 边界损失函数$L_{\mathrm{bdry}}$： 其目的是减小$h(x,y_{\mathrm{ori}})$和$h(x,y_{\sec }(x))$（即第二大概率的热力图）之间的距离。如果第二类的注意力大小超过正确类的注意力大小，网络将更加关注关于错误预测的信息，具体形式如下所示： $$L_{\mathrm{bdry}}(x)=\Vert h(x,y_{\mathrm{ori}}){\Vert }_1-\Vert h(x,y_{\sec }(x)){\Vert }_1$$不同模型的注意力热力图值差异很大，因此自归一化可以提高对抗样本的可迁移性。 除此之外还可以考虑$h(x,y_{\mathrm{ori}})$和$h(x,y_{\sec }(x))$之间的比率，从而得到以下对数边界损失：$$L_{\log }(x)=\log (\Vert h(x,y_{\mathrm{ori}}){\Vert }_1)-\log (\Vert h(x,y_{\sec }(x)){\Vert }_1)$$

经实验可知，对数边界损失是迁移攻击效果最好的，因此该损失函数被选为目标函数的中的一项。 此外，注意力攻击可以很容易地与交叉熵损失函数$L_{\mathrm{CE}}$相结合，则有AoA损失函数如下所示：$$L_{\mathrm{AoA}}(x)=L_{\log }(x)-\lambda L_{\mathrm{ce}}(x,y_{\mathrm{ori}})$$其中$\lambda$是注意力攻击和交叉熵之间的权衡系数。
 通过最小化损失函数$L_{\mathrm{AoA}}$来生成对抗样本，令$x_{\mathrm{adv}}^0=x_{\mathrm{ori}}$，则具体的更新过程如下所示：$$\begin{array}{rl}{x}_{\mathrm{adv}}^{k+1}& ={\mathrm{clip}}_{\epsilon }\left(x_{\mathrm{adv}}^k-\alpha \frac{g(x_{\mathrm{adv}}^k)}{\Vert g(x_{\mathrm{adv}}^k){\Vert }_1/N}\right)\\ g(x)& =\frac{\partial L_{\mathrm{AoA}}(x)}{\partial x}\end{array}$$其中梯度$g$进行${\ell }_1$范数正则化，其中$N$表示的是图像像素数量。为了使得对抗扰动不可见，作者通过与原始干净样本的距离来限制对抗攻击的强度。 AoA也可以直接运用到对抗样本的可迁移攻击中，通过输入修改，AoA的可迁移性能得到进一步提高。AoA算法的算法流程图如下所示：

当为有目标攻击时，且攻击目标类别为$y_{\mathrm{tar}}$，则AoA损失函数如下所示：$$\begin{array}{rl}{L}_{\mathrm{AoA}}(x)& =L_{\log }(x)+\lambda L_{\mathrm{ce}}(x,y_{\mathrm{tar}})\\ & =\log (\Vert h(x,\underset{i\ne \mathrm{tar}}{\max }{y}_i(x)){\Vert }_1)-\log (\Vert h(x,y_{\mathrm{tar}}){\Vert }_1)+\lambda L_{\mathrm{ce}}(x,y_{\mathrm{tar}})\end{array}$$

3 线性反向传播（LinBP）

3.1 论文简介

 在该论文中，作者重新审视了Goodfellow等人之前提出了一个深度学习模型线性假设，在此基础上作者提出一种增强对抗样本可迁移性的方法线性反向传播 （LinBP），这是一种使用梯度的现成攻击以更线性的方式执行反向传播的方法，该方法在神经网络中正常计算前向传播过程，但在计算反向传播损失时，就好像在前向传播中没有遇到一些非线性激活函数一样。

论文链接：https://arxiv.org/abs/2012.03528
代码链接：https://github.com/qizhangli/linbp-attack

3.2 论文方法

 Goodfellow等人曾提出一个假设，即对抗样本的可迁移性其主要原因在于深度学习模型其内在的近似线性特征，类似于在同一数据集上训练的线性模型。如下图所示，每个方格表示CIFAR数据集的一个样本，每个方格里的颜色中白色表示该样本经过模型分类为正确的类别，其它的颜色表示模型分类出错为其它类别。可以发现样本沿着某个方向扰动，分类边界呈现线性特征。

 尽管该假设在小数据集模型中的实验里得到了验证，但在大数据集中的大型网络上几乎没有经验证据可以验证它，更不用说在实践中使用该假设。所以，在该论文中，作者首先需要验证大数据集中的大型网络上对抗样本的可迁移性根植于模型的近似线性特征。
 给定一个源模型$f:{\mathbb{R}}^n\to {\mathbb{R}}^c$，将输入实例分类输出$c$类。在该论文中作者比较基于迁移攻击在模型$f$和更线性的模型$f^{\prime }$（或更非线性的模型$f^{\prime \prime }$）上的成功率。 为简单起见，考虑由一系列权重矩阵 $W_1\in {\mathbb{R}}^{n_0\times n_1}\cdots ,W_d\in {\mathbb{R}}^{n_{d-1}\times n_d}$参数化的源模型，其中$n_0=n$和$n_d=c$，其输出可以写为$$f(\mathbf{x})=W_d^{\top }\sigma (W_{d-1}^{\top }\cdots \sigma (W_1^{\top }\mathbf{x}))$$其中$\sigma (\cdot )$是非线性激活函数，一般情况下激活函数会选择ReLU激活函数。由于模型$f$的非线性仅来自于$\sigma (\cdot )$函数，作者通过简单地删除其中一些$\sigma (\cdot )$函数来获得所需的$f^{\prime }$，从而得到一个与模型$f$共享相同数量的参数和核心架构的模型。 与使用泰勒展开并在局部获得线性化的某些工作不同，论文作者的方法（称为线性替换，LinS）会导致全局近似。

证明： 令${\mathbf{z}}_h=h(\mathbf{x})$，$g$是分类器$f$的由第$k$层到第$d$层的子网络，激活函数为$\mathrm{ReLU}$激活函数，即$${\mathbf{z}}_g=g({\mathbf{z}}_h)=W_d^{\top }\sigma (W_{d-1}^{\top }\cdots \sigma (W_k^{\top }{\mathbf{z}}_h))=f(\mathbf{x})$$由矩阵的微分定理可知$$dL(\mathbf{x},y)={\left(\frac{\partial L(\mathbf{x},y)}{\partial \mathbf{x}}\right)}^{\top }d\mathbf{x},dL(\mathbf{x},y)={\left(\frac{\partial L(\mathbf{x},y)}{\partial {\mathbf{z}}_g}\right)}^{\top }d{\mathbf{z}}_g$$对$d{\mathbf{z}}_g$求微分可知$$d{\mathbf{z}}_g=W_d^{\top }{M}_{d-1}{W}_{d-1}^{\top }{M}_{d-2}\cdots W_{k+1}^{\top }{M}_k{W}_k^{\top }d{\mathbf{z}}_h$$对$d{\mathbf{z}}_h$求微分$$d{\mathbf{z}}_h={\left(\frac{\partial {\mathbf{z}}_h}{\partial \mathbf{x}}\right)}^{\top }d(\mathbf{x})$$将以上公式进行整理可得$$dL(\mathbf{x},y)={\left(\frac{\partial L(\mathbf{x},y)}{\partial {\mathbf{z}}_g}\right)}^{\top }{W}_d^{\top }{M}_{d-1}{W}_{d-1}^{\top }{M}_{d-2}\cdots W_{k+1}^{\top }{M}_k{W}_k^{\top }{\left(\frac{\partial {\mathbf{z}}_h}{\partial \mathbf{x}}\right)}^{\top }d\mathbf{x}$$进而可推知$${\nabla }_{\mathbf{x}}L(\mathbf{x},y)=\frac{\partial L(\mathbf{x},y)}{\partial \mathbf{x}}=\frac{\partial {\mathbf{z}}_h}{\partial \mathbf{x}}{W}_k{M}_k\cdots M_{d-1}{W}_d\frac{\partial L(\mathbf{x},y)}{\partial {\mathbf{z}}_g}\in {\mathbb{R}}^{n\times 1}$$当除去激活函数时，此时则有$M_k=M_{k+1}=\cdots =M_{d-1}$，进而则有$${\nabla }_{\mathbf{x}}L(\mathbf{x},y)=\frac{\partial L(\mathbf{x},y)}{\partial \mathbf{x}}=\frac{\partial {\mathbf{z}}_h}{\partial \mathbf{x}}{W}_k\cdots W_d\frac{\partial L(\mathbf{x},y)}{\partial {\mathbf{z}}_g}\in {\mathbb{R}}^{n\times 1}$$论文中采用的是行向量，以上证明是用列向量，所以结论得证。
 实验是在 CIFAR-10数据集上使用VGG-19网络和批量归一化得到源模型$f$进行的。作者移除最后两个 VGG 块中的所有非线性单元以产生初始模型$f^{\prime }$，即表示为$f_0^{\prime }$。它可以写成两个子网的组合，即$f_0^{\prime }=g^{\prime }\circ h$，所以可知自网络$g_0^{\prime }$是纯线性的。由于这种简单的“线性化”会导致网络在预测干净样本时的准确性下降，因此作者尝试微调 LinS模型$f^{\prime }$。作者评估由模型$f_0^{\prime },\cdots ,f_m^{\prime }\cdots$在第$0,\cdots ,m$轮后生成对抗样本的可迁移性。实验结果如下图所示，这表明LinS方法确实可以提高对抗样本的可迁移性，而且在短期微调的情况下，它大大提高了网络的预测精度。当迭代轮数$m\ge 1$，$f_m^{\prime }$总是有助于生成比模型$f$更多的可迁移对抗样本，在$f_0^{\prime }$上由I-FGSM生成的对抗样本也实现了不错的可迁移性。当迭代轮数$m=80$时，由于过度拟合，进一步的训练会导致可迁移性降低。还能够发现当模型没有ReLU激活函数时，这两个模型都产生了更多可迁移的对抗样本，因此该假设得到了部分验证。

 以上实验已经证实，通过直接去除 ReLU层可以获得提高的对抗样本的可转移性，但是删除越多的 ReLU层并不总是意味着更好的性能，因为直接修改架构不可避免地会降低预测精度。如何在线性和准确性之间寻求合理的权衡是一个论文作者接下来要解决的问题。在该论文中作者提出了线性反向传播LinBP方法，其具体的计算公式如下所示：$${\nabla }_{\mathbf{x}}L(\mathbf{x},y)=\frac{dL(\mathbf{x},y)}{d{\mathbf{z}}_g}{W}_d\cdots W_k\frac{d{\mathbf{z}}_h}{d\mathbf{x}}$$其中${\mathbf{z}}_h=h(\mathbf{x})$，$g$是由$f$的第$k$层到第$d$层组成的子网络，则有$${\mathbf{z}}_g=g({\mathbf{z}}_h)=W_d^{\top }\sigma (W_{d-1}^{\top }\cdots (W_k^{\top }{\mathbf{z}}_h))=f(\mathbf{x})$$LinBP方法不需要微调，因为它前向计算并做出预测，就像训练有素的源模型$f$一样。如下表可知，与或没有微调的LinS模型相比，LinBP的表现良好，实现了在线性和精度之间进行更合理的权衡。 由于（部分）没有 ReLU，它们都显示出比基线更高的计算效率。

对于残差块${\mathbf{z}}_{i+1}={\mathbf{z}}_i+W_{i+1}^{\top }\sigma (W_i^{\top }{\mathbf{z}}_i)$，标准反向传播计算导数为$d{\mathbf{z}}_{i+1}/d{\mathbf{z}}_{\mathbf{i}}=1+W_i{M}_i{W}_{i+1}$，而“线性化”计算导数为${\Omega }_i=1+W_i{W}_{i+1}$，其中$M_i$是一个对角矩阵。作者将梯度进行归一化即在反向传播期间计算$1+{\alpha }_i{W}_i{W}_{i+1}$，其中${\alpha }_i=\Vert d{\mathbf{z}}_{i+1}/d{\mathbf{z}}_i-1\Vert /\Vert {\Omega }_i-1\Vert$，标量${\alpha }_i$是由梯度自动确定。

4 方差调整动量攻击（VMI-FGSM）

4.1 论文简介

 在该论文中，作者提出了一种梯度方差调整的对抗攻击的方法，其目的是增强基于迭代梯度的攻击方法生成对抗样本的可迁移性。在每次迭代进行梯度计算时，不再直接使用当前梯度进行动量累积，而是进一步考虑上一次迭代的梯度方差来调整当前梯度，从而稳定更新方向，避免不良局部最优。

论文链接：https://arxiv.org/abs/2103.15571
代码链接：https://github.com/JHL-HUST/VT

4.2 论文方法

 给定目标参数为$\theta$的分类器$f$和初始干净对抗样本$x\in \mathcal{X}$，其中$x$是$d$维，$\mathcal{X}$表示所有的样本。对抗攻击的形式函数如下所示：$$f(x;\theta )\ne f(x^{\mathrm{adv}};\theta )s.t.\Vert x-x^{\mathrm{adv}}\Vert <ϵ$$对于白盒攻击，可以把对抗攻击看作是一个优化问题，在$x$的邻域中搜索一个样本，从而最大化目标分类器$f$的损失函数$J$：$$x^{\mathrm{adv}}=\arg \underset{x^{\prime }}{\max }J(x^{\prime },y;\theta )$$

定义（梯度方差）： 给定具有参数$\theta$和损失函数$J(x,y;\theta )$的分类器$f$，任意图像$x\in \mathcal{X}$和邻域的上限${ϵ}^{\prime }$，梯度方差可以定义为：$$V_{{ϵ}^{\prime }}^g={\mathbb{E}}_{\Vert x^{\prime }-x{\Vert }_p<{ϵ}^{\prime }}[{\nabla }_{x^{\prime }}J(x^{\prime },y;\theta )]-{\nabla }_{x}J(x,y;\theta )$$

 令$V(x)$来表示$V_{{ϵ}^{\prime }}^g(x)$，由于输入空间的连续性，不能直接计算${\mathbb{E}}_{\Vert x^{\prime }-x{\Vert }_p<{ϵ}^{\prime }}[{\nabla }_{x^{\prime }}J(x^{\prime },y;\theta )]$。 因此，通过在$x$的邻域采样$N$个样本来近似其值，计算$V(x)$具体形式如下所示：
$$V(x)=\frac{1}{N}\sum _{i=1}^N{\nabla }_{x^i}J(x^i,y;\theta )-{\nabla }_{x}J(x,y;\theta )$$其中$x^i=x+r_i$，$r_i\sim U[-(\beta \cdot ϵ{)}^d,(\beta \cdot ϵ{)}^d]$，$U[a^d,b^d]$表示$d$维均匀分布。得到梯度方差后，可以用第$(t-1)$次迭代的梯度方差$V(x_{t-1}^{\mathrm{adv}})$调整第$t$次迭代的$x_t^{\mathrm{adv}}$的梯度，以稳定更新方向。论文具体的算法流程图如下所示：

5 梯度加速和尺度不变对抗攻击

5.1 论文简介

 在该论文中，作者从将对抗样本生成视为优化过程的角度，提出了两种新的方法来提高对抗样本的可迁移性，即Nesterov迭代快速梯度符号方法（NI-FGSM）和尺度不变攻击方法（SIM）。 NI-FGSM旨在将Nesterov加速梯度适应于迭代攻击中，从而有效地预见并提高对抗样本的可迁移性。SIM方法是基于对深度学习模型的尺度不变特性，利用它来优化输入图像尺度副本上的对抗扰动，以避免对白盒模型的过拟合被攻击并产生更多可转移的对抗样本。 NI-FGSM和SIM可以自然地集成以构建强大的基于梯度的攻击，从而针对防御模型生成更多可转移的对抗样本。

论文链接：https://arxiv.org/abs/1908.06281
代码链接：https://github.com/JHL-HUST/SI-NI-FGSM

5.2 论文方法

 NAG是在标准梯度下降法中引入一些轻微的改变，它可以加快训练过程并显着提高收敛性。 NAG可以看作是一种改进的动量方法，其可以表示为：
$$\begin{array}{rl}{v}_{t+1}& =\mu \cdot v_t+{\nabla }_{{\theta }_t}J({\theta }_t-\alpha \cdot \mu \cdot v_t)\\ {\theta }_{t+1}& ={\theta }_t-\alpha \cdot v_{t+1}\end{array}$$典型的基于梯度的迭代攻击在每次迭代时贪婪地扰乱梯度符号方向的图像，通常陷入较差的局部最大值，并且比单步攻击表现出弱的可迁移性。但有研究表明在攻击中采用动量可以稳定其更新方向，这有助于摆脱陷入不良的局部最大值并提高可迁移性。与动量相比，除了稳定更新方向之外，NAG的预期更新对先前累积的梯度进行了修正， NAG 的这种前瞻性特性可以帮助更轻松、更快地摆脱不良的局部最大值，从而提高可迁移性。在该论文中作者将 NAG 集成到基于迭代梯度的攻击中，以利用 NAG 的前瞻性属性并构建强大的对抗性攻击，作者将其称为 NI-FGSM。具体来说，在每次迭代中计算梯度之前，会在先前累积梯度的方向上进行一次跳跃。以$g_0=0$开始，NI-FGSM的更新过程可以形式化为如下所示：$$\begin{array}{rl}{x}_t^{\mathrm{nes}}& =x_t^{\mathrm{adv}}+\alpha \cdot \mu \cdot g_t,\\ g_{t+1}& =\mu \cdot g_t+\frac{{\nabla }_{x}J(x_t^{\mathrm{nes}},y^{\mathrm{true}})}{\Vert {\nabla }_{x}J(x_t^{\mathrm{nes}},y^{\mathrm{true}}){\Vert }_1}\\ x_{t+1}^{\mathrm{adv}}& ={\mathrm{Clip}}_x^{ϵ}\left\{x^{\mathrm{adv}}+\alpha \cdot \mathrm{sign}(g_{t+1})\right\}\end{array}$$其中$g_t$表示迭代$t$处的累积梯度，$\mu$表示 $g_t$的衰减因子。

 除了为对抗攻击考虑更好的优化算法外，作者还通过模型增强来提高对抗样本的可迁移性。作者介绍了保损变换和模型增强的正式定义如下所示：

定义（保损变换）: 给定一个输入$x$及其对应的真实标签$y^{\mathrm{true}}$和一个分类器$f(x):x\in \mathcal{X}\to y\in \mathcal{Y}$和交叉熵损失$J(x,y)$，如果存在输入变换$\mathcal{T}(\cdot )$对于任意$x\in \mathcal{X}$满足$J(\mathcal{T}(x),y^{\mathrm{true}})\approx J(x,y^{\mathrm{true}})$ ，则此时$\mathcal{T}(\cdot )$是一个保损变换。

定义（模型增强）: 给定一个输入$x$及其对应的真实标签$y^{\mathrm{true}}$和一个分类器$f(x):x\in \mathcal{X}\to y\in \mathcal{Y}$和交叉熵损失$J(x,y)$，如果存在保损变换$\mathcal{T}(\cdot )$，使得$f^{(}x)=f(\mathcal{T}(x))$，则此时新的模型为原始模型的模型增强。

在该论文中，作者通过模型增强从原始模型中推导出一组模型，这是一种通过保损变换获得多个模型的简单方法。为了获得保损变换，作者发现深度神经网络除了平移不变性外，还可能具有尺度不变性。具体来说，同一模型上的原始图像和缩放图像的损失值相似。因此，尺度变换可以作为一种模型增强的方法。由上述分析，作者提出了一种尺度不变攻击方法（SIM），它优化了输入图像尺度副本上的对抗扰动：$$\begin{array}{rl}\arg \underset{x^{\mathrm{adv}}}{\max }& \frac{1}{m}\sum _{i=0}J(S_i(x^{\mathrm{adv}}),y^{\mathrm{true}})\\ s.t.& \Vert x^{\mathrm{adv}}-x{\Vert }_{\infty }\le ϵ\end{array}$$其中$S_i(x)=x/2^i$表示输入图像$x$的比例副本，比例因子为$1/2^i$，$m$表示比例副本的数量。使用SIM攻击，作者可以通过模型增强有效地实现对多个模型的集成攻击，而不是训练一组模型进行攻击。更重要的是，它可以帮助避免对白盒模型的“过拟合”被攻击并生成更具可转移性的对抗样本。
 对于生成对抗样本的梯度处理，NI-FGSM引入了更好的优化算法来稳定和纠正每次迭代的更新方向。对于生成对抗样本的集成攻击，SIM 引入了模型增强以从单个模型中派生多个模型进行攻击。因此，NI-FGSM和SIM可以自然地结合起来构建更强的攻击，在论文将其称为 SI-NI-FGSM。 SI-NI-FGSM攻击算法的流程图如下所示：

6 代码实例

 以下为本文介绍的相关论文算法的pytorch的代码实现，为方便调用将每个算法都定义成一个函数。尤其需要注意的是，在注意力攻击AoA算法时，会涉及到pytorch对损失函数的二次求导操作，并不能简单的用backward()函数进行实现。

from torchvision import datasets, transforms
from torch.utils.data import DataLoader, Dataset
import torch
import torch.nn as nn
from torch.autograd import Variable
import torch.optim as optim
import torch.nn.functional as F
import os

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.Sq1 = nn.Sequential(         
            nn.Conv2d(in_channels=1, out_channels=16, kernel_size=5, stride=1, padding=2),   # (16, 28, 28)                           #  output: (16, 28, 28)
            nn.ReLU(),                    
            nn.MaxPool2d(kernel_size=2),    # (16, 14, 14)
        )
        self.Sq2 = nn.Sequential(
            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=5, stride=1, padding=2),  # (32, 14, 14)
            nn.ReLU(),                      
            nn.MaxPool2d(2),                # (32, 7, 7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)   

    def forward(self, x):
        x = self.Sq1(x)
        x = self.Sq2(x)
        x = x.view(x.size(0), -1)          
        output = self.out(x)
        return output

epsilon 和 torch.sign()都会影响扰动大小
def AOA_attack(model, input_x, labels, beta, alpha, epsilon):
	input_x.requires_grad = True 
	# Compute CrossEntropyLoss
	outputs = model(input_x)
	loss1 = nn.CrossEntropyLoss()(outputs, labels)
	grad1 = torch.autograd.grad(outputs[0][labels], input_x, retain_graph = True, create_graph=True) # source map、
	one_hot_labels = torch.eye(len(outputs[0]))[labels]
	sec_labels = torch.argmax((1-one_hot_labels)*outputs)
	grad2 = torch.autograd.grad(outputs[0][sec_labels], input_x, retain_graph = True, create_graph=True) # second map 
 	# Compute Log Loss
	loss2 = torch.log(torch.norm(grad1[0],p=1)) - torch.log(torch.norm(grad2[0], p=1)) 
	# AOA loss
	loss = loss1 - beta * loss2
	delta = torch.autograd.grad(loss, input_x, retain_graph = True)
	grad = delta[0]
	return input_x + 0.2 * torch.sign(grad)

def AOA_attack(model, input_x, labels, beta, alpha, epsilon):
	delta = torch.zeros_like(input_x)
	input_x.requires_grad = True 
	# Compute CrossEntropyLoss
	outputs = model(input_x)
	loss1 = nn.CrossEntropyLoss()(outputs, labels)
	grad1 = torch.autograd.grad(outputs[0][labels], input_x, retain_graph = True, create_graph=True) # source map
	one_hot_labels = torch.eye(len(outputs[0]))[labels]
	sec_labels = torch.argmax((1-one_hot_labels)*outputs)
	grad2 = torch.autograd.grad(outputs[0][sec_labels], input_x, retain_graph = True, create_graph=True) # second map 
	# Compute Log Loss
	loss2 = torch.log(torch.norm(grad1[0],p=1)) - torch.log(torch.norm(grad2[0], p=1)) 
	# AOA loss
	loss = loss1 - beta * loss2
	delta = torch.autograd.grad(loss, input_x, retain_graph = True)
	return input_x + alpha * torch.sign(delta[0])



        
def FGM_attack(inputs, targets, net, alpha, epsilon, attack_type):
	delta = torch.zeros_like(inputs)
	delta.requires_grad = True
	outputs = net(inputs + delta)
	loss = nn.CrossEntropyLoss()(outputs, targets)
	loss.backward()
	grad = delta.grad.detach()
	if type == 'FGSN':
		zeta = (torch.norm(inputs, p=0, dim=(2,3), keepdim=True) / torch.norm(inputs, p=2, dim=(2,3), keepdim=True)) * torch.ones(inputs.shape)
		delta.data = torch.clamp(delta + alpha * zeta * grad, -epsilon, epsilon)
	else:
		delta.data = torch.clamp(delta + alpha * torch.sign(grad), -epsilon, epsilon)
	delta = delta.detach()
	return delta


class SIM_NI(object):
	def __init__(self, epsilon, T, mu, m):
		self.epsilon = epsilon
		self.mu = mu
		self.T = T
		self.m = m

	def attack(self, model, images, labels):
		x_adv = images.detach()
		g_t = torch.zeros_like(images)
		loss_fn = nn.CrossEntropyLoss()
		alpha = self.epsilon / self.T
		for t in range(self.T):
			g = torch.zeros_like(x_adv)
			x_nes = x_adv + alpha * self.mu * g_t
			for i in range(self.m):
				x_temp = (x_nes / (2**i)).detach()
				x_temp.requires_grad = True
				outputs_temp = model(x_temp)
				loss_temp = loss_fn(outputs_temp, labels) 
				loss_temp.backward()
				g += x_temp.grad.detach()
			g = g / self.m
			g_t = self.mu * g_t + g / torch.norm(g, p=1, dim=(1,2,3), keepdim = True)
			x_adv = torch.clamp(x_adv + alpha * torch.sign(g_t), -self.epsilon, self.epsilon).detach()
		return x_adv


def SIM_NI_attack(model, images, labels, alpha, mu, m, T):
	x_adv = images.detach()
	g_t = torch.zeros_like(images)
	loss_fn = nn.CrossEntropyLoss()
	epsilon = alpha / T
	for t in range(T):
		g = torch.zeros_like(x_adv)
		x_nes = x_adv + alpha * mu * g_t
		for i in range(m):
			x_temp = (x_nes / (2**i)).detach()
			x_temp.requires_grad = True
			outputs_temp = model(x_temp)
			loss_temp = loss_fn(outputs_temp, labels) 
			loss_temp.backward()
			g += x_temp.grad.detach()
		g = g / m
		g_t = mu * g_t + g / torch.norm(g, p=1, dim=(1,2,3))
		x_adv = torch.clamp(x_adv + alpha * torch.sign(g_t), -0.3, 0.3).detach()
	return x_adv



class VMI(object):
	def __init__(self, epsilon, beta, N, T, mu):
		self.epsilon = epsilon
		self.beta = beta
		self.mu = mu
		self.N = N
		self.T = T

	def attack(self, model, images, lables):
		g = torch.zeros_like(images)
		v = torch.zeros_like(images)
		x_adv = images.detach()
		loss_fn = nn.CrossEntropyLoss()
		alpha = self.epsilon / self.T
		for i in range(self.T):
			x_adv.requires_grad = True
			outputs = model(x_adv)
			loss = loss_fn(outputs, lables)
			loss.backward()
			g_prime = x_adv.grad.detach()
			g = self.mu * g + (g_prime + v) / torch.norm(g_prime + v, p = 2, dim = (1, 2, 3), keepdim = True)
			grad_temp = torch.zeros_like(x_adv)
			for k in range(self.N):
				x_temp = x_adv.detach() + (torch.randn(x_adv.shape)-0.5) * 2 * self.beta
				x_temp.requires_grad = True
				output_temp = model(x_temp)
				loss_temp  = loss_fn(output_temp, lables)
				loss_temp.backward()
				grad_temp += x_temp.detach()
			v = grad_temp / self.N  - g_prime
			x_adv = torch.clamp(x_adv + alpha * torch.sign(g), 0, 1)
			x_adv = x_adv.detach()
		return x_adv

def VMI_attack(model, images, lables, iteration, mu, number, epsilon, alpha):
	g = torch.zeros_like(images)
	v = torch.zeros_like(images)
	x_adv = images.detach()
	loss_fn = nn.CrossEntropyLoss()
	for i in range(iteration):
		x_adv.requires_grad = True
		outputs = model(x_adv)
		loss = loss_fn(outputs, lables)
		loss.backward()
		g_prime = x_adv.grad.detach()
		g = mu * g + (g_prime + v) / torch.unsqueeze(torch.norm(g_prime + v, p=1 , dim=1),1)
		grad_temp = torch.zeros_like(x_adv)
		for k in range(number):
			x_temp = x_adv.detach() + (torch.randn(x_adv.shape)-0.5) * 2 * epsilon
			x_temp.requires_grad = True
			output_temp = model(x_temp)
			loss_temp  = loss_fn(output_temp, lables)
			loss_temp.backward()
			grad_temp += x_temp.detach()
		v = grad_temp / number  - g_prime
		x_adv = x_adv + alpha * torch.sign(g)
		x_adv = x_adv.detach()
	return x_adv




class AoA(object):
	def __init__(self, epsilon, eta, alpha, lambda_, T):
		self.epsilon = epsilon
		self.eta = eta
		self.alpha = alpha
		self.lambda_ = lambda_
		self.T = T

	def attack(self, model, inputs, labels):
		x_ori = inputs.detach()
		x_adv = inputs.detach()
		x_shape = x_ori.shape
		N = float(x_shape[0] * x_shape[1] * x_shape[2] * x_shape[3])
		k = 0
		while torch.sqrt(torch.norm(x_adv-x_ori, p=2)) < self.eta and k < self.T:  ## 3.3591
			x_adv.requires_grad = True  # shape: [1,1,28,28]
			outputs = model(x_adv)
			loss1 = nn.CrossEntropyLoss()(outputs, labels)
			outputs_max, _ = torch.max(outputs, dim=1)
			grad1 = torch.autograd.grad(outputs_max, x_adv, grad_outputs = torch.ones_like(outputs_max), retain_graph = True, create_graph=True) # source map
			one_hot_labels = torch.eye(len(outputs[0]))[labels]
			outputs_sec, _ = torch.max((1-one_hot_labels)*outputs, dim=1)
			grad2 = torch.autograd.grad(outputs_sec, x_adv, grad_outputs = torch.ones_like(outputs_sec), retain_graph = True, create_graph=True) # second map 
			# Compute Log Loss
			loss2 = (torch.log(torch.norm(grad1[0], p=1, dim=[1,2,3])) - torch.log(torch.norm(grad2[0], p=1,dim=(1,2,3)))).sum() / x_shape[0]
			# AOA loss
			loss = loss2 - self.lambda_ * loss1
			delta = torch.autograd.grad(loss, x_adv, retain_graph = True)
			x_adv = torch.clamp(x_adv -  self.alpha * delta[0]/(torch.norm(delta[0], p=1)/N), 0,1).detach()
			k = k + 1
		return x_adv


def main():
	alpha = 0.2
	epsilon = 0.5
	total = 0
	correct1 = 0
	correct2 = 0
	# model = CNN()
	# model.load_state_dict(torch.load('model/model.pt'))
	model = torch.load('model_test.pkl')
	use_cuda = torch.cuda.is_available()
	mnist_train = datasets.MNIST("mnist-data", train=False, download=True, transform=transforms.ToTensor())
	train_loader = torch.utils.data.DataLoader(mnist_train, batch_size= 5, shuffle=True)

	for batch_idx, (inputs, targets) in enumerate(train_loader):
		if use_cuda:
			inputs, targets = inputs.cuda(), targets.cuda()
		inputs, targets = Variable(inputs), Variable(targets)
		total += targets.size(0)
		# print(inputs.shape)

		outputs = model(inputs)
		_, predicted = torch.max(outputs.data, 1)
		print('Original:',predicted[1])

		# image = torch.unsqueeze(inputs[0],0)
		# image = torch.unsqueeze(batch_x[idx],0)
		# label = torch.unsqueeze(targets[0],0)


		# delta1 = FGM_attack(inputs, targets, model, alpha, epsilon, 'FGNM')
		# adv_image1 = torch.clamp(inputs + delta1, 0, 1)
		# adv_image1 = VMI_attack(model, inputs, targets, 10, 0.9, 5, 0.2, 0.2) # successful
		# adv_image1 = SIM_NI_attack(model, inputs, targets, 0.1, 0.9, 5, 10) #successful
		# adv_image1 = AOA_attack(model, image, label, 0.1, 0.2, 0.3)
		# adv_type = AoA(epsilon = 0.5, eta = 0.8, alpha = 0.3, lambda_ = 0.8, T = 10)
		# adv_image1 = adv_type.attack(model, inputs, targets)
		adv_type = VMI(epsilon = 10, beta = 0.3,  N = 10, T = 10, mu = 0.9)  # epsilon太小了
		adv_image1 = adv_type.attack(model, inputs, targets)
		# adv_type = SIM_NI(epsilon=0.5, T=10, mu=0.9, m=4)
		# adv_image1 = adv_type.attack(model, inputs, targets)

		outputs1 = model(adv_image1)
		_, predicted1 = torch.max(outputs1.data, 1)
		correct1 += predicted1.eq(targets.data).cpu().sum().item()
		# print('The FGNM accuracy:', correct1, total, correct1/total)
		print('AOA_attack:', predicted1[1])


		delta2 = FGM_attack(inputs, targets, model, alpha, epsilon, 'FGSM')
		adv_images2 = torch.clamp(inputs + delta2, 0, 1)
		outputs2 = model(adv_images2)
		_, predicted2 = torch.max(outputs2.data, 1)
		correct2 += predicted2.eq(targets.data).cpu().sum().item()
		# print('The FGSM accuracy:', correct2, total, correct2/total)
		print('FGSM:', predicted2[1])
	# print('The FGNM accuracy:', correct1)
	# print('The FGSM accuracy:', correct2)

if __name__ == '__main__':
	main()