def rename_Conv()

in mmdnn/conversion/paddle/paddle_parser.py [0:0]

• 52 lines of code
• 22 McCabe index (conditional complexity)

    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)