onnx 1.13.1__cp39-cp39-win32.whl → 1.14.1__cp39-cp39-win32.whl

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
 
@@ -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,9 +477,22 @@ 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,
+    const std::vector<TypeProto>& input_types,
+    const std::vector<AttributeProto>& attributes);
 
-std::string GetErrorWithNodeInfo(const NodeProto& n, std::runtime_error err);
+std::string GetErrorWithNodeInfo(const NodeProto& n, const std::runtime_error& err);
 
 void TraverseGraphsToAddExistingSymbols(const GraphProto& g, SymbolTable& symbolTable);
 

onnx/shape_inference.py

@@ -1,14 +1,17 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
+
 """onnx shape inference. Shape inference is not guaranteed to be
 complete.
 
 """
 
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Sequence, Union
 
 import onnx
-import onnx.onnx_cpp2py_export.shape_inference as C
-from onnx import ModelProto
+import onnx.onnx_cpp2py_export.shape_inference as C  # noqa: N812
+from onnx import AttributeProto, FunctionProto, ModelProto, TypeProto
 
 
 def infer_shapes(
@@ -41,16 +44,15 @@ def infer_shapes(
             model_str, check_type, strict_mode, data_prop
         )
         return onnx.load_from_string(inferred_model_str)
-    elif isinstance(model, str):
+    if isinstance(model, str):
         raise TypeError(
             "infer_shapes only accepts ModelProto or bytes,"
             "you can use infer_shapes_path for the model path (String)."
         )
-    else:
-        raise TypeError(
-            "infer_shapes only accepts ModelProto or bytes, "
-            "incorrect type: {}".format(type(model))
-        )
+
+    raise TypeError(
+        f"infer_shapes only accepts ModelProto or bytes, incorrect type: {type(model)}"
+    )
 
 
 def infer_shapes_path(
@@ -70,7 +72,7 @@ def infer_shapes_path(
             "you can use infer_shapes for the ModelProto."
         )
     # Directly output the inferred model into the specified path, return nothing
-    elif isinstance(model_path, str):
+    if isinstance(model_path, str):
         # If output_path is not defined, default output_path would be the original model path
         if output_path == "":
             output_path = model_path
@@ -78,7 +80,7 @@ def infer_shapes_path(
     else:
         raise TypeError(
             "infer_shapes_path only accepts model path (String), "
-            "incorrect type: {}".format(type(model_path))
+            f"incorrect type: {type(model_path)}"
         )
 
 
@@ -121,7 +123,7 @@ def infer_node_outputs(
         if key in input_sparse_data
     }
 
-    outputs = schema._infer_node_outputs(
+    outputs = schema._infer_node_outputs(  # pylint: disable=protected-access
         node.SerializeToString(),
         passed_input_types,
         passed_input_data,
@@ -132,4 +134,27 @@ def infer_node_outputs(
     return {key: onnx.TypeProto.FromString(out) for key, out in outputs.items()}
 
 
+def infer_function_output_types(
+    function: FunctionProto,
+    input_types: Sequence[TypeProto],
+    attributes: Sequence[AttributeProto],
+) -> List[TypeProto]:
+    """
+    Apply type-and-shape-inference to given function body, with given input types
+    and given input attribute values.
+    """
+    result = C.infer_function_output_types(
+        function.SerializeToString(),
+        [x.SerializeToString() for x in input_types],
+        [x.SerializeToString() for x in attributes],
+    )
+
+    def to_type_proto(x) -> TypeProto:
+        type_proto = onnx.TypeProto()
+        type_proto.ParseFromString(x)
+        return type_proto
+
+    return [to_type_proto(x) for x in result]
+
+
 InferenceError = C.InferenceError

onnx/string_utils.h

@@ -1,6 +1,6 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- */
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 

onnx/test/cpp/common_path_test.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/test/cpp/data_propagation_test.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/test/cpp/function_context_test.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/test/cpp/function_get_test.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/test/cpp/function_verify_test.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -8,6 +10,7 @@
 #include "onnx/checker.h"
 #include "onnx/common/constants.h"
 #include "onnx/defs/parser.h"
+#include "onnx/defs/printer.h"
 #include "onnx/defs/schema.h"
 #include "onnx/onnx-operators_pb.h"
 #include "onnx/onnx_pb.h"
@@ -102,6 +105,174 @@ void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* func
   ++counter;
 }
 
+// Testing the function-definitions provided for function-ops in ONNX schema registry.
+// We type-check the function-definition for all possible input-typings, as permitted
+// by the op-schema. Since the type-checking is dependent on attribute-values, we specify
+// the attribute-values for which we want to do the testing down below.
+
+// The set of attribute-values (for testing a function) is represented using a vector.
+using AttributeValues = std::vector<AttributeProto>;
+
+// FunctionOpAttributeMap: Used to implement a map from OpSchema to a set of AttributeValues
+// (implemented as a vector). The testing will be done for each attribute-values specified.
+
+struct FunctionOpAttributeMap {
+  std::unordered_map<std::string, std::vector<AttributeValues>> map;
+
+  std::string key(std::string domain, std::string opname, int opset_version) const {
+    return domain + ":" + opname + ":" + std::to_string(opset_version);
+  }
+
+  void addTestCase(const std::string& opname, int opset_version, std::initializer_list<const char*> attributes) {
+    auto& schema_test_cases = map[key("", opname, opset_version)];
+    schema_test_cases.push_back(AttributeValues());
+    auto& test_case = schema_test_cases.back();
+    for (auto attr_text : attributes) {
+      test_case.push_back(AttributeProto());
+      OnnxParser::Parse(test_case.back(), attr_text);
+    }
+  }
+
+  FunctionOpAttributeMap() {
+    addTestCase("Elu", 6, {"alpha = 1.0"});
+    addTestCase("LeakyRelu", 16, {"alpha = 0.1"});
+    addTestCase("HardSigmoid", 6, {"alpha = 0.2", "beta=0.5"});
+    addTestCase("Selu", 6, {"alpha = 1.6", "gamma=1.05"});
+    addTestCase("ReduceL1", 18, {}); // Use default-value for attributes
+    addTestCase("ReduceL1", 18, {"keepdims = 0"});
+    addTestCase("ReduceL1", 18, {"noop_with_empty_axes = 1"});
+    addTestCase("ReduceL2", 18, {});
+    addTestCase("ReduceL2", 18, {"noop_with_empty_axes = 1", "keepdims = 0"});
+    addTestCase("ReduceSumSquare", 18, {});
+    addTestCase("ReduceLogSumExp", 18, {});
+    addTestCase("ThresholdedRelu", 10, {"alpha = 0.9"});
+    addTestCase("HannWindow", 17, {"output_datatype = 1", "periodic = 1"});
+    addTestCase("HammingWindow", 17, {"output_datatype = 1", "periodic = 1"});
+    addTestCase("BlackmanWindow", 17, {"output_datatype = 1", "periodic = 1"});
+    addTestCase("MeanValueNormalization", 13, {});
+
+    // The following test-cases fails, correctly so: Some clarification/changes required
+    // to handle unsigned integers or similar issues:
+    // addTestCase("Shrink", 9, {"bias = 0.0", "lambd = 0.5"});
+    // addTestCase("ReduceLogSum", 18, {});
+    // addTestCase("Range", 11, {});
+
+    // The following test-case fails because the checker doesn't support handling of
+    // default-values of attributes of function-ops
+    // addTestCase("ThresholdedRelu", 10, {});
+  }
+
+  const std::vector<AttributeValues>& getTestCases(const OpSchema& schema) {
+    auto key_value = key(schema.domain(), schema.Name(), schema.SinceVersion());
+    auto it = map.find(key_value);
+    if (it != map.end())
+      return it->second;
+    if (schema.attributes().size() == 0) {
+      // Test with no-attributes
+      map[key_value].push_back(std::vector<AttributeProto>());
+    }
+    return map[key_value];
+  }
+
+  static FunctionOpAttributeMap& instance() {
+    static FunctionOpAttributeMap _instance;
+    return _instance;
+  }
+};
+
+struct FunctionTypeChecker {
+  const OpSchema& schema;
+  const FunctionProto& function_proto;
+  const std::vector<AttributeValues>* attribute_cases;
+
+  FunctionTypeChecker(const OpSchema& op_schema, const FunctionProto& proto)
+      : schema(op_schema), function_proto(proto) {
+    attribute_cases = &FunctionOpAttributeMap::instance().getTestCases(op_schema);
+  }
+
+  // Binds each type-variable in schema to a type-value
+  std::unordered_map<std::string, DataType> typeVarBindings;
+
+  std::vector<std::string> errors;
+
+  void recordError(const std::string& error, AttributeValues attrs) {
+    std::ostringstream ostr;
+    ostr << "Type checking failed for instantiation " << schema.Name() << ":" << schema.SinceVersion() << " {";
+    for (auto& pair : typeVarBindings) {
+      ostr << pair.first << " = " << *pair.second << ", ";
+    }
+    for (auto& attr : attrs) {
+      ostr << attr << ", ";
+    }
+    ostr << "}\n" << error << "\n";
+    errors.push_back(ostr.str());
+  }
+
+  void recordSuccess(AttributeValues attrs) {
+    std::cout << "Type checking succeeded for instantiation " << schema.Name() << ":" << schema.SinceVersion() << " {";
+    for (auto& pair : typeVarBindings) {
+      std::cout << pair.first << " = " << *pair.second << ", ";
+    }
+    for (auto& attr : attrs) {
+      std::cout << attr << ", ";
+    }
+    std::cout << "}\n";
+  }
+
+  // forTypeVar: This is used to iterate through all possible bindings of type-values
+  // to all type-variables used in the op schema, and invoke the type-checker for
+  // each possible instantiation.
+  void forTypeVar(int i) {
+    auto& typeConstraintVector = schema.typeConstraintParams();
+    if (i < typeConstraintVector.size()) {
+      std::string typeVar = typeConstraintVector[i].type_param_str;
+      auto& values = schema.typeConstraintMap().at(typeVar).first;
+      for (auto typeValue : values) {
+        typeVarBindings[typeVar] = typeValue;
+        // Now, process remaining type-variables
+        forTypeVar(i + 1);
+      }
+    } else {
+      // Generated a complete instantiation of type-values to all type-variables.
+      // Now, check for this instantiation.
+      typeCheckBinding();
+    }
+  }
+
+  // typeCheckBinding: Type-check the function-body for the current type-instantiation
+  void typeCheckBinding() {
+    std::vector<TypeProto> input_types;
+    for (const auto& input : schema.inputs()) {
+      DataType datatype = (1 == input.GetTypes().size())
+          ?
+          // Select the single possible type
+          (*(input.GetTypes().begin()))
+          :
+          // Select the type bound to the type-var in current instantiation
+          typeVarBindings[input.GetTypeStr()];
+      input_types.push_back(Utils::DataTypeUtils::ToTypeProto(datatype));
+    }
+
+    for (auto& attribute_vals : *attribute_cases) {
+      ONNX_TRY {
+        auto output_types = shape_inference::InferFunctionOutputTypes(function_proto, input_types, attribute_vals);
+      }
+      ONNX_CATCH(ONNX_NAMESPACE::InferenceError & e) {
+        ONNX_HANDLE_EXCEPTION(([&]() { recordError(e.what(), attribute_vals); }));
+      }
+    }
+  }
+
+  std::string checkAll() {
+    if (attribute_cases->size() > 0)
+      forTypeVar(0);
+    std::string all_errors = "";
+    for (const std::string& error : errors)
+      all_errors += error;
+    return all_errors;
+  }
+};
+
 void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int& counter) {
   // Verify function proto is valid
   if (!function_proto) {
@@ -128,6 +299,11 @@ void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int
   // Verify function op has compatible Type constraints defined in
   // op and function body.
   VerifyTypeConstraint(op, function_proto, counter);
+
+  FunctionTypeChecker type_checker(op, *function_proto);
+  auto type_errors = type_checker.checkAll();
+  auto success = (type_errors == "");
+  ASSERT_TRUE(success) << type_errors;
 }
 
 // Verify registered ops with function body has compatible

onnx/test/cpp/op_reg_test.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/test/cpp/parser_test.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -194,6 +196,12 @@ TEST(ParserTest, AttributeTest) {
 )ONNX");
   EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_GRAPH);
   EXPECT_EQ(attr.g().node_size(), 2);
+
+  Parse(attr, "type = float[3]");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_TYPE_PROTO);
+  EXPECT_TRUE(attr.tp().has_tensor_type());
+  int float_type = static_cast<int>(TensorProto_DataType::TensorProto_DataType_FLOAT);
+  EXPECT_EQ(attr.tp().tensor_type().elem_type(), float_type);
 }
 
 TEST(ParserTest, AttrListTest) {
@@ -488,6 +496,34 @@ square (x) => (y) {
 )ONNX";
 
   CheckModel(code);
+
+  const char* code_function_with_attributes = R"ONNX(
+<
+  ir_version: 9,
+  opset_import: [ "" : 15, "custom_domain" : 1]
+>
+agraph (float[N] x) => (float[N] out)
+{
+  out = custom_domain.foo<alpha=2.0, gamma=3.0>(x)
+}
+
+<
+domain: "custom_domain",
+opset_import: [ "" : 15],
+doc_string: "function foo"
+>
+  foo
+  <alpha: float=4.0, gamma>
+  (X) => (C)
+  {
+      constant_alpha = Constant<value_float: float=@alpha>()
+      constant_gamma = Constant<value_float: float=@gamma>()
+      constant_alpha_x = Mul(constant_alpha, X)
+      C = Add(constant_alpha_x, constant_gamma)
+  }
+)ONNX";
+
+  CheckModel(code_function_with_attributes);
 }
 
 TEST(ParserTest, TypesModelTest1) {
@@ -519,4 +555,4 @@ TEST(ParserTest, TypesModelTest2) {
 }
 
 } // namespace Test
-} // namespace ONNX_NAMESPACE
+} // namespace ONNX_NAMESPACE

onnx/test/cpp/schema_registration_test.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/test/cpp/shape_inference_test.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/test/cpp/test_main.cc

@@ -1,3 +1,5 @@
+// Copyright (c) ONNX Project Contributors
+
 /*
  * SPDX-License-Identifier: Apache-2.0
  */

onnx/tools/__init__.py

@@ -1 +1,3 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0

onnx/tools/net_drawer.py

@@ -1,7 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # A library and utility for drawing ONNX nets. Most of this implementation has
 # been borrowed from the caffe2 implementation
-# https://github.com/caffe2/caffe2/blob/master/caffe2/python/net_drawer.py
+# https://github.com/pytorch/pytorch/blob/master/caffe2/python/net_drawer.py
 #
 # The script takes two required arguments:
 #   -input: a path to a serialized ModelProto .pb file.
@@ -45,14 +47,16 @@ def _form_and_sanitize_docstring(s: str) -> str:
     return url
 
 
-def GetOpNodeProducer(embed_docstring: bool = False, **kwargs: Any) -> _NodeProducer:
-    def ReallyGetOpNode(op: NodeProto, op_id: int) -> pydot.Node:
+def GetOpNodeProducer(  # noqa: N802
+    embed_docstring: bool = False, **kwargs: Any
+) -> _NodeProducer:
+    def really_get_op_node(op: NodeProto, op_id: int) -> pydot.Node:
         if op.name:
-            node_name = "%s/%s (op#%d)" % (op.name, op.op_type, op_id)
+            node_name = f"{op.name}/{op.op_type} (op#{op_id})"
         else:
-            node_name = "%s (op#%d)" % (op.op_type, op_id)
-        for i, input in enumerate(op.input):
-            node_name += "\n input" + str(i) + " " + input
+            node_name = f"{op.op_type} (op#{op_id})"
+        for i, input_ in enumerate(op.input):
+            node_name += "\n input" + str(i) + " " + input_
         for i, output in enumerate(op.output):
             node_name += "\n output" + str(i) + " " + output
         node = pydot.Node(node_name, **kwargs)
@@ -61,10 +65,10 @@ def GetOpNodeProducer(embed_docstring: bool = False, **kwargs: Any) -> _NodeProd
             node.set_URL(url)
         return node
 
-    return ReallyGetOpNode
+    return really_get_op_node
 
 
-def GetPydotGraph(
+def GetPydotGraph(  # noqa: N802
     graph: GraphProto,
     name: Optional[str] = None,
     rankdir: str = "LR",