Better conversion for the subclassing model and code reformat. (#446)

* Better conversion for the subclassed model and code reformat.

* Update the tutorial

* fixing anonying layer name reusing issue.

Author: wenbingl

.gitignore

@@ -36,10 +36,13 @@ dist
 # test generated files
 .pytest_cache/
 .cache
+.ipynb_checkpoints/
 htmlcov
 coverage.xml
 .coverage
 docs/auto_examples/*
 docs/examples/imagenet*.json
 docs/examples/*.onnx
 docs/examples/tiny_yolov2*
+tutorial/*.onnx
+tutorial/.ipynb_checkpoints/*

keras2onnx/_parse_tf.py

@@ -175,33 +175,25 @@ def _layer_name_dict(tf_utils, layer, prefix, parent=None):
     return output_dict
 
 
-def _to_tf_ops(layer_name, graph, fstr):
+def _to_tf_ops(layer_name, fstr, ops_table):
     ops = []
     op_name = fstr.format(layer_name) if fstr is not None else None
     if op_name is None:
         return ops
 
-    try:
-        ops[0:] = [graph.get_operation_by_name(op_name)]
-        idx = 1
-        if not re.match(r".+_\d+", layer_name):  # if layer name already numbered, skipped then.
-            while True:  # break out by exception.
-                op_name = fstr.format("%s_%d" % (layer_name, idx))
-                ops[idx:] = [graph.get_operation_by_name(op_name)]
-                idx += 1
-    except KeyError:
-        pass
-
-    return ops
-
+    if re.match(r".+_\d+$", layer_name):  # if layer name already numbered, skipped then.
+        return ops
 
-def _advance_output_node_if_successor(graph, layer, output):
-    for op_ in graph.get_operations():
-        if op_.name.find(layer) == 0:
-            if output in [ts_.op.name for ts_ in op_.inputs]:
-                return op_.name
+    idx = 0
+    while True:
+        op_name = fstr.format("%s_%d" % (layer_name, idx + 1))
+        if op_name in ops_table:
+            ops.append(ops_table[op_name])
+        else:
+            break
+        idx += 1
 
-    return output
+    return ops
 
 
 def build_layer_outputs(model, graph, outputs):
@@ -211,23 +203,39 @@ def build_layer_outputs(model, graph, outputs):
     output_dict = {}
     layer_dict = _layer_name_dict(tf_utils, model, model.name)
 
+    ops_table = {op_.name: op_ for op_ in graph.get_operations()}
+
+    def add_output_node(graph, op, fx_list, layer_name):
+        output_node_name = op.name
+        if len(fx_list) > 1:  # if there is no output node function.
+            # fx_[1] is output node redirect function.
+            output_node_name = fx_list[1](lobj, op)
+        assert graph.get_operation_by_name(output_node_name) is not None, "Parsing layer({}) failed.".format(lobj)
+        if output_node_name not in output_dict:  # if there is already a same kind of layer, not overwrite it.
+            output_dict[output_node_name] = layer_dict[layer_name]
+
+    for ln_, layer_info_ in layer_dict.items():
+        lobj = layer_info_[0]
+        fstr_list, fx_list = keras_layer_spec(type(lobj))
+        if fstr_list is None:
+            continue
+
+        for fstr_ in fstr_list:
+            op_name = fstr_.format(ln_)
+            if op_name not in ops_table:
+                continue
+            add_output_node(graph, ops_table[op_name], fx_list, ln_)
+
+    # now process the case when a layer was re-used several times in one model.
     for ln_, layer_info_ in layer_dict.items():
         lobj = layer_info_[0]
         fstr_list, fx_list = keras_layer_spec(type(lobj))
         if fstr_list is None:
             continue
 
         for fstr_ in fstr_list:
-            for op_ in _to_tf_ops(ln_, graph, fstr_):
-                if len(fx_list) <= 1:
-                    output_dict[op_.name] = layer_dict[ln_]
-                else:
-                    # fx_[1] is output node redirect function.
-                    output_node = fx_list[1](lobj, op_)
-                    output_node = _advance_output_node_if_successor(graph, ln_, output_node)
-                    assert graph.get_operation_by_name(output_node) is not None, "Parsing layer({}) failed.".format(
-                        lobj)
-                    output_dict[output_node] = layer_dict[ln_]
+            for op_ in _to_tf_ops(ln_, fstr_, ops_table):
+                add_output_node(graph, op_, fx_list, ln_)
 
     return output_dict
 

keras2onnx/ke2onnx/layer_spec.py

@@ -27,13 +27,7 @@ def _simple_layer_name_extractor(fstr_list, node_name):
 
 
 def _conv_layer_spec_outputs(layer, node):
-    if type(layer) == _layer.DepthwiseConv2D:
-        if not layer.use_bias:
-            return node.name
-        else:
-            ri = node.name.rindex('/')
-            return node.name[:ri + 1] + 'BiasAdd'
-    elif type(layer) == _layer.Conv1D:
+    if type(layer) == _layer.Conv1D:
         return node.name + '/Squeeze'
 
     activation_map = {
@@ -42,15 +36,26 @@ def _conv_layer_spec_outputs(layer, node):
         tf.nn.softmax: 'Softmax',
         tf.nn.relu: 'Relu',
         tf.nn.elu: 'Elu',
-        tf.nn.tanh: 'Tanh'}
+        tf.nn.tanh: 'Tanh',
+        tf.nn.swish: 'mul'}
 
     node_act = activation_map.get(layer.activation, None)
+    if node_act is None:
+        actname_map = {a_.__name__: a_ for a_ in activation_map}
+        act_trans = actname_map.get(layer.activation.__name__, None)
+        if act_trans is not None:
+            node_act = activation_map.get(act_trans)
+
     assert node_act is not None, "Unsupported activation in the layer({})".format(layer.activation)
     if node_act:
         ri = node.name.rindex('/')
         return node.name[:ri + 1] + node_act
     else:
-        return node.name
+        if not layer.use_bias:
+            return node.name
+        else:
+            ri = node.name.rindex('/')
+            return node.name[:ri + 1] + 'BiasAdd'
 
 
 def _relu_like_spec_outputs(layer, node):
@@ -69,11 +74,17 @@ def _relu_like_spec_outputs(layer, node):
     _layer.MaxPooling1D: (["{}/MaxPool"], [_default_layer_name_extractor]),
     _layer.MaxPooling2D: (["{}/MaxPool"], [_default_layer_name_extractor]),
     _layer.MaxPooling3D: (["{}/MaxPool"], [_default_layer_name_extractor]),
+
     _layer.Conv1D: (["{}/conv1d"], [_simple_layer_name_extractor, _conv_layer_spec_outputs]),
+    _layer.Conv2D: (["{}/Conv2D"], [_simple_layer_name_extractor, _conv_layer_spec_outputs]),
+
     _layer.Conv2DTranspose: (["{}/conv2d_transpose"], [_simple_layer_name_extractor, _conv_layer_spec_outputs]),
     _layer.DepthwiseConv2D: (["{}/depthwise"], [_simple_layer_name_extractor, _conv_layer_spec_outputs]),
+
     _layer.LeakyReLU: (["{}/LeakyRelu"], [_default_layer_name_extractor]),
-    _adv_activations.PReLU: (["{}/Relu"], [_simple_layer_name_extractor, _relu_like_spec_outputs])
+    _adv_activations.PReLU: (["{}/Relu"], [_simple_layer_name_extractor, _relu_like_spec_outputs]),
+
+    _layer.Reshape: (["{}/Reshape"], [_default_layer_name_extractor])
 }
 
 if not is_keras_older_than('2.2.0'):

keras2onnx/topology.py

@@ -299,37 +299,38 @@ def convert_topology(topology, model_name, doc_string, target_opset, channel_fir
     # enable the ONNX optimizations
     graph = None
     nodes = container.nodes
-    try:
-        import onnxconverter_common
-        origin_node_number = len(container.nodes)
-        if target_opset < 9:
-            nodes = onnxconverter_common.optimizer.optimize_onnx(nodes, nchw_inputs=nchw_inputs,
-                                                                 inputs=container.inputs + extra_inputs,
-                                                                 outputs=container.outputs)
-            node_number = len(nodes)
-        else:
-            graph = onnxconverter_common.optimizer.optimize_onnx_graph(nodes, nchw_inputs=nchw_inputs,
-                                                                       inputs=container.inputs,
-                                                                       outputs=container.outputs,
-                                                                       initializers=container.initializers,
-                                                                       model_value_info=container.value_info,
-                                                                       model_name=model_name,
-                                                                       target_opset=container.target_opset)
-            node_number = len(graph.node)
-        k2o_logger().info("The node number after optimization: {} -> {}".format(origin_node_number, node_number))
-    except ImportError:
-        onnx_not_imported = 'onnxconverter_common is not imported,'
-        if nchw_inputs:
-            raise Exception(
-                '{} nchw_inputs does not make effect. Please set nchw_inputs to empty.'.format(onnx_not_imported))
-        k2o_logger().warning('{} so the convertor optimizer is not enabled.'.format(onnx_not_imported))
-    except Exception as e:
-        # either optimizer issue or converter issue, we just let it go to diagnose the issue from the converted model.
-        k2o_logger().warning('There is an error({}) happened during optimizing on the converted model!'.format(type(e)))
-        k2o_logger().warning(str(e))
-        import traceback
-        tb = traceback.format_exc()
-        k2o_logger().warning(tb)
+    if not topology.debug_mode:
+        try:
+            import onnxconverter_common
+            origin_node_number = len(container.nodes)
+            if target_opset < 9:
+                nodes = onnxconverter_common.optimizer.optimize_onnx(nodes, nchw_inputs=nchw_inputs,
+                                                                     inputs=container.inputs + extra_inputs,
+                                                                     outputs=container.outputs)
+                node_number = len(nodes)
+            else:
+                graph = onnxconverter_common.optimizer.optimize_onnx_graph(nodes, nchw_inputs=nchw_inputs,
+                                                                           inputs=container.inputs,
+                                                                           outputs=container.outputs,
+                                                                           initializers=container.initializers,
+                                                                           model_value_info=container.value_info,
+                                                                           model_name=model_name,
+                                                                           target_opset=container.target_opset)
+                node_number = len(graph.node)
+            k2o_logger().info("The node number after optimization: {} -> {}".format(origin_node_number, node_number))
+        except ImportError:
+            onnx_not_imported = 'onnxconverter_common is not imported,'
+            if nchw_inputs:
+                raise Exception(
+                    '{} nchw_inputs does not make effect. Please set nchw_inputs to empty.'.format(onnx_not_imported))
+            k2o_logger().warning('{} so the convertor optimizer is not enabled.'.format(onnx_not_imported))
+        except Exception as e:  # noqa
+            # either optimizer issue or converter issue, we just let it go to diagnose the issue from the converted model.
+            k2o_logger().warning('There is an error({}) happened during optimizing on the converted model!'.format(type(e)))
+            k2o_logger().warning(str(e))
+            import traceback
+            tb = traceback.format_exc()
+            k2o_logger().warning(tb)
 
     if graph is None:
         # Create a graph from its main components

tests/data/panda.jpg

@@ -8,12 +8,10 @@
 import keras2onnx
 import numpy as np
 from keras2onnx.proto import keras, is_tf_keras
-from test_utils import run_onnx_runtime
 from distutils.version import StrictVersion
 
 Activation = keras.layers.Activation
 BatchNormalization = keras.layers.BatchNormalization
-Conv2D = keras.layers.Conv2D
 Dense = keras.layers.Dense
 Dropout = keras.layers.Dropout
 Embedding = keras.layers.Embedding
@@ -121,7 +119,7 @@ def build_discriminator(self):
 
 @pytest.mark.skipif(keras2onnx.proto.tfcompat.is_tf2 and is_tf_keras, reason="Tensorflow 1.x only tests.")
 @pytest.mark.skipif(is_tf_keras and StrictVersion(tf.__version__.split('-')[0]) < StrictVersion("1.14.0"),
-                 reason="Not supported before tensorflow 1.14.0 for tf_keras")
+                    reason="Not supported before tensorflow 1.14.0 for tf_keras")
 def test_CGAN(runner):
     keras_model = CGAN().combined
     batch = 5

tests/test_cgan.py

@@ -72,7 +72,7 @@
 RNN_CLASSES = [SimpleRNN, GRU, LSTM]
 
 
-def asarray(*a):
+def _asarray(*a):
     return np.array([a], dtype='f')
 
 
@@ -758,7 +758,7 @@ def test_dense(runner):
         model.compile('sgd', 'mse')
         onnx_model = keras2onnx.convert_keras(model, model.name)
 
-        data = asarray(1, 0, 0, 1)
+        data = _asarray(1, 0, 0, 1)
         expected = model.predict(data)
         assert runner('dense', onnx_model, data, expected)
 
@@ -775,7 +775,7 @@ def test_dense_add(runner):
     model.compile('sgd', 'mse')
     onnx_model = keras2onnx.convert_keras(model, model.name)
 
-    data = [asarray(1.2, 2.4, -2, 1), asarray(-1, -2, 0, 1, 2), asarray(0.5, 1.5, -3.14159)]
+    data = [_asarray(1.2, 2.4, -2, 1), _asarray(-1, -2, 0, 1, 2), _asarray(0.5, 1.5, -3.14159)]
     expected = model.predict(data)
     assert runner('onnx_dense_add', onnx_model, data, expected)
 
@@ -796,7 +796,7 @@ def test_conv_add(runner):
 
 
 def test_dense_softmax(runner):
-    data = asarray(1, 2, 3, 4)
+    data = _asarray(1, 2, 3, 4)
     model = Sequential()
     model.add(Dense(5, input_shape=(4,), activation='softmax'))
     model.add(Dense(3, input_shape=(5,), use_bias=True))
@@ -831,7 +831,7 @@ def test_dense_softmax(runner):
     (lambda: Concatenate(2), ([[1, 2], [3, 4]], [[4, 5], [6, 7]])),
 ])
 def test_merge_layer(runner, layer_type, data):
-    data2 = [asarray(*d) for d in data]
+    data2 = [_asarray(*d) for d in data]
     inputs = [Input(shape=d.shape[1:]) for d in data2]
     layer = layer_type()(inputs)
     model = keras.models.Model(inputs=inputs, outputs=layer)
@@ -1043,7 +1043,7 @@ def test_repeat_vector(runner):
     model.add(keras.layers.core.RepeatVector(3, input_shape=(4,)))
     onnx_model = keras2onnx.convert_keras(model, model.name)
 
-    data = asarray(1, 2, 3, 4)
+    data = _asarray(1, 2, 3, 4)
 
     expected = model.predict(data)
     assert runner('repeat_vector', onnx_model, data, expected)
@@ -1134,7 +1134,7 @@ def test_pooling_global(pooling_runner):
     keras.activations.linear,
 ])
 def test_activation_layer(runner, layer):
-    data = asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
+    data = _asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
     layer = Activation(layer, input_shape=(data.size,))
 
     model = keras.Sequential()
@@ -1177,13 +1177,13 @@ def test_selu(runner):
 
 
 def test_LeakyReLU(advanced_activation_runner):
-    data = asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
+    data = _asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
     layer = advanced_activations.LeakyReLU(alpha=0.1, input_shape=(data.size,))
     advanced_activation_runner(layer, data)
 
 
 def test_ThresholdedReLU(advanced_activation_runner):
-    data = asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
+    data = _asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
     layer = advanced_activations.ThresholdedReLU(theta=1.0, input_shape=(data.size,))
     advanced_activation_runner(layer, data, op_version=8)
 
@@ -1192,13 +1192,13 @@ def test_ThresholdedReLU(advanced_activation_runner):
 
 
 def test_ELU(advanced_activation_runner):
-    data = asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
+    data = _asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
     layer = advanced_activations.ELU(alpha=1.0, input_shape=(data.size,))
     advanced_activation_runner(layer, data)
 
 
 def test_PReLU(advanced_activation_runner):
-    data = asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
+    data = _asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
     layer = advanced_activations.PReLU(alpha_initializer='zeros', input_shape=(data.size,))
     advanced_activation_runner(layer, data)
     layer = advanced_activations.PReLU(alpha_initializer='ones', input_shape=(data.size,))
@@ -1208,7 +1208,7 @@ def test_PReLU(advanced_activation_runner):
 
 
 def test_Softmax(advanced_activation_runner):
-    data = asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
+    data = _asarray(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
     layer = advanced_activations.Softmax(axis=-1, input_shape=(data.size,))
     advanced_activation_runner(layer, data)
 
@@ -1327,8 +1327,8 @@ def func(l2Normalize, input1, input2):
 
 
 def test_dot(dot_runner):
-    dot_runner(False, asarray(1, 2, 3), asarray(4, 5, 6))
-    dot_runner(True, asarray(1, 2, 3), asarray(4, 5, 6))
+    dot_runner(False, _asarray(1, 2, 3), _asarray(4, 5, 6))
+    dot_runner(True, _asarray(1, 2, 3), _asarray(4, 5, 6))
 
 
 def test_dot2(runner):
@@ -1397,7 +1397,7 @@ def func(data, gamma, beta, scale, center, axis):
 
 
 def test_batch_normalization(batch_norm_runner):
-    data = asarray([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
+    data = _asarray([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
     batch_norm_runner(data, 'ones', 'zeros', True, True, 3)
     batch_norm_runner(data, 'ones', 'ones', True, True, 3)
     # The CPU implementation of FusedBatchNorm only supports NHWC tensor format in tf keras