code: def verify_deformable_conv2d_nhwc(
      batch,
      in_channel,
      in_size,
      num_filter,
      kernel,
      stride,
      padding,
      dilation=1,
      deformable_groups=1,
      groups=1,
  ):
      print(
          "Workload: (%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)"
          % (
              batch,
              in_channel,
              in_size,
              num_filter,
              kernel,
              stride,
              padding,
              dilation,
              deformable_groups,
              groups,
          )
      )
  
      A = te.placeholder(
          (batch, in_size, in_size, in_channel), name="A"
      )
      out_size = (
          in_size - (kernel - 1) * dilation - 1 + 2 * padding
      ) // stride + 1
      Offset = te.placeholder(
          (
              batch,
              out_size,
              out_size,
              deformable_groups * kernel * kernel * 2,
          ),
          name="offset",
      )
      W = te.placeholder(
          (kernel, kernel, in_channel, num_filter), name="W"
      )
      bias = te.placeholder((num_filter,), name="bias")
  
      a_shape = get_const_tuple(A.shape)
      offset_shape = get_const_tuple(Offset.shape)
      w_shape = get_const_tuple(W.shape)
      bias_shape = get_const_tuple(bias.shape)
      dtype = A.dtype
  
      @memoize(
          "topi.tests.test_topi_deformable_conv2d_nchw.verify_deformable_conv2d_nhwc"
      )
      def get_ref_data():
          a_np = np.random.uniform(size=a_shape).astype(dtype)
          offset_np = np.random.randn(*offset_shape).astype(dtype)
          w_np = np.random.uniform(size=w_shape).astype(dtype)
          b_np = np.random.uniform(size=bias_shape).astype(dtype)
          c_np = tvm.topi.testing.deformable_conv2d_nhwc_python(
              a_np,
              offset_np,
              w_np,
              stride,
              padding,
              dilation,
              deformable_groups,
              groups,
          )
  
          return a_np, offset_np, w_np, c_np
  
      a_np, offset_np, w_np, c_np = get_ref_data()
  
      def check_device(device):
          dev = tvm.device(device, 0)
          if not tvm.testing.device_enabled(device):
              print("Skip because %s is not enabled" % device)
              return
          print("Running on target: %s" % device)
          fcompute, fschedule = tvm.topi.testing.dispatch(
              device, _deformable_conv2d_nhwc_implement
          )
          with tvm.target.Target(device):
              C = fcompute(
                  A,
                  Offset,
                  W,
                  stride,
                  padding,
                  dilation,
                  deformable_groups,
                  groups,
                  dtype,
              )
              s = fschedule([C])
  
              a = tvm.nd.array(a_np, dev)
              offset = tvm.nd.array(offset_np, dev)
              w = tvm.nd.array(w_np, dev)
              c = tvm.nd.empty(c_np.shape, dtype=c_np.dtype, device=dev)
  
              func = tvm.build(s, [A, Offset, W, C], device)
              func(a, offset, w, c)
              tvm.testing.assert_allclose(c.numpy(), c_np, rtol=1e-5)
  
      for device in ["llvm"]:
          check_device(device)
  
file_path: tvm/tests/python/topi/test_topi_deformable_conv2d.py
imports: import numpy
  import tvm
  from tvm import te
  from tvm import autotvm
  from tvm import topi
  import tvm.topi.testing
  from tvm.contrib.pickle_memoize import memoize
  from tvm.topi.utils import get_const_tuple
  import tvm.testing
label_desc: Use image node_id 2 for calling a global function with example usage: verify_deformable_conv2d_nhwc(batch, in_channel, in_size, num_filter, kernel, stride, padding, dilation, deformable_groups, groups) and returns: a_np,  offset_np,  w_np,  c_np