onnx 1.13.1__cp37-cp37m-win_amd64.whl → 1.14.1__cp37-cp37m-win_amd64.whl

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,13 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- */
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
 
 #include "onnx/shape_inference/implementation.h"
+#include <algorithm>
 #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 +42,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 +52,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;
   }
@@ -339,6 +341,56 @@ class ShapeInferenceImplBase {
     }
   }
 
+  // Initialize a DataValueMap for a called function from the DataValueMap of the caller
+  void bindValuesOnCall(
+      const DataValueMap& caller_map,
+      const NodeProto& caller,
+      DataValueMap& callee_map,
+      const FunctionProto& callee) {
+    auto num_inputs = (std::min)(caller.input_size(), callee.input_size());
+    for (int i = 0; i < num_inputs; ++i) {
+      const std::string& actual = caller.input(i);
+      const std::string& formal = callee.input(i);
+      if (!actual.empty()) {
+        auto it = caller_map.find(actual);
+        if (it != caller_map.end()) {
+          callee_map[formal] = it->second;
+        }
+      }
+    }
+  }
+
+  // Update a DataValueMap for a calling function from the DataValueMap of the callee
+  void bindValuesOnReturn(
+      const DataValueMap& callee_map,
+      const FunctionProto& callee,
+      DataValueMap& caller_map,
+      const NodeProto& caller) {
+    auto num_outputs = (std::min)(caller.output_size(), callee.output_size());
+    for (int i = 0; i < num_outputs; ++i) {
+      const std::string& actual = caller.output(i);
+      const std::string& formal = callee.output(i);
+      if (!actual.empty()) {
+        auto it = callee_map.find(formal);
+        if (it != callee_map.end()) {
+          caller_map[actual] = it->second;
+        }
+      }
+    }
+  }
+
+  void processCall(const NodeProto& caller, const FunctionProto& callee, InferenceContext& ctx) {
+    DataValueMap callee_value_map;
+    if (generated_shape_data_by_name != nullptr) {
+      bindValuesOnCall(*generated_shape_data_by_name, caller, callee_value_map, callee);
+    }
+    InferShapeForFunctionNode(
+        callee, schema_registry, ctx, options, model_local_functions_map, symbol_table, &callee_value_map);
+    if (generated_shape_data_by_name != nullptr) {
+      bindValuesOnReturn(callee_value_map, callee, *generated_shape_data_by_name, caller);
+    }
+  }
+
   void process(NodeProto& n) {
     // Resolve domain for node
     auto dit = opset_imports.find(n.domain());
@@ -372,14 +424,7 @@ class ShapeInferenceImplBase {
         if (schema->has_type_and_shape_inference_function()) {
           schema->GetTypeAndShapeInferenceFunction()(ctx);
         } else if (schema->HasFunction()) {
-          InferShapeForFunctionNode(
-              *(schema->GetFunction()),
-              schema_registry,
-              ctx,
-              options,
-              model_local_functions_map,
-              symbol_table,
-              generated_shape_data_by_name);
+          processCall(n, *(schema->GetFunction()), ctx);
         } else {
           // Continue with inference for remaining nodes
           return;
@@ -387,14 +432,7 @@ class ShapeInferenceImplBase {
       } else if (model_local_functions_map.size() > 0) {
         auto iter = model_local_functions_map.find(GetModelLocalFunctionsMapIdentifier(n.domain(), n.op_type()));
         if (iter != model_local_functions_map.end()) {
-          InferShapeForFunctionNode(
-              *(iter->second),
-              schema_registry,
-              ctx,
-              options,
-              model_local_functions_map,
-              symbol_table,
-              generated_shape_data_by_name);
+          processCall(n, *(iter->second), ctx);
         } else {
           has_unsupported_op = true;
           return;
@@ -521,7 +559,7 @@ class ShapeInferenceImplBase {
     }
   }
 
-  void replaceAttrRefs(NodeProto& n, std::unordered_map<std::string, const AttributeProto*> attr_map) {
+  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;
@@ -550,13 +588,13 @@ class ShapeInferenceImplBase {
     }
   }
 
-  void replaceAttrRefs(GraphProto& graph, std::unordered_map<std::string, const AttributeProto*> attr_map) {
+  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, std::unordered_map<std::string, const AttributeProto*> 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);
@@ -568,23 +606,31 @@ class ShapeInferenceImplBase {
     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);
-      } else if (type->value_case() == TypeProto::kSparseTensorType && ctx.getInputSparseData(i) != nullptr) {
-        input_sparse_data_by_name[func_proto.input().Get(i)] = ctx.getInputSparseData(i);
+      if (type != nullptr) {
+        if (type->value_case() == TypeProto::kTensorType && ctx.getInputData(i) != nullptr) {
+          input_data_by_name[func_proto.input().Get(i)] = ctx.getInputData(i);
+        } else if (type->value_case() == TypeProto::kSparseTensorType && ctx.getInputSparseData(i) != nullptr) {
+          input_sparse_data_by_name[func_proto.input().Get(i)] = ctx.getInputSparseData(i);
+        }
       }
     }
 
@@ -595,6 +641,12 @@ class ShapeInferenceImplBase {
       }
     }
 
+    for (auto& default_value : func_proto.attribute_proto()) {
+      const std::string& name = default_value.name();
+      const AttributeProto* value = ctx.getAttribute(name);
+      attr_map[name] = (value != nullptr) ? value : &default_value;
+    }
+
     for (auto& n : func_proto.node()) {
       process(n, attr_map);
     }
@@ -623,7 +675,7 @@ class ShapeInferenceImplBase {
       SymbolTable* symbol_table_in,
       const ModelLocalFunctionsMap& model_local_functions_map_in,
       const ISchemaRegistry* schema_registry_in = OpSchemaRegistry::Instance(),
-      std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name_in = nullptr,
+      DataValueMap* generated_shape_data_by_name_in = nullptr,
       const int ir_version_in = IR_VERSION // default the latest one
       )
       : g(*g_in),
@@ -649,6 +701,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;
@@ -658,7 +714,7 @@ class ShapeInferenceImplBase {
   SymbolTable* symbol_table;
   const ModelLocalFunctionsMap& model_local_functions_map;
   const ISchemaRegistry* schema_registry;
-  std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name;
+  DataValueMap* generated_shape_data_by_name;
   int ir_version;
   GraphInferenceContext graph_inference_context;
 
@@ -687,10 +743,10 @@ static void InferShapesImpl(
     SymbolTable* symbol_table,
     const ModelLocalFunctionsMap& model_local_functions_map,
     const ISchemaRegistry* schema_registry = OpSchemaRegistry::Instance(),
-    std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name = nullptr,
+    DataValueMap* generated_shape_data_by_name = nullptr,
     const int ir_version = IR_VERSION // default the latest one
 ) {
-  std::unordered_map<std::string, TensorShapeProto> empty;
+  DataValueMap empty;
   if (generated_shape_data_by_name == nullptr) {
     generated_shape_data_by_name = &empty;
   }
@@ -738,7 +794,7 @@ void InferShapes(
     ModelProto& m,
     const ISchemaRegistry* schema_registry,
     const ShapeInferenceOptions& options,
-    std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name) {
+    DataValueMap* generated_shape_data_by_name) {
   auto opset_imports = GetOpsetImportsFromProto(m);
   SymbolTableImpl symbol_table;
   ModelLocalFunctionsMap model_local_functions_by_id;
@@ -763,7 +819,7 @@ void InferShapes(
     const std::string& save_path,
     const ISchemaRegistry* schema_registry,
     const ShapeInferenceOptions& options,
-    std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name) {
+    DataValueMap* generated_shape_data_by_name) {
   ModelProto model;
   LoadProtoFromPath(model_path, model);
   InferShapes(model, schema_registry, options, generated_shape_data_by_name);
@@ -789,7 +845,7 @@ void InferShapeForFunctionNode(
     const ShapeInferenceOptions& options,
     const std::unordered_map<std::string, const FunctionProto*>& model_local_functions_map,
     SymbolTable* symbol_table,
-    std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name) {
+    DataValueMap* generated_shape_data_by_name) {
   GraphProto g;
   ShapeInferenceImplBase base(
       &g,
@@ -810,7 +866,7 @@ void InferShapeForFunctionNode(
     const ShapeInferenceOptions& options,
     const std::unordered_map<std::string, const FunctionProto*>& model_local_functions_map,
     SymbolTable* symbol_table,
-    std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name) {
+    DataValueMap* generated_shape_data_by_name) {
   auto opset_imports = GetOpsetImportsFromProto(function_proto);
   InferShapeForFunctionNode(
       function_proto,
@@ -823,6 +879,111 @@ 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 {
+    // We should return nullptr for missing optional parameters.
+    // An uninitialized TypeProto() is used for missing optional parameters, and
+    // is mapped to a nullptr here.
+    if (index >= input_types_.size())
+      return nullptr;
+    if (input_types_[index].value_case() == TypeProto::ValueCase::VALUE_NOT_SET)
+      return nullptr;
+    return &input_types_[index];
+  }
+
+  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) {
@@ -904,7 +1065,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();
 }