code: def rename_Pooling(self, source_node):
      IR_node = self.IR_graph.node.add()
  
      # name, op
      PaddleParser._copy_and_reop(source_node, IR_node, "Pool")
  
      # input edge
      self.convert_inedge(source_node, IR_node)
  
      # layer and spec
      pool_spec = source_node.layer
      spec = pool_spec.inputs[0].pool_conf
  
      # assert False
      kwargs = dict()
  
      if spec.pool_type == "max-projection":
          kwargs["pooling_type"] = "MAX"
      elif spec.pool_type == "avg-projection":
          kwargs["pooling_type"] = "AVG"
      else:
          kwargs["pooling_type"] = "MAX"
  
      width = spec.size_x
      height = spec.size_y if spec.HasField("size_y") else width
      channel = spec.channels
      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
      )
      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, channel]
      self.shape_dict[source_node.name] = output_shapes
      PaddleParser._set_output_shape(
          source_node, IR_node, output_shapes
      )
  
      kwargs["global_pooling"] = False
  
      kwargs["strides"] = [1, stride_x, stride_y, 1]
      kwargs["kernel_shape"] = [1, width, height, 1]
  
      # pad_dim
      pad_dim = [0, 0, padding_x, padding_y, padding_x, padding_y, 0, 0]
  
      # padding mode
      # If padding == "SAME": output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])
      # If padding == "VALID": output_spatial_shape[i] = ceil((input_spatial_shape[i] - (spatial_filter_shape[i]-1) * dilation_rate[i]) / strides[i]).
  
      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
  
      pad_dim = convert_tf_pad_to_onnx(pad_dim)
      kwargs["pads"] = pad_dim
  
      assign_IRnode_values(IR_node, kwargs)
  
      if (
          pool_spec.HasField("active_type")
          and pool_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 14 for calling the PaddleParser obj's underlying member method code with example usage: obj.rename_Pooling(source_node) without return types