onnx 1.13.0__cp311-cp311-macosx_10_12_universal2.whl → 1.14.0__cp311-cp311-macosx_10_12_universal2.whl

onnx/reference/ops/op_unsqueeze.py

@@ -1,9 +1,10 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=E0203,W0221
 
 import numpy as np
 
-from onnx.defs import onnx_opset_version
 from onnx.reference.op_run import OpRun
 
 
@@ -51,11 +52,3 @@ class Unsqueeze_13(OpRun):
                 "axes cannot be None for operator Unsqueeze (Unsqueeze_13)."
             )
         return (sq,)
-
-
-if onnx_opset_version() >= 13:
-    Unsqueeze = Unsqueeze_13
-elif onnx_opset_version() >= 11:
-    Unsqueeze = Unsqueeze_11  # type: ignore
-else:
-    Unsqueeze = Unsqueeze_1  # type: ignore

onnx/reference/ops/op_upsample.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221,R0913
 
@@ -8,12 +10,11 @@ from onnx.reference.op_run import OpRun
 
 class Upsample(OpRun):
     def _run(self, x, scale, mode=None):  # type: ignore
-        if mode == "nearest":
-            if scale.astype(np.int64).tolist() == scale.tolist():
-                r = x
-                for axis, s in enumerate(scale):
-                    if s == 1:
-                        continue
-                    r = np.repeat(r, int(s), axis=axis)
-                return (r,)
+        if mode == "nearest" and scale.astype(np.int64).tolist() == scale.tolist():
+            r = x
+            for axis, s in enumerate(scale):
+                if s == 1:
+                    continue
+                r = np.repeat(r, int(s), axis=axis)
+            return (r,)
         raise RuntimeError(f"Not implemented for mode={mode!r} and scale={scale!r}.")

onnx/reference/ops/op_where.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -8,7 +10,11 @@ from onnx.reference.op_run import OpRun
 
 class Where(OpRun):
     def _run(self, condition, x, y):  # type: ignore
-        if x.dtype != y.dtype and x.dtype not in (np.object_,):
+        if (
+            x.dtype != y.dtype
+            and x.dtype not in (object,)
+            and not (x.dtype.type is np.str_ and y.dtype.type is np.str_)
+        ):
             raise RuntimeError(
                 f"x and y should share the same dtype {x.dtype} != {y.dtype}"
             )

onnx/reference/ops/op_xor.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunBinary
+from onnx.reference.ops._op import OpRunBinary
 
 
 class Xor(OpRunBinary):

onnx/reference/reference_evaluator.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=C0415,R0902,R0912,R0913,R0914,R0915
 from io import BytesIO
@@ -8,9 +10,7 @@ import numpy as np
 from onnx import load, numpy_helper
 from onnx.defs import onnx_opset_version
 from onnx.onnx_pb import FunctionProto, GraphProto, ModelProto, NodeProto, TypeProto
-from onnx.shape_inference import infer_shapes
-
-from .op_run import OpRun, RuntimeContextError
+from onnx.reference.op_run import OpRun, RuntimeContextError
 
 
 class ReferenceEvaluator:
@@ -126,6 +126,32 @@ class ReferenceEvaluator:
         x = np.array([[0, 1], [-1, 2]], dtype=np.float32)
         y = Celu.eval(x, alpha=0.5)
         print(y)
+
+    It is possible to overwrite an existing operator.
+    The class name must be the same. The domain does not have
+    to be specified for the default domain. However, by default,
+    class `OpRun` will load the most recent for this operator.
+    It can be explicirely specified by adding static attribute
+    `op_schema` of type :class:`OpSchema
+    <onnx.onnx_cpp2py_export.defs.OpSchema>`.
+
+    ::
+
+        from onnx.reference.op_run.op_conv import Conv as _Conv
+
+        class Conv(_Conv):
+
+            op_schema = instance_of_OpSchema()
+
+            def _run(self, ...):
+                ...
+
+        An operator may be different in a later opset. In that case,
+        a new implementation needs to be registered. `Pad_11`, `Pad_18`.
+        `Pad_11` is the implementation chose for opset in [11, 17].
+        `Pad_18` is selected for any greater opset. Both classes must be
+        imported into file `_op_list.py` to register their existence to the
+        runtime.
     """
 
     def __init__(  # type: ignore
@@ -153,7 +179,7 @@ class ReferenceEvaluator:
                 raise ValueError("opsets must be None if proto is ModelProto.")
             if functions is not None:
                 raise ValueError("functions must be None if proto is ModelProto.")
-            functions = proto.functions
+            functions = proto.functions  # type: ignore[assignment]
         elif isinstance(proto, GraphProto):
             self.onnx_graph_ = proto
             if not isinstance(opsets, dict):
@@ -191,7 +217,7 @@ class ReferenceEvaluator:
             self.output_names_ = list(proto.output)
             self.inits_ = []
             if isinstance(proto, NodeProto):
-                self.nodes_ = [proto]
+                self.nodes_ = [proto]  # type: ignore[assignment]
             else:
                 self.nodes_ = proto.node
         if functions is not None:
@@ -211,12 +237,10 @@ class ReferenceEvaluator:
         if new_ops is not None:
             for cl in new_ops:
                 if not issubclass(cl, OpRun):  # type: ignore
-                    raise TypeError(
-                        f"Class {type(cl)} must inherit from OpRun (in new_ops)."
-                    )
+                    raise TypeError(f"Class {cl} must inherit from OpRun (in new_ops).")
                 if not hasattr(cl, "op_domain"):
                     raise AttributeError(
-                        f"Class {type(cl)} must define attribute 'op_domain'."
+                        f"Class {cl} must define attribute 'op_domain'."
                     )
                 key = cl.op_domain, cl.__name__  # type: ignore
                 if key in self.new_ops_:
@@ -271,6 +295,14 @@ class ReferenceEvaluator:
         "Returns the opsets."
         return self.opsets_
 
+    @property
+    def has_linked_attribute(self):
+        """
+        Checks if the graph has a linked attribute (= an attribute whose value is defined
+        by a function attribute.
+        """
+        return any(node.has_linked_attribute for node in self.rt_nodes_)
+
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({', '.join(self.input_names)}) -> {', '.join(self.output_names)}"
 
@@ -292,11 +324,12 @@ class ReferenceEvaluator:
         self.rt_inits_ = {}
         self.rt_nodes_ = []
         for init in self.inits_:
-            self.rt_inits_[init.name] = numpy_helper.to_array(init)
+            self.rt_inits_[init.name] = numpy_helper.to_array(init)  # type: ignore[union-attr,arg-type]
         run_params = {
             "log": lambda pattern, *args: self._log(10, pattern, *args),
             "opsets": self.opsets,
             "verbose": self.verbose,
+            "new_ops": self.new_ops_,
         }
         if self.input_types_:
             all_types = {i.name: i.type for i in self.onnx_graph_.input}
@@ -322,7 +355,13 @@ class ReferenceEvaluator:
                         f"If this node has a context dependent implementation, you should run function infer_shapes "
                         f"before calling ReferenceEvaluator."
                     ) from e
-            inst = cl(node, run_params)
+            try:
+                inst = cl(node, run_params)
+            except TypeError as e:
+                raise TypeError(
+                    f"Unable to instantiate class {cl!r} with "
+                    f"run_params={run_params} and node={node}."
+                ) from e
             self.rt_nodes_.append(inst)
 
     def _load_impl(
@@ -345,7 +384,7 @@ class ReferenceEvaluator:
             return self.new_ops_[key]
 
         if node.domain == "":
-            from .ops import load_op
+            from onnx.reference.ops import load_op
 
             try:
                 return load_op(node.domain, node.op_type, version)
@@ -357,22 +396,27 @@ class ReferenceEvaluator:
                     node.op_type,
                     version,
                     node=node,
-                    input_types=input_types,
+                    input_types=input_types,  # type: ignore[arg-type]
                 )
 
         if node.domain == "ai.onnx.preview.training":
-            from .ops.aionnx_preview_training import load_op as load_op_pt
+            from onnx.reference.ops.aionnx_preview_training import load_op as load_op_pt
 
             return load_op_pt(node.domain, node.op_type, version)
 
         if node.domain == "experimental":
-            from .ops.experimental import load_op as load_op_exp
+            from onnx.reference.ops.experimental import load_op as load_op_exp
 
             return load_op_exp(node.domain, node.op_type, version)
 
+        if node.domain == "ai.onnx.ml":
+            from onnx.reference.ops.aionnxml import load_op as load_op_ml
+
+            return load_op_ml(node.domain, node.op_type, version)
+
         # It has to be a function.
         if key in self.functions_:
-            from .ops import load_op
+            from onnx.reference.ops import load_op
 
             impl = self.functions_[key]
             return load_op(node.domain, node.op_type, version, custom=impl)
@@ -398,12 +442,12 @@ class ReferenceEvaluator:
 
         # step 1: inputs and initializers
         results = {"": None}  # optional input
-        results.update(self.rt_inits_)
+        results.update(self.rt_inits_)  # type: ignore[arg-type]
         results.update(feed_inputs)
         for k, v in self.rt_inits_.items():
-            self._log(2, " +C %s: %s", k, v)
+            self._log(2, " +C %s: %s", k, v)  # type: ignore[arg-type]
         for k, v in feed_inputs.items():
-            self._log(2, " +I %s: %s", k, v)
+            self._log(2, " +I %s: %s", k, v)  # type: ignore[arg-type]
 
         # step 2: execute nodes
         for node in self.rt_nodes_:
@@ -421,7 +465,7 @@ class ReferenceEvaluator:
                     raise TypeError(
                         f"Unexected type {type(value)} for output {name!r}."
                     )
-                self._log(2, " + %s: %s", name, value)
+                self._log(2, " + %s: %s", name, value)  # type: ignore[arg-type]
                 results[name] = value
 
         # return the results

onnx/shape_inference/implementation.cc

@@ -1,11 +1,12 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- */
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
 
 #include "onnx/shape_inference/implementation.h"
 #include <fstream>
 #include <list>
 #include "onnx/checker.h"
+#include "onnx/common/common.h"
 #include "onnx/common/file_utils.h"
 #include "onnx/defs/data_type_utils.h"
 #include "onnx/proto_utils.h"
@@ -40,7 +41,7 @@ std::string GetValueCaseString(const TypeProto& type) {
 
 std::string GetElemTypeString(const TypeProto_Tensor& type) {
 #ifndef ONNX_USE_LITE_PROTO
-  const std::string type_str = TensorProto::DataType_Name(static_cast<TensorProto_DataType>(type.elem_type()));
+  std::string type_str = TensorProto::DataType_Name(static_cast<TensorProto_DataType>(type.elem_type()));
   if (!type_str.empty()) {
     return type_str;
   }
@@ -50,7 +51,7 @@ std::string GetElemTypeString(const TypeProto_Tensor& type) {
 
 std::string GetElemTypeString(const TypeProto_SparseTensor& type) {
 #ifndef ONNX_USE_LITE_PROTO
-  const std::string type_str = TensorProto::DataType_Name(static_cast<TensorProto_DataType>(type.elem_type()));
+  std::string type_str = TensorProto::DataType_Name(static_cast<TensorProto_DataType>(type.elem_type()));
   if (!type_str.empty()) {
     return type_str;
   }
@@ -284,21 +285,56 @@ class ShapeInferenceImplBase {
     }
   }
 
+  template <typename T>
+  void addTemporaryConstant(const std::string& name, const T& vector) {
+    input_data_by_name_holder[name] = ToTensor(vector);
+    input_data_by_name[name] = &input_data_by_name_holder[name];
+  }
+
   void preprocess(const NodeProto& n) {
     if (checker::check_is_experimental_op(n)) {
       has_experimental_op = true;
     } else if (n.op_type() == "Constant" && n.output().size() == 1) {
+      const std::string& output_name = n.output(0);
       for (const auto& attr : n.attribute()) {
         if (attr.name() == "value") {
           if (attr.type() == AttributeProto::TENSOR && attr.has_t()) {
-            input_data_by_name[n.output(0)] = &attr.t();
+            if (reuse_constant_tensors) {
+              input_data_by_name[output_name] = &attr.t();
+            } else {
+              input_data_by_name_holder[output_name] = attr.t();
+              input_data_by_name[output_name] = &input_data_by_name_holder[output_name];
+            }
           } else if (attr.type() == AttributeProto::SPARSE_TENSOR && attr.has_sparse_tensor()) {
-            input_sparse_data_by_name[n.output(0)] = &attr.sparse_tensor();
+            if (reuse_constant_tensors) {
+              input_sparse_data_by_name[output_name] = &attr.sparse_tensor();
+            }
+          }
+        } else {
+          switch (attr.type()) {
+            case AttributeProto::INTS: {
+              std::vector<int64_t> ints{attr.ints().begin(), attr.ints().end()};
+              addTemporaryConstant(output_name, ints);
+              break;
+            }
+            case AttributeProto::INT: {
+              std::vector<int64_t> ints({attr.i()});
+              addTemporaryConstant(output_name, ints);
+              break;
+            }
+            case AttributeProto::FLOATS: {
+              std::vector<float> floats{attr.floats().begin(), attr.floats().end()};
+              addTemporaryConstant(output_name, floats);
+              break;
+            }
+            case AttributeProto::FLOAT: {
+              std::vector<float> floats({attr.f()});
+              addTemporaryConstant(output_name, floats);
+              break;
+            }
+            default:
+              break;
           }
-        } else if (attr.type() == AttributeProto::INTS && attr.name() == "value_ints") {
-          std::vector<int64_t> ints{attr.ints().begin(), attr.ints().end()};
-          input_data_by_name_holder[n.output(0)] = ToTensor(ints);
-          input_data_by_name[n.output(0)] = &input_data_by_name_holder[n.output(0)];
         }
       }
     }
@@ -486,38 +522,71 @@ class ShapeInferenceImplBase {
     }
   }
 
-  void process(const NodeProto& n, std::unordered_map<std::string, const AttributeProto*> attr_map) {
-    NodeProto copy_n(n);
-    // Add attribute information into the temporary node
-    copy_n.clear_attribute();
-    for (const auto& attr : n.attribute()) {
-      if (attr.has_ref_attr_name()) {
-        if (attr_map.count(attr.ref_attr_name())) {
-          auto copy_attr = *attr_map[attr.ref_attr_name()];
-          copy_attr.set_name(attr.name());
-          copy_n.add_attribute()->CopyFrom(copy_attr);
+  void replaceAttrRefs(NodeProto& n, const std::unordered_map<std::string, const AttributeProto*>& attr_map) {
+    auto& attributes = *n.mutable_attribute();
+    for (auto attr_iter = attributes.begin(); attr_iter != attributes.end();) {
+      auto& attr = *attr_iter;
+      if (!attr.ref_attr_name().empty()) {
+        // Attribute-references must be replaced by the corresponding attribute-value in the call-node
+        // if the call-node contains the attribute. Otherwise, this attribute must be removed.
+        auto entry = attr_map.find(attr.ref_attr_name());
+        if (entry != attr_map.cend()) {
+          // Copy value of attribute, but retain original name:
+          std::string name = attr.name();
+          attr = *(entry->second);
+          attr.set_name(name);
+        } else {
+          attr_iter = attributes.erase(attr_iter);
+          continue;
         }
-      } else {
-        copy_n.add_attribute()->CopyFrom(attr);
       }
+      // Subgraphs must be recursively processed.
+      if (attr.has_g()) {
+        replaceAttrRefs(*attr.mutable_g(), attr_map);
+      }
+      for (auto& graph : *attr.mutable_graphs()) {
+        replaceAttrRefs(graph, attr_map);
+      }
+      ++attr_iter;
+    }
+  }
+
+  void replaceAttrRefs(GraphProto& graph, const std::unordered_map<std::string, const AttributeProto*>& attr_map) {
+    for (auto& n : *graph.mutable_node()) {
+      replaceAttrRefs(n, attr_map);
     }
+  }
+
+  void process(const NodeProto& n, const std::unordered_map<std::string, const AttributeProto*>& attr_map) {
+    NodeProto copy_n(n);
+    replaceAttrRefs(copy_n, attr_map);
     process(copy_n);
   }
 
   void process(const FunctionProto& func_proto, InferenceContext& ctx) {
+    // Ensure Constant node tensor-attributes are copied
+    bool old_reuse_constant_tensors = reuse_constant_tensors;
+    reuse_constant_tensors = false;
+
     // Get a temporary tensor-shape map
+    const int num_actual_inputs = static_cast<int>(ctx.getNumInputs());
     const auto num_func_inputs = func_proto.input_size();
     std::vector<TypeProto> types_cache(num_func_inputs);
     for (int i = 0; i < num_func_inputs; ++i) {
-      if (ctx.getInputType(i) == nullptr) {
-        fail_type_inference("Input ", i, " type is missing.");
-      }
-      types_cache[i] = *ctx.getInputType(i); // TODO: investigate whether we can remove cache
-      value_types_by_name[func_proto.input().Get(i)] = &types_cache[i];
+      auto& parameter_name = func_proto.input().Get(i);
+      auto* type_ptr = (i < num_actual_inputs) ? ctx.getInputType(i) : nullptr;
+      // nullptr is valid, and indicates a missing optional input
+      if (type_ptr != nullptr) {
+        // Use a temporary copy of original type.
+        // TODO: investigate whether we can eliminate use of temporary copy
+        types_cache[i] = *type_ptr;
+        value_types_by_name[parameter_name] = &types_cache[i];
+      } else
+        value_types_by_name[parameter_name] = nullptr;
     }
 
     // Create a temporary initializer value map
-    for (int i = 0; i < static_cast<int>(ctx.getNumInputs()) && i < num_func_inputs; ++i) {
+    for (int i = 0; i < num_actual_inputs && i < num_func_inputs; ++i) {
       const TypeProto* type = ctx.getInputType(i);
       if (type->value_case() == TypeProto::kTensorType && ctx.getInputData(i) != nullptr) {
         input_data_by_name[func_proto.input().Get(i)] = ctx.getInputData(i);
@@ -548,6 +617,8 @@ class ShapeInferenceImplBase {
         type_proto->CopyFrom(*(iter->second));
       }
     }
+
+    reuse_constant_tensors = old_reuse_constant_tensors;
   }
 
  public:
@@ -585,6 +656,10 @@ class ShapeInferenceImplBase {
     }
   }
 
+  const std::vector<std::string>& getErrors() const {
+    return inference_errors;
+  }
+
  private:
   GraphProto& g;
   std::unordered_map<std::string, TypeProto*> value_types_by_name;
@@ -609,6 +684,10 @@ class ShapeInferenceImplBase {
   std::vector<std::string> inference_errors;
 
   std::list<TypeProto> initializer_type_list;
+
+  // reuse_constant_tensors: controls whether we need to copy tensors occurring as attributes
+  // in Constant nodes. We avoid it for inference for graphs, but must make a copy for functions.
+  bool reuse_constant_tensors = true;
 };
 
 static void InferShapesImpl(
@@ -755,6 +834,104 @@ void InferShapeForFunctionNode(
       generated_shape_data_by_name);
 }
 
+struct FunctionInferenceContext : public InferenceContext {
+  FunctionInferenceContext(
+      const FunctionProto& func_proto,
+      const std::vector<TypeProto>& input_types,
+      const std::vector<AttributeProto>& attributes)
+      : input_types_(input_types) {
+    for (const auto& attr : attributes) {
+      attributesByName_[attr.name()] = &attr;
+    }
+    auto num_outputs = func_proto.output_size();
+    for (int i = 0; i < num_outputs; i++) {
+      output_types_.push_back(TypeProto());
+    }
+  }
+
+  const AttributeProto* getAttribute(const std::string& name) const override {
+    auto iter = attributesByName_.find(name);
+    if (iter == attributesByName_.end()) {
+      return nullptr;
+    } else {
+      return iter->second;
+    }
+  }
+  size_t getNumInputs() const override {
+    return input_types_.size();
+  }
+
+  size_t getNumOutputs() const override {
+    return output_types_.size();
+  }
+
+  const TypeProto* getInputType(size_t index) const override {
+    return (index < input_types_.size()) ? &input_types_[index] : nullptr;
+  }
+
+  TypeProto* getOutputType(size_t index) override {
+    return (index < output_types_.size()) ? &output_types_[index] : nullptr;
+  }
+
+  GraphInferencer* getGraphAttributeInferencer(const std::string& attribute_name) override {
+    ONNX_UNUSED_PARAMETER(attribute_name); // This method is unused for function-type-inference.
+    return nullptr;
+  }
+
+  const TensorProto* getInputData(size_t index) const override {
+    ONNX_UNUSED_PARAMETER(index); // This inference doesn't take advantage of statically known input values.
+    return nullptr;
+  }
+
+  const SparseTensorProto* getInputSparseData(size_t index) const override {
+    ONNX_UNUSED_PARAMETER(index); // This inference doesn't take advantage of statically known input values.
+    return nullptr;
+  }
+
+  const TensorShapeProto* getSymbolicInput(size_t index) const override {
+    ONNX_UNUSED_PARAMETER(index); // This inference doesn't take advantage of data-propagation.
+    return nullptr;
+  }
+
+  std::vector<TypeProto> popOutputTypes() {
+    return std::move(output_types_);
+  }
+
+ private:
+  const std::vector<TypeProto>& input_types_;
+  std::vector<TypeProto> output_types_;
+  std::unordered_map<std::string, const AttributeProto*> attributesByName_;
+};
+
+std::vector<TypeProto> InferFunctionOutputTypes(
+    const FunctionProto& function_proto,
+    const std::vector<TypeProto>& input_types,
+    const std::vector<AttributeProto>& attributes) {
+  FunctionInferenceContext ctx(function_proto, input_types, attributes);
+  auto opset_imports = GetOpsetImportsFromProto(function_proto);
+  GraphProto g;
+  ShapeInferenceOptions options{true, 1, false};
+  ShapeInferenceImplBase base(
+      &g,
+      {}, // outer_scope_value_types_by_name
+      opset_imports,
+      options,
+      /*symbol_table*/ nullptr,
+      /*model_local_functions_map*/ {},
+      /*schema_registry*/ OpSchemaRegistry::Instance(),
+      /*generated_shape_data_by_name*/ nullptr);
+  base.process(function_proto, ctx);
+  auto& errors = base.getErrors();
+  if (!errors.empty()) {
+    std::string all_errors = "Inference error(s): ";
+    for (const std::string& error : errors) {
+      all_errors += error + "\n";
+    }
+    fail_shape_inference(all_errors);
+  }
+  return ctx.popOutputTypes();
+}
+
 std::vector<const TypeProto*> GraphInferencerImpl::doInferencing(
     const std::vector<const TypeProto*>& input_types,
     const std::vector<const TensorProto*>& input_data) {
@@ -836,7 +1013,7 @@ std::vector<const TypeProto*> GraphInferencerImpl::doInferencing(
   return graph_output_types;
 }
 
-std::string GetErrorWithNodeInfo(const NodeProto& n, std::runtime_error err) {
+std::string GetErrorWithNodeInfo(const NodeProto& n, const std::runtime_error& err) {
   std::string op_name = n.has_name() ? (", node name: " + n.name()) : "";
   return "(op_type:" + n.op_type() + op_name + "): " + err.what();
 }

onnx/shape_inference/implementation.h

@@ -1,6 +1,6 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- */
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 
@@ -472,7 +472,18 @@ void InferShapeForFunctionNode(
     SymbolTable* symbolTable = nullptr,
     std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name = nullptr);
 
-std::string GetErrorWithNodeInfo(const NodeProto& n, std::runtime_error err);
+///
+/// Apply type-and-shape-inference based checks to a Function body.
+/// Returns the inferred types of the outputs of the function.
+/// Inference depends on the types of the inputs of the function as well as
+/// the attribute values supplied.
+///
+std::vector<TypeProto> InferFunctionOutputTypes(
+    const FunctionProto& func_proto,
+    const std::vector<TypeProto>& input_types,
+    const std::vector<AttributeProto>& attributes);
+
+std::string GetErrorWithNodeInfo(const NodeProto& n, const std::runtime_error& err);
 
 void TraverseGraphsToAddExistingSymbols(const GraphProto& g, SymbolTable& symbolTable);