paddle2onnx support opset:9,10,11

x2paddle/convert.py

@@ -178,7 +178,7 @@ def onnx2paddle(model_path, save_dir, params_merge=False):
         return
     print("Now translating model from onnx to paddle.")
 
-    from x2paddle.op_mapper.onnx_op_mapper import ONNXOpMapper
+    from x2paddle.op_mapper.onnx2paddle.onnx_op_mapper import ONNXOpMapper
     from x2paddle.decoder.onnx_decoder import ONNXDecoder
     from x2paddle.optimizer.onnx_optimizer import ONNXOptimizer
     model = ONNXDecoder(model_path)
@@ -192,12 +192,12 @@ def onnx2paddle(model_path, save_dir, params_merge=False):
     print("Paddle model and code generated.")
 
 
-def paddle2onnx(model_path, save_dir, opset):
+def paddle2onnx(model_path, save_dir, opset_number):
     from x2paddle.decoder.paddle_decoder import PaddleDecoder
-    from x2paddle.op_mapper.paddle_op_mapper import PaddleOpMapper
+    from x2paddle.op_mapper.paddle2onnx.paddle_op_mapper import PaddleOpMapper
     model = PaddleDecoder(model_path, '__model__', '__params__')
     mapper = PaddleOpMapper()
-    mapper.convert(model.program, save_dir, opset)
+    mapper.convert(model.program, save_dir, opset_number=opset_number)
 
 
 def main():

x2paddle/op_mapper/onnx_op_mapper.py

-# Copyright (c) 2019  PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from x2paddle.op_mapper.onnx_opsets.opset9 import OpSet9
-from x2paddle.core.op_mapper import OpMapper
-from x2paddle.op_mapper.onnx_opsets.custom_layer import *
-from x2paddle.decoder.onnx_decoder import ONNXGraph, ONNXGraphNode, ONNXGraphDataNode
-
-
-class ONNXOpMapper(OpMapper):
-    def __init__(self, decoder):
-        super(ONNXOpMapper, self).__init__()
-        self.support_op_sets = [9, ]
-        self.default_op_set = 9
-        self.graph = decoder.graph
-        self.opset = self.create_opset(decoder)
-        if not self.op_checker():
-            raise Exception("Model are not supported yet.")
-        #mapping op
-        print("Total nodes: {}".format(
-            sum([
-                isinstance(node, ONNXGraphNode)
-                for name, node in self.graph.node_map.items()
-            ])))
-
-        print("Nodes converting ...")
-        for node_name in self.graph.topo_sort:
-            node = self.graph.get_node(node_name)
-            op = node.layer_type
-            if hasattr(self.opset, op):
-                func = getattr(self.opset, op)
-                func(node)
-            elif op in self.opset.default_op_mapping:
-                self.opset.directly_map(node)
-            elif op in custom_layers:
-                self.opset.deal_custom_layer(node)
-            elif op in self.opset.elementwise_ops:
-                self.opset.elementwise_map(node)
-        print("Nodes converted.")
-        self.weights = self.opset.weights
-        self.omit_nodes = self.opset.omit_nodes
-        self.used_custom_layers = self.opset.used_custom_layers
-
-    def op_checker(self):
-        unsupported_ops = set()
-        for node_name in self.graph.topo_sort:
-            node = self.graph.get_node(node_name)
-            op = node.layer_type
-            if not hasattr(self.opset, op) and \
-                op not in self.opset.default_op_mapping and \
-                op not in custom_layers and \
-                op not in self.opset.elementwise_ops:
-                unsupported_ops.add(op)
-        if len(unsupported_ops) == 0:
-            return True
-        else:
-            print("There are {} ops not supported yet, list as below".format(
-                len(unsupported_ops)))
-            for op in unsupported_ops:
-                print(op)
-            return False
-
-    def create_opset(self, decoder):
-        run_op_set = self.default_op_set
-        opset = ''
-        if decoder.op_set in self.support_op_sets:
-            opset = 'OpSet' + str(decoder.op_set)
-        elif decoder.op_set < self.default_op_set:
-            opset = 'OpSet' + str(self.default_op_set)
-        else:
-            for op_set in self.support_op_sets:
-                if decoder.op_set > op_set:
-                    run_op_set = op_set
-                else:
-                    break
-            opset = 'OpSet' + str(run_op_set)
-        print(
-            'Now, onnx2paddle support convert onnx model opset_verison {},'
-            'opset_verison of your onnx model is {}, automatically treated as op_set: {}.'
-            .format(self.support_op_sets, decoder.op_set, run_op_set))
-        return eval(opset)(decoder)

x2paddle/op_mapper/onnx_opsets/custom_layer/InstanceNormalization.py

-#   Copyright (c) 2019  PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .register import register
-
-
-def InstanceNormalization_shape(input_shape):
-    return input_shape
-
-
-def InstanceNormalization_layer(inputs, name=None):
-    # TODO(lvmengsi@baidu.com): Check the accuracy when using fluid.layers.layer_norm.
-    epsilon = 1e-5
-    input_ = inputs[0]
-    mean = fluid.layers.reduce_mean(input_, dim=[2, 3], keep_dim=True)
-    var = fluid.layers.reduce_mean(
-        fluid.layers.square(input_ - mean), dim=[2, 3], keep_dim=True)
-    if name is not None:
-        scale_name = name + "_scale"
-        offset_name = name + "_offset"
-
-    scale_param = inputs[1]
-    offset_param = inputs[2]
-    scale = fluid.layers.create_parameter(
-        name=scale_param.name, shape=input_.shape[1:2], dtype="float32")
-    offset = fluid.layers.create_parameter(
-        name=offset_param.name, shape=input_.shape[1:2], dtype="float32")
-
-    tmp = fluid.layers.elementwise_mul(x=(input_ - mean), y=scale, axis=1)
-    tmp = tmp / fluid.layers.sqrt(var + epsilon)
-    tmp = fluid.layers.elementwise_add(tmp, offset, axis=1)
-    return tmp
-
-
-def InstanceNormalization_weights(name, data=None):
-    weights_name = [name + '_scale']
-    return weights_name
-
-
-register(
-    kind='InstanceNormalization',
-    shape=InstanceNormalization_shape,
-    layer=InstanceNormalization_layer,
-    child_func=None,
-    weights=InstanceNormalization_weights)

x2paddle/op_mapper/onnx_opsets/custom_layer/__init__.py

-#   Copyright (c) 2019  PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .register import get_registered_layers
-#custom layer import begins
-
-from . import InstanceNormalization
-#custom layer import ends
-
-custom_layers = get_registered_layers()
-
-
-def set_args(f, params):
-    """ set args for function 'f' using the parameters in node.layer.param
-    Args:
-        f (function): a python function object
-        params (object): a object contains attributes needed by f's arguments
-    Returns:
-        arg_names (list): a list of argument names
-        kwargs (dict): a dict contains needed arguments
-    """
-    argc = f.__code__.co_argcount
-    arg_list = f.__code__.co_varnames[0:argc]
-    kwargs = {}
-    for arg_name in arg_list:
-        if hasattr(params, arg_name) and params is not None:
-            kwargs[arg_name] = getattr(params, arg_name)
-    return arg_list, kwargs
-
-
-def has_layer(layer_type):
-    """ test whether this layer exists in custom layer
-    """
-    return layer_type in custom_layers
-
-
-def get_params(layer, layer_type):
-    import re
-    if layer_type.lower() == "deconvolution" or layer_type.lower(
-    ) == "convolutiondepthwise":
-        param_name = '_'.join(('convolution', 'param'))
-    elif layer_type.lower() == "normalize":
-        param_name = '_'.join(('norm', 'param'))
-    elif len(layer_type) - len(re.sub("[A-Z]", "", layer_type)) >= 2:
-        s = ''
-        tmp_name = ''
-        for i, ch in enumerate(layer_type):
-            if i == 0:
-                s += ch.lower()
-                continue
-            elif ch.isupper() and layer_type[i - 1].islower():
-                tmp_name += (s + '_')
-                s = ''
-            s += ch.lower()
-        tmp_name += s
-        param_name = '_'.join((tmp_name, 'param'))
-    else:
-        param_name = '_'.join((layer_type.lower(), 'param'))
-    return getattr(layer, param_name, None)
-
-
-def compute_output_shape(node):
-    """ compute the output shape of custom layer
-    """
-    layer_type = node.layer_type
-    assert layer_type in custom_layers, "layer[%s] not exist in custom layers" % (
-        layer_type)
-    shape_func = custom_layers[layer_type]['shape']
-    layer = node.layer
-    params = get_params(layer, layer_type)
-    arg_names, kwargs = set_args(shape_func, params)
-    input_shape = node.input_shape
-    return shape_func(input_shape, **kwargs)
-
-
-def make_custom_layer(node):
-    """ get the code which implement the custom layer function
-    """
-    layer_type = node.layer_type
-    assert layer_type in custom_layers, "layer[%s] not exist in custom layers" % (
-        layer_type)
-    layer_func = custom_layers[layer_type]['layer']
-    import inspect
-    return inspect.getsource(layer_func), layer_func
-
-
-def make_custom_child_func(node):
-    """ get the code which implement the custom layer function
-    """
-    layer_type = node.layer_type
-    child_func = custom_layers[layer_type]['child_func']
-    if child_func is None:
-        return None, child_func
-    import inspect
-    return inspect.getsource(child_func), child_func
-
-
-def deal_weights(node, data=None):
-    """ deal the weights of the custom layer
-    """
-    layer_type = node.layer_type
-    weights_func = custom_layers[layer_type]['weights']
-    name = node.layer_name
-    return weights_func(name, data)

x2paddle/op_mapper/onnx_opsets/custom_layer/register.py

-#   Copyright (c) 2019  PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-""" this module provides 'register' for registering customized layers
-"""
-
-g_custom_layers = {}
-
-
-def register(kind, shape, layer, child_func, weights):
-    """ register a custom layer or a list of custom layers
-
-    Args:
-        @kind (str or list): type name of the layer
-        @shape (function): a function to generate the shape of layer's output
-        @layer (function): a function to generate the paddle code of layer
-        @weights (function): a function to deal with weights data
-
-    Returns:
-        None
-    """
-    assert type(shape).__name__ == 'function', 'shape should be a function'
-    assert type(layer).__name__ == 'function', 'layer should be a function'
-
-    if type(kind) is str:
-        kind = [kind]
-    else:
-        assert type(
-            kind) is list, 'invalid param "kind" for register, not a list or str'
-
-    for k in kind:
-        assert type(
-            k) is str, 'invalid param "kind" for register, not a list of str'
-        assert k not in g_custom_layers, 'this type[%s] has already been registered' % (
-            k)
-        g_custom_layers[k] = {
-            'shape': shape,
-            'layer': layer,
-            'child_func': child_func,
-            'weights': weights
-        }
-
-
-def get_registered_layers():
-    return g_custom_layers

x2paddle/op_mapper/paddle_custom_layer/im2sequence.py

-import onnx
-import numpy as np
-from onnx import onnx_pb, helper
-
-im2seq_counter = 0
-
-
-def im2sequence(op, block):
-    global im2sequence_counter
-    n, c, h, w = block.var(op.input('X')[0]).shape
-    assert h > 0 and w > 0, "Only supported fixed input shape for im2sequence operator."
-    stride_h, stride_w = op.attr('strides')
-    paddings = op.attr('paddings')
-    assert op.attr(
-        'out_stride'
-    ) != 1, "Only out_stride==1 is supported for im2sequence operator."
-    h = h + paddings[0] + paddings[1]
-    w = w + paddings[1] + paddings[2]
-    kernel_h, kernel_w = op.attr('kernels')
-    out_h = 1 + (h - kernel_h + stride_h - 1) // stride_h
-    out_w = 1 + (w - kernel_w + stride_w - 1) // stride_w
-    h_steps = list()
-    for i in range(out_h):
-        h_steps.append([i * stride_h, i * stride_h + kernel_h])
-    w_steps = list()
-    for i in range(out_w):
-        w_steps.append([i * stride_w, i * stride_w + kernel_w])
-
-    nodes = list()
-    slice_blocks = list()
-    for i in range(out_h):
-        for j in range(out_w):
-            starts_name = "im2sequence.starts.{}.{}.{}".format(im2seq_counter,
-                                                               i, j)
-            starts_tensor = helper.make_tensor(
-                name=starts_name,
-                data_type=onnx_pb.TensorProto.INT64,
-                dims=[4],
-                vals=[0, 0, h_steps[i][0], w_steps[j][0]])
-            ends_name = "im2sequence.ends.{}.{}.{}".format(im2seq_counter, i, j)
-            ends_tensor = helper.make_tensor(
-                name=ends_name,
-                data_type=onnx_pb.TensorProto.INT64,
-                dims=[4],
-                vals=[999999, 999999, h_steps[i][1], w_steps[j][1]])
-            starts_node = helper.make_node(
-                'Constant',
-                inputs=[],
-                outputs=[starts_name],
-                value=starts_tensor)
-            ends_node = helper.make_node(
-                'Constant', inputs=[], outputs=[ends_name], value=ends_tensor)
-            nodes.extend([starts_node, ends_node])
-
-            slice_block_name = "im2sequence.slice.{}.{}.{}".format(
-                im2seq_counter, i, j)
-            slice_block_node = helper.make_node(
-                'Slice',
-                inputs=[op.input('X')[0], starts_name, ends_name],
-                outputs=[slice_block_name])
-            flatten_block_name = "im2sequence.flatten.{}.{}.{}".format(
-                im2seq_counter, i, j)
-            flatten_block_node = helper.make_node(
-                "Flatten",
-                inputs=[slice_block_name],
-                outputs=[flatten_block_name],
-                axis=0)
-            nodes.extend([slice_block_node, flatten_block_node])
-            slice_blocks.append(flatten_block_name)
-    concat_block_name = "im2sequence.concat_block.{}".format(im2seq_counter)
-    #    concat_block_node = helper.make_node("Concat", inputs=slice_blocks, outputs=[concat_block_name], axis=0)
-    concat_block_node = helper.make_node(
-        "Concat", inputs=slice_blocks, outputs=op.output('Out'), axis=0)
-    nodes.append(concat_block_node)
-    print("\n\n==========Importance Notice===========")
-    print(
-        "Since im2sequence operator is used in your paddlepaddle model, the translated onnx model only support input data with batch_size=1."
-    )
-    print("======================================\n")
-    return nodes

x2paddle/op_mapper/paddle_custom_layer/multiclass_nms.py

-#   Copyright (c) 2019  PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import math
-import sys
-import os
-import numpy as np
-import paddle.fluid.core as core
-import paddle.fluid as fluid
-import onnx
-import warnings
-from onnx import helper, onnx_pb
-
-
-def multiclass_nms(op, block):
-    """
-    Convert the paddle multiclass_nms to onnx op.
-    This op is get the select boxes from origin boxes.
-    """
-    inputs = dict()
-    outputs = dict()
-    attrs = dict()
-    for name in op.input_names:
-        inputs[name] = op.input(name)
-    for name in op.output_names:
-        outputs[name] = op.output(name)
-    for name in op.attr_names:
-        attrs[name] = op.attr(name)
-
-    result_name = outputs['Out'][0]
-    background = attrs['background_label']
-    normalized = attrs['normalized']
-    if normalized == False:
-        warnings.warn(
-            'The parameter normalized of multiclass_nms OP of Paddle is False, which has diff with ONNX. \
-                         Please set normalized=True in multiclass_nms of Paddle')
-
-    #convert the paddle attribute to onnx tensor
-    name_score_threshold = [outputs['Out'][0] + "@score_threshold"]
-    name_iou_threshold = [outputs['Out'][0] + "@iou_threshold"]
-    name_keep_top_k = [outputs['Out'][0] + '@keep_top_k']
-    name_keep_top_k_2D = [outputs['Out'][0] + '@keep_top_k_1D']
-
-    node_score_threshold = onnx.helper.make_node(
-        'Constant',
-        inputs=[],
-        outputs=name_score_threshold,
-        value=onnx.helper.make_tensor(
-            name=name_score_threshold[0] + "@const",
-            data_type=onnx.TensorProto.FLOAT,
-            dims=(),
-            vals=[float(attrs['score_threshold'])]))
-
-    node_iou_threshold = onnx.helper.make_node(
-        'Constant',
-        inputs=[],
-        outputs=name_iou_threshold,
-        value=onnx.helper.make_tensor(
-            name=name_iou_threshold[0] + "@const",
-            data_type=onnx.TensorProto.FLOAT,
-            dims=(),
-            vals=[float(attrs['nms_threshold'])]))
-
-    node_keep_top_k = onnx.helper.make_node(
-        'Constant',
-        inputs=[],
-        outputs=name_keep_top_k,
-        value=onnx.helper.make_tensor(
-            name=name_keep_top_k[0] + "@const",
-            data_type=onnx.TensorProto.INT64,
-            dims=(),
-            vals=[np.int64(attrs['keep_top_k'])]))
-
-    node_keep_top_k_2D = onnx.helper.make_node(
-        'Constant',
-        inputs=[],
-        outputs=name_keep_top_k_2D,
-        value=onnx.helper.make_tensor(
-            name=name_keep_top_k_2D[0] + "@const",
-            data_type=onnx.TensorProto.INT64,
-            dims=[1, 1],
-            vals=[np.int64(attrs['keep_top_k'])]))
-
-    # the paddle data format is x1,y1,x2,y2
-    kwargs = {'center_point_box': 0}
-
-    name_select_nms = [outputs['Out'][0] + "@select_index"]
-    node_select_nms= onnx.helper.make_node(
-        'NonMaxSuppression',
-        inputs=inputs['BBoxes'] + inputs['Scores'] + name_keep_top_k +\
-            name_iou_threshold + name_score_threshold,
-        outputs=name_select_nms)
-    # step 1 nodes select the nms class
-    node_list = [
-        node_score_threshold, node_iou_threshold, node_keep_top_k,
-        node_keep_top_k_2D, node_select_nms
-    ]
-
-    # create some const value to use
-    name_const_value = [result_name+"@const_0",
-        result_name+"@const_1",\
-        result_name+"@const_2",\
-        result_name+"@const_-1"]
-    value_const_value = [0, 1, 2, -1]
-    for name, value in zip(name_const_value, value_const_value):
-        node = onnx.helper.make_node(
-            'Constant',
-            inputs=[],
-            outputs=[name],
-            value=onnx.helper.make_tensor(
-                name=name + "@const",
-                data_type=onnx.TensorProto.INT64,
-                dims=[1],
-                vals=[value]))
-        node_list.append(node)
-
-    # Ine this code block, we will deocde the raw score data, reshape N * C * M to 1 * N*C*M
-    # and the same time, decode the select indices to 1 * D, gather the select_indices
-    outputs_gather_1 = [result_name + "@gather_1"]
-    node_gather_1 = onnx.helper.make_node(
-        'Gather',
-        inputs=name_select_nms + [result_name + "@const_1"],
-        outputs=outputs_gather_1,
-        axis=1)
-    node_list.append(node_gather_1)
-
-    outputs_squeeze_gather_1 = [result_name + "@sequeeze_gather_1"]
-    node_squeeze_gather_1 = onnx.helper.make_node(
-        'Squeeze',
-        inputs=outputs_gather_1,
-        outputs=outputs_squeeze_gather_1,
-        axes=[1])
-    node_list.append(node_squeeze_gather_1)
-
-    outputs_gather_2 = [result_name + "@gather_2"]
-    node_gather_2 = onnx.helper.make_node(
-        'Gather',
-        inputs=name_select_nms + [result_name + "@const_2"],
-        outputs=outputs_gather_2,
-        axis=1)
-    node_list.append(node_gather_2)
-
-    #slice the class is not 0
-    if background == 0:
-        outputs_nonzero = [result_name + "@nonzero"]
-        node_nonzero = onnx.helper.make_node(
-            'NonZero', inputs=outputs_squeeze_gather_1, outputs=outputs_nonzero)
-        node_list.append(node_nonzero)
-    else:
-        name_thresh = [result_name + "@thresh"]
-        node_thresh = onnx.helper.make_node(
-            'Constant',
-            inputs=[],
-            outputs=name_thresh,
-            value=onnx.helper.make_tensor(
-                name=name_thresh[0] + "@const",
-                data_type=onnx.TensorProto.INT32,
-                dims=[1],
-                vals=[-1]))
-        node_list.append(node_thresh)
-
-        outputs_cast = [result_name + "@cast"]
-        node_cast = onnx.helper.make_node(
-            'Cast', inputs=outputs_squeeze_gather_1, outputs=outputs_cast, to=6)
-        node_list.append(node_cast)
-
-        outputs_greater = [result_name + "@greater"]
-        node_greater = onnx.helper.make_node(
-            'Greater',
-            inputs=outputs_cast + name_thresh,
-            outputs=outputs_greater)
-        node_list.append(node_greater)
-
-        outputs_nonzero = [result_name + "@nonzero"]
-        node_nonzero = onnx.helper.make_node(
-            'NonZero', inputs=outputs_greater, outputs=outputs_nonzero)
-        node_list.append(node_nonzero)
-
-    outputs_gather_1_nonzero = [result_name + "@gather_1_nonzero"]
-    node_gather_1_nonzero = onnx.helper.make_node(
-        'Gather',
-        inputs=outputs_gather_1 + outputs_nonzero,
-        outputs=outputs_gather_1_nonzero,
-        axis=0)
-    node_list.append(node_gather_1_nonzero)
-
-    outputs_gather_2_nonzero = [result_name + "@gather_2_nonzero"]
-    node_gather_2_nonzero = onnx.helper.make_node(
-        'Gather',
-        inputs=outputs_gather_2 + outputs_nonzero,
-        outputs=outputs_gather_2_nonzero,
-        axis=0)
-    node_list.append(node_gather_2_nonzero)
-
-    # reshape scores N * C * M to (N*C*M) * 1
-    outputs_reshape_scores_rank1 = [result_name + "@reshape_scores_rank1"]
-    node_reshape_scores_rank1 = onnx.helper.make_node(
-        "Reshape",
-        inputs=inputs['Scores'] + [result_name + "@const_-1"],
-        outputs=outputs_reshape_scores_rank1)
-    node_list.append(node_reshape_scores_rank1)
-
-    # get the shape of scores
-    outputs_shape_scores = [result_name + "@shape_scores"]
-    node_shape_scores = onnx.helper.make_node(
-        'Shape', inputs=inputs['Scores'], outputs=outputs_shape_scores)
-    node_list.append(node_shape_scores)
-
-    # gather the index: 2 shape of scores
-    outputs_gather_scores_dim1 = [result_name + "@gather_scores_dim1"]
-    node_gather_scores_dim1 = onnx.helper.make_node(
-        'Gather',
-        inputs=outputs_shape_scores + [result_name + "@const_2"],
-        outputs=outputs_gather_scores_dim1,
-        axis=0)
-    node_list.append(node_gather_scores_dim1)
-
-    # mul class * M
-    outputs_mul_classnum_boxnum = [result_name + "@mul_classnum_boxnum"]
-    node_mul_classnum_boxnum = onnx.helper.make_node(
-        'Mul',
-        inputs=outputs_gather_1_nonzero + outputs_gather_scores_dim1,
-        outputs=outputs_mul_classnum_boxnum)
-    node_list.append(node_mul_classnum_boxnum)
-
-    # add class * M * index
-    outputs_add_class_M_index = [result_name + "@add_class_M_index"]
-    node_add_class_M_index = onnx.helper.make_node(
-        'Add',
-        inputs=outputs_mul_classnum_boxnum + outputs_gather_2_nonzero,
-        outputs=outputs_add_class_M_index)
-    node_list.append(node_add_class_M_index)
-
-    # Squeeze the indices to 1 dim
-    outputs_squeeze_select_index = [result_name + "@squeeze_select_index"]
-    node_squeeze_select_index = onnx.helper.make_node(
-        'Squeeze',
-        inputs=outputs_add_class_M_index,
-        outputs=outputs_squeeze_select_index,
-        axes=[0, 2])
-    node_list.append(node_squeeze_select_index)
-
-    # gather the data from flatten scores
-    outputs_gather_select_scores = [result_name + "@gather_select_scores"]
-    node_gather_select_scores = onnx.helper.make_node('Gather',
-        inputs=outputs_reshape_scores_rank1 + \
-            outputs_squeeze_select_index,
-        outputs=outputs_gather_select_scores,
-        axis=0)
-    node_list.append(node_gather_select_scores)
-
-    # get nums to input TopK
-    outputs_shape_select_num = [result_name + "@shape_select_num"]
-    node_shape_select_num = onnx.helper.make_node(
-        'Shape',
-        inputs=outputs_gather_select_scores,
-        outputs=outputs_shape_select_num)
-    node_list.append(node_shape_select_num)
-
-    outputs_gather_select_num = [result_name + "@gather_select_num"]
-    node_gather_select_num = onnx.helper.make_node(
-        'Gather',
-        inputs=outputs_shape_select_num + [result_name + "@const_0"],
-        outputs=outputs_gather_select_num,
-        axis=0)
-    node_list.append(node_gather_select_num)
-
-    outputs_unsqueeze_select_num = [result_name + "@unsqueeze_select_num"]
-    node_unsqueeze_select_num = onnx.helper.make_node(
-        'Unsqueeze',
-        inputs=outputs_gather_select_num,
-        outputs=outputs_unsqueeze_select_num,
-        axes=[0])
-    node_list.append(node_unsqueeze_select_num)
-
-    outputs_concat_topK_select_num = [result_name + "@conat_topK_select_num"]
-    node_conat_topK_select_num = onnx.helper.make_node(
-        'Concat',
-        inputs=outputs_unsqueeze_select_num + name_keep_top_k_2D,
-        outputs=outputs_concat_topK_select_num,
-        axis=0)
-    node_list.append(node_conat_topK_select_num)
-
-    outputs_cast_concat_topK_select_num = [
-        result_name + "@concat_topK_select_num"
-    ]
-    node_outputs_cast_concat_topK_select_num = onnx.helper.make_node(
-        'Cast',
-        inputs=outputs_concat_topK_select_num,
-        outputs=outputs_cast_concat_topK_select_num,
-        to=6)
-    node_list.append(node_outputs_cast_concat_topK_select_num)
-    # get min(topK, num_select)
-    outputs_compare_topk_num_select = [result_name + "@compare_topk_num_select"]
-    node_compare_topk_num_select = onnx.helper.make_node(
-        'ReduceMin',
-        inputs=outputs_cast_concat_topK_select_num,
-        outputs=outputs_compare_topk_num_select,
-        keepdims=0)
-    node_list.append(node_compare_topk_num_select)
-
-    # unsqueeze the indices to 1D tensor
-    outputs_unsqueeze_topk_select_indices = [
-        result_name + "@unsqueeze_topk_select_indices"
-    ]
-    node_unsqueeze_topk_select_indices = onnx.helper.make_node(
-        'Unsqueeze',
-        inputs=outputs_compare_topk_num_select,
-        outputs=outputs_unsqueeze_topk_select_indices,
-        axes=[0])
-    node_list.append(node_unsqueeze_topk_select_indices)
-
-    # cast the indices to INT64
-    outputs_cast_topk_indices = [result_name + "@cast_topk_indices"]
-    node_cast_topk_indices = onnx.helper.make_node(
-        'Cast',
-        inputs=outputs_unsqueeze_topk_select_indices,
-        outputs=outputs_cast_topk_indices,
-        to=7)
-    node_list.append(node_cast_topk_indices)
-
-    # select topk scores  indices
-    outputs_topk_select_topk_indices = [result_name + "@topk_select_topk_values",\
-        result_name + "@topk_select_topk_indices"]
-    node_topk_select_topk_indices = onnx.helper.make_node(
-        'TopK',
-        inputs=outputs_gather_select_scores + outputs_cast_topk_indices,
-        outputs=outputs_topk_select_topk_indices)
-    node_list.append(node_topk_select_topk_indices)
-
-    # gather topk label, scores, boxes
-    outputs_gather_topk_scores = [result_name + "@gather_topk_scores"]
-    node_gather_topk_scores = onnx.helper.make_node(
-        'Gather',
-        inputs=outputs_gather_select_scores +
-        [outputs_topk_select_topk_indices[1]],
-        outputs=outputs_gather_topk_scores,
-        axis=0)
-    node_list.append(node_gather_topk_scores)
-
-    outputs_gather_topk_class = [result_name + "@gather_topk_class"]
-    node_gather_topk_class = onnx.helper.make_node(
-        'Gather',
-        inputs=outputs_gather_1_nonzero +
-        [outputs_topk_select_topk_indices[1]],
-        outputs=outputs_gather_topk_class,
-        axis=1)
-    node_list.append(node_gather_topk_class)
-
-    # gather the boxes need to gather the boxes id, then get boxes
-    outputs_gather_topk_boxes_id = [result_name + "@gather_topk_boxes_id"]
-    node_gather_topk_boxes_id = onnx.helper.make_node(
-        'Gather',
-        inputs=outputs_gather_2_nonzero +
-        [outputs_topk_select_topk_indices[1]],
-        outputs=outputs_gather_topk_boxes_id,
-        axis=1)
-    node_list.append(node_gather_topk_boxes_id)
-
-    # squeeze the gather_topk_boxes_id to 1 dim
-    outputs_squeeze_topk_boxes_id = [result_name + "@squeeze_topk_boxes_id"]
-    node_squeeze_topk_boxes_id = onnx.helper.make_node(
-        'Squeeze',
-        inputs=outputs_gather_topk_boxes_id,
-        outputs=outputs_squeeze_topk_boxes_id,
-        axes=[0, 2])
-    node_list.append(node_squeeze_topk_boxes_id)
-
-    outputs_gather_select_boxes = [result_name + "@gather_select_boxes"]
-    node_gather_select_boxes = onnx.helper.make_node(
-        'Gather',
-        inputs=inputs['BBoxes'] + outputs_squeeze_topk_boxes_id,
-        outputs=outputs_gather_select_boxes,
-        axis=1)
-    node_list.append(node_gather_select_boxes)
-
-    # concat the final result
-    # before concat need to cast the class to float
-    outputs_cast_topk_class = [result_name + "@cast_topk_class"]
-    node_cast_topk_class = onnx.helper.make_node(
-        'Cast',
-        inputs=outputs_gather_topk_class,
-        outputs=outputs_cast_topk_class,
-        to=1)
-    node_list.append(node_cast_topk_class)
-
-    outputs_unsqueeze_topk_scores = [result_name + "@unsqueeze_topk_scores"]
-    node_unsqueeze_topk_scores = onnx.helper.make_node(
-        'Unsqueeze',
-        inputs=outputs_gather_topk_scores,
-        outputs=outputs_unsqueeze_topk_scores,
-        axes=[0, 2])
-    node_list.append(node_unsqueeze_topk_scores)
-
-    inputs_concat_final_results = outputs_cast_topk_class + outputs_unsqueeze_topk_scores +\
-        outputs_gather_select_boxes
-    outputs_concat_final_results = outputs['Out']
-    node_concat_final_results = onnx.helper.make_node(
-        'Concat',
-        inputs=inputs_concat_final_results,
-        outputs=outputs_concat_final_results,
-        axis=2)
-    node_list.append(node_concat_final_results)
-
-    return node_list