code: def group_conv3d_transpose_ncdhw(
      data, kernel, strides, padding, out_dtype, output_padding, groups
  ):
      """Transposed group 3D convolution ncdhw forward operator.
  
      Parameters
      ----------
      data : tvm.te.Tensor
          5-D with shape [batch, in_channel, in_depth, in_height, in_width]
  
      kernel : tvm.te.Tensor
          5-D with shape [in_channel, num_filter, filter_depth, filter_height, filter_width]
  
      strides : int or a list/tuple of three ints
          The spatial stride along depth,height and width
  
      padding : int or str
          Padding size, or ['VALID', 'SAME']
  
      out_dtype : str
          The output data type. This is used for mixed precision.
  
      output_padding : tuple of ints
          Used to get the right output shape for gradients
  
      groups : int
          number of groups
  
      Returns
      -------
      Output : tvm.te.Tensor
          5-D with shape [batch, out_channel, out_depth, out_height, out_width]
      """
      if not isinstance(strides, (tuple, list)):
          strides = (strides, strides, strides)
  
      if groups == 1:
          return conv3d_transpose_ncdhw(
              data, kernel, strides, padding, out_dtype, output_padding
          )
  
      data_pad, kernel_transform = conv3d_transpose_ncdhw_preprocess(
          data, kernel, strides, padding, out_dtype, output_padding
      )
      batch, in_c, in_d, in_h, in_w = data_pad.shape
      out_c, _, filter_d, filter_h, filter_w = kernel_transform.shape
      assert (
          in_c % groups == 0
      ), f"input channels {in_c} must divide group size {groups}"
  
      # convolution stage
      out_c = simplify(out_c * groups)
      out_d = simplify(in_d - filter_d + 1)
      out_h = simplify(in_h - filter_h + 1)
      out_w = simplify(in_w - filter_w + 1)
      dc = te.reduce_axis((0, in_c // groups), name="dc")
      dd = te.reduce_axis((0, filter_d), name="dd")
      dh = te.reduce_axis((0, filter_h), name="dh")
      dw = te.reduce_axis((0, filter_w), name="dw")
  
      # data: batch, in_channels, out_d, out_h, out_w
      # weight: out_channels // G, in_channels, out_d, out_h, out_w
      return te.compute(
          (batch, out_c, out_d, out_h, out_w),
          lambda b, c, d, h, w: te.sum(
              data_pad[
                  b,
                  c // (out_c // groups) * (in_c // groups) + dc,
                  d + dd,
                  h + dh,
                  w + dw,
              ].astype(out_dtype)
              * kernel_transform[
                  c % (out_c // groups),
                  c // (out_c // groups) * (in_c // groups) + dc,
                  dd,
                  dh,
                  dw,
              ].astype(out_dtype),
              axis=[dc, dd, dh, dw],
          ),
          tag="group_conv3d_transpose_ncdhw",
      )
  
file_path: tvm/python/tvm/topi/nn/conv3d_transpose.py
imports: import tvm
  from tvm import te
  from tvm import relay
  from .dilate import dilate
  from .pad import pad
  from .utils import get_pad_tuple3d
  from ..utils import simplify
label_desc: Use image node_id 4 for calling a global function with example usage: group_conv3d_transpose_ncdhw(data, kernel, strides, padding, out_dtype, output_padding, groups) and returns: te, conv3d_transpose_ncdhw