code: def forward_on_instances(self,
                               instances: List[Instance]) -> List[Dict[str, numpy.ndarray]]:
          
          batch_size = len(instances)
          with torch.no_grad():
              cuda_device = self._get_prediction_device()
              dataset = Batch(instances)
              dataset.index_instances(self.vocab)
              model_input = util.move_to_device(dataset.as_tensor_dict(), cuda_device)
              outputs = self.decode(self(**model_input))
  
              instance_separated_output: List[Dict[str, numpy.ndarray]] = [{} for _ in dataset.instances]
              for name, output in list(outputs.items()):
                  if isinstance(output, torch.Tensor):
                      # NOTE(markn): This is a hack because 0-dim pytorch tensors are not iterable.
                      # This occurs with batch size 1, because we still want to include the loss in that case.
                      if output.dim() == 0:
                          output = output.unsqueeze(0)
  
                      if output.size(0) != batch_size:
                          self._maybe_warn_for_unseparable_batches(name)
                          continue
                      output = output.detach().cpu().numpy()
                  elif len(output) != batch_size:
                      self._maybe_warn_for_unseparable_batches(name)
                      continue
                  for instance_output, batch_element in zip(instance_separated_output, output):
                      instance_output[name] = batch_element
              return instance_separated_output
docs: Takes a list of  :class:`~allennlp.data.instance.Instance`s, converts that text into
          arrays using this model's :class:`Vocabulary`, passes those arrays through
          :func:`self.forward()` and :func:`self.decode()` (which by default does nothing)
          and returns the result.  Before returning the result, we convert any
          ``torch.Tensors`` into numpy arrays and separate the
          batched output into a list of individual dicts per instance. Note that typically
          this will be faster on a GPU (and conditionally, on a CPU) than repeated calls to
          :func:`forward_on_instance`.
  
          Parameters
          ----------
          instances : List[Instance], required
              The instances to run the model on.
  
          Returns
          -------
          A list of the models output for each instance.