onnx 1.14.0__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 1.14.1__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

onnx/checker.cc

@@ -151,8 +151,8 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
               "' points outside the directory");
         }
         std::wstring data_path = path_join(utf8str_to_wstring(ctx.get_model_dir()), relative_path);
-        struct _stat buff;
-        if (_wstat(data_path.c_str(), &buff) != 0) {
+        struct _stat64 buff;
+        if (_wstat64(data_path.c_str(), &buff) != 0) {
           fail_check(
               "Data of TensorProto ( tensor name: ",
               tensor.name(),
@@ -183,9 +183,14 @@ void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
               "' points outside the directory");
         }
         std::string data_path = path_join(ctx.get_model_dir(), relative_path);
-        // use stat to check whether the file exists
-        struct stat buffer;
+        // use stat64 to check whether the file exists
+#if defined(__APPLE__) || defined(__wasm__)
+        struct stat buffer; // APPLE does not have stat64
         if (stat((data_path).c_str(), &buffer) != 0) {
+#else
+        struct stat64 buffer; // All POSIX except APPLE have stat64
+        if (stat64((data_path).c_str(), &buffer) != 0) {
+#endif
           fail_check(
               "Data of TensorProto ( tensor name: ",
               tensor.name(),

onnx/common/version.h

@@ -9,6 +9,6 @@
 namespace ONNX_NAMESPACE {
 
 // Represents the most recent release version. Updated with every release.
-constexpr const char* LAST_RELEASE_VERSION = "1.14.0";
+constexpr const char* LAST_RELEASE_VERSION = "1.14.1";
 
 } // namespace ONNX_NAMESPACE

onnx/defs/generator/old.cc

@@ -12,6 +12,116 @@ This operator produces a constant tensor. Exactly one of the provided attributes
 or value_* must be specified.
 )DOC";
 
+void ConstantInference(InferenceContext& ctx) {
+  auto* value = ctx.getAttribute("value");
+  auto* sparse_value = ctx.getAttribute("sparse_value");
+  auto* value_int = ctx.getAttribute("value_int");
+  auto* value_ints = ctx.getAttribute("value_ints");
+  auto* value_float = ctx.getAttribute("value_float");
+  auto* value_floats = ctx.getAttribute("value_floats");
+  auto* value_string = ctx.getAttribute("value_string");
+  auto* value_strings = ctx.getAttribute("value_strings");
+
+  std::vector<bool> non_null_attr = {
+      (nullptr != value),
+      (nullptr != sparse_value),
+      (nullptr != value_int),
+      (nullptr != value_ints),
+      (nullptr != value_float),
+      (nullptr != value_floats),
+      (nullptr != value_string),
+      (nullptr != value_strings)};
+  if (std::count(non_null_attr.begin(), non_null_attr.end(), true) != 1) {
+    fail_shape_inference(
+        "One and only one of the attributes 'value', 'value_*' or 'sparse_value' must be specified for a Constant node.");
+  }
+
+  if (nullptr != value) {
+    // OpSchema::Verify check ensures that the attribute value has_t():
+    const TensorProto& tensor_proto = value->t();
+    updateOutputElemType(ctx, 0, tensor_proto.data_type());
+    updateOutputShape(ctx, 0, tensor_proto);
+    return;
+  }
+
+  if (nullptr != value_int) {
+    // OpSchema::Verify check ensures that the attribute value has_i():
+    if (!value_int->has_i()) {
+      fail_shape_inference("Attribute 'value_int' expect an integer.")
+    }
+    updateOutputElemType(ctx, 0, TensorProto::INT64);
+    updateOutputShape(ctx, 0, TensorShapeProto());
+    return;
+  }
+
+  if (nullptr != value_ints) {
+    // OpSchema::Verify check ensures that the attribute value has ints.
+    if (value_ints->ints_size() < 1) {
+      fail_shape_inference("Attribute 'value_ints' expect a list of integers.");
+    }
+    updateOutputElemType(ctx, 0, TensorProto::INT64);
+    appendDim(getOutputShape(ctx, 0), value_ints->ints_size());
+    return;
+  }
+
+  if (nullptr != value_float) {
+    // OpSchema::Verify check ensures that the attribute value has_i():
+    if (!value_float->has_f()) {
+      fail_shape_inference("Attribute 'value_float' expect a float.");
+    }
+    updateOutputElemType(ctx, 0, TensorProto::FLOAT);
+    updateOutputShape(ctx, 0, TensorShapeProto());
+    return;
+  }
+
+  if (nullptr != value_floats) {
+    // OpSchema::Verify check ensures that the attribute value has ints.
+    if (value_floats->floats_size() < 1) {
+      fail_shape_inference("Attribute 'value_floats' expect a list of floats.");
+    }
+    updateOutputElemType(ctx, 0, TensorProto::FLOAT);
+    appendDim(getOutputShape(ctx, 0), value_floats->floats_size());
+    return;
+  }
+
+  if (nullptr != value_string) {
+    // OpSchema::Verify check ensures that the attribute value has_i():
+    if (!value_string->has_s()) {
+      fail_shape_inference("Attribute 'value_string' expect a string.");
+    }
+    updateOutputElemType(ctx, 0, TensorProto::STRING);
+    updateOutputShape(ctx, 0, TensorShapeProto());
+    return;
+  }
+
+  if (nullptr != value_strings) {
+    // OpSchema::Verify check ensures that the attribute value has ints.
+    if (value_strings->strings_size() < 1) {
+      fail_shape_inference("Attribute 'value_strings' expect a list of strings.");
+    }
+    updateOutputElemType(ctx, 0, TensorProto::STRING);
+    appendDim(getOutputShape(ctx, 0), value_strings->strings_size());
+    return;
+  }
+
+  if (nullptr != sparse_value) {
+    // OpSchema::Verify check ensures that the attribute value
+    // has_sparse_tensor():
+    const SparseTensorProto& sparse = sparse_value->sparse_tensor();
+    // checker.cc::check_sparse_tensor checks that the sparse-value is
+    // well-formed
+    updateOutputElemType(ctx, 0, sparse.values().data_type());
+    auto* output_shape = getOutputShape(ctx, 0);
+    for (int i = 0; i < sparse.dims_size(); ++i)
+      appendDim(output_shape, sparse.dims(i));
+    return;
+  }
+
+  fail_shape_inference(
+      "TypeAndShapeInferenceFunction implementation incomplete: "
+      "this line should never be reached.");
+}
+
 ONNX_OPERATOR_SET_SCHEMA(
     Constant,
     13,
@@ -55,115 +165,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             false)
         .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
         .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
-        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
-          auto* value = ctx.getAttribute("value");
-          auto* sparse_value = ctx.getAttribute("sparse_value");
-          auto* value_int = ctx.getAttribute("value_int");
-          auto* value_ints = ctx.getAttribute("value_ints");
-          auto* value_float = ctx.getAttribute("value_float");
-          auto* value_floats = ctx.getAttribute("value_floats");
-          auto* value_string = ctx.getAttribute("value_string");
-          auto* value_strings = ctx.getAttribute("value_strings");
-
-          std::vector<bool> non_null_attr = {
-              (nullptr != value),
-              (nullptr != sparse_value),
-              (nullptr != value_int),
-              (nullptr != value_ints),
-              (nullptr != value_float),
-              (nullptr != value_floats),
-              (nullptr != value_string),
-              (nullptr != value_strings)};
-          if (std::count(non_null_attr.begin(), non_null_attr.end(), true) != 1) {
-            fail_shape_inference(
-                "One and only one of the attributes 'value', 'value_*' or 'sparse_value' must be specified for a Constant node.");
-          }
-
-          if (nullptr != value) {
-            // OpSchema::Verify check ensures that the attribute value has_t():
-            const TensorProto& tensor_proto = value->t();
-            updateOutputElemType(ctx, 0, tensor_proto.data_type());
-            updateOutputShape(ctx, 0, tensor_proto);
-            return;
-          }
-
-          if (nullptr != value_int) {
-            // OpSchema::Verify check ensures that the attribute value has_i():
-            if (!value_int->has_i()) {
-              fail_shape_inference("Attribute 'value_int' expect an integer.")
-            }
-            updateOutputElemType(ctx, 0, TensorProto::INT64);
-            updateOutputShape(ctx, 0, TensorShapeProto());
-            return;
-          }
-
-          if (nullptr != value_ints) {
-            // OpSchema::Verify check ensures that the attribute value has ints.
-            if (value_ints->ints_size() < 1) {
-              fail_shape_inference("Attribute 'value_ints' expect a list of integers.");
-            }
-            updateOutputElemType(ctx, 0, TensorProto::INT64);
-            appendDim(getOutputShape(ctx, 0), value_ints->ints_size());
-            return;
-          }
-
-          if (nullptr != value_float) {
-            // OpSchema::Verify check ensures that the attribute value has_i():
-            if (!value_float->has_f()) {
-              fail_shape_inference("Attribute 'value_float' expect a float.");
-            }
-            updateOutputElemType(ctx, 0, TensorProto::FLOAT);
-            updateOutputShape(ctx, 0, TensorShapeProto());
-            return;
-          }
-
-          if (nullptr != value_floats) {
-            // OpSchema::Verify check ensures that the attribute value has ints.
-            if (value_floats->floats_size() < 1) {
-              fail_shape_inference("Attribute 'value_floats' expect a list of floats.");
-            }
-            updateOutputElemType(ctx, 0, TensorProto::FLOAT);
-            appendDim(getOutputShape(ctx, 0), value_floats->floats_size());
-            return;
-          }
-
-          if (nullptr != value_string) {
-            // OpSchema::Verify check ensures that the attribute value has_i():
-            if (!value_string->has_s()) {
-              fail_shape_inference("Attribute 'value_string' expect a string.");
-            }
-            updateOutputElemType(ctx, 0, TensorProto::STRING);
-            updateOutputShape(ctx, 0, TensorShapeProto());
-            return;
-          }
-
-          if (nullptr != value_strings) {
-            // OpSchema::Verify check ensures that the attribute value has ints.
-            if (value_strings->strings_size() < 1) {
-              fail_shape_inference("Attribute 'value_strings' expect a list of strings.");
-            }
-            updateOutputElemType(ctx, 0, TensorProto::STRING);
-            appendDim(getOutputShape(ctx, 0), value_strings->strings_size());
-            return;
-          }
-
-          if (nullptr != sparse_value) {
-            // OpSchema::Verify check ensures that the attribute value
-            // has_sparse_tensor():
-            const SparseTensorProto& sparse = sparse_value->sparse_tensor();
-            // checker.cc::check_sparse_tensor checks that the sparse-value is
-            // well-formed
-            updateOutputElemType(ctx, 0, sparse.values().data_type());
-            auto* output_shape = getOutputShape(ctx, 0);
-            for (int i = 0; i < sparse.dims_size(); ++i)
-              appendDim(output_shape, sparse.dims(i));
-            return;
-          }
-
-          fail_shape_inference(
-              "TypeAndShapeInferenceFunction implementation incomplete: "
-              "this line should never be reached.");
-        }));
+        .TypeAndShapeInferenceFunction(ConstantInference));
 
 static const char* Constant_ver12_doc = R"DOC(
 This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,

onnx/defs/tensor/defs.cc

@@ -520,7 +520,7 @@ ONNX_OPERATOR_SET_SCHEMA(
           output_length->set_dim_value((end - start) < 0 ? 0 : (end - start));
         })
         .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
-          if (ctx.getInputType(0)->tensor_type().has_shape()) {
+          if (hasInputShape(ctx, 0)) {
             auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
             int64_t rank = static_cast<int64_t>(input_shape.dim_size());
             int64_t start = getAttribute(ctx, "start", 0);

onnx/defs/tensor/old.cc

@@ -5160,7 +5160,7 @@ ONNX_OPERATOR_SET_SCHEMA(
           output_length->set_dim_value((end - start) < 0 ? 0 : (end - start));
         })
         .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
-          if (ctx.getInputType(0)->tensor_type().has_shape()) {
+          if (hasInputShape(ctx, 0)) {
             auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
             int64_t rank = static_cast<int64_t>(input_shape.dim_size());
             int64_t start = getAttribute(ctx, "start", 0);

onnx/helper.py

@@ -72,6 +72,7 @@ VERSION_TABLE: VersionTableType = [
     ("1.13.0", 8, 18, 3, 1),
     ("1.13.1", 8, 18, 3, 1),
     ("1.14.0", 9, 19, 3, 1),
+    ("1.14.1", 9, 19, 3, 1),
 ]
 
 VersionMapType = Dict[Tuple[str, int], int]

onnx/shape_inference/implementation.cc

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "onnx/shape_inference/implementation.h"
+#include <algorithm>
 #include <fstream>
 #include <list>
 #include "onnx/checker.h"
@@ -340,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());
@@ -373,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;
@@ -388,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;
@@ -588,10 +625,12 @@ class ShapeInferenceImplBase {
     // Create a temporary initializer value map
     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);
+        }
       }
     }
 
@@ -602,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);
     }
@@ -630,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),
@@ -669,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;
 
@@ -698,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;
   }
@@ -749,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;
@@ -774,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);
@@ -800,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,
@@ -821,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,
@@ -866,7 +911,14 @@ struct FunctionInferenceContext : public InferenceContext {
   }
 
   const TypeProto* getInputType(size_t index) const override {
-    return (index < input_types_.size()) ? &input_types_[index] : nullptr;
+    // 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 {

onnx/shape_inference/implementation.h

@@ -14,6 +14,13 @@ namespace shape_inference {
 
 using ModelLocalFunctionsMap = std::unordered_map<std::string, const FunctionProto*>;
 
+// We reuse TensorShapeProto to propagate statically known (partial) information about
+// the values of tensors. It is intended for tensors used to store shape information
+// (the return values of ops like Shape and input values of ops like Reshape/Expand).
+
+// A DataValueMap is used to store the statically known (partial) values of variables.
+using DataValueMap = std::unordered_map<std::string, TensorShapeProto>;
+
 class SymbolTableImpl : public SymbolTable {
  public:
   SymbolTableImpl() : index_(0) {}
@@ -87,7 +94,7 @@ struct GraphInferenceContext {
       SymbolTable* symbol_table_in = nullptr,
       const ModelLocalFunctionsMap& model_local_functions_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)
       : outer_scope_value_types_by_name{&outer_scope_value_types_by_name_in},
         opset_imports{opset_imports_in},
@@ -102,7 +109,7 @@ struct GraphInferenceContext {
   SymbolTable* symbol_table;
   const ModelLocalFunctionsMap& model_local_functions;
   const ISchemaRegistry* schema_registry;
-  std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name;
+  DataValueMap* generated_shape_data_by_name;
   const int ir_version;
 };
 
@@ -125,7 +132,7 @@ struct InferenceContextImpl : public InferenceContext {
       const std::unordered_map<std::string, TypeProto*>& valueTypesByName,
       const std::unordered_map<std::string, const TensorProto*>& inputDataByName,
       const std::unordered_map<std::string, const SparseTensorProto*>& inputSparseDataByName,
-      std::unordered_map<std::string, TensorShapeProto>* generatedShapeData = nullptr,
+      DataValueMap* generatedShapeData = nullptr,
       GraphInferenceContext* graphInferenceContext = nullptr)
       : graphInferenceContext_{graphInferenceContext} {
     for (auto& attr : *n.mutable_attribute()) {
@@ -276,7 +283,7 @@ struct DataPropagationContextImpl : public DataPropagationContext {
       NodeProto& n,
       const std::unordered_map<std::string, TypeProto*>& valueTypesByName,
       const std::unordered_map<std::string, const TensorProto*>& inputDataByName,
-      std::unordered_map<std::string, TensorShapeProto>& generatedShapeData)
+      DataValueMap& generatedShapeData)
       : generatedShapeData_(generatedShapeData) {
     size_t input_idx = 0;
 
@@ -400,7 +407,7 @@ struct DataPropagationContextImpl : public DataPropagationContext {
   std::unordered_map<size_t, std::string> outputIndexToNameMap_;
   std::vector<const TypeProto*> allInputTypes_;
   std::vector<TypeProto> allOutputTypes_;
-  std::unordered_map<std::string, TensorShapeProto>& generatedShapeData_;
+  DataValueMap& generatedShapeData_;
   std::unordered_map<std::string, const AttributeProto*> attributesByName_;
 };
 
@@ -436,14 +443,14 @@ void InferShapes(
     ModelProto& m,
     const ISchemaRegistry* schema_registry = OpSchemaRegistry::Instance(),
     const ShapeInferenceOptions& options = {},
-    std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name = nullptr);
+    DataValueMap* generated_shape_data_by_name = nullptr);
 
 void InferShapes(
     const std::string& model_path,
     const std::string& save_path = "",
     const ISchemaRegistry* schema_registry = OpSchemaRegistry::Instance(),
     const ShapeInferenceOptions& options = {},
-    std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name = nullptr);
+    DataValueMap* generated_shape_data_by_name = nullptr);
 
 ///
 /// ModelLocalFunctionsMap is a map of function id -> model local function proto
@@ -456,7 +463,7 @@ void InferShapeForFunctionNode(
     const ShapeInferenceOptions& options = {},
     const ModelLocalFunctionsMap& model_local_functions_map = {},
     SymbolTable* symbolTable = nullptr,
-    std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name = nullptr);
+    DataValueMap* generated_shape_data_by_name = nullptr);
 
 ///
 /// ModelLocalFunctionsMap is a map of function id -> model local function proto
@@ -470,13 +477,15 @@ void InferShapeForFunctionNode(
     const ShapeInferenceOptions& options = {},
     const ModelLocalFunctionsMap& model_local_functions_map = {},
     SymbolTable* symbolTable = nullptr,
-    std::unordered_map<std::string, TensorShapeProto>* generated_shape_data_by_name = nullptr);
+    DataValueMap* generated_shape_data_by_name = nullptr);
 
 ///
 /// 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.
+/// A TypeProto with value_case() == TypeProto::ValueCase::VALUE_NOT_SET is used
+/// for missing optional parameters.
 ///
 std::vector<TypeProto> InferFunctionOutputTypes(
     const FunctionProto& func_proto,

onnx/version.py

@@ -1,5 +1,5 @@
 # This file is generated by setup.py. DO NOT EDIT!
 
 
-version = "1.14.0"
+version = "1.14.1"
 git_version = "None"

{onnx-1.14.0.dist-info → onnx-1.14.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: onnx
-Version: 1.14.0
+Version: 1.14.1
 Summary: Open Neural Network Exchange
 Home-page: https://github.com/onnx/onnx
 Author: ONNX
@@ -10,11 +10,11 @@ Classifier: Programming Language :: Python :: 3
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
-Requires-Dist: protobuf (>=3.20.2)
-Requires-Dist: typing-extensions (>=3.6.2.1)
+Requires-Dist: protobuf >=3.20.2
+Requires-Dist: typing-extensions >=3.6.2.1
 Provides-Extra: lint
-Requires-Dist: lintrunner (>=0.10.0) ; extra == 'lint'
-Requires-Dist: lintrunner-adapters (>=0.3) ; extra == 'lint'
+Requires-Dist: lintrunner >=0.10.0 ; extra == 'lint'
+Requires-Dist: lintrunner-adapters >=0.3 ; extra == 'lint'
 
 <!--
 Copyright (c) ONNX Project Contributors