class_docstr: Deformable 2D convolution.
  
  Applies a deformable 2D convolution over an input signal composed of
  several input planes. DeformConv2d was described in the paper
  `Deformable Convolutional Networks
  <https://arxiv.org/pdf/1703.06211.pdf>`_
  
  Note:
      The argument ``im2col_step`` was added in version 1.3.17, which means
      number of samples processed by the ``im2col_cuda_kernel`` per call.
      It enables users to define ``batch_size`` and ``im2col_step`` more
      flexibly and solved `issue mmcv#1440
      <https://github.com/open-mmlab/mmcv/issues/1440>`_.
  
  Args:
      in_channels (int): Number of channels in the input image.
      out_channels (int): Number of channels produced by the convolution.
      kernel_size(int, tuple): Size of the convolving kernel.
      stride(int, tuple): Stride of the convolution. Default: 1.
      padding (int or tuple): Zero-padding added to both sides of the input.
          Default: 0.
      dilation (int or tuple): Spacing between kernel elements. Default: 1.
      groups (int): Number of blocked connections from input.
          channels to output channels. Default: 1.
      deform_groups (int): Number of deformable group partitions.
      bias (bool): If True, adds a learnable bias to the output.
          Default: False.
      im2col_step (int): Number of samples processed by im2col_cuda_kernel
          per call. It will work when ``batch_size`` > ``im2col_step``, but
          ``batch_size`` must be divisible by ``im2col_step``. Default: 32.
          `New in version 1.3.17.`
docstr: Deformable Convolutional forward function.
  
  Args:
      x (Tensor): Input feature, shape (B, C_in, H_in, W_in)
      offset (Tensor): Offset for deformable convolution, shape
          (B, deform_groups*kernel_size[0]*kernel_size[1]*2,
          H_out, W_out), H_out, W_out are equal to the output's.
  
          An offset is like `[y0, x0, y1, x1, y2, x2, ..., y8, x8]`.
          The spatial arrangement is like:
  
          .. code:: text
  
              (x0, y0) (x1, y1) (x2, y2)
              (x3, y3) (x4, y4) (x5, y5)
              (x6, y6) (x7, y7) (x8, y8)
  
  Returns:
      Tensor: Output of the layer.
docstr_tok: ["Deformable","Convolutional","forward","function",".","Args",":","x","(","Tensor",")",":","Input","feature",",","shape","(","B",",","C_in",",","H_in",",","W_in",")","offset","(","Tensor",")",":","Offset","for","deformable","convolution",",","shape","(","B",",","deform_groups","*","kernel_size","[","0","]","*","kernel_size","[","1","]","*","2",",","H_out",",","W_out",")",",","H_out",",","W_out","are","equal","to","the","output","'s",".","An","offset","is","like","`","[","y0",",","x0",",","y1",",","x1",",","y2",",","x2",",","...",",","y8",",","x8","]","`",".","The","spatial","arrangement","is","like",":","..","code",":",":","text","(","x0",",","y0",")","(","x1",",","y1",")","(","x2",",","y2",")","(","x3",",","y3",")","(","x4",",","y4",")","(","x5",",","y5",")","(","x6",",","y6",")","(","x7",",","y7",")","(","x8",",","y8",")","Returns",":","Tensor",":","Output","of","the","layer","."]
code: def forward(self, x: Tensor, offset: Tensor) -> Tensor:
      """Deformable Convolutional forward function.
  
      Args:
          x (Tensor): Input feature, shape (B, C_in, H_in, W_in)
          offset (Tensor): Offset for deformable convolution, shape
              (B, deform_groups*kernel_size[0]*kernel_size[1]*2,
              H_out, W_out), H_out, W_out are equal to the output's.
  
              An offset is like `[y0, x0, y1, x1, y2, x2, ..., y8, x8]`.
              The spatial arrangement is like:
  
              .. code:: text
  
                  (x0, y0) (x1, y1) (x2, y2)
                  (x3, y3) (x4, y4) (x5, y5)
                  (x6, y6) (x7, y7) (x8, y8)
  
      Returns:
          Tensor: Output of the layer.
      """
      # To fix an assert error in deform_conv_cuda.cpp:128
      # input image is smaller than kernel
      input_pad = (x.size(2) < self.kernel_size[0]) or (
          x.size(3) < self.kernel_size[1]
      )
      if input_pad:
          pad_h = max(self.kernel_size[0] - x.size(2), 0)
          pad_w = max(self.kernel_size[1] - x.size(3), 0)
          x = F.pad(x, (0, pad_w, 0, pad_h), "constant", 0).contiguous()
          offset = F.pad(offset, (0, pad_w, 0, pad_h), "constant", 0)
          offset = offset.contiguous()
      out = deform_conv2d(
          x,
          offset,
          self.weight,
          self.stride,
          self.padding,
          self.dilation,
          self.groups,
          self.deform_groups,
          False,
          self.im2col_step,
      )
      if input_pad:
          out = out[
              :, :, : out.size(2) - pad_h, : out.size(3) - pad_w
          ].contiguous()
      return out
  
imports: from typing import Tuple, Union
  import torch
  import torch.nn
  import torch.nn.functional
  from torch import Tensor
  from torch.autograd import Function
  from torch.autograd.function import once_differentiable
  from torch.nn.modules.utils import _pair, _single
  from annotator.uniformer.mmcv.utils import deprecated_api_warning
  from ..cnn import CONV_LAYERS
  from ..utils import ext_loader, print_log
label_desc: Use image node_id 3 for calling the DeformConv2d obj's underlying member method code with example usage: obj.forward(x, offset) and returns: out