code: def _convert_convolution3d(
      inexpr, keras_layer, etab, data_layout, input_shape=None
  ):
      _check_data_format(keras_layer)
      is_deconv = type(keras_layer).__name__ == "Conv3DTranspose"
      weightList = keras_layer.get_weights()
      weight = weightList[0]
      if input_shape is None:
          input_shape = keras_layer.input_shape
  
      if data_layout == "NDHWC":
          kernel_layout = "DHWIO"
          if is_deconv:
              kernel_layout = "DHWOI"
      else:
          kernel_layout = "OIDHW"
          if is_deconv:
              kernel_layout = "IODHW"
          msg = (
              f"Kernel layout with {kernel_layout} is not supported for operator Convolution3D "
              f"in frontend Keras."
          )
          raise tvm.error.OpAttributeUnImplemented(msg)
  
      if is_deconv:
          kernel_d, kernel_h, kernel_w, n_filters, _ = weight.shape
          if kernel_layout == "IODHW":
              weight = weight.transpose([4, 3, 0, 1, 2])
      else:
          kernel_d, kernel_h, kernel_w, _, n_filters = weight.shape
  
      dilation_rate = keras_layer.dilation_rate
      if isinstance(dilation_rate, (list, tuple)):
          dilation = [
              dilation_rate[0],
              dilation_rate[1],
              dilation_rate[2],
          ]
      else:
          dilation = [dilation_rate, dilation_rate, dilation_rate]
  
      dilated_kernel_d = (kernel_d - 1) * dilation[0] + 1
      dilated_kernel_h = (kernel_h - 1) * dilation[1] + 1
      dilated_kernel_w = (kernel_w - 1) * dilation[2] + 1
      stride_d, stride_h, stride_w = keras_layer.strides
      params = {
          "weight": etab.new_const(weight),
          "kernel_size": [kernel_d, kernel_h, kernel_w],
          "strides": [stride_d, stride_h, stride_w],
          "dilation": dilation,
          "padding": [0, 0, 0],
          "data_layout": data_layout,
          "kernel_layout": kernel_layout,
      }
      params["channels"] = n_filters
      if is_deconv and keras_layer.output_padding:
          params["output_padding"] = keras_layer.output_padding
  
      if keras_layer.padding == "valid":
          pass
      # calculate the padding values
      elif keras_layer.padding == "same":
          in_d = input_shape[1]
          in_h = input_shape[2]
          in_w = input_shape[3]
          pad_d = _get_pad_pair(in_d, dilated_kernel_d, stride_d)
          pad_h = _get_pad_pair(in_h, dilated_kernel_h, stride_h)
          pad_w = _get_pad_pair(in_w, dilated_kernel_w, stride_w)
          params["padding"] = [
              pad_d[0],
              pad_h[0],
              pad_w[0],
              pad_d[1],
              pad_h[1],
              pad_w[1],
          ]
      else:
          msg = (
              f"Padding with {keras_layer.padding} is not supported for operator Convolution3D "
              f"in frontend Keras."
          )
          raise tvm.error.OpAttributeUnImplemented(msg)
      if is_deconv:
          out = _op.nn.conv3d_transpose(data=inexpr, **params)
      else:
          out = _op.nn.conv3d(data=inexpr, **params)
  
      channel_axis = -1 if data_layout == "NDHWC" else 1
      if keras_layer.use_bias:
          bias = etab.new_const(weightList[1])
          out = _op.nn.bias_add(out, bias, channel_axis)
  
      # defuse activation
      if sys.version_info.major < 3:
          act_type = keras_layer.activation.func_name
      else:
          act_type = keras_layer.activation.__name__
      if act_type != "linear":
          out = _convert_activation(out, act_type, etab, None)
  
      return out
  
imports: import dis
  import sys
  import numpy
  import tvm
  from tvm.ir import IRModule, TensorType, TupleType
  from ..None import analysis
  from ..None import expr
  from ..None import function
  from ..None import op
  from ...None import nd
  from .common import ExprTable, new_var
label_desc: Use image node_id 14 for calling a global function with example usage: _convert_convolution3d(inexpr, keras_layer, etab, data_layout, input_shape) and returns: out