Fisher信息量检测对抗样本代码详解

1 引言

 在上一篇《Fisher信息量在对抗样本中的应用》中详尽地阐述了Fisher信息量在对抗攻击，防御，以及检测中的应用，并解析了三篇具有代表性的论文。Fisher信息量是可以用来去挖掘深度学习模型对抗行为的深层原因的非常好用一个数学工具。本文主要基于用Fisher信息量去检测对抗样本的一篇论文《Inspecting adversarial examples using the Fisher information》的代码进行深度解析，该论文提出了三个指标对对抗样本进行检测分别是Fisher信息矩阵迹，Fisher信息二次型和Fisher信息敏感度。本文会对论文中直接给出的结果的中间证明过程进行补充，而且代码中一些重要的关键细节也会在对应的章节中有所说明。

2 Fisher信息矩阵迹

 给定输入样本$x$，神经网路的输出一个$C$维概率向量$f_{\theta }(x)=(f_{\theta }^c(x){)}_{c=1,\cdots ,C}$，则关于神经网络参数$\theta$的Fisher信息矩阵的连续形式和离散形式如下所示：
$$\begin{array}{rl}{\mathbb{F}}_{\theta }& ={\mathbb{E}}_y[{\nabla }_{\theta }\log f(x;\theta ){\nabla }_{\theta }^{\top }\log f(x;\theta )]\\ & =\int {\nabla }_{\theta }\log f(x;\theta ){\nabla }_{\theta }^{\top }\log f(x;\theta )dy\\ & \approx \sum _{c=1}^C{f}_{\theta }^c(x)\cdot {\nabla }_{\theta }\log f_{\theta }^c(x){\nabla }^{\top }\log f_{\theta }^c(x)\\ & =\sum _{c=1}^C{\nabla }_{\theta }{f}_{\theta }^c(x){\nabla }_{\theta }^{\top }\log f_{\theta }^c(x)\end{array}$$其中可知${\nabla }_{\theta }\log f(x;\theta )\in {\mathbb{R}}^{p\times C}$，${\nabla }_{\theta }\log f_{\theta }^c(x)\in {\mathbb{R}}^{p\times 1}$，${\mathbb{F}}_{\theta }\in {\mathbb{R}}^{p\times p}$。需要注意的是，计算一个非常小规模的神经网络，Fisher信息矩阵的计算量$O(p^2)$也是棘手的，更何况是那些动辄就上亿的参数量规模的神经网络，计算量更加庞大。因为原论文目的是只关注检测对抗样本，不需要详细计算Fisher信息矩阵中每个精确值，给定样本Fisher信息量的一个取值范围即可作为检测的指标，所以论文中采用Fisher信息矩阵的迹作为检测指标，具体计算公式如下所示
$$\mathrm{t}\mathrm{r}({\mathbb{F}}_{\theta })=\sum _{i=1}^p\sum _{c=1}^C{\partial }_{{\theta }_i}{f}_{\theta }^c(x){\partial }_{{\theta }_i}\log f_{\theta }^c(x)$$要知道理论分析和实际编程总会有一些出入，在以上公式推导中，是将神经网络里的所有权重参数当成一个一维参数向量来考虑，但实际编程中时，神经网络的参数是按层排序的，不过当在求解Fisher信息量的时候，这两种情况时一致的。假设有一个四隐层的神经网络，参数分别是${\theta }_1,{\theta }_2,{\theta }_3,{\theta }_4\in {\mathbb{R}}^{l\times 1}$，则对应的参数和梯度如下所示
$$\theta =\left(\begin{array}{c}{\theta }_1\\ {\theta }_2\\ {\theta }_3\\ {\theta }_3\end{array}\right)\in {\mathbb{R}}^{p\times 1},{\nabla }_{\theta }{f}_{\theta }^c(x)=\left(\begin{array}{c}{\nabla }_{{\theta }_1}{f}_{\theta }^c(x)\\ {\nabla }_{{\theta }_2}{f}_{\theta }^c(x)\\ {\nabla }_{{\theta }_3}{f}_{\theta }^c(x)\\ {\nabla }_{{\theta }_4}{f}_{\theta }^c(x)\end{array}\right)\in {\mathbb{R}}^{p\times 1}$$进一步可知两种情况下Fisher信息矩阵的迹相等$$\begin{array}{rl}\mathrm{t}\mathrm{r}({\mathbb{F}}_{\theta })& =\sum _{c=1}^C{\nabla }_{\theta }^{\top }{f}_{\theta }^c(x){\nabla }_{\theta }{f}_{\theta }^c(x)\\ & ={\nabla }_{{\theta }_1}^{\top }{f}_{\theta }^c(x){\nabla }_{{\theta }_1}{f}_{\theta }^c(x)+{\nabla }_{{\theta }_2}^{\top }{f}_{\theta }^c(x){\nabla }_{{\theta }_2}{f}_{\theta }^c(x)+{\nabla }_{{\theta }_3}^{\top }{f}_{\theta }^c(x){\nabla }_{{\theta }_3}{f}_{\theta }^c(x)+{\nabla }_{{\theta }_4}^{\top }{f}_{\theta }^c(x){\nabla }_{{\theta }_4}{f}_{\theta }^c(x)\\ & =\sum _{i=1}^p\sum _{c=1}^C{\partial }_{{\theta }_i}{f}_{\theta }^c(x){\partial }_{{\theta }_i}\log f_{\theta }^c(x)\end{array}$$此时可以发现使用反向传播计算Fisher信息矩阵的迹的计算量为$O(C\cdot p)$，要远远小于计算Fisher信息矩阵的计算量$O(p^2)$。

3 Fisher信息二次型

 矩阵${\mathbb{F}}_{\theta }$的迹可以写成$\sum _{i=1}^p{e}_i^{\top }{\mathbb{F}}_{\theta }{e}_i$，其中$e_i$为单位向量，即第$i$个元素为$1$，其余元素为$0$，这可以理解为$\mathrm{K}\mathrm{L}$散度对每个参数变化的平均值。受此启发，作者可以选择一个特定的方向和度量，而不是在完全正交的基础上求平均值，即有如下二次型$$v^{\top }{\mathbb{F}}_{\theta }v=\sum _{c=1}^C{v}^{\top }{\nabla }_{\theta }{f}_{\theta }^c(x)\cdot v^{\top }{\nabla }_{\theta }\log f_{\theta }^c(x)$$其中给定的向量$v$与参数$\theta$和数据点$(x,y)$有关$$v=\lambda \cdot {\nabla }_{\theta }\log p(y|x;\theta )$$当对$v$进行归一化时，则有如下二次型$${\bar{v}}^{\top }{\mathbb{F}}_{\theta }\bar{v}=\sum _{c=1}^C\frac{v^{\top }}{\Vert v\Vert }{\nabla }_{\theta }{f}_{\theta }^c(x)\frac{v^{\top }}{\Vert v\Vert }{\nabla }_{\theta }\log f_{\theta }^c(x)$$这里需要注意的是选取的方向并不唯一，如果想让二次型的取值达到最大，则是Fisher矩阵的最大特征值，选取的方向为在最大特征值对应的特征向量。需要指明一点的是，Fisher矩阵的迹要大于Fisher矩阵的最大特征值，具体证明如下所示$$\mathrm{t}\mathrm{r}(\Lambda )=\mathrm{t}\mathrm{r}(Q{\mathbb{F}}_{\theta }{Q}^{-1})=\mathrm{t}\mathrm{r}({\mathbb{F}}_{\theta }{\mathrm{Q}}^{-1}\mathrm{Q})=\mathrm{t}\mathrm{r}({\mathbb{F}}_{\theta })$$其中$\Lambda$为矩阵${\mathbb{F}}_{\theta }$的特征对角矩阵，$Q$为单位正交矩阵。在具体的实际编程中，为了简化计算，会利用有限差分计算来估计反向传播求梯度的结果，由泰勒公式可知$$\begin{array}{r}{f}_{\theta +\epsilon v}^c(x)=f_{\theta }^c(x)+\epsilon v^{\top }{\nabla }_{\theta }{f}_{\theta }^c(x)+\mathcal{O}(\Vert \epsilon v{\Vert }^2)\end{array}$$进而则有$$v^{\top }{\nabla }_{\theta }{f}_{\theta }^c(x)\approx \frac{f_{\theta +\epsilon v}^c(x)-f_{\theta }^c(x)}{\epsilon }\approx \frac{f_{\theta +\epsilon v}^c(x)-f_{\theta -\epsilon v}^c(x)}{2\epsilon }$$

4 Fisher信息敏感度

 为了进一步获得可利用的Fisher信息量，作者在输入样本中随机引入一个单随机变量$\xi \in \mathcal{N}(0,1)$，即有
$$x^{\epsilon ,\eta }=x+\epsilon \xi \cdot \eta$$其中$\epsilon >0$，并且$\eta$与$x$有相同的维度。对于这个被扰动的输入$x^{\epsilon ,\eta }$，对其Fisher信息矩阵为
$${\mathbb{F}}_{\theta }^{\epsilon ,\eta }=\sum _{c=1}^C{\mathbb{E}}_{x^{\epsilon ,\eta }}\left[{\nabla }_{\theta }{f}_{\theta }^c(x^{\epsilon ,\eta }){\nabla }_{\theta }^{\top }\log f_{\theta }^c(x^{\epsilon ,\eta })\right]$$其中${\mathbb{F}}^{\epsilon ,\eta }\in {\mathbb{R}}^{p\times p}$，该矩阵的第$i$行，第$j$列的元素可以表示为$${\left[{\mathbb{F}}_{\theta }^{\epsilon ,\eta }\right]}_{(i,j)}=\sum _{c=1}^C{\mathbb{E}}_{x^{\epsilon ,\eta }}[H_{(i,j)}^c(x)]=\sum _{c=1}^C{\mathbb{E}}_{x^{\epsilon ,\eta }}\left[{\partial }_{{\theta }_i}{f}_{\theta }^c(x+\epsilon \xi \eta )\cdot {\partial }_{{\theta }_j}\log f_{\theta }^c(x+\epsilon \xi \eta )\right]$$又因为${\mathbb{F}}_{\theta }\in {\mathbb{R}}^{p\times p}$的第$i$行，第$j$列的元素为$${\left[{\mathbb{F}}_{\theta }\right]}_{(i,j)}=\sum _{c=1}^C{\mathbb{E}}_{x^{\epsilon ,\eta }}[G_{(i,j)}^c(x)]=\sum _{c=1}^C{\mathbb{E}}_{x^{\epsilon ,\eta }}\left[{\partial }_{{\theta }_i}{f}_{\theta }^c(x){\partial }_{{\theta }_j}\log f_{\theta }^c(x)\right]$$则有泰勒展开式可知$$\begin{array}{rl}{H}_{(i,j)}^c(x)& ={\partial }_{{\theta }_i}{f}_{\theta }^c(x+\epsilon \xi \eta )\cdot {\partial }_{{\theta }_j}\log f_{\theta }^c(x+\epsilon \xi \eta )\\ & ={\partial }_{{\theta }_i}{f}_{\theta }^c(x)\cdot {\partial }_{{\theta }_j}{f}_{\theta }^c(x)+\epsilon \xi {\eta }^{\top }{\nabla }_x{G}_{(i,j)}^c(x)+\frac{1}{2}{\epsilon }^2{\xi }^2{\eta }^{\top }{\nabla }_x^{\top }{\nabla }_x{G}_{(i,j)}^c(x)\eta +\mathcal{O}({\epsilon }^3)\end{array}$$其中上公式的第二项$\mathrm{H}\mathrm{e}\mathrm{s}\mathrm{s}\mathrm{i}\mathrm{a}\mathrm{n}$矩阵可以表示为$$[{\nabla }_x^{\top }{\nabla }_x{G}^c(x){]}_{(m,n)}={\partial }_{x_m}{\partial }_{x_n}{\partial }_{{\theta }_i}{f}_{\theta }^c(x){\partial }_{{\theta }_j}\log f_{\theta }^c(x)$$又因为$\xi$是一个均值为$0$，方差为$1$的随机变量，进而则有 $$\mathbb{E}[\xi ]=0,\mathbb{E}[{\xi }^2]=\mathrm{V}\mathrm{a}\mathrm{r}[\xi ]+(\mathbb{E}[\xi ]{)}^2=1$$综合以上推导结果，则有$$\begin{array}{rl}[{\mathbb{F}}_{\theta }^{\epsilon ,\eta }{]}_{(i,j)}& =\sum _{c=1}^C{\mathbb{E}}_{x^{\epsilon ,\eta }}[H_{(i,j)}^c(x)]\\ & =\sum _{c=1}^C{\mathbb{E}}_{x^{\epsilon ,\eta }}[G_{(i,j)}^c(x)]+\epsilon \mathbb{E}[\xi ]\sum _{c=1}^C{\eta }^{\top }{\nabla }_x{G}_{(i,j)}^c(x)+\frac{1}{2}{\epsilon }^2\mathbb{E}[{\xi }^2]\sum _{c=1}^C{\eta }^{\top }{\nabla }_x^{\top }{\nabla }_x{G}_{(i,j)}^c(x)\eta +\mathcal{O}({\epsilon }^3)\end{array}$$最后可以得到与论文中相同的结果$${\mathbb{F}}_{\theta }^{\epsilon ,\eta }={\mathbb{F}}_{\theta }+0+\frac{1}{2}{\epsilon }^2\sum _{c=1}^C\sum _{i,j=1}^N{\eta }_i{\nabla }_{\theta }{\partial }_{x_i}{f}_{\theta }^c(x){\nabla }_{\theta }^{\top }{\partial }_{x_j}\log f_{\theta }(x){\eta }_j+\mathcal{O}({\epsilon }^3)$$与上一节求Fisher矩阵二次型一样，作者也对扰动样本$x^{\epsilon ,\eta }$的Fisher矩阵求二次型，则有$$v^{\top }{\mathbb{F}}_{\theta }^{\epsilon ,\eta }v=v^{\top }{\mathbb{F}}_{\theta }v+\frac{1}{2}{\epsilon }^2{\eta }^{\top }{\delta }_v{\mathbb{F}}_{\theta }\eta$$其中$${\delta }_v{\mathbb{F}}_{\theta }=\sum _{c=1}^C{\nabla }_x(v^{\top }{\nabla }_{\theta }{f}_{\theta }^c(x))\cdot {\nabla }_x^{\top }(v^{\top }{\nabla }_{\theta }\log f_{\theta }^c(x))$$假如给定的扰动向量$\eta$是单位向量$e_i$，即$\forall i=1,\cdots ,\eta =e_i$。在实际编程中利用有限差分来估计反反向传播求梯度的结果，进而则有$$\begin{array}{rl}{e}_i^{\top }{\delta }_v{\mathbb{F}}_{\theta }{e}_i& =\sum _{c=1}^C{\partial }_{x_i}(v^{\top }{\nabla }_{\theta }{f}_{\theta }^c(x))\cdot {\partial }_{x_i}(v^{\top }{\nabla }_{\theta }\log f_{\theta }^c(x))\\ & =\sum _{c=1}^C(v^{\top }{\nabla }_{\theta }{\partial }_{x_i}{f}_{\theta }^c(x))\cdot (v^{\top }{\nabla }_{\theta }{\partial }_{x_i}\log f_{\theta }^c(x))\\ & \approx \sum _{c=1}^C\frac{({\partial }_{x_i}{f}_{\theta +\epsilon \cdot v}^c(x)-{\partial }_{x_i}{f}_{\theta }^c(x))}{\epsilon }\cdot \frac{({\partial }_{x_i}\log f_{\theta +\epsilon v}^c(x)-{\partial }_{x_i}\log f_{\theta }^c(x))}{\epsilon }\end{array}$$以上公式在论文中被称为Fisher信息敏感度(FIS)，它主要用于评估第$i$个输入节点的重要性。

5 代码示例

  Fisher信息矩阵的迹，Fisher信息二次型以及Fisher信息敏感度的代码示例和实验结果如下所示，对应上文的原理介绍，可以更好的理解代码示例中相关原理的实现细节。

import torch
import torch.nn.functional as F
from copy import deepcopy


class FISHER_OPERATION(object):
        def __init__(self, input_data, network, vector, epsilon = 1e-3):
                self.input = input_data
                self.network = network
                self.vector = vector
                self.epsilon = epsilon

        # Computes the fisher matrix quadratic form along the specific vector
        def fisher_quadratic_form(self):
                fisher_sum = 0
                ## Computes the gradient of parameters of each layer
                for i, parameter in enumerate(self.network.parameters()):
                        ## Store the original parameters
                        store_data = deepcopy(parameter.data)
                        parameter.data += self.epsilon * self.vector[i]
                        log_softmax_output1 = self.network(self.input)
                        softmax_output1 = F.softmax(log_softmax_output1, dim=1)
                        parameter.data -= 2 * self.epsilon * self.vector[i]
                        log_softmax_output2 = self.network(self.input)
                        solfmax_output2 = F.softmax(log_softmax_output2, dim=1)
                        parameter.data = store_data
                        # The summation of finite difference approximate
                        fisher_sum += (((log_softmax_output1 - log_softmax_output2)/(2 * self.epsilon))*((softmax_output1 - solfmax_output2)/(2 * self.epsilon))).sum()
                return fisher_sum


        # Computes the fisher matrix trace
        def fisher_trace(self):
                fisher_trace = 0
                output = self.network(self.input)
                output_dim = output.shape[1]
                parameters = self.network.parameters()
                ## Computes the gradient of parameters of each layer
                for parameter in parameters:
                        for j in range(output_dim):
                                self.network.zero_grad()
                                log_softmax_output = self.network(self.input)
                                log_softmax_output[0,j].backward()
                                log_softmax_grad = parameter.grad
                                self.network.zero_grad()
                                softmax_output = F.softmax(self.network(self.input), dim=1)
                                softmax_output[0,j].backward()
                                softmax_grad = parameter.grad
                                fisher_trace += (log_softmax_grad * softmax_grad).sum()
                return fisher_trace


        # Computes fisher information sensitivity for x and v.
        def fisher_sensitivity(self):
                output = self.network(self.input)
                output_dim = output.shape[1]
                parameters = self.network.parameters()
                x = deepcopy(self.input.data)
                x.requires_grad = True
                fisher_sum = 0
                for i, parameter in enumerate(parameters):
                        for j in range(output_dim):
                                store_data = deepcopy(parameter.data)
                                # plus eps
                                parameter.data += self.epsilon * self.vector[i]
                                log_softmax_output1 = self.network(x)
                                log_softmax_output1[0,j].backward()
                                new_plus_log_softmax_grad = deepcopy(x.grad.data)
                                x.grad.zero_()
                                self.network.zero_grad()
                                softmax_output1 = F.softmax(self.network(x), dim=1)
                                softmax_output1[0,j].backward()
                                new_plus_softmax_grad = deepcopy(x.grad.data)
                                x.grad.zero_()
                                self.network.zero_grad()
                                # minus eps
                                parameter.data -= 2 * self.epsilon * self.vector[i]
                                log_softmax_output2 = self.network(x)
                                log_softmax_output2[0,j].backward()
                                new_minus_log_softmax_grad = deepcopy(x.grad.data)
                                x.grad.zero_()
                                self.network.zero_grad()
                                softmax_output2 = F.softmax(self.network(x), dim=1)
                                softmax_output2[0,j].backward()
                                new_minus_softmax_grad = deepcopy(x.grad.data)
                                x.grad.zero_()
                                self.network.zero_grad()
                                # reset and evaluate
                                parameter.data = store_data
                                fisher_sum += 1/(2 * self.epsilon)**2 * ((new_plus_log_softmax_grad - new_minus_log_softmax_grad)*(new_plus_softmax_grad - new_minus_softmax_grad))
                return fisher_sum

import torch
import torch.nn as nn
import fisher

network = nn.Sequential(
				nn.Linear(15,4),
				nn.Tanh(),
				nn.Linear(4,3),
				nn.LogSoftmax(dim=1)
	)
epsilon = 1e-3
input_data = torch.randn((1,15))
network.zero_grad()
output = network(input_data).max()
output.backward()
vector = []
for parameter in network.parameters():
	vector.append(parameter.grad.clone())

FISHER = fisher.FISHER_OPERATION(input_data, network, vector, epsilon)
print("The fisher matrix quadratic form:", FISHER.fisher_quadratic_form())
print("The fisher matrix trace:", FISHER.fisher_trace())
print("The fisher information sensitivity:", FISHER.fisher_sensitivity())