Merge pull request #3 from PaddlePaddle/develop

00

FAQ.md

@@ -11,3 +11,6 @@ x2paddle -f tensorflow -m tf.pb -s pd-model --without_data_format_optimization -
 ```
 
 > 1. 目前Tensorflow的CV模型大部分均为`NHWC`的输入格式，而Paddle的默认输入格式为`NCHW`，因此X2Paddle在转换过程中，会对如`axis`， `shape`等参数进行转换，适应Paddle的NCHW格式。但在这种情况下，可能会由于TensorFlow模型太复杂，导致出错。  指定`--without_data_format_optimization`后，会停止对`axis`，`shape`等参数的优化（这可能会带来一定数量的transpose操作）
+
+**Q3. ONNX模型转换过程中，提示『Unknown shape for input tensor[tensor name: "input"] -> shape: ['batch', 'sequence']， Please define shape of input here』**  
+A：该提示信息表示从ONNX的模型中获取到输入tensor(tensor名为"input:)的shape是语义象征性的['batch', 'sequence']，而不是dim为int类型的shape，从而可能会因为部分node的shape无法推理，导致转换失败。所以用户可以尝试手动在提示后输入详细的shape信息，如:-1,3,224,224  其中-1表示Batch

README.md

@@ -10,12 +10,12 @@ X2Paddle在多个主流的CV模型上，测试过TensorFlow/Caffe/ONNX模型的
 ## 环境依赖
 
 python == 2.7 | python >= 3.5  
-paddlepaddle >= 1.6.0  
+paddlepaddle >= 1.8.0  
 
 **按需安装以下依赖**  
 tensorflow ： tensorflow == 1.14.0  
 caffe ： 无  
-onnx ： onnx == 1.6.0  onnxruntime == 1.0.0
+onnx ： onnx == 1.6.0
 
 ## 安装
 ### 安装方式一（推荐）
@@ -61,6 +61,8 @@ x2paddle --framework=paddle2onnx --model=paddle_infer_model_dir --save_dir=onnx_
 |--without_data_format_optimization | **[可选]** For TensorFlow, 当指定该参数时，关闭NHWC->NCHW的优化，见[文档Q2](FAQ.md) |
 |--define_input_shape | **[可选]** For TensorFlow, 当指定该参数时，强制用户输入每个Placeholder的shape，见[文档Q2](FAQ.md) |
 |--params_merge | **[可选]** 当指定该参数时，转换完成后，inference_model中的所有模型参数将合并保存为一个文件__params__ |
+|--onnx_opset | **[可选]** 当framework为paddle2onnx时，该参数可设置转换为ONNX的OpSet版本，目前支持9、10、11，默认为10 |
+
 
 
 ## 使用转换后的模型

op_list.md

 # X2Paddle支持OP列表
-> 目前X2Paddle支持40+的TensorFlow OP，30+的Caffe Layer，覆盖了大部分CV分类模型常用的操作。我们在如下列表中给出了目前X2Paddle支持的全部OP。
+> 目前X2Paddle支持50+的TensorFlow OP，30+的Caffe Layer，覆盖了大部分CV分类模型常用的操作。我们在如下列表中给出了目前X2Paddle支持的全部OP。
 
 **注：** 目前，部分OP暂未支持，如您在转换过程中出现OP不支持的情况，可自行添加或反馈给我们。欢迎通过[ISSUE反馈](https://github.com/PaddlePaddle/X2Paddle/issues/new)的方式告知我们(模型名，代码实现或模型获取方式)，我们会及时跟进：）
 
@@ -20,7 +20,7 @@
 | 41 | Cast        | 42 | Split     | 43 | Squeeze   | 44 | ResizeNearestNeighbor |
 | 45 | Softmax     | 46 | Range     | 47 | ConcatV2  | 48 | MirrorPad             |
 | 49 | Identity    | 50 | GreaterEqual  | 51 | StopGradient | 52 | Minimum |
-| 53 | RadnomUniform | | | | | | |
+| 53 | RadnomUniform | 54 | Fill | 55 | Floor | 56 | DepthToSpace |
 
 ## Caffe
 

x2paddle/__init__.py

 __version__ = "0.7.4"
+
+from .core.program import PaddleProgram
+
+program = PaddleProgram()
+
+name_counter = dict()
+
+
+def gen_name(op_name, var_name):
+    name = "{}.{}".format(op_name, var_name)
+    if name not in name_counter:
+        name_counter[name] = 0
+    else:
+        name_counter[name] += 1
+    name = name + "." + str(name_counter[name])
+    return name

x2paddle/convert.py

@@ -75,6 +75,12 @@ def arg_parser():
         action="store_true",
         default=False,
         help="define input shape for tf model")
+    parser.add_argument(
+        "--onnx_opset",
+        "-oo",
+        type=int,
+        default=10,
+        help="when paddle2onnx set onnx opset version to export")
     parser.add_argument(
         "--params_merge",
         "-pm",
@@ -172,24 +178,26 @@ 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
-    import onnxruntime
     model = ONNXDecoder(model_path)
-    mapper = ONNXOpMapper(model, save_dir)
+    mapper = ONNXOpMapper(model)
+    print("Model optimizing ...")
     optimizer = ONNXOptimizer(mapper)
+    print("Model optimized.")
 
-    optimizer.delete_redundance_code()
+    print("Paddle model and code generating ...")
     mapper.save_inference_model(save_dir, params_merge)
+    print("Paddle model and code generated.")
 
 
-def paddle2onnx(model_path, save_dir):
+def paddle2onnx(model_path, save_dir, opset_version=10):
     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)
+    mapper.convert(model.program, save_dir, opset_number=opset_version)
 
 
 def main():
@@ -211,18 +219,6 @@ def main():
     assert args.framework is not None, "--framework is not defined(support tensorflow/caffe/onnx)"
     assert args.save_dir is not None, "--save_dir is not defined"
 
-    if args.framework == "onnx":
-        try:
-            import onnxruntime as rt
-            version = rt.__version__
-            if version != '1.0.0':
-                print("[ERROR] onnxruntime==1.0.0 is required")
-                return
-        except:
-            print(
-                "[ERROR] onnxruntime is not installed, use \"pip install onnxruntime==1.0.0\"."
-            )
-
     try:
         import paddle
         v0, v1, v2 = paddle.__version__.split('.')
@@ -261,13 +257,14 @@ def main():
     elif args.framework == "onnx":
         assert args.model is not None, "--model should be defined while translating onnx model"
         params_merge = False
+
         if args.params_merge:
             params_merge = True
         onnx2paddle(args.model, args.save_dir, params_merge)
 
     elif args.framework == "paddle2onnx":
         assert args.model is not None, "--model should be defined while translating paddle model to onnx"
-        paddle2onnx(args.model, args.save_dir)
+        paddle2onnx(args.model, args.save_dir, args.onnx_opset)
 
     else:
         raise Exception(

x2paddle/core/fluid_code.py

@@ -25,6 +25,7 @@ class Layer(object):
         self.inputs = dict()
         self.output = None
         self.is_custom_layer = False
+        self.use_fluid = False
 
     def get_code(self):
         layer_code = ""
@@ -38,6 +39,8 @@ class Layer(object):
             layer_code = layer_code + self.op + "("
         elif self.op == "=":
             layer_code = layer_code
+        elif self.use_fluid:
+            layer_code = layer_code + "fluid." + self.op + "("
         else:
             layer_code = layer_code + "fluid.layers." + self.op + "("
 
@@ -108,9 +111,11 @@ class FluidCode(object):
                   inputs,
                   output,
                   param_attr=None,
+                  use_fluid=False,
                   is_custom_layer=False):
         layer = Layer()
         layer.op = op
+        layer.use_fluid = use_fluid
         layer.is_custom_layer = is_custom_layer
         if inputs is not None:
             layer.inputs = inputs

x2paddle/core/op_mapper.py

@@ -29,11 +29,14 @@ def export_paddle_param(param, param_name, dir):
         "bool": [framework_pb2.VarType.BOOL, None]
     }
     shape = param.shape
+    if str(param.dtype) in ['uint8', 'uint_8', 'bool']:
+        param = param.astype('int64')
     if len(shape) == 0:
         assert param.size == 1, "Unexpected situation happend!"
         shape = [1]
-    assert str(param.dtype) in dtype_map, "Unknown dtype of params."
-
+    assert str(
+        param.dtype) in dtype_map, "Unknown dtype {} of params: {}.".format(
+            str(param.dtype), param_name)
     fp = open(os.path.join(dir, param_name), 'wb')
     numpy.array([0], dtype='int32').tofile(fp)
     numpy.array([0], dtype='int64').tofile(fp)
@@ -52,6 +55,24 @@ def export_paddle_param(param, param_name, dir):
 def run_net(param_dir="./"):
     import os
     inputs, outputs = x2paddle_net()
+
+    ops = fluid.default_main_program().global_block().ops
+    used_vars = list()
+    for op in ops:
+        used_vars += op.input_arg_names
+
+    tmp = list()
+    for input in inputs:
+        if isinstance(input, list):
+            for ipt in input:
+                if ipt.name not in used_vars:
+                    continue
+                tmp.append(ipt)
+        else:
+            if input.name not in used_vars:
+                continue
+            tmp.append(input)
+    inputs = tmp
     for i, out in enumerate(outputs):
         if isinstance(out, list):
             for out_part in out:
@@ -119,12 +140,30 @@ class OpMapper(object):
         import model
         try:
             inputs, outputs = model.x2paddle_net()
+
+            ops = fluid.default_main_program().global_block().ops
+            used_vars = list()
+            for op in ops:
+                used_vars += op.input_arg_names
+
             for i, out in enumerate(outputs):
                 if isinstance(out, list):
                     for out_part in out:
                         outputs.append(out_part)
                     del outputs[i]
-            input_names = [input.name for input in inputs]
+
+            input_names = list()
+            for input in inputs:
+                if isinstance(input, list):
+                    for ipt in input:
+                        if ipt.name not in used_vars:
+                            continue
+                        input_names.append(ipt.name)
+                else:
+                    if input.name not in used_vars:
+                        continue
+                    input_names.append(input.name)
+
             exe = fluid.Executor(fluid.CPUPlace())
             exe.run(fluid.default_startup_program())
 

x2paddle/core/program.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 __future__ import print_function
+from __future__ import division
+import collections
+import os
+
+
+class PaddleLayer(object):
+    def __init__(self, kernel, inputs, outputs, **kwargs):
+        assert isinstance(
+            inputs,
+            dict), "parameter 'inputs' for PaddleLayer should be type of dict"
+        assert isinstance(
+            outputs,
+            list), "parameter, 'outputs' for PaddleLayer should be type of list"
+        self.kernel = kernel
+        self.inputs = inputs
+        self.outputs = outputs
+        self.attrs = kwargs
+
+
+class PaddleProgram(object):
+    def __init__(self):
+        self.layers = list()
+        self.edges_out = dict()
+        self.edges_in = dict()
+        self.inputs = list()
+        self.outputs = list()
+        self.parameters = dict()
+
+    def add_layer(self, kernel, inputs, outputs, **kwargs):
+        layer = PaddleLayer(kernel, inputs, outputs, **kwargs)
+        self.layers.append(layer)
+
+    def build(self):
+        outputs = dict()
+        for i in range(len(self.layers)):
+            layer = self.layers[i]
+            for output in layer.outputs:
+                outputs[output] = i
+
+            for k, v in layer.inputs.items():
+                assert v in outputs, "Couldn't find {} in previous layers, the layers should be make by topological sort".format(
+                    v)
+                in_layer_index = outputs[v]
+
+                if in_layer_index not in self.edges_out:
+                    self.edges_out[in_layer_index] = list()
+                self.edges_out[in_layer_index].append(i)
+
+                if i not in self.edges_in:
+                    self.edges_in[i] = list()
+                self.edges_in[i].append(in_layer_index)
+
+    def get_layer_outputs(self, i):
+        return self.edges_out[i]
+
+    def get_layer_inputs(self, i):
+        return self.edges_in[i]
+
+    def gen_code(self, code_dir):
+        def write_code(f, code_list, indent=0):
+            indent_blank = "    " * indent
+            for code_line in code_list:
+                if code_line.strip() == "":
+                    f.write('\n')
+                else:
+                    f.write(indent_blank + code_line + '\n')
+
+        f = open(os.path.join(code_dir, 'model.py'), 'w')
+
+        write_code(
+            f, [
+                "from paddle.fluid.initializer import Constant",
+                "from paddle.fluid.param_attr import ParamAttr",
+                "import paddle.fluid as fluid"
+                "", "def x2paddle_net():"
+            ],
+            indent=0)
+
+        for i, layer in enumerate(self.layers):
+            if self.edges_in.get(i, 0) == 0 and self.edges_out.get(i, 0) == 0:
+                continue
+
+            line = ""
+
+            if len(layer.outputs) == 1:
+                line = layer.outputs[0]
+            else:
+                for output in layer.outputs:
+                    line += "{}, ".format(output)
+                line = line.strip(", ")
+
+            line += " = {}(".format(layer.kernel)
+            for k, v in layer.inputs.items():
+                line += "{}={}, ".format(k, v)
+            for k, v in layer.attrs.items():
+                line += "{}={}, ".format(k, v)
+            line = line.strip(", ")
+            line += ")"
+            write_code(f, [line], indent=1)
+        f.close()
+
+    def gen_parameters(self, code_dir):
+        pass
+
+    def gen_inference_model(self, model_dir):
+        pass

x2paddle/decoder/onnx_decoder.py

@@ -14,6 +14,7 @@
 
 from x2paddle.core.graph import GraphNode, Graph
 from x2paddle.core.fluid_code import FluidCode
+from x2paddle.decoder.onnx_shape_inference import SymbolicShapeInference
 from onnx.checker import ValidationError
 from onnx.checker import check_model
 from onnx.utils import polish_model
@@ -53,7 +54,7 @@ class ONNXGraphNode(GraphNode):
         convert ONNX node attributes to dict
         """
         return {
-            attr.name: self.get_attribute_value2(attr)
+            attr.name: self.get_attribute_value(attr)
             for attr in self.layer.attribute
         }
 
@@ -64,7 +65,7 @@ class ONNXGraphNode(GraphNode):
             return None
         return self.attr_map['value']
 
-    def get_attribute_value2(self, attr):
+    def get_attribute_value(self, attr):
         """
         get_attribute_value enhanced
         """
@@ -130,43 +131,90 @@ class ONNXGraphDataNode(GraphNode):
 
 class ONNXGraph(Graph):
     def __init__(self, onnx_model):
-        super(ONNXGraph, self).__init__(onnx_model.graph)
-        self.onnx_model = onnx_model
+        super(ONNXGraph, self).__init__(onnx_model)
+        self.fixed_input_shape = {}
         self.initializer = {}
         self.place_holder_nodes = list()
+        self.value_infos = {}
+        self.graph = onnx_model.graph
         self.get_place_holder_nodes()
-        self.value_infos = self.inferred_model_value_info(self.model)
-        self.results_of_inference = dict()
+        print("shape inferencing ...")
+        self.graph = SymbolicShapeInference.infer_shapes(
+            onnx_model, fixed_input_shape=self.fixed_input_shape)
+        print("shape inferenced.")
+        self.build()
+        self.collect_value_infos()
+        self.allocate_shapes()
 
     def get_inner_nodes(self):
         """
         generate inner node of ONNX model
         """
         inner_nodes = []
-        if not isinstance(self.model, onnx.GraphProto):
+        if not isinstance(self.graph, onnx.GraphProto):
             logger.error('graph is not a GraphProto instance')
             return
-        for initializer in self.model.initializer:
+        for initializer in self.graph.initializer:
             name = initializer.name
             inner_nodes.append(name)
         return inner_nodes
 
+    def get_symbolic_shape(self, dims):
+        shape = []
+        for dim in dims:
+            if dim.HasField('dim_param'):
+                shape.append(dim.dim_param)
+            else:
+                shape.append(dim.dim_value)
+        return shape
+
+    def check_input_shape(self, vi):
+        if vi.type.HasField('tensor_type'):
+            for dim in vi.type.tensor_type.shape.dim:
+                if dim.HasField(
+                        'dim_param') and vi.name not in self.fixed_input_shape:
+                    shape = self.get_symbolic_shape(
+                        vi.type.tensor_type.shape.dim)
+                    print(
+                        "Unknown shape for input tensor[tensor name: '{}'] -> shape: {}, Please define shape of input here,\nNote:you can use visualization tools like Netron to check input shape."
+                        .format(vi.name, shape))
+                    right_shape_been_input = False
+                    while not right_shape_been_input:
+                        try:
+                            shape = raw_input(
+                                "Shape of Input(e.g. -1,3,224,224), enter 'N' to skip: "
+                            )
+                        except:
+                            shape = input(
+                                "Shape of Input(e.g. -1,3,224,224), enter 'N' to skip: "
+                            )
+                        if shape.count("-1") > 1:
+                            print("Only 1 dimension can be -1, type again:)")
+                        else:
+                            right_shape_been_input = True
+                    if shape == 'N':
+                        break
+                    shape = [int(dim) for dim in shape.strip().split(',')]
+                    assert shape.count(-1) <= 1, "Only one dimension can be -1"
+                    self.fixed_input_shape[vi.name] = shape
+                    break
+
     def get_place_holder_nodes(self):
         """
         generate place_holder node of ONNX model
         """
         inner_nodes = self.get_inner_nodes()
-        input_nodes = [value.name for value in self.model.input]
-        for ipt_data in input_nodes:
-            if ipt_data not in inner_nodes:
-                self.place_holder_nodes.append(ipt_data)
+        for ipt_vi in self.graph.input:
+            if ipt_vi.name not in inner_nodes:
+                self.check_input_shape(ipt_vi)
+                self.place_holder_nodes.append(ipt_vi.name)
 
     def get_output_nodes(self):
         """
         generate output_nodes node of ONNX model
         """
         inner_nodes = self.get_inner_nodes()
-        output_nodes = [value.name for value in self.model.output]
+        output_nodes = [value.name for value in self.graph.output]
         for opt_data in output_nodes:
             if opt_data not in inner_nodes:
                 self.output_nodes.append(opt_data)
@@ -183,11 +231,11 @@ class ONNXGraph(Graph):
         """
         build topo_sort of ONNX model
         """
-        for layer in self.model.node:
+        for layer in self.graph.node:
             node = ONNXGraphNode(layer)
             self.node_map[layer.name] = node
 
-        for layer in self.model.input:
+        for layer in self.graph.input:
             if layer.name not in self.node_map:
                 is_place_holder = self.is_place_holder_nodes(layer.name)
                 self.node_map[layer.name] = ONNXGraphDataNode(
@@ -196,7 +244,7 @@ class ONNXGraph(Graph):
                     is_global_input=is_place_holder)
 
         #set data node's weight
-        for initializer in self.model.initializer:
+        for initializer in self.graph.initializer:
             name = initializer.name
             weight = to_array(initializer)
             if name in self.node_map:
@@ -228,7 +276,7 @@ class ONNXGraph(Graph):
                 continue
             if in_node not in self.node_map:
                 flag = 0
-                for nd in self.model.node:
+                for nd in self.graph.node:
                     for idx, opt in enumerate(nd.output):
                         if opt == in_node:
                             self.connect(nd.name, layer_name)
@@ -256,81 +304,68 @@ class ONNXGraph(Graph):
                 ipt_node.index = node.which_child[ipt_node.layer_name]
             return ipt_node
 
-    def graph_weights(self, graph):
+    def graph_weights(self):
         """
         generator for weights
         """
 
-        if not isinstance(graph, onnx.GraphProto):
+        if not isinstance(self.graph, onnx.GraphProto):
             logger.error('graph is not a GraphProto instance')
             return
 
-        for initializer in graph.initializer:
+        for initializer in self.graph.initializer:
             name = initializer.name
             weight = to_array(initializer)
             yield name, weight
 
-    def inferred_model_value_info(self, graph):
+    def collect_value_infos(self):
         """
         collect value/type info for an ONNX model
         """
-        assert isinstance(graph,
+        assert isinstance(self.graph,
                           onnx.GraphProto), 'model is not a ModelProto instance'
 
-        value_info = Dict()
-        for item in graph.value_info:
-            value_info[item.name] = {
+        for item in self.graph.value_info:
+            self.value_infos[item.name] = {
                 'dtype':
                 TENSOR_TYPE_TO_NP_TYPE[item.type.tensor_type.elem_type],
                 'shape':
                 [dim.dim_value for dim in item.type.tensor_type.shape.dim],
                 'external': False
             }
-        for item in graph.input:
-            assert item.name not in value_info
-            value_info[item.name] = {
-                'dtype':
-                TENSOR_TYPE_TO_NP_TYPE[item.type.tensor_type.elem_type],
-                'shape':
-                [dim.dim_value for dim in item.type.tensor_type.shape.dim],
-                'external': True
-            }
-        for item in graph.output:
-            assert item.name not in value_info
-            value_info[item.name] = {
-                'dtype':
-                TENSOR_TYPE_TO_NP_TYPE[item.type.tensor_type.elem_type],
-                'shape':
-                [dim.dim_value for dim in item.type.tensor_type.shape.dim],
-                'external': True
-            }
-        return value_info
+
+    def allocate_shapes(self):
+        """
+        run shape inference
+        """
+        for layer in self.graph.node:
+            node = self.node_map[layer.name]
+            for opt in layer.output:
+                if opt in self.value_infos:
+                    value_info = self.value_infos[opt]
+                    #if len(value_info['shape']) == 0 or value_info[
+                    #        'dtype'] is None or 0 in value_info['shape']:
+                    #    #TODO add node shape inference
+                    node.dtype = value_info['dtype']
+                    node.out_shapes.append(value_info['shape'])
+                else:
+                    node.out_shapes.append([])
 
 
 class ONNXDecoder(object):
     def __init__(self, onnx_model):
-        model = onnx.load(onnx_model)
+        onnx_model = onnx.load(onnx_model)
         print('model ir_version: {}, op version: {}'.format(
-            model.ir_version, model.opset_import[0].version))
-        if model.opset_import[0].version < 9:
-            _logger.warning(
-                'Now, onnx2paddle support convert onnx model opset_verison == 9,'
-                'opset_verison of your onnx model is %d < 9,'
-                'some operator maybe unsuccessful in convertion.',
-                model.opset_import[0].version)
-
-        check_model(model)
-        self.check_model_running_state(onnx_model)
-
-        model = onnx.shape_inference.infer_shapes(model)
-        model = self.optimize_model_skip_op_for_inference(model)
-        model = self.optimize_model_strip_initializer(model)
-        self.standardize_variable_name(model.graph)
-
-        self.model = model
-        graph = model.graph
-        self.onnx_graph = ONNXGraph(model)
-        self.onnx_graph.build()
+            onnx_model.ir_version, onnx_model.opset_import[0].version))
+        self.op_set = onnx_model.opset_import[0].version
+
+        check_model(onnx_model)
+
+        onnx_model = self.optimize_model_skip_op(onnx_model)
+        onnx_model = self.optimize_model_strip_initializer(onnx_model)
+        onnx_model = self.optimize_node_name(onnx_model)
+        self.graph = ONNXGraph(onnx_model)
+        #self.onnx_model = onnx_model
 
     def build_value_refs(self, nodes):
         """
@@ -373,14 +408,13 @@ class ONNXDecoder(object):
                     processed += 1
         return processed
 
-    def optimize_model_skip_op_for_inference(self, model, op_list=None):
+    def optimize_model_skip_op(self, model, op_list=None):
         """
         skip ops can be bypassed for inference
         """
+        nodes = model.graph.node
         if op_list is None:
             op_list = ['Dropout']
-
-        nodes = model.graph.node
         input_refs, output_refs = self.build_value_refs(nodes)
         ret = type(model)()
         ret.CopyFrom(model)
@@ -473,38 +507,11 @@ class ONNXDecoder(object):
             name = name.replace(s, '_')
         return 'x2paddle_' + name
 
-    def check_model_running_state(self, model_path):
-        import onnxruntime as rt
-        model = onnx.load(model_path)
-        model = onnx.shape_inference.infer_shapes(model)
-        if len(model.graph.value_info) < len(model.graph.node) - 1:
-            _logger.warning(
-                'During conversion of your  model, some operators will be assignd node.out_shape==None, '
-                'refer to https://github.com/onnx/onnx/blob/master/docs/ShapeInference.md'
-            )
-        try:
-            datatype_map = {
-                'tensor(int64)': 'int',
-                'tensor(float)': 'float32',
-                'tensor(int32)': 'int32'
-            }
-            input_dict = {}
-            sess = rt.InferenceSession(model_path)
-            for ipt in sess.get_inputs():
-                datatype = datatype_map[ipt.type]
-                input_dict[ipt.name] = np.random.random(ipt.shape).astype(
-                    datatype)
-
-            res = sess.run(None, input_feed=input_dict)
-        except:
-            raise Exception(
-                "onnxruntime inference onnx model failed, Please confirm the correctness of onnx model by onnxruntime, if onnx model is correct, please submit issue in github."
-            )
-
-    def standardize_variable_name(self, graph):
+    def optimize_node_name(self, model):
         """
         standardize variable name for paddle's code
         """
+        graph = model.graph
         for initializer in graph.initializer:
             initializer.name = self.make_variable_name(initializer.name)
         for ipt in graph.input:
@@ -523,3 +530,4 @@ class ONNXDecoder(object):
                     node.input[i] = self.make_variable_name(node.input[i])
             for i in range(len(node.output)):
                 node.output[i] = self.make_variable_name(node.output[i])
+        return model

x2paddle/decoder/tf_decoder.py

@@ -48,7 +48,7 @@ class TFGraphNode(GraphNode):
 
     @property
     def out_shapes(self):
-        if self.layer_type == "OneShotIterator":
+        if self.layer_type == "OneShotIterator" or self.layer_type == "IteratorV2":
             values = self.layer.attr["output_shapes"].list.shape
         else:
             values = self.layer.attr["_output_shapes"].list.shape
@@ -68,7 +68,8 @@ class TFGraphNode(GraphNode):
         if dtype == 0:
             dtype = self.layer.attr['output_types'].list.type[0]
         if dtype not in self.dtype_map:
-            raise Exception("Dtype[{}] not in dtype_map".format(dtype))
+            raise Exception("Dtype[{}] of node({}) not in dtype_map".format(
+                dtype, self.layer.name))
         return self.dtype_map[dtype]
 
     @property
@@ -114,16 +115,20 @@ class TFGraph(Graph):
     def __init__(self, model, data_format="NHWC"):
         super(TFGraph, self).__init__(model)
         self.identity_map = dict()
-        self.multi_out_ops = ['Split', 'SplitV']
+        self.multi_out_ops = ['Split', 'SplitV', 'IteratorV2']
         self.tf_data_format = data_format
 
     def build(self):
         for layer in self.model.node:
+            if layer.op == 'Assert':
+                continue
             self.node_map[layer.name.replace('/', '_').replace(
                 '-', '_')] = TFGraphNode(
                     layer, data_format=self.tf_data_format)
 
         for layer_name, node in self.node_map.items():
+            if node.layer_type == 'Const':
+                continue
             for in_node in node.layer.input:
                 in_node = in_node.replace('/', '_').replace('-', '_').replace(
                     '^', '')
@@ -139,6 +144,14 @@ class TFGraph(Graph):
 
         super(TFGraph, self).build()
 
+        for layer in self.model.node:
+            if layer.op == 'Assert':
+                for ipt in layer.input:
+                    ipt_name = ipt.replace('-', '_').replace('/', '_')
+                    if ipt_name in self.output_nodes:
+                        idx = self.output_nodes.index(ipt_name)
+                        del self.output_nodes[idx]
+
         # tensorflow graph optimize
         self._remove_isolated_node()
         self._optimize_dialiation_conv()
@@ -272,7 +285,6 @@ class TFGraph(Graph):
 
     def data_format_propagation(self, node):
         current_node = self.node_map[node.layer_name]
-        current_node = node.tf_data_format
         outputs = current_node.outputs
         if len(outputs) == 0:
             return
@@ -322,7 +334,7 @@ class TFDecoder(object):
         graph_def = cp.deepcopy(graph_def)
         input_map = dict()
         for layer in graph_def.node:
-            if layer.op != "Placeholder" and layer.op != "OneShotIterator":
+            if layer.op != "Placeholder" and layer.op != "OneShotIterator" and layer.op != "IteratorV2":
                 continue
             graph_node = TFGraphNode(layer)
             dtype = graph_node.layer.attr['dtype'].type
@@ -403,7 +415,7 @@ class TFDecoder(object):
             else:
                 value = graph_node.layer.attr["shape"].shape
                 shape = [dim.size for dim in value.dim]
-                self.input_info[graph_node.layer_name] = (shape, dtype)
+                self.input_info[layer.name] = (shape, dtype)
 
         return input_map
 

x2paddle/op_mapper/onnx2paddle/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.onnx2paddle.opset9 import OpSet9, custom_layers
+from x2paddle.core.op_mapper import OpMapper
+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/onnx2paddle/opset9/__init__.py

+from .opset import OpSet9
+from .custom_layer import custom_layers

x2paddle/op_mapper/onnx_custom_layer/__init__.py → x2paddle/op_mapper/onnx2paddle/opset9/custom_layer/__init__.py

@@ -13,10 +13,6 @@
 # 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()
 

x2paddle/op_mapper/onnx_directly_map.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 collections import OrderedDict as _dict
-import numpy as _np
-
-default_op_mapping_field_values = _dict()
-default_op_mapping_field_values['FLUID_OP'] = ''
-default_op_mapping_field_values['FLUID_INPUT_ARGS'] = None
-default_op_mapping_field_values['FLUID_OUTPUT_ARGS'] = None
-default_op_mapping_field_values['ATTR_MAPPING'] = dict()
-default_op_mapping_field_values['DEFAULTS'] = dict()
-default_op_mapping_field_values['INPUT_PERM'] = None
-default_op_mapping_field_values['OUTPUT_PERM'] = None
-default_op_mapping_field_values['FILL_NAME_FIELD'] = True
-
-default_op_mapping = {
-    'Shape': ['shape', ['X'], ['Out']],
-    'Clip': [
-        'clip', ['X'], ['Out'], dict(), dict(
-            min=(_np.asarray(
-                [255, 255, 127, 255], dtype=_np.uint8).view(_np.float32)[0]),
-            max=(_np.asarray(
-                [255, 255, 127, 127], dtype=_np.uint8).view(_np.float32)[0]), )
-    ],
-    'Erf': ['erf', ['X'], ['Out']],
-    'Ceil': ['ceil', ['X'], ['Out']],
-    'ReduceMean': [
-        'reduce_mean', ['X'], ['Out'], dict(
-            axes='dim', keepdims='keep_dim'), dict(keep_dim=1)
-    ],
-    'ReduceSum': [
-        'reduce_sum', ['X'], ['Out'], dict(
-            axes='dim', keepdims='keep_dim'), dict(keep_dim=1)
-    ],
-    'ReduceMin': [
-        'reduce_min', ['X'], ['Out'], dict(
-            axes='dim', keepdims='keep_dim'), dict(keep_dim=1)
-    ],
-    'ReduceMax': [
-        'reduce_max', ['X'], ['Out'], dict(
-            axes='dim', keepdims='keep_dim'), dict(keep_dim=1)
-    ],
-    #active function
-    'Relu': ['relu', ['X'], ['Out']],
-    'LeakyRelu': ['leaky_relu', ['X'], ['Out'], dict(), dict(alpha=.01)],
-    'Elu': ['elu', ['X'], ['Out'], dict(), dict(alpha=1.)],
-    'ThresholdedRelu': [
-        'thresholded_relu', ['X'], ['Out'], dict(alpha='threshold'),
-        dict(alpha=1.)
-    ],
-    'Tanh': ['tanh', ['X'], ['Out']],
-    'Sigmoid': ['sigmoid', ['X'], ['Out']],
-    'HardSigmoid': [
-        'hard_sigmoid', ['X'], ['Out'], dict(
-            alpha='slope', beta='offset'), dict(
-                slope=.2, offset=.5)
-    ],
-    'Softsign': ['softsign', ['X'], ['Out']],
-    'Softplus': ['softplus', ['X'], ['Out']],
-    'Exp': ['exp', ['X'], ['Out']],
-    'Softmax': ['softmax', ['X'], ['Out'], dict(), dict(axis=1)],
-    'Sqrt': ['sqrt', ['X'], ['Out']],
-    'Floor': ['floor', ['X'], ['Out']],
-    'Abs': ['abs', ['X'], ['Out']],
-}
-
-default_ioa_constraint = {
-    'Gather': [(lambda i, o, a: a.get('axis', 0) == 0,
-                'only axis = 0 is supported')],
-}

x2paddle/op_mapper/paddle2onnx/opset10/opset.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 x2paddle
+import os
+import numpy as np
+import paddle.fluid.core as core
+import paddle.fluid as fluid
+import onnx
+from onnx import helper, onnx_pb
+from x2paddle.op_mapper.paddle2onnx.opset9.opset import OpSet9
+
+
+class OpSet10(OpSet9):
+    def __init__(self):
+        super(OpSet10, self).__init__()
+
+    def slice(self, op, block):
+        axes = op.attr('axes')
+        starts = op.attr('starts')
+        ends = op.attr('ends')
+        axes_name = self.get_name(op.type, 'axes')
+        starts_name = self.get_name(op.type, 'starts')
+        ends_name = self.get_name(op.type, 'ends')
+
+        axes_node = self.make_constant_node(axes_name,
+                                            onnx_pb.TensorProto.INT64, axes)
+        starts_node = self.make_constant_node(starts_name,
+                                              onnx_pb.TensorProto.INT64, starts)
+        ends_node = self.make_constant_node(ends_name,
+                                            onnx_pb.TensorProto.INT64, ends)
+        node = helper.make_node(
+            "Slice",
+            inputs=[op.input('Input')[0], starts_name, ends_name, axes_name],
+            outputs=op.output('Out'), )
+        return [starts_node, ends_node, axes_node, node]
+
+    def im2sequence(self, op, block):
+        from .paddle_custom_layer.im2sequence import im2sequence
+        return im2sequence(op, block)
+
+    def yolo_box(self, op, block):
+        from .paddle_custom_layer.yolo_box import yolo_box
+        return yolo_box(op, block)
+
+    def multiclass_nms(self, op, block):
+        from .paddle_custom_layer.multiclass_nms import multiclass_nms
+        return multiclass_nms(op, block)

x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/im2sequence.py

+# Copyright (c) 2020  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 onnx
+import numpy as np
+from onnx import onnx_pb, helper
+from x2paddle.op_mapper.paddle2onnx.opset9.paddle_custom_layer.im2sequence import im2sequence as im2sequence9
+
+
+def im2sequence(op, block):
+    return im2sequence9(op, block)

x2paddle/op_mapper/onnx_custom_layer/InstanceNormalization.py → x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/multiclass_nms.py

@@ -12,45 +12,21 @@
 # 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)
+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
+from x2paddle.op_mapper.paddle2onnx.opset9.paddle_custom_layer.multiclass_nms import multiclass_nms as multiclass_nms9
+
+
+def multiclass_nms(op, block):
+    """
+    Convert the paddle multiclass_nms to onnx op.
+    This op is get the select boxes from origin boxes.
+    """
+    return multiclass_nms9(op, block)

x2paddle/op_mapper/paddle2onnx/opset10/paddle_custom_layer/yolo_box.py

+# Copyright (c) 2020  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 onnx
+import numpy as np
+from onnx import onnx_pb, helper
+from x2paddle.op_mapper.paddle2onnx.opset9.paddle_custom_layer.yolo_box import yolo_box as yolo_box9
+
+
+def yolo_box(op, block):
+    return yolo_box9(op, block)

x2paddle/op_mapper/paddle2onnx/opset11/opset.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 x2paddle
+import os
+import numpy as np
+import paddle.fluid.core as core
+import paddle.fluid as fluid
+import onnx
+from onnx import helper, onnx_pb
+from x2paddle.op_mapper.paddle2onnx.opset10.opset import OpSet10
+
+
+class OpSet11(OpSet10):
+    def __init__(self):
+        super(OpSet11, self).__init__()
+
+    def relu6(self, op, block):
+        min_name = self.get_name(op.type, 'min')
+        max_name = self.get_name(op.type, 'max')
+        min_node = self.make_constant_node(min_name, onnx_pb.TensorProto.FLOAT,
+                                           0)
+        max_node = self.make_constant_node(max_name, onnx_pb.TensorProto.FLOAT,
+                                           op.attr('threshold'))
+        node = helper.make_node(
+            'Clip',
+            inputs=[op.input('X')[0], min_name, max_name],
+            outputs=op.output('Out'), )
+        return [min_node, max_node, node]
+
+    def pad2d(self, op, block):
+        x_shape = block.var(op.input('X')[0]).shape
+        paddings = op.attr('paddings')
+        onnx_pads = []
+        #TODO support pads is Variable
+        if op.attr('data_format') == 'NCHW':
+            pads = [
+                0, 0, paddings[0], paddings[2], 0, 0, paddings[1], paddings[3]
+            ]
+        else:
+            pads = [
+                0, paddings[0], paddings[2], 0, 0, paddings[1], paddings[3], 0
+            ]
+        pads_name = self.get_name(op.type, 'pads')
+        pads_node = self.make_constant_node(pads_name,
+                                            onnx_pb.TensorProto.INT64, pads)
+        constant_value_name = self.get_name(op.type, 'constant_value')
+        constant_value_node = self.make_constant_node(constant_value_name,
+                                                      onnx_pb.TensorProto.FLOAT,
+                                                      op.attr('pad_value'))
+        node = helper.make_node(
+            'Pad',
+            inputs=op.input('X') + [pads_name, constant_value_name],
+            outputs=op.output('Out'),
+            mode=op.attr('mode'))
+        return [pads_node, constant_value_node, node]
+
+    def bilinear_interp(self, op, block):
+        input_names = op.input_names
+        coordinate_transformation_mode = ''
+        align_corners = op.attr('align_corners')
+        align_mode = op.attr('align_mode')
+        if align_corners:
+            coordinate_transformation_mode = 'align_corners'
+        elif align_mode == 1:
+            coordinate_transformation_mode = 'asymmetric'
+        else:
+            coordinate_transformation_mode = 'half_pixel'
+
+        if ('OutSize' in input_names and len(op.input('OutSize')) > 0) or (
+                'SizeTensor' in input_names and
+                len(op.input('SizeTensor')) > 0):
+            node_list = list()
+            roi_node = self.make_constant_node(
+                self.get_name(op.type, 'roi'), onnx_pb.TensorProto.FLOAT,
+                [1, 1, 1, 1, 1, 1, 1, 1])
+            roi_name = self.get_name(op.type, 'roi')
+            roi_node = self.make_constant_node(
+                roi_name, onnx_pb.TensorProto.FLOAT, [1, 1, 1, 1, 1, 1, 1, 1])
+            empty_name = self.get_name(op.type, 'empty')
+            empty_tensor = helper.make_tensor(
+                empty_name,
+                onnx_pb.TensorProto.FLOAT, (0, ),
+                np.array([]).astype('float32'),
+                raw=False)
+            empty_node = helper.make_node(
+                'Constant', [], outputs=[empty_name], value=empty_tensor)
+            shape_name0 = self.get_name(op.type, 'shape')
+            shape_node0 = helper.make_node(
+                'Shape', inputs=op.input('X'), outputs=[shape_name0])
+            starts_name = self.get_name(op.type, 'slice.starts')
+            starts_node = self.make_constant_node(
+                starts_name, onnx_pb.TensorProto.INT64, [0])
+            ends_name = self.get_name(op.type, 'slice.ends')
+            ends_node = self.make_constant_node(ends_name,
+                                                onnx_pb.TensorProto.INT64, [2])
+            shape_name1 = self.get_name(op.type, 'shape')
+            shape_node1 = helper.make_node(
+                'Slice',
+                inputs=[shape_name0, starts_name, ends_name],
+                outputs=[shape_name1])
+            node_list.extend([
+                roi_node, empty_node, shape_node0, starts_node, ends_node,
+                shape_node1
+            ])
+            if 'OutSize' in input_names and len(op.input('OutSize')) > 0:
+                cast_shape_name = self.get_name(op.type, "shape.cast")
+                cast_shape_node = helper.make_node(
+                    'Cast',
+                    inputs=op.input('OutSize'),
+                    outputs=[cast_shape_name],
+                    to=onnx_pb.TensorProto.INT64)
+                node_list.append(cast_shape_node)
+            else:
+                concat_shape_name = self.get_name(op.type, "shape.concat")
+                concat_shape_node = helper.make_node(
+                    "Concat",
+                    inputs=op.input('SizeTensor'),
+                    outputs=[concat_shape_name],
+                    axis=0)
+                cast_shape_name = self.get_name(op.type, "shape.cast")
+                cast_shape_node = helper.make_node(
+                    'Cast',
+                    inputs=[concat_shape_name],
+                    outputs=[cast_shape_name],
+                    to=onnx_pb.TensorProto.INT64)
+                node_list.extend([concat_shape_node, cast_shape_node])
+            shape_name3 = self.get_name(op.type, "shape.concat")
+            shape_node3 = helper.make_node(
+                'Concat',
+                inputs=[shape_name1, cast_shape_name],
+                outputs=[shape_name3],
+                axis=0)
+            result_node = helper.make_node(
+                'Resize',
+                inputs=[op.input('X')[0], roi_name, empty_name, shape_name3],
+                outputs=op.output('Out'),
+                mode='linear',
+                coordinate_transformation_mode=coordinate_transformation_mode)
+            node_list.extend([shape_node3, result_node])
+            return node_list
+        elif 'Scale' in input_names and len(op.input('Scale')) > 0:
+            node = helper.make_node(
+                'Resize',
+                inputs=[op.input('X')[0], op.input('Scale')[0]],
+                outputs=op.output('Out'),
+                mode='linear',
+                coordinate_transformation_mode=coordinate_transformation_mode)
+        else:
+            out_shape = [op.attr('out_h'), op.attr('out_w')]
+            scale = op.attr('scale')
+            if out_shape.count(-1) > 0:
+                scale_name = self.get_name(op.type, 'scale')
+                scale_node = self.make_constant_node(scale_name,
+                                                     onnx_pb.TensorProto.FLOAT,
+                                                     [1, 1, scale, scale])
+                roi_name = self.get_name(op.type, 'roi')
+                roi_node = self.make_constant_node(roi_name,
+                                                   onnx_pb.TensorProto.FLOAT,
+                                                   [1, 1, 1, 1, 1, 1, 1, 1])
+                node = helper.make_node(
+                    'Resize',
+                    inputs=[op.input('X')[0], roi_name, scale_name],
+                    outputs=op.output('Out'),
+                    mode='nearest',
+                    coordinate_transformation_mode=coordinate_transformation_mode
+                )
+                return [scale_node, roi_node, node]
+            else:
+                raise Exception("Unexpected situation happend")
+        return node
+
+    def nearest_interp(self, op, block):
+        input_names = op.input_names
+        coordinate_transformation_mode = ''
+        align_corners = op.attr('align_corners')
+        if align_corners:
+            coordinate_transformation_mode = 'align_corners'
+        else:
+            coordinate_transformation_mode = 'asymmetric'
+        if 'OutSize' in input_names and len(op.input('OutSize')) > 0:
+            node = helper.make_node(
+                'Resize',
+                inputs=[op.input('X')[0], '', op.input('OutSize')[0]],
+                outputs=op.output('Out'),
+                mode='nearest',
+                coordinate_transformation_mode=coordinate_transformation_mode)
+        elif 'Scale' in input_names and len(op.input('Scale')) > 0:
+            node = helper.make_node(
+                'Resize',
+                inputs=[op.input('X')[0], op.input('Scale')[0]],
+                outputs=op.output('Out'),
+                mode='nearest',
+                coordinate_transformation_mode=coordinate_transformation_mode)
+        else:
+            out_shape = [op.attr('out_h'), op.attr('out_w')]
+            scale = op.attr('scale')
+            if out_shape.count(-1) > 0:
+                scale_name = self.get_name(op.type, 'scale')
+                scale_node = self.make_constant_node(scale_name,
+                                                     onnx_pb.TensorProto.FLOAT,
+                                                     [1, 1, scale, scale])
+                roi_name = self.get_name(op.type, 'roi')
+                roi_node = self.make_constant_node(roi_name,
+                                                   onnx_pb.TensorProto.FLOAT,
+                                                   [1, 1, 1, 1, 1, 1, 1, 1])
+                node = helper.make_node(
+                    'Resize',
+                    inputs=[op.input('X')[0], roi_name, scale_name],
+                    outputs=op.output('Out'),
+                    mode='nearest',
+                    coordinate_transformation_mode=coordinate_transformation_mode
+                )
+                return [scale_node, roi_node, node]
+            else:
+                raise Exception("Unexpected situation happend")
+        return node
+
+    def hard_swish(self, op, block):
+        min_name = self.get_name(op.type, 'min')
+        max_name = self.get_name(op.type, 'max')
+        scale_name = self.get_name(op.type, 'scale')
+        offset_name = self.get_name(op.type, 'offset')
+        min_node = self.make_constant_node(min_name, onnx_pb.TensorProto.FLOAT,
+                                           0)
+        max_node = self.make_constant_node(max_name, onnx_pb.TensorProto.FLOAT,
+                                           op.attr('threshold'))
+        scale_node = self.make_constant_node(scale_name,
+                                             onnx_pb.TensorProto.FLOAT,
+                                             op.attr('scale'))
+        offset_node = self.make_constant_node(offset_name,
+                                              onnx_pb.TensorProto.FLOAT,
+                                              op.attr('offset'))
+
+        name0 = self.get_name(op.type, 'add')
+        node0 = helper.make_node(
+            'Add', inputs=[op.input('X')[0], offset_name], outputs=[name0])
+        name1 = self.get_name(op.type, 'relu')
+        node1 = helper.make_node(
+            'Clip',
+            inputs=[name0, min_name, max_name],
+            outputs=[name1], )
+        name2 = self.get_name(op.type, 'mul')
+        node2 = helper.make_node(
+            'Mul', inputs=[op.input('X')[0], name1], outputs=[name2])
+        node3 = helper.make_node(
+            'Div', inputs=[name2, scale_name], outputs=op.output('Out'))
+        return [
+            min_node, max_node, scale_node, offset_node, node0, node1, node2,
+            node3
+        ]
+
+    def im2sequence(self, op, block):
+        from .paddle_custom_layer.im2sequence import im2sequence
+        return im2sequence(op, block)
+
+    def yolo_box(self, op, block):
+        from .paddle_custom_layer.yolo_box import yolo_box
+        return yolo_box(op, block)
+
+    def multiclass_nms(self, op, block):
+        from .paddle_custom_layer.multiclass_nms import multiclass_nms
+        return multiclass_nms(op, block)

x2paddle/op_mapper/paddle2onnx/opset11/paddle_custom_layer/im2sequence.py

+# Copyright (c) 2020  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 onnx
+import numpy as np
+from onnx import onnx_pb, helper
+from x2paddle.op_mapper.paddle2onnx.opset10.paddle_custom_layer.im2sequence import im2sequence as im2sequence10
+
+
+def im2sequence(op, block):
+    return im2sequence10(op, block)

x2paddle/op_mapper/paddle_custom_layer/multiclass_nms.py → x2paddle/op_mapper/paddle2onnx/opset11/paddle_custom_layer/multiclass_nms.py

@@ -125,7 +125,7 @@ def multiclass_nms(op, block):
                 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
+    # In 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(
@@ -405,12 +405,36 @@ def multiclass_nms(op, block):
 
     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(
+    outputs_sort_by_socre_results = [result_name + "@concat_topk_scores"]
+    node_sort_by_socre_results = onnx.helper.make_node(
         'Concat',
         inputs=inputs_concat_final_results,
-        outputs=outputs_concat_final_results,
+        outputs=outputs_sort_by_socre_results,
         axis=2)
-    node_list.append(node_concat_final_results)
+    node_list.append(node_sort_by_socre_results)
 
+    # select topk classes indices
+    outputs_squeeze_cast_topk_class = [result_name + "@squeeze_cast_topk_class"]
+    node_squeeze_cast_topk_class = onnx.helper.make_node(
+        'Squeeze',
+        inputs=outputs_cast_topk_class,
+        outputs=outputs_squeeze_cast_topk_class,
+        axes=[0, 2])
+    node_list.append(node_squeeze_cast_topk_class)
+    outputs_topk_select_classes_indices = [result_name + "@topk_select_topk_classes_scores",\
+        result_name + "@topk_select_topk_classes_indices"]
+    node_topk_select_topk_indices = onnx.helper.make_node(
+        'TopK',
+        inputs=outputs_squeeze_cast_topk_class + outputs_cast_topk_indices,
+        outputs=outputs_topk_select_classes_indices,
+        largest=0)
+    node_list.append(node_topk_select_topk_indices)
+    outputs_concat_final_results = outputs['Out']
+    node_concat_final_results = onnx.helper.make_node(
+        'Gather',
+        inputs=outputs_sort_by_socre_results +
+        [outputs_topk_select_classes_indices[1]],
+        outputs=outputs_concat_final_results,
+        axis=1)
+    node_list.append(node_concat_final_results)
     return node_list

x2paddle/op_mapper/paddle_custom_layer/im2sequence.py → x2paddle/op_mapper/paddle2onnx/opset9/paddle_custom_layer/im2sequence.py

+# Copyright (c) 2020  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 onnx
 import numpy as np
 from onnx import onnx_pb, helper