docstr: Perform an evaluation step on `model` using `inputs`.
  
  Subclass and override to inject custom behavior.
  
  Args:
      model (`nn.Module`):
          The model to evaluate.
      inputs (`Dict[str, Union[torch.Tensor, Any]]`):
          The inputs and targets of the model.
  
          The dictionary will be unpacked before being fed to the model. Most models expect the targets under the
          argument `labels`. Check your model's documentation for all accepted arguments.
      prediction_loss_only (`bool`):
          Whether or not to return the loss only.
  
  Return:
      Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]: A tuple with the loss, logits and
      labels (each being optional).
docstr_tok: ["Perform","an","evaluation","step","on","`","model","`","using","`","inputs","`",".","Subclass","and","override","to","inject","custom","behavior",".","Args",":","model","(","`","nn.Module","`",")",":","The","model","to","evaluate",".","inputs","(","`","Dict","[","str",",","Union","[","torch.Tensor",",","Any","]","]","`",")",":","The","inputs","and","targets","of","the","model",".","The","dictionary","will","be","unpacked","before","being","fed","to","the","model",".","Most","models","expect","the","targets","under","the","argument","`","labels","`",".","Check","your","model","'s","documentation","for","all","accepted","arguments",".","prediction_loss_only","(","`","bool","`",")",":","Whether","or","not","to","return","the","loss","only",".","Return",":","Tuple","[","Optional","[","float","]",",","Optional","[","torch.Tensor","]",",","Optional","[","torch.Tensor","]","]",":","A","tuple","with","the","loss",",","logits","and","labels","(","each","being","optional",")","."]
code: def prediction_step(
      self,
      model: nn.Module,
      inputs: Dict[str, Union[torch.Tensor, Any]],
      prediction_loss_only: bool,
      ignore_keys: Optional[List[str]] = None,
  ) -> Tuple[
      Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]
  ]:
      """
      Perform an evaluation step on `model` using `inputs`.
  
      Subclass and override to inject custom behavior.
  
      Args:
          model (`nn.Module`):
              The model to evaluate.
          inputs (`Dict[str, Union[torch.Tensor, Any]]`):
              The inputs and targets of the model.
  
              The dictionary will be unpacked before being fed to the model. Most models expect the targets under the
              argument `labels`. Check your model's documentation for all accepted arguments.
          prediction_loss_only (`bool`):
              Whether or not to return the loss only.
  
      Return:
          Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]: A tuple with the loss, logits and
          labels (each being optional).
      """
  
      if not self.args.predict_with_generate or prediction_loss_only:
          return super().prediction_step(
              model,
              inputs,
              prediction_loss_only=prediction_loss_only,
              ignore_keys=ignore_keys,
          )
  
      has_labels = "labels" in inputs
      inputs = self._prepare_inputs(inputs)
  
      # XXX: adapt synced_gpus for fairscale as well
      gen_kwargs = self._gen_kwargs.copy()
      if (
          gen_kwargs.get("max_length") is None
          and gen_kwargs.get("max_new_tokens") is None
      ):
          gen_kwargs["max_length"] = self.model.config.max_length
      gen_kwargs["num_beams"] = (
          gen_kwargs["num_beams"]
          if gen_kwargs.get("num_beams") is not None
          else self.model.config.num_beams
      )
      default_synced_gpus = (
          True if is_deepspeed_zero3_enabled() else False
      )
      gen_kwargs["synced_gpus"] = (
          gen_kwargs["synced_gpus"]
          if gen_kwargs.get("synced_gpus") is not None
          else default_synced_gpus
      )
  
      if "attention_mask" in inputs:
          gen_kwargs["attention_mask"] = inputs.get(
              "attention_mask", None
          )
      if "global_attention_mask" in inputs:
          gen_kwargs["global_attention_mask"] = inputs.get(
              "global_attention_mask", None
          )
  
      # prepare generation inputs
      # some encoder-decoder models can have varying encoder's and thus
      # varying model input names
      if (
          hasattr(self.model, "encoder")
          and self.model.encoder.main_input_name
          != self.model.main_input_name
      ):
          generation_inputs = inputs[self.model.encoder.main_input_name]
      else:
          generation_inputs = inputs[self.model.main_input_name]
  
      generated_tokens = self.model.generate(
          generation_inputs,
          **gen_kwargs,
      )
      # in case the batch is shorter than max length, the output should be padded
      if (
          gen_kwargs.get("max_length") is not None
          and generated_tokens.shape[-1] < gen_kwargs["max_length"]
      ):
          generated_tokens = self._pad_tensors_to_max_len(
              generated_tokens, gen_kwargs["max_length"]
          )
      elif gen_kwargs.get(
          "max_new_tokens"
      ) is not None and generated_tokens.shape[-1] < (
          gen_kwargs["max_new_tokens"] + 1
      ):
          generated_tokens = self._pad_tensors_to_max_len(
              generated_tokens, gen_kwargs["max_new_tokens"] + 1
          )
  
      with torch.no_grad():
          if has_labels:
              with self.compute_loss_context_manager():
                  outputs = model(**inputs)
              if self.label_smoother is not None:
                  loss = (
                      self.label_smoother(outputs, inputs["labels"])
                      .mean()
                      .detach()
                  )
              else:
                  loss = (
                      (
                          outputs["loss"]
                          if isinstance(outputs, dict)
                          else outputs[0]
                      )
                      .mean()
                      .detach()
                  )
          else:
              loss = None
  
      if self.args.prediction_loss_only:
          return (loss, None, None)
  
      if has_labels:
          labels = inputs["labels"]
          if (
              gen_kwargs.get("max_length") is not None
              and labels.shape[-1] < gen_kwargs["max_length"]
          ):
              labels = self._pad_tensors_to_max_len(
                  labels, gen_kwargs["max_length"]
              )
          elif gen_kwargs.get(
              "max_new_tokens"
          ) is not None and labels.shape[-1] < (
              gen_kwargs["max_new_tokens"] + 1
          ):
              labels = self._pad_tensors_to_max_len(
                  labels, (gen_kwargs["max_new_tokens"] + 1)
              )
      else:
          labels = None
  
      return (loss, generated_tokens, labels)
  
file_path: H2O/h2o_flexgen/benchmark/third_party/transformers/src/transformers/trainer_seq2seq.py
imports: from typing import Any, Dict, List, Optional, Tuple, Union
  import torch
  from torch import nn
  from torch.utils.data import Dataset
  from .deepspeed import is_deepspeed_zero3_enabled
  from .trainer import Trainer
  from .trainer_utils import PredictionOutput
  from .utils import logging
label_desc: Use image node_id 3 for calling the Seq2SeqTrainer obj's underlying member method code with example usage: obj.prediction_step(model, inputs, prediction_loss_only, ignore_keys) and returns: loss,  generated_tokens,  labels, super, loss,  None,  None