code: def rename_Deconvolution(self, source_node):
      IR_node = self.IR_graph.node.add()
  
      # name, op
      self._copy_and_reop(source_node, IR_node, "ConvTranspose")
  
      # input edge
      self.convert_inedge(source_node, IR_node)
  
      dim = 0
      layout = "None"
  
      # padding
      if "pad" in source_node.attr:
          pad = MXNetParser.str2intList(source_node.get_attr("pad"))
          IR_node.attr["pads"].list.i.extend(([0] + pad + [0]) * 2)
      else:
          IR_node.attr["pads"].list.i.extend([0, 0] * (dim + 2))
  
      # output shape
      self.set_output_shape(source_node, IR_node)
  
      # kernel_shape
      kernel = MXNetParser.str2intList(source_node.get_attr("kernel"))
      dim = len(kernel)
      IR_node.attr["kernel_shape"].list.i.extend(kernel)
  
      layout = source_node.get_attr("layout")
      if layout == None or layout == "None":
          if dim == 1:
              layout = "NCW"
          elif dim == 2:
              layout = "NCHW"
          elif dim == 3:
              layout = "NCDHW"
  
      if not self.data_format == layout:
          # print("Warning: Layer [{}] has changed model data format from [{}] to [{}]".format(source_node.name, self.data_format, layout))
          self.data_format = layout
  
      in_channel = (
          self.IR_layer_map[IR_node.input[0]]
          .attr["_output_shapes"]
          .list.shape[0]
          .dim[-1]
          .size
      )
  
      out_channel = int(source_node.get_attr("num_filter"))
  
      IR_node.attr["kernel_shape"].list.i.extend(
          [out_channel, in_channel]
      )
  
      # use_bias (no_bias default = False)
      IR_node.attr["use_bias"].b = not MXNetParser.str2bool(
          source_node.get_attr("no_bias", "False")
      )
  
      # strides
      strides = source_node.get_attr("strides")
      IR_node.attr["strides"].list.i.append(1)
      if not strides == None:
          IR_node.attr["strides"].list.i.extend(
              MXNetParser.str2intList(strides)
          )
      else:
          IR_node.attr["strides"].list.i.extend([1] * dim)
      IR_node.attr["strides"].list.i.append(1)
  
      # dilations
      dilate = source_node.get_attr("dilate")
      IR_node.attr["dilations"].list.i.append(1)
      if not dilate == None:
          IR_node.attr["dilations"].list.i.extend(
              MXNetParser.str2intList(dilate)
          )
      else:
          IR_node.attr["dilations"].list.i.extend([1] * dim)
      IR_node.attr["dilations"].list.i.append(1)
  
      # data_format
      IR_node.attr["data_format"].s = layout
  
      # groups
      IR_node.attr["group"].i = int(
          source_node.get_attr("num_group", "1")
      )
  
      # weights
      if self.weight_loaded:
          weight = self.weight_data.get(
              source_node.name + "_weight"
          ).asnumpy()
          if not layout in MXNetParser.channels_last:
              weight = MXNetParser.transpose(weight, dim)
          self.set_weight(source_node.name, "weights", weight)
  
          if IR_node.attr["use_bias"].b:
              self.set_weight(
                  source_node.name,
                  "bias",
                  self.weight_data.get(
                      source_node.name + "_bias"
                  ).asnumpy(),
              )
  
imports: import os
  import sys
  import math
  import mxnet
  import numpy
  from mmdnn.conversion.mxnet.mxnet_graph import MXNetGraph
  import mmdnn.conversion.common.IR.graph_pb2
  from mmdnn.conversion.common.IR.graph_pb2 import NodeDef, GraphDef, DataType
  from mmdnn.conversion.common.DataStructure.parser import Parser
  from mmdnn.conversion.common.utils import *
label_desc: Use image node_id 26 for calling the MXNetParser obj's underlying member method code with example usage: obj.rename_Deconvolution(source_node) without return types