code: def rename_Conv(self, source_node):
      IR_node = self.IR_graph.node.add()
  
      # input edge
      self.convert_inedge(source_node, IR_node)
  
      # layer and spec
      conv_spec = source_node.layer
  
      spec = conv_spec.inputs[0].conv_conf
  
      # width <=> x or height <=> y
      width = spec.filter_size
      height = (
          spec.filter_size_y
          if spec.HasField("filter_size_y")
          else spec.filter_size
      )
      inputchannel = spec.channels
      outputchannel = conv_spec.num_filters
      stride_x = spec.stride
      stride_y = (
          spec.stride_y if spec.HasField("stride_y") else stride_x
      )
      padding_x = spec.padding
      padding_y = (
          spec.padding_y if spec.HasField("padding_y") else padding_x
      )
      dilation_x = spec.dilation
      dilation_y = (
          spec.dilation_y if spec.HasField("dilation_y") else dilation_x
      )
      output_x = spec.output_x
      output_y = (
          spec.output_y if spec.HasField("output_y") else output_x
      )
      input_x = spec.img_size
      input_y = (
          spec.img_size_y if spec.HasField("img_size_y") else input_x
      )
  
      # output shape
      output_shapes = [-1, output_y, output_x, outputchannel]
      self.shape_dict[source_node.name] = output_shapes
      PaddleParser._set_output_shape(
          source_node, IR_node, output_shapes
      )
  
      kwargs = dict()
  
      if conv_spec.type == "exconv" or "cudnn_conv":
          # name, op
          PaddleParser._copy_and_reop(source_node, IR_node, "Conv")
      else:
          kwargs["isDeconvolution"] = True
          PaddleParser._copy_and_reop(
              source_node, IR_node, "ConvTranspose"
          )
  
      w_name = conv_spec.inputs[0].input_parameter_name
      w = self.parameters.get(w_name)
  
      self.set_weight(
          IR_node.name,
          "weights",
          w.reshape(
              [outputchannel, inputchannel, height, width]
          ).transpose([2, 3, 1, 0]),
      )
  
      #  it should be in the shape of height x width x inputchannel x outputchannel
  
      # use_bias: TODO
      kwargs["use_bias"] = False
      if conv_spec.HasField("bias_parameter_name"):
          bias_name = conv_spec.bias_parameter_name
          bias = self.parameters.get(bias_name).squeeze()
          self.set_weight(IR_node.name, "bias", bias)
          kwargs["use_bias"] = True
  
      kwargs["kernel_shape"] = [
          height,
          width,
          inputchannel,
          outputchannel,
      ]
  
      # pad_dim
      pad_dim = [0, 0, padding_x, padding_y, padding_x, padding_y, 0, 0]
  
      # fail report because of auto_pad
      # if dilation_x == 1 and dilation_y == 1:
      #     if output_x * stride_x == input_x and output_y * stride_y == input_y:
      #         auto_pad = "SAME"
      #         kwargs['auto_pad'] = auto_pad
      #     elif output_x * stride_x == input_x - width + 1 and output_y * stride_y == input_y - height + 1:
      #         auto_pad = "VALID"
      #         kwargs['auto_pad'] = auto_pad
  
      if input_x == output_x and input_y == output_y:
          auto_pad = "SAME"
      else:
          auto_pad = "SAME"
  
      pad_dim = convert_tf_pad_to_onnx(pad_dim)
      kwargs["pads"] = pad_dim
  
      kwargs["group"] = spec.groups
  
      kwargs["dilation"] = [1, dilation_x, dilation_y, 1]
  
      kwargs["strides"] = [1, stride_x, stride_y, 1]
  
      assign_IRnode_values(IR_node, kwargs)
  
      # defuse the activation layer
  
      if (
          conv_spec.HasField("active_type")
          and conv_spec.active_type != ""
      ):
          IR_node_act = self._defuse_activation(source_node)
          PaddleParser._set_output_shape(
              source_node, IR_node_act, output_shapes
          )
  
imports: from __future__ import absolute_import
  import os
  import gzip
  from six import string_types
  import paddle.v2
  import paddle.trainer_config_helpers.layers
  import numpy
  from mmdnn.conversion.paddle.paddle_graph import PaddleGraph
  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 12 for calling the PaddleParser obj's underlying member method code with example usage: obj.rename_Conv(source_node) without return types