在本教程中，我將將展示如何使用梯度上升來解決如何對輸入進行錯誤分類，
出如何使用梯度上升改變一個輸入分類
神經網路是一個黑盒，理解他們的決策需要創造力，但他們并不是那么不透明，
在本教程中，我將向您展示如何使用反向傳播來更改輸入，使其按照想要的方式進行分類，
人類的黑盒
首先讓我們以人類為例，如果我向你展示以下輸入:
很有可能你不知道這是5還是6，事實上，我相信我可以讓你們相信這也可能是8，
現在，如果你問一個人，他們需要做什么才能把一個東西變成5，你可能會在視覺上做這樣的事情:
如果我想讓你把這個變成8，你可以這樣做:
現在，用幾個if陳述句或查看幾個系數不容易解釋這個問題的答案， 并且對于某些型別的輸入（影像，聲音，視頻等），可解釋性無疑會變得更加困難，但并非不可能，
神經網路怎么處理
一個神經網路如何回答我上面提出的同樣的問題?要回答這個問題，我們可以用梯度上升來做，
這是神經網路認為我們需要修改輸入使其更接近其他分類的方式，
由此產生了兩個有趣的結果，首先，黑色區域是我們需要去除像素密度的網路物體，第二，黃色區域是它認為我們需要增加像素密度的地方，
我們可以在這個梯度方向上采取一步，添加梯度到原始影像，當然，我們可以一遍又一遍地重復這個程序，最終將輸入變為我們所希望的預測，
你可以看到圖片左下角的黑斑和人類的想法非常相似，
讓輸入看起來更像8怎么樣?這是網路認為你必須改變輸入的方式，
值得注意的是，在左下角有一團黑色的物質在中間有一團明亮的物質，如果我們把這個和輸入相加，我們得到如下結果:
在這種情況下，我并不特別相信我們已經將這個5變成了8，但是，我們減少了5的概率，說服你這個是8的論點肯定會更容易使用 右側的圖片，而不是左側的圖片，
梯度
在回歸分析中，我們通過系數來了解我們所學到的知識，在隨機森林中，我們可以觀察決策節點，
在神經網路中，它歸結為我們如何創造性地使用梯度，為了對這個數字進行分類，我們根據可能的預測生成了一個分布，
這就是我們說的前向傳播
在前程序序中，我們計算輸出的概率分布
代碼類似這樣：
現在假設我們想要欺騙網路，讓它預測輸入x的值為“5”，實作這一點的方法是給它一個影像(x)，計算對影像的預測，然后最大化預測標簽“5”的概率，
為此，我們可以使用梯度上升來計算第6個索引處(即label = 5) §相對于輸入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翻譯組
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/107922.html
標籤：python