code: def depthwise_conv2d_backward_input_nhwc(
      Filter, Out_grad, oshape, ishape, stride, padding
  ):
      """Depthwise convolution nhwc backward wrt input operator.
  
      Parameters
      ----------
      Filter : tvm.te.Tensor
          4-D with shape [filter_height, filter_width, in_channel, channel_multiplier]
  
      Out_grad : tvm.te.Tensor
          4-D with shape [batch, out_height, out_width, out_channel]
  
      stride : tuple of two ints
          The spatial stride along height and width
  
      padding : int or str
          Padding size, or ['VALID', 'SAME']
  
      Returns
      -------
      Output : tvm.te.Tensor
          4-D with shape [batch, in_height, in_width, in_channel]
      """
      batch, in_h, in_w, in_c = ishape
      _, out_h, out_w, out_c = oshape
      filter_h, filter_w, _, channel_multiplier = Filter.shape
      if isinstance(stride, int):
          stride_h = stride_w = stride
      else:
          stride_h, stride_w = stride
  
      dilated_out_grad = dilate(
          Out_grad, [1, stride_h, stride_w, 1], name="dilated_out_grad"
      )
  
      # padding params in forward propagation
      fpad_top, fpad_left, fpad_bottom, fpad_right = get_pad_tuple(
          padding, (filter_h, filter_w)
      )
      # padding params in backward propagation
      bpad_top = filter_h - 1 - fpad_top
      bpad_bottom = (filter_h - 1 - fpad_bottom) + (stride_h - 1)
      bpad_left = filter_w - 1 - fpad_left
      bpad_right = (filter_w - 1 - fpad_right) + (stride_w - 1)
  
      padded_out_grad = pad(
          dilated_out_grad,
          [0, bpad_top, bpad_left, 0],
          [0, bpad_bottom, bpad_right, 0],
          name="padded_out_grad",
      )
  
      dh = te.reduce_axis((0, filter_h), name="dh")
      dw = te.reduce_axis((0, filter_w), name="dw")
      dc = te.reduce_axis((0, channel_multiplier), name="dc")
  
      In_grad = te.compute(
          (batch, in_h, in_w, in_c),
          lambda b, h, w, c: te.sum(
              padded_out_grad[
                  b, h + dh, w + dw, c * channel_multiplier + dc
              ]
              * Filter[filter_h - 1 - dh, filter_w - 1 - dw, c, dc],
              axis=[dh, dw, dc],
          ),
          tag="depthwise_conv2d_backward_input_nhwc",
      )
  
      return In_grad
  
file_path: tvm/python/tvm/topi/nn/depthwise_conv2d.py
imports: from __future__ import absolute_import
  from collections import namedtuple
  import numpy
  import tvm
  from tvm import te
  from .dilate import dilate
  from .pad import pad
  from .utils import get_pad_tuple
  from ..utils import simplify, get_const_tuple
label_desc: Use image node_id 4 for calling a global function with example usage: depthwise_conv2d_backward_input_nhwc(Filter, Out_grad, oshape, ishape, stride, padding) and returns: In_grad