code: def conv3d(
      x: Union[ivy.Array, ivy.NativeArray, ivy.Container],
      filters: Union[ivy.Array, ivy.NativeArray, ivy.Container],
      strides: Union[int, Tuple[int, int, int]],
      padding: Union[str, int, Sequence[Tuple[int, int]]],
      /,
      *,
      data_format: str = "NDHWC",
      filter_format: str = "channel_last",
      x_dilations: Union[int, Tuple[int, int, int]] = 1,
      dilations: Union[int, Tuple[int, int, int]] = 1,
      bias: Optional[ivy.Array] = None,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Compute a 3-D convolution given 5-D input x and filters arrays.
  
      Parameters
      ----------
      x
          Input volume *[batch_size,d,h,w,d_in]* or *[batch_size,d_in,d,h,w]*.
      filters
          Convolution filters *[fd,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 "NDHWC" or "NCDHW". "NDHWC"
          corresponds to inputs with shape (batch_size, depth, height, width, channels),
          while "NCDHW" corresponds to input with shape (batch_size, channels, depth,
          height, width).
      filter_format
          Either "channel_first" or "channel_last". "channel_first" corresponds
          to "OIDHW",input data formats, while "channel_last" corresponds to "DHWIO".
       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. ,1.], [1., 2. ,1.], [1., 2. ,1.]],
      ...         [[1., 2. ,1.], [1., 2. ,1.], [1., 2. ,1.]],
      ...         [[1., 2. ,1.], [1., 2. ,1.], [1., 2. ,1.]]]).reshape((1, 3, 3, 3, 1))
      >>> filters = ivy.array([[[0.,1.,0.],
      ...                       [0.,1.,0.],
      ...                       [0.,1.,0.]]]).reshape((1,3,3,1,1))
      >>> result = ivy.conv3d(x, filters, 1, 'SAME', data_format='NDHWC', dilations=1)
      >>> print(result)
      ivy.array([[[[[2.],[4.],[2.]],[[3.],[6.],[3.]],[[2.],[4.],[2.]]],
                  [[[2.],[4.],[2.]],[[3.],[6.],[3.]],[[2.],[4.],[2.]]],
                  [[[2.],[4.],[2.]],[[3.],[6.],[3.]],[[2.],[4.],[2.]]]]])
  
      With one :class:`ivy.Container` input:
  
      >>> x = ivy.Container(a = ivy.ones((1, 3, 3, 3, 1)).astype(ivy.float32))
      >>> filters = ivy.ones((3, 3, 3, 1, 1)).astype(ivy.float32)
      >>> result = ivy.conv3d(x, filters, 2, 'SAME')
      >>> print(result)
      {
          a: ivy.array([[[[[8.],[8.]],[[8.],[8.]]],[[[8.],[8.]],[[8.],[8.]]]]])
      }
  
      With multiple :class:`ivy.Container` input:
  
      >>> x = ivy.Container( a = ivy.random_normal(mean = 0, std = 1,
      ...                        shape = [1, 3, 5, 5, 1]),
      ...                    b = ivy.random_normal(mean = 0, std = 1,
      ...                        shape = [1, 5, 32 ,32, 1]),
      ...                    c = ivy.random_normal(mean = 0, std = 1,
      ...                        shape = [1, 32, 32, 32, 1]))
      >>> filters = ivy.ones((3, 5, 5, 1, 3)).astype(ivy.float32)
      >>> result = ivy.conv3d(x, filters, 1, 'SAME')
      >>> print(result.cont_shapes)
      {
          a: ivy.Shape(1, 3, 5, 5, 3),
          b: ivy.Shape(1, 5, 32, 32, 3),
          c: ivy.Shape(1, 32, 32, 32, 3)
      }
      """
      return current_backend(x).conv3d(
          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 12 for calling a global function with example usage: conv3d() and returns: current_backend