code: def conv2d(
      x: Union[ivy.Array, ivy.NativeArray],
      filters: Union[ivy.Array, ivy.NativeArray],
      strides: Union[int, Tuple[int, int]],
      padding: Union[str, int, Sequence[Tuple[int, int]]],
      /,
      *,
      data_format: str = "NHWC",
      filter_format: str = "channel_last",
      x_dilations: Union[int, Tuple[int, int]] = 1,
      dilations: Union[int, Tuple[int, int]] = 1,
      bias: Optional[ivy.Array] = None,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Compute a 2-D 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_out]*.
      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).
      filter_format
          Either "channel_first" or "channel_last". "channel_first" corresponds to "OIHW",
           input data formats, while "channel_last" corresponds to "HWIO".
       x_dilations
          The dilation factor for each dimension of input. (Default value = 1)
      dilations
          The dilation factor for each dimension of input. (Default value = 1)
      bias
          Bias array of shape *[d_out]*.
      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.array([[[[1.], [2.0],[3.]],
      ...                 [[1.], [2.0],[3.]],
      ...                 [[1.], [2.0],[3.]]]])
      >>> filters = ivy.array([[[[0.]],[[1.]],[[0.]]],
      ...                      [[[0.]],[[1.]], [[0.]]],
      ...                      [[[0.]],[[1.]], [[0.]]]])
      >>> result = ivy.conv2d(x, filters, 1, 'SAME', data_format='NHWC', dilations=1)
      >>> print(result)
      ivy.array([[
                [[2.],[4.],[6.]],
                [[3.],[6.],[9.]],
                [[2.],[4.],[6.]]
                ]])
  
      With one :class:`ivy.Container` input:
  
      >>> x = ivy.Container(a=ivy.array([[[[1.], [2.0],[3.]],
      ...                                 [[1.], [2.0],[3.]],
      ...                                 [[1.], [2.0],[3.]]]]))
      >>> filters = ivy.eye(3, 3).reshape((3, 3, 1, 1)).astype(ivy.float32)
      >>> result = ivy.conv2d(x, filters, 2, 'SAME', data_format='NHWC', dilations= 1)
      >>> print(result)
      {
          a:ivy.array([[[[3.], [3.]], [[1.], [5.]]]])
      }
  
      With multiple :class:`ivy.Container` inputs:
  
      >>> x = ivy.Container(a = ivy.eye(3, 3).reshape((1, 3, 3, 1)),
      ...                   b = ivy.eye(4, 4).reshape((1, 4, 4, 1)),
      ...                   c = ivy.eye(5, 5).reshape((1, 5, 5, 1)))
      >>> filters = ivy.array([[1, 1, 1],
      ...                      [0, 1, 1],
      ...                      [0, 0, 1]], dtype = ivy.float32).reshape((3, 3, 1, 1))
      >>> result = ivy.conv2d(x, filters, 2, 'SAME')
      >>> print(result)
      {
          a:ivy.array([[[[2.], [0.]], [[1.], [2.]]]]),
          b:ivy.array([[[[3.], [0.]], [[1.], [2.]]]]),
          c:ivy.array([[[[2.], [0.], [0.]],
                        [[1.], [3.], [0.]],
                        [[0.], [1.], [2.]]
                      ]])
      }
  
      With a mix of :class:`ivy.Array` and :class:`ivy.Container` inputs:
  
      >>> x = ivy.Container(a = ivy.eye(3, 3).reshape((1, 3, 3, 1)),
      ...                   b = ivy.eye(5, 5).reshape((1, 5, 5, 1)))
      >>> filters = ivy.array([[2, 0, 1],
      ...                      [1, 3, 1],
      ...                      [0, 1, 1]], dtype = ivy.float32).reshape((3, 3, 1, 1))
      >>> result = ivy.conv2d(x, filters, 2, 'SAME')
      >>> print(result)
      {
          a:ivy.array([[[[4.],[0.]],[[1.],[5.]]]]),
          b:ivy.array([[[[4.],[0.],[0.]],[[1.],[6.],[0.]],[[0.],[1.],[5.]]]])
      }
      """
      return current_backend(x).conv2d(
          x,
          filters,
          strides,
          padding,
          data_format=data_format,
          filter_format=filter_format,
          x_dilations=x_dilations,
          dilations=dilations,
          bias=bias,
          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 9 for calling a global function with example usage: conv2d() and returns: current_backend