code: def conv1d_transpose(
      x: Union[ivy.Array, ivy.NativeArray],
      filters: Union[ivy.Array, ivy.NativeArray],
      strides: Union[int, Tuple[int]],
      padding: str,
      /,
      *,
      output_shape: Optional[Union[ivy.Shape, ivy.NativeShape]] = None,
      filter_format: str = "channel_last",
      data_format: str = "NWC",
      dilations: Union[int, Tuple[int]] = 1,
      bias: Optional[ivy.Array] = None,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Compute a 1-D transpose convolution given 3-D input x and filters
      arrays.
  
      Parameters
      ----------
      x
          Input image *[batch_size,w,d_in]* or *[batch_size,d_in,w]*.
      filters
          Convolution filters *[fw,d_out,d_in]*.
      strides
          The stride of the sliding window for each dimension of input.
      padding
          Either ‘SAME’ (padding so that the output's shape is the same as the
          input's), or ‘VALID’ (padding so that the output's shape is `output_shape`).
      output_shape
          Shape of the output (Default value = None)
      filter_format
          Either "channel_first" or "channel_last". "channel_first" corresponds
          to "IOW",input data formats, while "channel_last" corresponds to "WOI".
      data_format
          The ordering of the dimensions in the input, one of "NWC" or "NCW". "NWC"
          corresponds to input with shape (batch_size, width, channels), while "NCW"
          corresponds to input with shape (batch_size, channels, width).
      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 transpose 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, 3])
      >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 6, 3])
      >>> y = ivy.conv1d_transpose(x, filters, 2, 'SAME')
      >>> print(y.shape)
      ivy.Shape(1, 56, 6)
  
      >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 128, 64])
      >>> filters = ivy.random_normal(mean=0, std=1, shape=[1, 64, 64])
      >>> ivy.conv1d_transpose(x, filters, 1, 'VALID', out=x)
      >>> print(x.shape)
      ivy.Shape(1, 128, 64)
  
      >>> x = ivy.random_normal(mean=0, std=1, shape=[1, 256, 64])
      >>> y = ivy.zeros((1, 258, 32))
      >>> filters = ivy.random_normal(mean=0, std=1, shape=[3, 32, 64])
      >>> ivy.conv1d_transpose(x, filters, 1, 'VALID', out=y)
      >>> print(y.shape)
      ivy.Shape(1, 258, 32)
  
      With :class:`ivy.NativeArray` input:
  
      >>> x = ivy.native_array(
      ...         ivy.random_normal(mean=0, std=1, shape=[1, 256, 128]))
      >>> filters = ivy.native_array(
      ...         ivy.random_normal(mean=0, std=1, shape=[3, 32, 128]))
      >>> y = ivy.conv1d_transpose(x, filters, 2, 'SAME')
      >>> print(y.shape)
      ivy.Shape(1, 512, 32)
  
      With one :class:`ivy.Container` input:
  
      >>> x = ivy.full((1, 6, 1), 2.7)
      >>> a = ivy.random_normal(mean=0, std=1, shape=[3, 1, 1])
      >>> b = ivy.random_normal(mean=0, std=1, shape=[3, 1, 1])
      >>> filters = ivy.Container(a=a, b=b)
      >>> y = ivy.conv1d_transpose(x, filters, 1, 'VALID', dilations=2)
      >>> print(y.shape)
      {
          a: ivy.Shape(1, 10, 1),
          b: ivy.Shape(1, 10, 1)
      }
  
      With multiple :class:`ivy.Container` inputs:
  
      >>> a = ivy.random_normal(mean=0, std=1, shape=[1, 14, 3])
      >>> b = ivy.random_normal(mean=0, std=1, shape=[1, 28, 3])
      >>> c = ivy.random_normal(mean=0, std=1, shape=[6, 3, 3])
      >>> d = ivy.random_normal(mean=0, std=1, shape=[6, 3, 3])
      >>> x = ivy.Container(a=a, b=b)
      >>> filters = ivy.Container(c=c, d=d)
      >>> y = ivy.conv1d_transpose(x, filters, 2, 'SAME')
      >>> print(y.shape)
      {
          a: {
              c: ivy.Shape(1, 28, 3),
              d: ivy.Shape(1, 28, 3)
          },
          b: {
              c: ivy.Shape(1, 56, 3),
              d: ivy.Shape(1, 56, 3)
          },
          c: {
              c: ivy.Shape(6, 6, 3),
              d: ivy.Shape(6, 6, 3)
          },
          d: {
              c: ivy.Shape(6, 6, 3),
              d: ivy.Shape(6, 6, 3)
          }
      }
      """
      return current_backend(x).conv1d_transpose(
          x,
          filters,
          strides,
          padding,
          output_shape=output_shape,
          filter_format=filter_format,
          data_format=data_format,
          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 8 for calling a global function with example usage: conv1d_transpose() and returns: current_backend