使用梯度上升欺骗神经网络，让网络进行错误的分类

Posted 2021-04-26 DeepHub IMBA

在本教程中，我将将展示如何使用梯度上升来解决如何对输入进行错误分类。

出如何使用梯度上升改变一个输入分类

神经网络是一个黑盒。理解他们的决策需要创造力，但他们并不是那么不透明。

在本教程中，我将向您展示如何使用反向传播来更改输入，使其按照想要的方式进行分类。

人类的黑盒

首先让我们以人类为例。如果我向你展示以下输入:

很有可能你不知道这是5还是6。事实上，我相信我可以让你们相信这也可能是8。

现在，如果你问一个人，他们需要做什么才能把一个东西变成5，你可能会在视觉上做这样的事情:

如果我想让你把这个变成8，你可以这样做:

现在，用几个if语句或查看几个系数不容易解释这个问题的答案。并且对于某些类型的输入（图像，声音，视频等），可解释性无疑会变得更加困难，但并非不可能。

神经网络怎么处理

一个神经网络如何回答我上面提出的同样的问题?要回答这个问题，我们可以用梯度上升来做。

这是神经网络认为我们需要修改输入使其更接近其他分类的方式。

由此产生了两个有趣的结果。首先，黑色区域是我们需要去除像素密度的网络物体。第二，黄色区域是它认为我们需要增加像素密度的地方。

我们可以在这个梯度方向上采取一步，添加梯度到原始图像。当然，我们可以一遍又一遍地重复这个过程，最终将输入变为我们所希望的预测。

你可以看到图片左下角的黑斑和人类的想法非常相似。

让输入看起来更像8怎么样?这是网络认为你必须改变输入的方式。

值得注意的是，在左下角有一团黑色的物质在中间有一团明亮的物质。如果我们把这个和输入相加，我们得到如下结果:

在这种情况下，我并不特别相信我们已经将这个5变成了8。但是，我们减少了5的概率，说服你这个是8的论点肯定会更容易使用 右侧的图片，而不是左侧的图片。

梯度

在回归分析中，我们通过系数来了解我们所学到的知识。在随机森林中，我们可以观察决策节点。

在神经网络中，它归结为我们如何创造性地使用梯度。为了对这个数字进行分类，我们根据可能的预测生成了一个分布。

这就是我们说的前向传播

在前进过程中，我们计算输出的概率分布

代码类似这样：

现在假设我们想要欺骗网络，让它预测输入x的值为“5”，实现这一点的方法是给它一个图像(x)，计算对图像的预测，然后最大化预测标签“5”的概率。

为此，我们可以使用梯度上升来计算第6个索引处(即label = 5) (p)相对于输入x的预测的梯度。

为了在代码中做到这一点，我们将输入x作为参数输入到神经网络，选择第6个预测(因为我们有标签:0,1,2,3,4,5，…)，第6个索引意味着标签“5”。

视觉上这看起来像:

代码如下：

当我们调用.backward()时，所发生的过程可以通过前面的动画可视化。

现在我们计算了梯度，我们可以可视化并绘制它们:

由于网络还没有经过训练，所以上面的梯度看起来像随机噪声……但是，一旦我们对网络进行训练，梯度的信息会更丰富:

通过回调实现自动化

这是一个非常有用的工具，帮助阐明在你的网络训练中发生了什么。在这种情况下，我们想要自动化这个过程，这样它就会在训练中自动发生。

为此，我们将使用PyTorch Lightning来实现我们的神经网络:

 import torch
 import torch.nn.functional as F
 import pytorch_lightning as pl
 
 class LitClassifier(pl.LightningModule):
 
     def __init__(self):
         super().__init__()
         self.l1 = torch.nn.Linear(28 * 28, 10)
 
     def forward(self, x):
         return torch.relu(self.l1(x.view(x.size(0), -1)))
 
     def training_step(self, batch, batch_idx):
         x, y = batch
         y_hat = self(x)
         loss = F.cross_entropy(y_hat, y)
         result = pl.TrainResult(loss)
 
         # enable the auto confused logit callback
         self.last_batch = batch
         self.last_logits = y_hat.detach()
 
         result.log('train_loss', loss, on_epoch=True)
         return result
         
     def validation_step(self, batch, batch_idx):
         x, y = batch
         y_hat = self(x)
         loss = F.cross_entropy(y_hat, y)
         result = pl.EvalResult(checkpoint_on=loss)
         result.log('val_loss', loss)
         return result
 
     def configure_optimizers(self):
         return torch.optim.Adam(self.parameters(), lr=0.005)

可以将自动绘制出此处描述内容的复杂代码，抽象为Lightning中的Callback。Callback回调是一个小程序，您可能会在训练的各个部分调用它。

在本例中，当处理训练批处理时，我们希望生成这些图像，以防某些输入出现混乱。。

 import torch
 from pytorch_lightning import Callback
 from torch import nn
 
 
 class ConfusedLogitCallback(Callback):
 
     def __init__(
             self,
             top_k,
             projection_factor=3,
             min_logit_value=5.0,
             logging_batch_interval=20,
             max_logit_difference=0.1
     ):
         super().__init__()
         self.top_k = top_k
         self.projection_factor = projection_factor
         self.max_logit_difference = max_logit_difference
         self.logging_batch_interval = logging_batch_interval
         self.min_logit_value = min_logit_value
 
     def on_train_batch_end(self, trainer, pl_module, batch, batch_idx, dataloader_idx):
         # show images only every 20 batches
         if (trainer.batch_idx + 1) % self.logging_batch_interval != 0:
             return
 
         # pick the last batch and logits
         x, y = batch
         try:
             logits = pl_module.last_logits
         except AttributeError as e:
             m = """please track the last_logits in the training_step like so:
                 def training_step(...):
                     self.last_logits = your_logits
             """
             raise AttributeError(m)
 
         # only check when it has opinions (ie: the logit > 5)
         if logits.max() > self.min_logit_value:
             # pick the top two confused probs
             (values, idxs) = torch.topk(logits, k=2, dim=1)
 
             # care about only the ones that are at most eps close to each other
             eps = self.max_logit_difference
             mask = (values[:, 0] - values[:, 1]).abs() < eps
 
             if mask.sum() > 0:
                 # pull out the ones we care about
                 confusing_x = x[mask, ...]
                 confusing_y = y[mask]
 
                 mask_idxs = idxs[mask]
 
                 pl_module.eval()
                 self._plot(confusing_x, confusing_y, trainer, pl_module, mask_idxs)
                 pl_module.train()
 
     def _plot(self, confusing_x, confusing_y, trainer, model, mask_idxs):
         from matplotlib import pyplot as plt
 
         confusing_x = confusing_x[:self.top_k]
         confusing_y = confusing_y[:self.top_k]
 
         x_param_a = nn.Parameter(confusing_x)
         x_param_b = nn.Parameter(confusing_x)
 
         batch_size, c, w, h = confusing_x.size()
         for logit_i, x_param in enumerate((x_param_a, x_param_b)):
             x_param = x_param.to(model.device)
             logits = model(x_param.view(batch_size, -1))
             logits[:, mask_idxs[:, logit_i]].sum().backward()
 
         # reshape grads
         grad_a = x_param_a.grad.view(batch_size, w, h)
         grad_b = x_param_b.grad.view(batch_size, w, h)
 
         for img_i in range(len(confusing_x)):
             x = confusing_x[img_i].squeeze(0).cpu()
             y = confusing_y[img_i].cpu()
             ga = grad_a[img_i].cpu()
             gb = grad_b[img_i].cpu()
 
             mask_idx = mask_idxs[img_i].cpu()
 
             fig, axarr = plt.subplots(nrows=2, ncols=3, figsize=(15, 10))
             self.__draw_sample(fig, axarr, 0, 0, x, f'True: {y}')
             self.__draw_sample(fig, axarr, 0, 1, ga, f'd{mask_idx[0]}-logit/dx')
             self.__draw_sample(fig, axarr, 0, 2, gb, f'd{mask_idx[1]}-logit/dx')
             self.__draw_sample(fig, axarr, 1, 1, ga * 2 + x, f'd{mask_idx[0]}-logit/dx')
             self.__draw_sample(fig, axarr, 1, 2, gb * 2 + x, f'd{mask_idx[1]}-logit/dx')
 
             trainer.logger.experiment.add_figure('confusing_imgs', fig, global_step=trainer.global_step)
 
     @staticmethod
     def __draw_sample(fig, axarr, row_idx, col_idx, img, title):
         im = axarr[row_idx, col_idx].imshow(img)
         fig.colorbar(im, ax=axarr[row_idx, col_idx])
         axarr[row_idx, col_idx].set_title(title, fontsize=20)

但是，通过安装pytorch-lightning-bolts，我们让它变得更容易了

 !pip install pytorch-lightning-bolts
 from pl_bolts.callbacks.vision import ConfusedLogitCallback
 
 trainer = Trainer(callbacks=[ConfusedLogitCallback(1)])

把它们放在一起

最后，我们可以训练我们的模型，并在判断逻辑产生混乱时自动生成图像。

 # data
 dataset = MNIST(os.getcwd(), download=True, transform=transforms.ToTensor())
 train, val = random_split(dataset, [55000, 5000])
 
 # model
 model = LitClassifier()
 
 # attach callback
 trainer = Trainer(callbacks=[ConfusedLogitCallback(1)])
 
 # train!
 trainer.fit(model, DataLoader(train, batch_size=64), DataLoader(val, batch_size=64))

tensorboard会自动生成如下图片:

看看这个是不是变得不一样了

完整代码：https://colab.research.google.com/drive/16HVAJHdCkyj7W43Q3ZChnxZ7DOwx6K5i?usp=sharing

deephub翻译组