docstr: Args:
      query (Tensor): [bs, query_length, C]
      reference_points (Tensor): [bs, query_length, n_levels, 2], range in [0, 1], top-left (0,0),
          bottom-right (1, 1), including padding area
      value (Tensor): [bs, value_length, C]
      value_spatial_shapes (Tensor): [n_levels, 2], [(H_0, W_0), (H_1, W_1), ..., (H_{L-1}, W_{L-1})]
      value_level_start_index (Tensor(int64)): [n_levels], [0, H_0*W_0, H_0*W_0+H_1*W_1, ...]
      value_mask (Tensor): [bs, value_length], True for non-padding elements, False for padding elements
  
  Returns:
      output (Tensor): [bs, Length_{query}, C]
code: def forward(
      self,
      query,
      reference_points,
      value,
      value_spatial_shapes,
      value_level_start_index,
      value_mask=None,
  ):
      """
      Args:
          query (Tensor): [bs, query_length, C]
          reference_points (Tensor): [bs, query_length, n_levels, 2], range in [0, 1], top-left (0,0),
              bottom-right (1, 1), including padding area
          value (Tensor): [bs, value_length, C]
          value_spatial_shapes (Tensor): [n_levels, 2], [(H_0, W_0), (H_1, W_1), ..., (H_{L-1}, W_{L-1})]
          value_level_start_index (Tensor(int64)): [n_levels], [0, H_0*W_0, H_0*W_0+H_1*W_1, ...]
          value_mask (Tensor): [bs, value_length], True for non-padding elements, False for padding elements
  
      Returns:
          output (Tensor): [bs, Length_{query}, C]
      """
      bs, Len_q = query.shape[:2]
      Len_v = value.shape[1]
      assert int(value_spatial_shapes.prod(1).sum()) == Len_v
  
      value = self.value_proj(value)
      if value_mask is not None:
          value_mask = value_mask.astype(value.dtype).unsqueeze(-1)
          value *= value_mask
      value = value.reshape([bs, Len_v, self.num_heads, self.head_dim])
  
      sampling_offsets = self.sampling_offsets(query).reshape(
          [
              bs,
              Len_q,
              self.num_heads,
              self.num_levels,
              self.num_points,
              2,
          ]
      )
      attention_weights = self.attention_weights(query).reshape(
          [bs, Len_q, self.num_heads, self.num_levels * self.num_points]
      )
      attention_weights = F.softmax(attention_weights).reshape(
          [bs, Len_q, self.num_heads, self.num_levels, self.num_points]
      )
  
      if reference_points.shape[-1] == 2:
          offset_normalizer = value_spatial_shapes.flip([1]).reshape(
              [1, 1, 1, self.num_levels, 1, 2]
          )
          sampling_locations = (
              reference_points.reshape(
                  [bs, Len_q, 1, self.num_levels, 1, 2]
              )
              + sampling_offsets / offset_normalizer
          )
      elif reference_points.shape[-1] == 4:
          sampling_locations = (
              reference_points[:, :, None, :, None, :2]
              + sampling_offsets
              / self.num_points
              * reference_points[:, :, None, :, None, 2:]
              * 0.5
          )
      else:
          raise ValueError(
              "Last dim of reference_points must be 2 or 4, but get {} instead.".format(
                  reference_points.shape[-1]
              )
          )
  
      output = self.ms_deformable_attn_core(
          value,
          value_spatial_shapes,
          value_level_start_index,
          sampling_locations,
          attention_weights,
      )
      output = self.output_proj(output)
  
      return output
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import math
  import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddle import ParamAttr
  from ppdet.core.workspace import register
  from ..layers import MultiHeadAttention
  from .position_encoding import PositionEmbedding
  from .utils import _get_clones, get_valid_ratio
  from ..initializer import linear_init_, constant_, xavier_uniform_, normal_
label_desc: Use image node_id 3 for calling the MSDeformableAttention obj's underlying member method code with example usage: obj.forward(query, reference_points, value, value_spatial_shapes, value_level_start_index, value_mask) and returns: output