code: def verify_group_conv2d_transpose_nchw(
      batch,
      in_channel,
      in_size,
      num_filter,
      kernel,
      stride,
      padding,
      output_padding,
      groups,
  ):
      print(
          "Workload: (%d, %d, %s, %d, %s, %s, %s, %s, %d)"
          % (
              batch,
              in_channel,
              in_size,
              num_filter,
              kernel,
              stride,
              padding,
              output_padding,
              groups,
          )
      )
  
      in_height, in_width = in_size
      kernel_height, kernel_width = kernel
  
      A = te.placeholder(
          (batch, in_channel, in_height, in_width), name="A"
      )
      W = te.placeholder(
          (
              in_channel,
              num_filter // groups,
              kernel_height,
              kernel_width,
          ),
          name="W",
      )
      bias = te.placeholder((num_filter, 1, 1), name="bias")
  
      a_shape = get_const_tuple(A.shape)
      w_shape = get_const_tuple(W.shape)
      bias_shape = get_const_tuple(bias.shape)
      dtype = A.dtype
  
      @memoize(
          "topi.tests.test_topi_group_conv2d_transpose.verify_group_conv2d_transpose_nchw"
      )
      def get_ref_data():
          a_np = np.random.uniform(size=a_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.conv2d_transpose_nchw_python(
              a_np, w_np, stride, padding, output_padding, groups
          ).astype(dtype)
  
          return a_np, w_np, b_np, c_np
  
      a_np, w_np, b_np, c_np = get_ref_data()
  
      def check_target(target):
          dev = tvm.device(target, 0)
          if not tvm.testing.device_enabled(target):
              print("Skip because %s is not enabled" % target)
              return
  
          print("Running on target: %s" % target)
          with tvm.target.Target(target):
              fcompute, fschedule = tvm.topi.testing.dispatch(
                  target, _group_conv2d_nchw_implement
              )
              C = fcompute(
                  A, W, stride, padding, dtype, output_padding, groups
              )
              s = fschedule([C])
  
          a = tvm.nd.array(a_np, dev)
          w = tvm.nd.array(w_np, dev)
          c = tvm.nd.array(
              np.zeros(get_const_tuple(C.shape), dtype=C.dtype), dev
          )
          func = tvm.build(
              s,
              [A, W, C],
              target,
              name="group_conv2d_transpose_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d"
              % (
                  batch,
                  in_channel,
                  in_size[0],
                  in_size[1],
                  num_filter,
                  kernel[0],
                  kernel[1],
                  stride[0],
                  stride[1],
                  padding[0],
                  padding[1],
                  padding[2],
                  padding[3],
                  output_padding[0],
                  output_padding[1],
                  groups,
              ),
          )
          func(a, w, c)
          c = c.numpy()
          for measurement, reference in zip(c, c_np):
              tvm.testing.assert_allclose(
                  measurement, reference, rtol=1e-5
              )
  
      for target in ["llvm", "cuda"]:
          check_target(target)
  
file_path: tvm/tests/python/topi/test_topi_group_conv2d_transpose.py
imports: import numpy
  import tvm
  import tvm.testing
  import tvm.topi.testing
  from tvm import te, topi
  from tvm.contrib.pickle_memoize import memoize
  from tvm.topi.utils import get_const_tuple
label_desc: Use image node_id 1 for calling a global function with example usage: verify_group_conv2d_transpose_nchw(batch, in_channel, in_size, num_filter, kernel, stride, padding, output_padding, groups) and returns: a_np,  w_np,  b_np,  c_np