Add convert 11 (#12)

* Add resampling

* Add merge

Author: Laicheng0830

README.md

@@ -25,55 +25,57 @@ pip install tlx2onnx
 ## Usage
 TLX2ONNX can convert models built using TensorLayerX Module Subclass and Layers, and the Layers support list can be found in [Operator list](OP_LIST.md).
 
+The following is an example of converting a multi-layer perceptron. You can get the code from [here](https://github.com/tensorlayer/TLX2ONNX/tree/main/tests/test_merge.py).
 ```python
-#! /usr/bin/python
-# -*- coding: utf-8 -*-
-
+import os
+os.environ["TL_BACKEND"] = 'tensorflow'
 import tensorlayerx as tlx
 from tensorlayerx.nn import Module
-from tensorlayerx.nn import Linear, Dropout, Flatten, ReLU6
-from tlx2onnx import export
+from tensorlayerx.nn import Linear, Concat, Elementwise
+from tlx2onnx.main import export
 import onnxruntime as rt
 import numpy as np
 
-class MLP(Module):
+class CustomModel(Module):
     def __init__(self):
-        super(MLP, self).__init__()
-        # weights init
-        self.flatten = Flatten()
-        self.line1 = Linear(in_features=32, out_features=64, act=tlx.nn.LeakyReLU(0.3))
-        self.d1 = Dropout()
-        self.line2 = Linear(in_features=64, out_features=128, b_init=None, act=tlx.nn.ReLU)
-        self.relu6 = ReLU6()
-        self.line3 = Linear(in_features=128, out_features=10, act=tlx.nn.ReLU)
-
-    def forward(self, x):
-        x = self.flatten(x)
-        z = self.line1(x)
-        z = self.d1(z)
-        z = self.line2(z)
-        z = self.relu6(z)
-        z = self.line3(z)
-        return z
-
-net = MLP()
-net.eval()
-input = tlx.nn.Input(shape=(3, 2, 2, 8))
-onnx_model = export(net, input_spec=input, path='linear_model.onnx')
+        super(CustomModel, self).__init__(name="custom")
+        self.linear1 = Linear(in_features=20, out_features=10, act=tlx.ReLU, name='relu1_1')
+        self.linear2 = Linear(in_features=20, out_features=10, act=tlx.ReLU, name='relu2_1')
+        self.concat = Concat(concat_dim=1, name='concat_layer')
+
+    def forward(self, inputs):
+        d1 = self.linear1(inputs)
+        d2 = self.linear2(inputs)
+        outputs = self.concat([d1, d2])
+        return outputs
+
+net = CustomModel()
+input = tlx.nn.Input(shape=(3, 20), init=tlx.initializers.RandomNormal())
+net.set_eval()
+output = net(input)
+print("tlx out", output)
+onnx_model = export(net, input_spec=input, path='concat.onnx')
 
 # Infer Model
-sess = rt.InferenceSession('linear_model.onnx')
+sess = rt.InferenceSession('concat.onnx')
 input_name = sess.get_inputs()[0].name
 output_name = sess.get_outputs()[0].name
-input_data = tlx.nn.Input(shape=(3, 2, 2, 8))
-input_data = np.array(input_data, dtype=np.float32)
+input_data = np.array(input, dtype=np.float32)
 result = sess.run([output_name], {input_name: input_data})
-print(result)
+print('onnx out', result)
 ```
+The converted onnx file can be viewed via Netron.
+
+<p align="center"><img src="https://git.openi.org.cn/laich/pose_data/raw/commit/7ac74f03dbfdd8e023cdb205cd415a8571ebb91a/onnxfile.png" width="580"\></p>
+
+
+The converted results have almost no loss of accuracy. 
+And the graph show the input and output sizes of each layer, which is very helpful for checking the model.
+
 
 # Citation
 
-If you find TensorLayerX useful for your project, please cite the following papers：
+If you find TensorLayerX or TLX2ONNX useful for your project, please cite the following papers：
 
 ```
 @article{tensorlayer2017,

tests/test_merge.py

@@ -0,0 +1,76 @@
+#! /usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+os.environ["TL_BACKEND"] = 'tensorflow'
+import tensorlayerx as tlx
+from tensorlayerx.nn import Module
+from tensorlayerx.nn import Linear, Concat, Elementwise
+from tlx2onnx.main import export
+import onnxruntime as rt
+import numpy as np
+
+class CustomModel(Module):
+    def __init__(self):
+        super(CustomModel, self).__init__(name="custom")
+        self.linear1 = Linear(in_features=20, out_features=10, act=tlx.ReLU, name='relu1_1')
+        self.linear2 = Linear(in_features=20, out_features=10, act=tlx.ReLU, name='relu2_1')
+        self.concat = Concat(concat_dim=1, name='concat_layer')
+
+    def forward(self, inputs):
+        d1 = self.linear1(inputs)
+        d2 = self.linear2(inputs)
+        outputs = self.concat([d1, d2])
+        return outputs
+
+net = CustomModel()
+input = tlx.nn.Input(shape=(3, 20), init=tlx.initializers.RandomNormal())
+net.set_eval()
+output = net(input)
+print("tlx out", output)
+onnx_model = export(net, input_spec=input, path='concat.onnx')
+
+# Infer Model
+sess = rt.InferenceSession('concat.onnx')
+
+input_name = sess.get_inputs()[0].name
+output_name = sess.get_outputs()[0].name
+
+input_data = np.array(input, dtype=np.float32)
+
+result = sess.run([output_name], {input_name: input_data})
+print('onnx out', result)
+
+#####################################  Elementwise  ###################################################
+class CustomModel2(Module):
+    def __init__(self):
+        super(CustomModel2, self).__init__(name="custom")
+        self.linear1 = Linear(in_features=10, out_features=10, act=tlx.ReLU, name='relu1_1')
+        self.linear2 = Linear(in_features=10, out_features=10, act=tlx.ReLU, name='relu2_1')
+        self.linear3 = Linear(in_features=10, out_features=10, act=tlx.ReLU, name='relu3_1')
+        self.element = Elementwise(combine_fn=tlx.matmul, name='concat')
+
+    def forward(self, inputs):
+        d1 = self.linear1(inputs)
+        d2 = self.linear2(inputs)
+        d3 = self.linear3(inputs)
+        outputs = self.element([d1, d2, d3])
+        return outputs
+
+net = CustomModel2()
+input = tlx.nn.Input(shape=(10, 10), init=tlx.initializers.RandomNormal())
+net.set_eval()
+output = net(input)
+print("tlx out", output)
+onnx_model2 = export(net, input_spec=input, path='elementwise.onnx')
+
+# Infer Model
+sess = rt.InferenceSession('elementwise.onnx')
+
+input_name = sess.get_inputs()[0].name
+output_name = sess.get_outputs()[0].name
+
+input_data = np.array(input, dtype=np.float32)
+
+result = sess.run([output_name], {input_name: input_data})
+print('onnx out', result)

tlx2onnx/op_mapper/nn/__init__.py

@@ -16,3 +16,4 @@
 from .extend import *
 from .rnn import *
 from .resampling import *
+from .merge import *

tlx2onnx/op_mapper/nn/merge.py

@@ -0,0 +1,72 @@
+#! /usr/bin/python
+# -*- coding: utf-8 -*-
+
+from onnx import helper
+from ..op_mapper import OpMapper
+from ...common import make_node
+from ..datatype_mapping import NP_TYPE_TO_TENSOR_TYPE
+import numpy as np
+
+@OpMapper(['Concat'])
+class Concat():
+    # supports v1-v12
+
+    @classmethod
+    def version_1(cls, node, **kwargs):
+        onnx_node = []
+        onnx_value = []
+        onnx_init = []
+        # get inputs outputs
+        in_name = node['in_nodes_name']
+        out_name = node['out_nodes_name'][0]
+        out_shape = node['out_tensors'][0]
+        dtype = NP_TYPE_TO_TENSOR_TYPE[node['dtype']]
+        layer = node['node'].layer
+        concat_dim = layer.concat_dim
+        # make concat node
+        out_v = helper.make_tensor_value_info(out_name, dtype, shape=out_shape)
+        onnx_value.append(out_v)
+        out_node, _ = make_node('Concat', inputs=[s for s in in_name], outputs=node['out_nodes_name'], axis=concat_dim)
+        onnx_node.append(out_node)
+        return onnx_node, onnx_value, onnx_init
+
+
+@OpMapper(['Elementwise'])
+class Elementwise():
+    # supports v1-v12
+
+    @classmethod
+    def version_1(cls, node, **kwargs):
+        onnx_node = []
+        onnx_value = []
+        onnx_init = []
+        # get inputs outputs
+        in_name = node['in_nodes_name']
+        out_name = node['out_nodes_name'][0]
+        out_shape = node['out_tensors'][0]
+        dtype = NP_TYPE_TO_TENSOR_TYPE[node['dtype']]
+        layer = node['node'].layer
+        combine_fn_name = cls.fn_dict(str(layer.combine_fn.__name__))
+        print(combine_fn_name)
+        # make combine_fn node
+        out_v = helper.make_tensor_value_info(out_name, dtype, shape=out_shape)
+        onnx_value.append(out_v)
+
+        out = in_name[0]
+        for i in np.arange(1, len(in_name)):
+            if i == len(in_name) - 1:
+                out_node, out = make_node(combine_fn_name, inputs=[out, in_name[i]], outputs=[out_name])
+                onnx_node.append(out_node)
+            else:
+                out_node, out = make_node(combine_fn_name, inputs=[out, in_name[i]], outputs=[out_name + str(i)])
+                onnx_node.append(out_node)
+        return onnx_node, onnx_value, onnx_init
+
+    @staticmethod
+    def fn_dict(fn):
+        # More operator operations can be added from here.
+        _dict = {
+            'matmul': 'MatMul',
+            'add': 'Add',
+        }
+        return _dict[fn]