code: def rename_Dense(self, source_node):
      IR_node = self.IR_graph.node.add()
  
      # name, op
      PaddleParser._copy_and_reop(
          source_node, IR_node, "FullyConnected"
      )
  
      # input edge
      self.convert_inedge(source_node, IR_node)
  
      # layer and spec
      fc_spec = source_node.layer
  
      # units
      IR_node.attr["units"].i = fc_spec.size
  
      # output shape
      output_shapes = [-1, fc_spec.size]
      self.shape_dict[source_node.name] = output_shapes
      PaddleParser._set_output_shape(
          source_node, IR_node, output_shapes
      )
  
      # use_bias
      IR_node.attr["use_bias"].b = fc_spec.HasField(
          "bias_parameter_name"
      )
  
      w_name = fc_spec.inputs[0].input_parameter_name
      bias_name = fc_spec.bias_parameter_name
  
      w = self.parameters.get(w_name)
  
      bias = self.parameters.get(bias_name).flatten()
  
      # Kit weight tranpose
      # weight: N x M -> C x H x W x M -> H x W x C x M -> N x M
      if self.weight_loaded:
          parent = self.src_graph.get_parent(source_node.name, [0])
          if len(self.shape_dict[parent.name]) == 4:
              #
              original_shape = w.shape
              channel_first_list = self.shape_dict[parent.name][1:]
              dim = len(channel_first_list) + 1
              weight = w.reshape(
                  channel_first_list + [original_shape[1]]
              )
              assert dim > 2
              weight = weight.transpose(
                  list(range(1, dim - 1)) + [0, dim - 1]
              )
              w = weight.reshape(original_shape)
      if fc_spec.HasField("drop_rate"):
          w = w * fc_spec.drop_rate
          if IR_node.attr["use_bias"].b:
              bias = bias * fc_spec.drop_rate
  
      # weights
      self.set_weight(IR_node.name, "weights", w)
      if IR_node.attr["use_bias"].b:
          self.set_weight(IR_node.name, "bias", bias)
  
      if fc_spec.HasField("active_type") and fc_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 15 for calling the PaddleParser obj's underlying member method code with example usage: obj.rename_Dense(source_node) without return types