code: def forward(
      self,
      input_ids: Optional[torch.LongTensor] = None,
      attention_mask: Optional[torch.FloatTensor] = None,
      decoder_input_ids: Optional[torch.LongTensor] = None,
      decoder_attention_mask: Optional[torch.BoolTensor] = None,
      head_mask: Optional[torch.FloatTensor] = None,
      decoder_head_mask: Optional[torch.FloatTensor] = None,
      cross_attn_head_mask: Optional[torch.Tensor] = None,
      encoder_outputs: Optional[Tuple[Tuple[torch.Tensor]]] = None,
      past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
      inputs_embeds: Optional[torch.FloatTensor] = None,
      decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
      labels: Optional[torch.LongTensor] = None,
      use_cache: Optional[bool] = None,
      output_attentions: Optional[bool] = None,
      output_hidden_states: Optional[bool] = None,
      return_dict: Optional[bool] = None,
  ) -> Union[Tuple[torch.FloatTensor], Seq2SeqLMOutput]:
      use_cache = (
          use_cache if use_cache is not None else self.config.use_cache
      )
      return_dict = (
          return_dict
          if return_dict is not None
          else self.config.use_return_dict
      )
  
      # FutureWarning: head_mask was separated into two input args - head_mask, decoder_head_mask
      if head_mask is not None and decoder_head_mask is None:
          if self.config.num_layers == self.config.num_decoder_layers:
              warnings.warn(__HEAD_MASK_WARNING_MSG, FutureWarning)
              decoder_head_mask = head_mask
  
      # Encode if needed (training, first prediction pass)
      if encoder_outputs is None:
          # Convert encoder inputs in embeddings if needed
          encoder_outputs = self.encoder(
              input_ids=input_ids,
              attention_mask=attention_mask,
              inputs_embeds=inputs_embeds,
              head_mask=head_mask,
              output_attentions=output_attentions,
              output_hidden_states=output_hidden_states,
              return_dict=return_dict,
          )
      elif return_dict and not isinstance(
          encoder_outputs, BaseModelOutput
      ):
          encoder_outputs = BaseModelOutput(
              last_hidden_state=encoder_outputs[0],
              hidden_states=encoder_outputs[1]
              if len(encoder_outputs) > 1
              else None,
              attentions=encoder_outputs[2]
              if len(encoder_outputs) > 2
              else None,
          )
  
      hidden_states = encoder_outputs[0]
  
      if (
          labels is not None
          and decoder_input_ids is None
          and decoder_inputs_embeds is None
      ):
          # get decoder inputs from shifting lm labels to the right
          decoder_input_ids = self._shift_right(labels)
  
      # Decode
      decoder_outputs = self.decoder(
          input_ids=decoder_input_ids,
          attention_mask=decoder_attention_mask,
          inputs_embeds=decoder_inputs_embeds,
          past_key_values=past_key_values,
          encoder_hidden_states=hidden_states,
          encoder_attention_mask=attention_mask,
          head_mask=decoder_head_mask,
          cross_attn_head_mask=cross_attn_head_mask,
          use_cache=use_cache,
          output_attentions=output_attentions,
          output_hidden_states=output_hidden_states,
          return_dict=return_dict,
      )
  
      sequence_output = decoder_outputs[0]
  
      if self.config.tie_word_embeddings:
          # Rescale output before projecting on vocab
          # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/transformer.py#L586
          sequence_output = sequence_output * (self.model_dim**-0.5)
  
      lm_logits = self.lm_head(sequence_output)
  
      loss = None
      if labels is not None:
          loss_fct = CrossEntropyLoss(ignore_index=-100)
          # move labels to correct device to enable PP
          labels = labels.to(lm_logits.device)
          loss = loss_fct(
              lm_logits.view(-1, lm_logits.size(-1)), labels.view(-1)
          )
          # TODO(thom): Add z_loss https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L666
  
      if not return_dict:
          output = (lm_logits,) + decoder_outputs[1:] + encoder_outputs
          return ((loss,) + output) if loss is not None else output
  
      return Seq2SeqLMOutput(
          loss=loss,
          logits=lm_logits,
          past_key_values=decoder_outputs.past_key_values,
          decoder_hidden_states=decoder_outputs.hidden_states,
          decoder_attentions=decoder_outputs.attentions,
          cross_attentions=decoder_outputs.cross_attentions,
          encoder_last_hidden_state=encoder_outputs.last_hidden_state,
          encoder_hidden_states=encoder_outputs.hidden_states,
          encoder_attentions=encoder_outputs.attentions,
      )
  
imports: import copy
  import math
  import warnings
  from typing import Optional, Tuple, Union
  from loguru import logger
  import torch
  import torch.distributed
  from torch import nn
  from torch.nn import CrossEntropyLoss
  from transformers.activations import ACT2FN
  from transformers.modeling_outputs import BaseModelOutput, BaseModelOutputWithPastAndCrossAttentions, Seq2SeqLMOutput
  from transformers.modeling_utils import PreTrainedModel
  from transformers.pytorch_utils import ALL_LAYERNORM_LAYERS
  from transformers.utils import is_torch_fx_proxy
  from transformers import T5Config
  from text_generation_server.utils.layers import TensorParallelColumnLinear, TensorParallelEmbedding, TensorParallelRowLinear, TensorParallelHead
label_desc: Use image node_id 2 for calling the T5ForConditionalGeneration obj's underlying member method code with example usage: obj.forward(input_ids, attention_mask, decoder_input_ids, decoder_attention_mask, head_mask, decoder_head_mask, cross_attn_head_mask, encoder_outputs, past_key_values, inputs_embeds, decoder_inputs_embeds, labels, use_cache, output_attentions, output_hidden_states, return_dict) and returns: Seq2SeqLMOutput, unknown