docs: def numericalize(self, arr, device=None):
          """Turn a batch of examples that use this field into a Variable.
  
          If the field has include_lengths=True, a tensor of lengths will be
          included in the return value.
  
          Arguments:
              arr (List[List[str]], or tuple of (List[List[str]], List[int])):
                  List of tokenized and padded examples, or tuple of List of
                  tokenized and padded examples and List of lengths of each
                  example if self.include_lengths is True.
              device (str or torch.device): A string or instance of `torch.device`
                  specifying which device the Variables are going to be created on.
                  If left as default, the tensors will be created on cpu. Default: None.
          """
          if self.include_lengths and not isinstance(arr, tuple):
              raise ValueError("Field has include_lengths set to True, but "
                               "input data is not a tuple of "
                               "(data batch, batch lengths).")
          if isinstance(arr, tuple):
              arr, lengths = arr
              lengths = torch.tensor(lengths, dtype=self.dtype, device=device)
  
          if self.use_vocab:
              if self.sequential:
                  arr = [[self.vocab.stoi[x] for x in ex] for ex in arr]
              else:
                  arr = [self.vocab.stoi[x] for x in arr]
  
              if self.postprocessing is not None:
                  arr = self.postprocessing(arr, self.vocab)
          else:
              if self.dtype not in self.dtypes:
                  raise ValueError(
                      "Specified Field dtype {} can not be used with "
                      "use_vocab=False because we do not know how to numericalize it. "
                      "Please raise an issue at "
                      "https://github.com/pytorch/text/issues".format(self.dtype))
              numericalization_func = self.dtypes[self.dtype]
              # It doesn't make sense to explicitly coerce to a numeric type if
              # the data is sequential, since it's unclear how to coerce padding tokens
              # to a numeric type.
              if not self.sequential:
                  arr = [numericalization_func(x) if isinstance(x, six.string_types)
                         else x for x in arr]
              if self.postprocessing is not None:
                  arr = self.postprocessing(arr, None)
  
          var = torch.tensor(arr, dtype=self.dtype, device=device)
  
          if self.sequential and not self.batch_first:
              var.t_()
          if self.sequential:
              var = var.contiguous()
  
          if self.include_lengths:
              return var, lengths
          return var