在本教程中，我將將展現如何使用梯度上升來解決如何對輸入進行錯誤分類。git
出如何使用梯度上升改變一個輸入分類
小程序
神經網絡是一個黑盒。理解他們的決策須要創造力，但他們並非那麼不透明。微信
在本教程中，我將向您展現如何使用反向傳播來更改輸入，使其按照想要的方式進行分類。網絡
人類的黑盒
首先讓咱們以人類爲例。若是我向你展現如下輸入:dom
頗有可能你不知道這是5仍是6。事實上，我相信我可讓大家相信這也多是8。ide
如今，若是你問一我的，他們須要作什麼才能把一個東西變成5，你可能會在視覺上作這樣的事情:工具
若是我想讓你把這個變成8，你能夠這樣作:動畫
如今，用幾個if語句或查看幾個係數不容易解釋這個問題的答案。而且對於某些類型的輸入（圖像，聲音，視頻等），可解釋性無疑會變得更加困難，但並不是不可能。
google
神經網絡怎麼處理
一個神經網絡如何回答我上面提出的一樣的問題?要回答這個問題，咱們能夠用梯度上升來作。url
這是神經網絡認爲咱們須要修改輸入使其更接近其餘分類的方式。
由此產生了兩個有趣的結果。首先，黑色區域是咱們須要去除像素密度的網絡物體。第二，黃色區域是它認爲咱們須要增長像素密度的地方。
咱們能夠在這個梯度方向上採起一步，添加梯度到原始圖像。固然，咱們能夠一遍又一遍地重複這個過程，最終將輸入變爲咱們所但願的預測。
你能夠看到圖片左下角的黑斑和人類的想法很是類似。
讓輸入看起來更像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源創計劃」，歡迎正在閱讀的你也加入，一塊兒分享。