class_docstr: Fixed (1 line):
      attn_output.reshape(bsz, tgt_len, embed_dim) -> attn_output.reshape(bsz, tgt_len, self.embed_dim)
docstr: Input shape: Batch x Time x Channel
docstr_tok: ["Input","shape",":","Batch","x","Time","x","Channel"]
code: def forward(
      self,
      hidden_states: torch.Tensor,
      attention_mask: Optional[torch.Tensor] = None,
      position_embeddings: Optional[torch.Tensor] = None,
      key_value_states: Optional[torch.Tensor] = None,
      key_value_position_embeddings: Optional[torch.Tensor] = None,
      output_attentions: bool = False,
  ) -> Tuple[
      torch.Tensor,
      Optional[torch.Tensor],
      Optional[Tuple[torch.Tensor]],
  ]:
      """Input shape: Batch x Time x Channel"""
  
      # if key_value_states are provided this layer is used as a cross-attention layer
      # for the decoder
      is_cross_attention = key_value_states is not None
      bsz, tgt_len, embed_dim = hidden_states.size()
  
      # add position embeddings to the hidden states before projecting to queries and keys
      if position_embeddings is not None:
          hidden_states_original = hidden_states
          hidden_states = self.with_pos_embed(
              hidden_states, position_embeddings
          )
  
      # add key-value position embeddings to the key value states
      if key_value_position_embeddings is not None:
          key_value_states_original = key_value_states
          key_value_states = self.with_pos_embed(
              key_value_states, key_value_position_embeddings
          )
  
      # get query proj
      query_states = self.q_proj(hidden_states) * self.scaling
      # get key, value proj
      if is_cross_attention:
          # cross_attentions
          key_states = self._shape(
              self.k_proj(key_value_states), -1, bsz
          )
          value_states = self._shape(
              self.v_proj(key_value_states_original), -1, bsz
          )
      else:
          # self_attention
          key_states = self._shape(self.k_proj(hidden_states), -1, bsz)
          value_states = self._shape(
              self.v_proj(hidden_states_original), -1, bsz
          )
  
      proj_shape = (bsz * self.num_heads, -1, self.head_dim)
      query_states = self._shape(query_states, tgt_len, bsz).view(
          *proj_shape
      )
      key_states = key_states.view(*proj_shape)
      value_states = value_states.view(*proj_shape)
  
      src_len = key_states.size(1)
  
      attn_weights = torch.bmm(query_states, key_states.transpose(1, 2))
  
      if attn_weights.size() != (
          bsz * self.num_heads,
          tgt_len,
          src_len,
      ):
          raise ValueError(
              f"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is {attn_weights.size()}"
          )
  
      if attention_mask is not None:
          if attention_mask.size() != (bsz, 1, tgt_len, src_len):
              raise ValueError(
                  f"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is {attention_mask.size()}"
              )
          attn_weights = (
              attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
              + attention_mask
          )
          attn_weights = attn_weights.view(
              bsz * self.num_heads, tgt_len, src_len
          )
  
      attn_weights = nn.functional.softmax(attn_weights, dim=-1)
  
      if output_attentions:
          # this operation is a bit awkward, but it's required to
          # make sure that attn_weights keeps its gradient.
          # In order to do so, attn_weights have to reshaped
          # twice and have to be reused in the following
          attn_weights_reshaped = attn_weights.view(
              bsz, self.num_heads, tgt_len, src_len
          )
          attn_weights = attn_weights_reshaped.view(
              bsz * self.num_heads, tgt_len, src_len
          )
      else:
          attn_weights_reshaped = None
  
      attn_probs = nn.functional.dropout(
          attn_weights, p=self.dropout, training=self.training
      )
  
      attn_output = torch.bmm(attn_probs, value_states)
  
      if attn_output.size() != (
          bsz * self.num_heads,
          tgt_len,
          self.head_dim,
      ):
          raise ValueError(
              f"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {attn_output.size()}"
          )
  
      attn_output = attn_output.view(
          bsz, self.num_heads, tgt_len, self.head_dim
      )
      attn_output = attn_output.transpose(1, 2)
      attn_output = attn_output.reshape(bsz, tgt_len, self.embed_dim)
  
      attn_output = self.out_proj(attn_output)
  
      return attn_output, attn_weights_reshaped
  
imports: from typing import Optional, Tuple
  import torch
  import torch.nn
  from transformers.models.detr.modeling_detr import DetrAttention
label_desc: Use image node_id 1 for calling the DetrAttention_ obj's underlying member method code with example usage: obj.forward(hidden_states, attention_mask, position_embeddings, key_value_states, key_value_position_embeddings, output_attentions) and returns: attn_output,  attn_weights_reshaped