code: def depthwise_conv2d(
      x: Union[ivy.Array, ivy.NativeArray],
      filters: Union[ivy.Array, ivy.NativeArray],
      strides: Union[int, Tuple[int, int]],
      padding: Union[str, Sequence[Tuple[int, int]]],
      /,
      *,
      data_format: str = "NHWC",
      dilations: Union[int, Tuple[int, int]] = 1,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Compute a 2-D depthwise convolution given 4-D input ``x`` and filters
      arrays.
  
      Parameters
      ----------
      x
          Input image *[batch_size,h,w,d_in]* or *[batch_size,d_in,h,w]*.
      filters
          Convolution filters *[fh,fw,d_in]*. (d_in must be the same as d from x)
      strides
          The stride of the sliding window for each dimension of input.
      padding
          either the string ‘SAME’ (padding with zeros evenly), the string ‘VALID’ (no
          padding), or a sequence of n (low, high) integer pairs that give the padding to
          apply before and after each spatial dimension.
      data_format
          The ordering of the dimensions in the input, one of "NHWC" or "NCHW". "NHWC"
          corresponds to inputs with shape (batch_size, height, width, channels), while
          "NCHW" corresponds to input with shape (batch_size, channels, height, width).
      dilations
          The dilation factor for each dimension of input. (Default value = 1)
      out
          optional output array, for writing the result to. It must have a shape that the
          inputs broadcast to.
  
      Returns
      -------
      ret
          The result of the convolution operation.
  
      Both the description and the type hints above assumes an array input for simplicity,
      but this function is *nestable*, and therefore also accepts :class:`ivy.Container`
      instances in place of any of the arguments.
  
      Examples
      --------
      With :class:`ivy.Array` input:
  
      >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 28, 28, 3])
      >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 3, 3])
      >>> y = ivy.depthwise_conv2d(x, filters, (1, 1), 'VALID')
      >>> print(y.shape)
      ivy.Shape(1, 26, 26, 3)
  
      >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 32, 32, 3])
      >>> y = ivy.zeros((1, 16, 16, 3))
      >>> filters = ivy.random_normal(mean=0, std=1, shape=[5, 5, 3])
      >>> ivy.depthwise_conv2d(x, filters, [2, 2], 'SAME', out=y)
      >>> print(y.shape)
      ivy.Shape(1, 16, 16, 3)
  
      >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 64, 64, 32])
      >>> y = ivy.zeros((1, 61, 61, 32))
      >>> filters = ivy.random_normal(mean=0, std=1, shape=[4, 4, 32])
      >>> ivy.depthwise_conv2d(x, filters, [1, 1], 'VALID', out=y)
      >>> print(x.shape)
      ivy.Shape(1, 64, 64, 32)
  
      With :class:`ivy.NativeArray` input:
  
      >>> x = ivy.native_array(ivy.random_normal(mean=0, std=1, shape=[1, 7, 7, 64]))
      >>> filters = ivy.native_array(ivy.random_normal(mean=0, std=1, shape=[3, 3, 64]))
      >>> y = ivy.depthwise_conv2d(x, filters, [1, 1], 'SAME')
      >>> print(y.shape)
      ivy.Shape(1, 7, 7, 64)
  
      With a mix of :class:`ivy.Array` and :class:`ivy.Container` inputs:
  
      >>> x = ivy.eye(6, 6).reshape((1, 6, 6, 1)) #NHWC
      >>> a = ivy.array([[1., 1., 1.], [1., -8., 1.], [1., 1., 1.]]).expand_dims(axis=-1)
      >>> b = ivy.array([[1., 1., 1.],
      ...                [1., 1., 1.],
      ...                [1., 1., 1.]]).expand_dims(axis=-1) / 9.0
      >>> filters = ivy.Container(a = a, b = b)
      >>> y = ivy.depthwise_conv2d(x, filters, 1, 'VALID', dilations=2)
      >>> print(y)
      {
          a: ivy.array([[[[-6.],
                          [0.]],
                         [[0.],
                          [-6.]]]]),
          b: ivy.array([[[[0.33333334],
                          [0.]],
                         [[0.],
                          [0.33333334]]]])
      }
  
      With a mix of :class:`ivy.Array`, code:`ivy.NativeArray`
      and :class:`ivy.Container` inputs:
  
      >>> x = ivy.eye(6, 6).reshape((1, 6, 6, 1)) #NHWC
      >>> y = ivy.native_array(ivy.eye(6, 6).reshape((1, 6, 6, 1)))
      >>> inp = ivy.Container(x = x, y = y)
      >>> filter = ivy.array([[1., 1., 1.],
      ...                     [1., -8., 1.],
      ...                     [1., 1., 1.]]).expand_dims(axis=-1)
      >>> y = ivy.depthwise_conv2d(inp, filter, 1, 'VALID', dilations=2)
      >>> print(y)
      {
          x: ivy.array([[[[-6.],
                          [0.]],
                         [[0.],
                          [-6.]]]]),
          y: ivy.array([[[[-6.],
                          [0.]],
                         [[0.],
                          [-6.]]]])
      }
      """
      return current_backend(x).depthwise_conv2d(
          x,
          filters,
          strides,
          padding,
          data_format=data_format,
          dilations=dilations,
          out=out,
      )
  
imports: from typing import Optional, Tuple, Union, Sequence
  import ivy
  from ivy.utils.backend import current_backend
  from ivy.func_wrapper import handle_array_function, handle_partial_mixed_function, inputs_to_ivy_arrays, to_native_arrays_and_back, inputs_to_native_shapes, handle_out_argument, handle_nestable, handle_array_like_without_promotion, handle_device, handle_backend_invalid
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 11 for calling a global function with example usage: depthwise_conv2d() and returns: current_backend