docs: def _get_predictions(self, data, break_ties="random", return_probs=False, **kwargs):
          """Computes predictions in batch, given a labeled dataset
  
          Args:
              data: a Pytorch DataLoader, Dataset, or tuple with Tensors (X,Y):
                  X: The input for the predict method
                  Y: An [n] or [n, 1] torch.Tensor or np.ndarray of target labels
                      in {1,...,k}
              break_ties: How to break ties when making predictions
              return_probs: Return the predicted probabilities as well
  
          Returns:
              Y_p: A Tensor of predictions
              Y: A Tensor of labels
              [Optionally: Y_s: An [n, k] np.ndarray of predicted probabilities]
          """
          data_loader = self._create_data_loader(data)
          Y_p = []
          Y = []
          Y_s = []
  
          # Do batch evaluation by default, getting the predictions and labels
          for batch_num, data in enumerate(data_loader):
              Xb, Yb = data
              Y.append(self._to_numpy(Yb))
  
              # Optionally move to device
              if self.config["device"] != "cpu":
                  Xb = place_on_gpu(Xb)
  
              # Append predictions and labels from DataLoader
              Y_pb, Y_sb = self.predict(
                  Xb, break_ties=break_ties, return_probs=True, **kwargs
              )
              Y_p.append(self._to_numpy(Y_pb))
              Y_s.append(self._to_numpy(Y_sb))
          Y_p, Y, Y_s = map(self._stack_batches, [Y_p, Y, Y_s])
          if return_probs:
              return Y_p, Y, Y_s
          else:
              return Y_p, Y