当前位置：网站首页>Fisher信息量检测对抗样本代码详解

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

2022-07-04 12:48:00 【PaperWeekly】

PaperWeekly 原创 · 作者 | 鬼谷子

引言

在上一篇《Fisher信息量在对抗样本中的应用》中详尽地阐述了 Fisher 信息量在对抗攻击，防御，以及检测中的应用，并解析了三篇具有代表性的论文。Fisher 信息量是可以用来去挖掘深度学习模型对抗行为的深层原因的非常好用一个数学工具。

本文主要基于用 Fisher 信息量去检测对抗样本的一篇论文《Inspecting adversarial examples using the Fisher information》的代码进行深度解析，该论文提出了三个指标对对抗样本进行检测分别是 Fisher 信息矩阵迹，Fisher 信息二次型和 Fisher 信息敏感度。本文会对论文中直接给出的结果的中间证明过程进行补充，而且代码中一些重要的关键细节也会在对应的章节中有所说明。

Fisher信息矩阵迹

给定输入样本，神经网路的输出一个维概率向量，则关于神经网络参数的 Fisher 信息矩阵的连续形式和离散形式如下所示：

其中可知，，。需要注意的是，计算一个非常小规模的神经网络，Fisher 信息矩阵的计算量也是棘手的，更何况是那些动辄就上亿的参数量规模的神经网络，计算量更加庞大。因为原论文目的是只关注检测对抗样本，不需要详细计算 Fisher 信息矩阵中每个精确值，给定样本 Fisher 信息量的一个取值范围即可作为检测的指标，所以论文中采用 Fisher 信息矩阵的迹作为检测指标，具体计算公式如下所示：

要知道理论分析和实际编程总会有一些出入，在以上公式推导中，是将神经网络里的所有权重参数当成一个一维参数向量来考虑，但实际编程中时，神经网络的参数是按层排序的，不过当在求解Fisher信息量的时候，这两种情况时一致的。假设有一个四隐层的神经网络，参数分别是，则对应的参数和梯度如下所示：

进一步可知两种情况下 Fisher 信息矩阵的迹相等：

此时可以发现使用反向传播计算 Fisher 信息矩阵的迹的计算量为，要远远小于计算 Fisher 信息矩阵的计算量。

Fisher信息二次型

矩阵的迹可以写成，其中为单位向量，即第个元素为，其余元素为，这可以理解为散度对每个参数变化的平均值。受此启发，作者可以选择一个特定的方向和度量，而不是在完全正交的基础上求平均值，即有如下二次型：

其中给定的向量与参数和数据点有关：

当对进行归一化时，则有如下二次型：

这里需要注意的是选取的方向并不唯一，如果想让二次型的取值达到最大，则是 Fisher 矩阵的最大特征值，选取的方向为在最大特征值对应的特征向量。需要指明一点的是，Fisher 矩阵的迹要大于 Fisher 矩阵的最大特征值，具体证明如下所示：

其中为矩阵的特征对角矩阵，为单位正交矩阵。在具体的实际编程中，为了简化计算，会利用有限差分计算来估计反向传播求梯度的结果，由泰勒公式可知：

进而则有：

Fisher信息敏感度

为了进一步获得可利用的 Fisher 信息量，作者在输入样本中随机引入一个单随机变量，即有：

其中，并且与有相同的维度。对于这个被扰动的输入，对其 Fisher 信息矩阵为：

其中，该矩阵的第行，第列的元素可以表示为：

又因为的第行，第列的元素为：

则有泰勒展开式可知：

其中上公式的第二项矩阵可以表示为：

又因为是一个均值为，方差为的随机变量，进而则有：

综合以上推导结果，则有：

最后可以得到与论文中相同的结果：

与上一节求 Fisher 矩阵二次型一样，作者也对扰动样本的 Fisher 矩阵求二次型，则有：

其中：

假如给定的扰动向量是单位向量，即。在实际编程中利用有限差分来估计反反向传播求梯度的结果，进而则有：

以上公式在论文中被称为 Fisher 信息敏感度（FIS），它主要用于评估第个输入节点的重要性。

代码示例

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())