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

原创
09/21 08:35
阅读数 1K

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

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

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

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

人类的黑盒

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

很有可能你不知道这是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会自动生成如下图片:

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

作者:William Falcon

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

deephub翻译组



本文分享自微信公众号 - DeepHub IMBA(deephub-imba)。
如有侵权,请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”,欢迎正在阅读的你也加入,一起分享。

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部