class_docstr: Fast Adaptive Boundary Attack (Linf, L2, L1)
  https://arxiv.org/abs/1907.02044
  
  :param predict:       forward pass function
  :param norm:          Lp-norm to minimize ('Linf', 'L2', 'L1' supported)
  :param n_restarts:    number of random restarts
  :param n_iter:        number of iterations
  :param eps:           epsilon for the random restarts
  :param alpha_max:     alpha_max
  :param eta:           overshooting
  :param beta:          backward step
  :param device:        device to use ('cuda' or 'cpu')
code: def get_diff_logits_grads_batch(self, imgs, la):
      im = imgs.clone().requires_grad_()
      with torch.enable_grad():
          y = self.predict(im)
  
      g2 = torch.zeros([y.shape[-1], *imgs.size()]).to(self.device)
      grad_mask = torch.zeros_like(y)
      for counter in range(y.shape[-1]):
          zero_gradients(im)
          grad_mask[:, counter] = 1.0
          y.backward(grad_mask, retain_graph=True)
          grad_mask[:, counter] = 0.0
          g2[counter] = im.grad.data
  
      g2 = torch.transpose(g2, 0, 1).detach()
      y2 = self.predict(imgs).detach()
      df = y2 - y2[torch.arange(imgs.shape[0]), la].unsqueeze(1)
      dg = g2 - g2[torch.arange(imgs.shape[0]), la].unsqueeze(1)
      df[torch.arange(imgs.shape[0]), la] = 1e10
  
      return df, dg
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from __future__ import unicode_literals
  import torch
  import time
  from advertorch.utils import replicate_input
  from advertorch.attacks.utils import zero_gradients
  from .base import Attack
  from .base import LabelMixin
label_desc: Use image node_id 3 for calling the FABAttack obj's underlying member method code with example usage: obj.get_diff_logits_grads_batch(imgs, la) and returns: df,  dg