add onnx package version check, skip onnx attr check for unknown op

Author: nbcsm

tf2onnx/convert.py

@@ -80,7 +80,7 @@ def main():
 
     opset = utils.find_opset(args.opset)
     print("using tensorflow={}, onnx={}, opset={}, tfonnx={}/{}".format(
-        tf.__version__, onnx.__version__, opset,
+        tf.__version__, utils.get_onnx_version(), opset,
         tf2onnx.__version__, tf2onnx.version.git_version[:6]))
 
     # override unknown dimensions from -1 to 1 (aka batchsize 1) since not every runtime does

tf2onnx/graph.py

@@ -11,6 +11,7 @@
 
 import collections
 import copy
+import logging
 import sys
 import traceback
 import six
@@ -22,6 +23,9 @@
 from tf2onnx.optimizer import IdentityOptimizer, TransposeOptimizer
 from tf2onnx.schemas import get_schema
 
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger("graph")
+
 
 # todo(pengwa): remove protected-access later
 # pylint: disable=broad-except,protected-access
@@ -83,12 +87,15 @@ def attr(self):
 
     @property
     def attr_onnx(self):
+        schema = get_schema(self.type, self.graph.opset, self.domain)
+        if schema is None and not (self.is_const() or self.is_graph_input()):
+            log.warning("Node %s uses non-stardard onnx op <%s, %s>, skip attribute check", self.name, self.domain,
+                        self.type)
+
         onnx_attrs = {}
         for a in self._attr.values():
-            schema = get_schema(self.type, self.graph.opset)
-            if schema:
-                if schema.has_attribute(a.name):
-                    onnx_attrs[a.name] = a
+            if schema is None or schema.has_attribute(a.name):
+                onnx_attrs[a.name] = a
         return onnx_attrs
 
     @property
@@ -1054,7 +1061,7 @@ def optimize_graph(graph, doc_string, optimize=None, debug=False):
         try:
             opts = [TransposeOptimizer(graph, output_names=graph.outputs, debug=debug),
                     IdentityOptimizer(graph, output_names=graph.outputs, debug=debug)
-                   ]
+                    ]
             for opt in opts:
                 opt.optimize()
             model_proto = graph.make_model(doc_string, optimize=optimize)
@@ -1080,7 +1087,7 @@ def optimize_graph_with_model_proto(onnx_model_proto, debug=False):
 
             opts = [TransposeOptimizer(g, output_names=g.outputs, debug=debug),
                     IdentityOptimizer(g, output_names=g.outputs, debug=debug)
-                   ]
+                    ]
             for opt in opts:
                 opt.optimize()
 

tf2onnx/schemas.py

@@ -12,7 +12,6 @@
 from collections import defaultdict, OrderedDict
 from onnx import defs
 
-
 ONNX_DOMAIN = ""
 
 
@@ -77,16 +76,39 @@ def _register_all_schemas_with_history():
     return ordered_map
 
 
+def _parse_domain_opset_versions(schemas):
+    """ Get max opset version among all schemas within each domain. """
+    domain_opset_versions = dict()
+    for domain_version_schema_map in schemas.values():
+        for domain, version_schema_map in domain_version_schema_map.items():
+            # version_schema_map is sorted by since_version in descend order
+            max_version = next(iter(version_schema_map))
+            if domain not in domain_opset_versions:
+                domain_opset_versions[domain] = int(max_version)
+            else:
+                domain_opset_versions[domain] = max(domain_opset_versions[domain], int(max_version))
+    return domain_opset_versions
+
+
 # format is <OpName, <Domain, <SinceVersion, OpSchema>>>
 # SinceVersion is sorted from high to low
 _schemas = _register_all_schemas_with_history()
 
+_domain_opset_versions = _parse_domain_opset_versions(_schemas)
+
 
 def get_schema(name, max_inclusive_opset_version, domain=ONNX_DOMAIN):
     """Get schema by name within specific version."""
+    domain = domain or ONNX_DOMAIN
     domain_version_schema_map = _schemas[name]
     version_schema_map = domain_version_schema_map[domain]
     for version, schema in version_schema_map.items():
         if version <= max_inclusive_opset_version:
             return schema
     return None
+
+
+def get_max_supported_opset_version(domain=ONNX_DOMAIN):
+    """Get max supported opset version by current onnx package given a domain."""
+    domain = domain or ONNX_DOMAIN
+    return _domain_opset_versions.get(domain, None)

tf2onnx/tfonnx.py

@@ -20,7 +20,7 @@
 from tensorflow.tools.graph_transforms import TransformGraph
 
 import tf2onnx
-from tf2onnx import utils
+from tf2onnx import schemas, utils
 from tf2onnx.function import *  # pylint: disable=wildcard-import
 from tf2onnx.graph import Graph
 from tf2onnx.graph_matcher import OpTypePattern, GraphMatcher
@@ -1461,6 +1461,7 @@ def reverse_op8(ctx, node, name, args):
     node.input[0] = node.input[1]
     node.input[1] = tmp
 
+
 def reverse_op9(ctx, node, name, args):
     # T output = ReverseSequence(T input, int32|int64 seq_lengths, @int seq_dim, @int batch_dim)
     # we cannot easily construct reverse_sequence equivalence in opset 9, so we will not support it
@@ -1649,6 +1650,7 @@ def logical_compare_op(ctx, node, name, args):
                 ctx.copy_shape(inp, inp_cast.output[0])
                 ctx.set_dtype(inp_cast.output[0], target_dtype)
 
+
 def logical_compareeq_op(ctx, node, name, args):
     logical_compare_op(ctx, node, name, [])
     output_name = node.output[0]
@@ -2400,6 +2402,11 @@ def process_tf_graph(tf_graph, continue_on_error=False, verbose=False, target=No
         Return:
             onnx graph
     """
+    if opset > schemas.get_max_supported_opset_version():
+        log.warning("currently installed onnx package %s is too low to support opset %s, "
+                    "please upgrade onnx package to avoid potential conversion issue.",
+                    utils.get_onnx_version(), opset)
+
     if shape_override is None:
         shape_override = {}
     if inputs_as_nchw is None:

tf2onnx/utils.py

@@ -18,6 +18,7 @@
 import tensorflow as tf
 from tensorflow.core.framework import types_pb2, tensor_pb2
 from google.protobuf import text_format
+import onnx
 from onnx import helper, onnx_pb, defs, numpy_helper
 
 #
@@ -74,13 +75,15 @@
     onnx_pb.TensorProto.BOOL: "bool"
 }
 
+
 class TensorValueInfo(object):
     def __init__(self, tensor_id, g):
         self.id = tensor_id
         if self.id:
             self.dtype = g.get_dtype(tensor_id)
             self.shape = g.get_shape(tensor_id)
 
+
 ONNX_UNKNOWN_DIMENSION = -1
 
 # index for internally generated names
@@ -409,3 +412,7 @@ def are_shapes_equal(src, dest):
 def create_vague_shape_like(shape):
     make_sure(len(shape) >= 0, "rank should be >= 0")
     return [-1 for i in enumerate(shape)]
+
+
+def get_onnx_version():
+    return onnx.__version__