Add pad and gaussiannoise layer

Author: Laicheng0830

README.md

@@ -64,7 +64,7 @@ input_data = np.array(input, dtype=np.float32)
 result = sess.run([output_name], {input_name: input_data})
 print('onnx out', result)
 ```
-The converted onnx file can be viewed via Netron.
+The converted onnx file can be viewed via [Netron](https://github.com/lutzroeder/netron).
 
 <p align="center"><img src="https://git.openi.org.cn/laich/pose_data/raw/commit/7ac74f03dbfdd8e023cdb205cd415a8571ebb91a/onnxfile.png" width="580"\></p>
 

tests/test_noise.py

@@ -0,0 +1,38 @@
+#! /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 GaussianNoise
+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.noise = GaussianNoise()
+
+    def forward(self, inputs):
+        x = self.noise(inputs)
+        return x
+
+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='noise.onnx')
+
+# Infer Model
+sess = rt.InferenceSession('noise.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)

tests/test_padding.py

@@ -0,0 +1,38 @@
+#! /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 PadLayer, ZeroPad1d, ZeroPad2d, ZeroPad3d
+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.pad = PadLayer([[1, 2], [3, 4], [5, 6], [7, 8]], "REFLECT", name='inpad')
+
+    def forward(self, inputs):
+        x = self.pad(inputs)
+        return x
+
+net = CustomModel()
+input = tlx.nn.Input(shape=(5, 5, 10, 10), init=tlx.initializers.RandomNormal())
+net.set_eval()
+output = net(input)
+print("tlx out", output.shape)
+onnx_model = export(net, input_spec=input, path='padding.onnx')
+
+# Infer Model
+sess = rt.InferenceSession('padding.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', np.shape(result))

tlx2onnx/op_mapper/nn/__init__.py

@@ -16,4 +16,6 @@
 from .extend import *
 from .rnn import *
 from .resampling import *
-from .merge import *
+from .merge import *
+from .noise import *
+from .padding import *

tlx2onnx/op_mapper/nn/noise.py

@@ -0,0 +1,39 @@
+#! /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
+
+@OpMapper(['GaussianNoise'])
+class GaussianNoise():
+    # 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'][0]
+        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
+        mean = layer.mean
+        scale = layer.stddev
+        seed = layer.seed
+        # make random normal node
+        r_out = helper.make_tensor_value_info(out_name + '_r', dtype, shape=out_shape)
+        onnx_value.append(r_out)
+        r_node, out = make_node('RandomNormal', inputs='', outputs=[out_name + 'r'],
+                                  dtype=dtype, mean=mean, scale=scale, seed=seed, shape=out_shape)
+        onnx_node.append(r_node)
+
+        a_out = helper.make_tensor_value_info(out_name, dtype, shape=out_shape)
+        onnx_value.append(a_out)
+        a_node, out = make_node('Add', inputs=[in_name, out], outputs=[out_name])
+        onnx_node.append(a_node)
+        return onnx_node, onnx_value, onnx_init

tlx2onnx/op_mapper/nn/padding.py

@@ -0,0 +1,55 @@
+#! /usr/bin/python
+# -*- coding: utf-8 -*-
+
+from onnx import helper, numpy_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(['PadLayer'])
+class PadLayer():
+    # 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'][0]
+        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
+        # get attrs
+        value = np.array(layer.constant_values).astype(node['dtype'])
+        c_value = numpy_helper.from_array(value, name='value')
+        onnx_init.append(c_value)
+        # processing mode
+        mode_dict = {"CONSTANT": 'constant', "REFLECT": 'reflect',"SYMMETRIC": 'edge'}
+        mode = mode_dict[layer.mode]
+        # processing padding. `pads` should be a 1D tensor of shape [2 * input_rank].
+        # `pads` format should be: [x1_begin, x2_begin,...,x1_end, x2_end,...],
+        padding = layer.padding
+        pads_temp = padding[0]
+        for i in np.arange(1, len(padding)):
+            pads_temp += padding[i]
+        pads = []
+        for i in range(len(pads_temp)//2):
+            pads.append(pads_temp[2*i])
+        for i in range(len(pads_temp) // 2):
+            pads.append(pads_temp[i*2+1])
+        pads = np.array(pads).astype(np.int64)
+        p_value = numpy_helper.from_array(pads, name='pads')
+        onnx_init.append(p_value)
+        # make nodes
+        v_out = helper.make_tensor_value_info(out_name, dtype, shape=out_shape)
+        onnx_value.append(v_out)
+
+        if mode == 'constant':
+            p_node, out = make_node('Pad', inputs=[in_name, 'pads', 'value'], outputs=[out_name], mode='constan')
+            onnx_node.append(p_node)
+        else:
+            p_node, out = make_node('Pad', inputs=[in_name, 'pads'], outputs=[out_name], mode=mode)
+            onnx_node.append(p_node)
+
+        return onnx_node, onnx_value, onnx_init