merge constant with same value

Author: lucienwang1009

tests/test_optimizers.py

@@ -8,11 +8,11 @@
 from __future__ import unicode_literals
 
 import numpy as np
-from onnx import helper, TensorProto
+from onnx import helper, TensorProto, OperatorSetIdProto
 from tf2onnx import utils
 from tf2onnx.graph import GraphUtil
 from backend_test_base import Tf2OnnxBackendTestBase
-from common import unittest_main, group_nodes_by_type
+from common import unittest_main, group_nodes_by_type, check_opset_min_version
 
 
 # pylint: disable=missing-docstring,invalid-name,unused-argument,using-constant-test
@@ -629,6 +629,35 @@ def test_duplicated_duplicated_attributes(self):
         self.run_merge_duplicated_nodes_compare(["OUT"], {"X": np.random.randn(5, 5).astype(np.float32)}, model_proto,
                                                 op_type="ReduceSum", remaining_op_num=2)
 
+    @check_opset_min_version(9, "Constant")
+    def test_duplicated_duplicated_constant(self):
+        const_val = np.array([1, 2, 3], dtype=np.float32)
+        tensor_1 = helper.make_tensor("tensor_1", TensorProto.FLOAT, const_val.shape, const_val)
+        tensor_2 = helper.make_tensor("tensor_2", TensorProto.FLOAT, const_val.shape, const_val)
+        tensor_3 = helper.make_tensor("tensor_3", TensorProto.FLOAT, const_val.shape, const_val.tobytes(), raw=True)
+        tensor_4 = helper.make_tensor("tensor_4", TensorProto.FLOAT, const_val.shape, const_val.tobytes(), raw=True)
+        node0 = helper.make_node('Constant', inputs=[], outputs=["value0"], value=tensor_1)
+        node1 = helper.make_node('Constant', inputs=[], outputs=["value1"], value=tensor_2)
+        node2 = helper.make_node('Constant', inputs=[], outputs=["value2"], value=tensor_3)
+        node3 = helper.make_node('Constant', inputs=[], outputs=["value3"], value=tensor_4)
+        node4 = helper.make_node("Mul", ["value0", "value1"], ["output1"])
+        node5 = helper.make_node("Mul", ["value2", "output1"], ["output2"])
+        node6 = helper.make_node("Mul", ["value3", "output2"], ["OUT"])
+
+        graph = helper.make_graph(
+            [node0, node1, node2, node3, node4, node5, node6],
+            "test_duplicated_duplicated_constant",
+            [],
+            [helper.make_tensor_value_info("OUT", TensorProto.FLOAT, (3,))],
+        )
+
+        imp = OperatorSetIdProto()
+        imp.version = self.config.opset
+
+        model_proto = helper.make_model(graph, producer_name="onnx-tests", opset_imports=[imp])
+        self.run_merge_duplicated_nodes_compare(["OUT"], {}, model_proto,
+                                                op_type="Constant", remaining_op_num=1)
+
     def test_duplicated_node_is_graph_output(self):
         node0 = helper.make_node('Add', inputs=["X", "X"], outputs=["value0"])
         node1 = helper.make_node('Add', inputs=["X", "X"], outputs=["value1"])

tf2onnx/optimizer/merge_duplicated_nodes_optimizer.py

@@ -9,6 +9,8 @@
 
 from collections import defaultdict, namedtuple
 
+import numpy as np
+
 from .optimizer_base import GraphOptimizerBase
 
 # pylint: disable=logging-not-lazy,unused-argument,missing-docstring
@@ -59,14 +61,25 @@ def _del_nodes_if_duplicated(self, nodes_group, graph):
             unprocessed_node = []
             nodes_to_process = [nodes_group[0]]
             for node in nodes_group[1:]:
-                if node.attr == nodes_to_process[0].attr:
+                if self._have_equal_attr(node, nodes_to_process[0]):
                     nodes_to_process.append(node)
                 else:
                     unprocessed_node.append(node)
 
             self._merge_nodes_that_are_duplicated(nodes_to_process, graph)
             nodes_group = unprocessed_node
 
+    def _have_equal_attr(self, node_1, node_2):
+        if node_1.attr == node_2.attr:
+            return True
+        if node_1.is_const() and node_2.is_const():
+            const_1 = node_1.get_tensor_value(as_list=False)
+            const_2 = node_2.get_tensor_value(as_list=False)
+            if const_1.dtype == const_2.dtype and \
+                    np.array_equal(const_1, const_2):
+                return True
+        return False
+
     def _merge_nodes_that_are_duplicated(self, nodes_to_process, graph):
         # node's output may not all be used, so have to select the one that uses most of node's outputs
         nodes_to_process.sort(key=self._len_of_node_output, reverse=True)