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

 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)

 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)

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