code: def forward(
      self,
      input_ids: Optional[torch.LongTensor] = None,
      past_key_values: Optional[
          Tuple[Tuple[torch.Tensor, torch.Tensor], ...]
      ] = None,
      attention_mask: Optional[torch.Tensor] = None,
      head_mask: Optional[torch.LongTensor] = None,
      inputs_embeds: 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,
      **deprecated_arguments,
  ) -> Union[
      Tuple[torch.Tensor, ...],
      BaseModelOutputWithPastAndCrossAttentions,
  ]:
      if deprecated_arguments.pop("position_ids", False) is not False:
          # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
          warnings.warn(
              "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
              " passing `position_ids`.",
              FutureWarning,
          )
      if len(deprecated_arguments) > 0:
          raise ValueError(
              f"Got unexpected arguments: {deprecated_arguments}"
          )
  
      output_attentions = (
          output_attentions
          if output_attentions is not None
          else self.config.output_attentions
      )
      output_hidden_states = (
          output_hidden_states
          if output_hidden_states is not None
          else self.config.output_hidden_states
      )
      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
      )
  
      if input_ids is not None and inputs_embeds is not None:
          raise ValueError(
              "You cannot specify both input_ids and inputs_embeds at the same time"
          )
      elif input_ids is not None:
          batch_size, seq_length = input_ids.shape
      elif inputs_embeds is not None:
          batch_size, seq_length, _ = inputs_embeds.shape
      else:
          raise ValueError(
              "You have to specify either input_ids or inputs_embeds"
          )
  
      if past_key_values is None:
          past_key_values = tuple([None] * len(self.h))
  
      # Prepare head mask if needed
      # 1.0 in head_mask indicate we keep the head
      # attention_probs has shape batch_size x num_heads x N x N
      # head_mask has shape n_layer x batch x num_heads x N x N
      head_mask = self.get_head_mask(head_mask, self.config.n_layer)
  
      if inputs_embeds is None:
          inputs_embeds = self.word_embeddings(input_ids)
  
      hidden_states = self.word_embeddings_layernorm(inputs_embeds)
  
      presents = () if use_cache else None
      all_self_attentions = () if output_attentions else None
      all_hidden_states = () if output_hidden_states else None
  
      # Compute alibi tensor: check build_alibi_tensor documentation
      seq_length_with_past = seq_length
      past_key_values_length = 0
      if past_key_values[0] is not None:
          past_key_values_length = past_key_values[0][0].shape[-1]
          seq_length_with_past = (
              seq_length_with_past + past_key_values_length
          )
      if attention_mask is None:
          attention_mask = torch.ones(
              (batch_size, seq_length_with_past),
              device=hidden_states.device,
          )
      else:
          attention_mask = attention_mask.to(hidden_states.device)
  
      alibi = build_alibi_tensor(attention_mask, self.num_heads)
  
      causal_mask = self._prepare_attn_mask(
          attention_mask,
          input_shape=(batch_size, seq_length),
          past_key_values_length=past_key_values_length,
      )
  
      if hasattr(self, "tp_rank"):
          assert self.num_heads % self.tp_world_size == 0
          block_size = self.num_heads // self.tp_world_size
          alibi = alibi[
              :,
              self.tp_rank
              * block_size : (self.tp_rank + 1)
              * block_size,
          ]
          alibi = alibi.reshape(
              batch_size * block_size, 1, seq_length_with_past
          )
          causal_mask = torch.repeat_interleave(
              causal_mask, block_size, dim=0
          )
      else:
          alibi = alibi.reshape(
              batch_size * self.num_heads, 1, seq_length_with_past
          )
          causal_mask = torch.repeat_interleave(
              causal_mask, self.num_heads, dim=0
          )
  
      alibi = alibi.to(hidden_states.dtype)
  
      for i, (block, layer_past) in enumerate(
          zip(self.h, past_key_values)
      ):
          if output_hidden_states:
              all_hidden_states = all_hidden_states + (hidden_states,)
  
          outputs = block(
              hidden_states,
              layer_past=layer_past,
              attention_mask=causal_mask,
              head_mask=head_mask[i],
              use_cache=use_cache,
              output_attentions=output_attentions,
              alibi=alibi,
          )
  
          hidden_states = outputs[0]
          if use_cache is True:
              presents = presents + (outputs[1],)
  
          if output_attentions:
              all_self_attentions = all_self_attentions + (
                  outputs[2 if use_cache else 1],
              )
  
      # Add last hidden state
      hidden_states = self.ln_f(hidden_states)
  
      if output_hidden_states:
          all_hidden_states = all_hidden_states + (hidden_states,)
  
      if not return_dict:
          return tuple(
              v
              for v in [
                  hidden_states,
                  presents,
                  all_hidden_states,
                  all_self_attentions,
              ]
              if v is not None
          )
  
      return BaseModelOutputWithPastAndCrossAttentions(
          last_hidden_state=hidden_states,
          past_key_values=presents,
          hidden_states=all_hidden_states,
          attentions=all_self_attentions,
      )
  
imports: import math
  import os
  import warnings
  from typing import Optional, Tuple, Union
  import torch
  import torch.distributed
  import torch.utils.checkpoint
  from torch import nn
  from torch.nn import LayerNorm
  from torch.nn import functional
  from transformers.modeling_outputs import BaseModelOutputWithPastAndCrossAttentions, CausalLMOutputWithCrossAttentions
  from transformers import BloomConfig, PreTrainedModel
  from text_generation_server.utils.layers import TensorParallelColumnLinear, TensorParallelEmbedding, TensorParallelRowLinear, TensorParallelHead
label_desc: Use image node_id 4 for calling the BloomModel obj's underlying member method code with example usage: obj.forward(input_ids, past_key_values, attention_mask, head_mask, inputs_embeds, use_cache, output_attentions, output_hidden_states, return_dict) and returns: BaseModelOutputWithPastAndCrossAttentions, tuple