code: def get_accuracy(targets, outputs, k=1, ignore_index=None):
      
      n_correct = 0.0
      for target, output in zip(targets, outputs):
          if not torch.is_tensor(target) or is_scalar(target):
              target = torch.LongTensor([target])
  
          if not torch.is_tensor(output) or is_scalar(output):
              output = torch.LongTensor([[output]])
  
          predictions = output.topk(k=min(k, len(output)), dim=0)[0]
          for prediction in predictions:
              if torch_equals_ignore_index(
                      target.squeeze(), prediction.squeeze(), ignore_index=ignore_index):
                  n_correct += 1
                  break
  
      return n_correct / len(targets), int(n_correct), len(targets)
docs: Get the accuracy top-k accuracy between two tensors.
  
      Args:
        targets (1 - 2D :class:`torch.Tensor`): Target or true vector against which to measure
            saccuracy
        outputs (1 - 3D :class:`torch.Tensor`): Prediction or output vector
        ignore_index (int, optional): Specifies a target index that is ignored
  
      Returns:
        :class:`tuple` consisting of accuracy (:class:`float`), number correct (:class:`int`) and
        total (:class:`int`)
  
      Example:
  
          >>> import torch
          >>> from torchnlp.metrics import get_accuracy
          >>> targets = torch.LongTensor([1, 2, 3, 4, 5])
          >>> outputs = torch.LongTensor([1, 2, 2, 3, 5])
          >>> accuracy, n_correct, n_total = get_accuracy(targets, outputs, ignore_index=3)
          >>> accuracy
          0.8
          >>> n_correct
          4
          >>> n_total
          5