docstr: Call the module
  
  Args:
      hidden_states (`torch.FloatTensor`):
          Input states to the module usually the output from previous layer, it will be the Q,K and V in
          *Attention(Q,K,V)*
  
      attention_mask (`torch.ByteTensor`):
          An attention mask matrix of shape [*B*, *N*, *N*] where *B* is the batch size, *N* is the maximum
          sequence length in which element [i,j] = *1* means the *i* th token in the input can attend to the *j*
          th token.
  
      output_attentions (`bool`, optional):
          Whether return the attention matrix.
  
      query_states (`torch.FloatTensor`, optional):
          The *Q* state in *Attention(Q,K,V)*.
  
      relative_pos (`torch.LongTensor`):
          The relative position encoding between the tokens in the sequence. It's of shape [*B*, *N*, *N*] with
          values ranging in [*-max_relative_positions*, *max_relative_positions*].
  
      rel_embeddings (`torch.FloatTensor`):
          The embedding of relative distances. It's a tensor of shape [\(2 \times
          \text{max_relative_positions}\), *hidden_size*].
docstr_tok: ["Call","the","module","Args",":","hidden_states","(","`","torch.FloatTensor","`",")",":","Input","states","to","the","module","usually","the","output","from","previous","layer",",","it","will","be","the","Q",",","K","and","V","in","*","Attention","(","Q",",","K",",","V",")","*","attention_mask","(","`","torch.ByteTensor","`",")",":","An","attention","mask","matrix","of","shape","[","*","B","*",",","*","N","*",",","*","N","*","]","where","*","B","*","is","the","batch","size",",","*","N","*","is","the","maximum","sequence","length","in","which","element","[","i",",","j","]","=","*","1","*","means","the","*","i","*","th","token","in","the","input","can","attend","to","the","*","j","*","th","token",".","output_attentions","(","`","bool","`",",","optional",")",":","Whether","return","the","attention","matrix",".","query_states","(","`","torch.FloatTensor","`",",","optional",")",":","The","*","Q","*","state","in","*","Attention","(","Q",",","K",",","V",")","*",".","relative_pos","(","`","torch.LongTensor","`",")",":","The","relative","position","encoding","between","the","tokens","in","the","sequence",".","It","'s","of","shape","[","*","B","*",",","*","N","*",",","*","N","*","]","with","values","ranging","in","[","*","-max_relative_positions","*",",","*","max_relative_positions","*","]",".","rel_embeddings","(","`","torch.FloatTensor","`",")",":","The","embedding","of","relative","distances",".","It","'s","a","tensor","of","shape","[","\\","(","2","\\times","\\text","{","max_relative_positions","}","\\",")",",","*","hidden_size","*","]","."]
code: def forward(
      self,
      hidden_states,
      attention_mask,
      output_attentions=False,
      query_states=None,
      relative_pos=None,
      rel_embeddings=None,
  ):
      """
      Call the module
  
      Args:
          hidden_states (`torch.FloatTensor`):
              Input states to the module usually the output from previous layer, it will be the Q,K and V in
              *Attention(Q,K,V)*
  
          attention_mask (`torch.ByteTensor`):
              An attention mask matrix of shape [*B*, *N*, *N*] where *B* is the batch size, *N* is the maximum
              sequence length in which element [i,j] = *1* means the *i* th token in the input can attend to the *j*
              th token.
  
          output_attentions (`bool`, optional):
              Whether return the attention matrix.
  
          query_states (`torch.FloatTensor`, optional):
              The *Q* state in *Attention(Q,K,V)*.
  
          relative_pos (`torch.LongTensor`):
              The relative position encoding between the tokens in the sequence. It's of shape [*B*, *N*, *N*] with
              values ranging in [*-max_relative_positions*, *max_relative_positions*].
  
          rel_embeddings (`torch.FloatTensor`):
              The embedding of relative distances. It's a tensor of shape [\\(2 \\times
              \\text{max_relative_positions}\\), *hidden_size*].
      """
      attention_mask = prefix_attention_mask(attention_mask, dim=3, prefix_value=1)  # type: ignore
      attention_mask = prefix_attention_mask(attention_mask, dim=2, prefix_value=1)  # type: ignore
  
      if query_states is None:
          query_states = hidden_states
      query_layer = self.transpose_for_scores_extended(
          self.query_proj(query_states), self.num_attention_heads
      )
      key_layer = self.transpose_for_scores_extended(
          self.key_proj(hidden_states), self.num_attention_heads
      )
      value_layer = self.transpose_for_scores_extended(
          self.value_proj(hidden_states), self.num_attention_heads
      )
  
      (
          query_layer,
          key_layer,
          value_layer,
      ) = match_attn_matrices_for_parallel(
          query_layer, key_layer, value_layer
      )
      (attention_mask,) = adjust_tensors_for_parallel(
          query_layer, attention_mask
      )
  
      orig_key_layer = (
          key_layer.contiguous()
      )  # save this for relative attention
      key_layer, value_layer, attention_mask = self.prefix_tuning(
          key_layer, value_layer, hidden_states, attention_mask, False
      )  # [:, 0, :, 0])
      query_layer, orig_key_layer = adjust_tensors_for_parallel(
          key_layer, query_layer, orig_key_layer
      )
  
      query_layer = query_layer.contiguous().view(
          -1, query_layer.size(2), query_layer.size(-1)
      )
      key_layer = key_layer.contiguous().view(
          -1, key_layer.size(2), key_layer.size(-1)
      )
      value_layer = value_layer.contiguous().view(
          -1, value_layer.size(2), value_layer.size(-1)
      )
      orig_key_layer = orig_key_layer.contiguous().view(
          -1, orig_key_layer.size(2), orig_key_layer.size(-1)
      )
  
      rel_att = None
      # Take the dot product between "query" and "key" to get the raw attention scores.
      scale_factor = 1
      if "c2p" in self.pos_att_type:
          scale_factor += 1
      if "p2c" in self.pos_att_type:
          scale_factor += 1
      scale = torch.sqrt(
          torch.tensor(query_layer.size(-1), dtype=torch.float)
          * scale_factor
      )
      attention_scores = torch.bmm(
          query_layer, key_layer.transpose(-1, -2)
      ) / scale.to(dtype=query_layer.dtype)
      if self.relative_attention:
          rel_embeddings = self.pos_dropout(rel_embeddings)
          rel_att = self.disentangled_attention_bias(
              query_layer,
              orig_key_layer,
              relative_pos,
              rel_embeddings,
              scale_factor,
          )
  
      if rel_att is not None:
          rel_att_padded = torch.zeros_like(attention_scores)
          rel_att_padded[:, :, -rel_att.size(2) :] = rel_att
          attention_scores = attention_scores + rel_att_padded
      attention_scores = attention_scores
      attention_scores = attention_scores.view(
          -1,
          self.num_attention_heads,
          attention_scores.size(-2),
          attention_scores.size(-1),
      )
  
      # bsz x height x length x dimension
      attention_probs = XSoftmax.apply(
          attention_scores, attention_mask, -1
      )
      attention_probs = self.dropout(attention_probs)
      context_layer = torch.bmm(
          attention_probs.view(
              -1, attention_probs.size(-2), attention_probs.size(-1)
          ),
          value_layer,
      )
      context_layer = (
          context_layer.view(
              -1,
              self.num_attention_heads,
              context_layer.size(-2),
              context_layer.size(-1),
          )
          .permute(0, 2, 1, 3)
          .contiguous()
      )
      new_context_layer_shape = context_layer.size()[:-2] + (-1,)
      context_layer = context_layer.view(new_context_layer_shape)
      if output_attentions:
          return (context_layer, attention_probs)
      else:
          return context_layer
  
file_path: adapters/src/adapters/models/deberta_v2/modeling_deberta_v2.py
imports: import torch
  import torch.utils.checkpoint
  from transformers.models.deberta_v2.modeling_deberta_v2 import DebertaV2Output, DebertaV2SelfOutput, DisentangledSelfAttention, XSoftmax
  from ...composition import adjust_tensors_for_parallel, match_attn_matrices_for_parallel
  from ...utils import prefix_attention_mask
  from ..bert.mixin_bert import BertOutputAdaptersMixin, BertSelfOutputAdaptersMixin
  from .mixin_deberta_v2 import DebertaV2SelfAttentionAdaptersMixin
label_desc: Use image node_id 2 for calling the DisentangledSelfAttentionWithAdapters obj's underlying member method code with example usage: obj.forward(hidden_states, attention_mask, output_attentions, query_states, relative_pos, rel_embeddings) and returns: context_layer,  attention_probs, context_layer