code: def _tranpose_padding(
      x_shape,
      filter_shape,
      strides,
      padding,
      dims,
      dilations,
      output_shape,
      data_format,
  ):
      if output_shape is not None and len(output_shape) > dims:
          if data_format[-1] == "C" or data_format == "channel_last":
              output_shape = output_shape[1:-1]
          elif data_format[1] == "C" or data_format == "channel_first":
              output_shape = output_shape[2:]
      strides = (
          [strides] * dims if isinstance(strides, int) else strides
      )
      dilations = (
          [dilations] * dims
          if isinstance(dilations, int)
          else dilations
      )
      not_valid_pad = [False] * dims
      if isinstance(padding, str):
          if output_shape is None:
              output_shape = [
                  _deconv_length(
                      x_shape[i],
                      strides[i],
                      filter_shape[i],
                      padding,
                      dilations[i],
                  )
                  for i in range(dims)
              ]
          if padding == "VALID":
              symmetric_padding = [0] * dims
          else:
              pad_specific = [
                  _handle_padding(
                      output_shape[i],
                      strides[i],
                      filter_shape[i]
                      + (filter_shape[i] - 1) * (dilations[i] - 1),
                      padding,
                  )
                  for i in range(dims)
              ]
              for i in range(dims):
                  if pad_specific[i] % 2 != 0:
                      pad_specific[i] -= 1
                      not_valid_pad[i] = True
              symmetric_padding = [
                  pad_specific[i] // 2 for i in range(dims)
              ]
          out_shape = [
              (x_shape[i] - 1) * strides[i]
              - 2 * symmetric_padding[i]
              + dilations[i] * (filter_shape[i] - 1)
              + 1
              for i in range(dims)
          ]
          output_padding = [
              max(output_shape[i] - out_shape[i], 0)
              for i in range(dims)
          ]
      else:
          if isinstance(padding, int):
              padding = [[padding, padding]] * dims
          symmetric_padding = [max(pad) for pad in padding]
          output_padding = [max(pad) - min(pad) for pad in padding]
      return not_valid_pad, symmetric_padding, output_padding
  
imports: from typing import Optional, Tuple, Union, Sequence
  import torch
  import ivy
  from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes
  from .None import backend_version
  from ivy.functional.ivy.layers import _get_embed_dim, _handle_padding, _deconv_length
label_desc: Use image node_id 6 for calling a global function with example usage: _tranpose_padding(x_shape, filter_shape, strides, padding, dims, dilations, output_shape, data_format) and returns: not_valid_pad,  symmetric_padding,  output_padding