onnx 1.15.0__cp311-cp311-win_amd64.whl → 1.16.1__cp311-cp311-win_amd64.whl

onnx/defs/traditionalml/old.cc

@@ -37,12 +37,14 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
         .Attr("classes_strings", "A list of labels.", AttributeProto::STRINGS, OPTIONAL_VALUE)
         .Attr(
             "default_int64",
-            "An integer to use when an input string value is not found in the map.<br>One and only one of the 'default_*' attributes must be defined.",
+            "An integer to use when an input string value is not found in the map.<br>One and only one of the "
+            "'default_*' attributes must be defined.",
             AttributeProto::INT,
             static_cast<int64_t>(-1))
         .Attr(
             "default_string",
-            "A string to use when an input integer value is not found in the map.<br>One and only one of the 'default_*' attributes must be defined.",
+            "A string to use when an input integer value is not found in the map.<br>One and only one of the "
+            "'default_*' attributes must be defined.",
             AttributeProto::STRING,
             std::string("_Unused"))
         .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
@@ -82,7 +84,8 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
         .TypeConstraint(
             "T2",
             {"tensor(string)", "tensor(int64)"},
-            "The output type will be a tensor of strings or integers, depending on which of the classlabels_* attributes is used.")
+            "The output type will be a tensor of strings or integers, depending on which of the classlabels_* "
+            "attributes is used.")
         .Attr("nodes_treeids", "Tree id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
         .Attr(
             "nodes_nodeids",
@@ -102,14 +105,17 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
             OPTIONAL_VALUE)
         .Attr(
             "nodes_modes",
-            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
+            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf "
+            "node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
             AttributeProto::STRINGS,
             OPTIONAL_VALUE)
         .Attr("nodes_truenodeids", "Child node if expression is true.", AttributeProto::INTS, OPTIONAL_VALUE)
         .Attr("nodes_falsenodeids", "Child node if expression is false.", AttributeProto::INTS, OPTIONAL_VALUE)
         .Attr(
             "nodes_missing_value_tracks_true",
-            "For each node, define what to do in the presence of a missing value: if a value is missing (NaN), use the 'true' or 'false' branch based on the value in this array.<br>This attribute may be left undefined, and the default value is false (0) for all nodes.",
+            "For each node, define what to do in the presence of a missing value: if a value is missing (NaN), use the "
+            "'true' or 'false' branch based on the value in this array.<br>This attribute may be left undefined, and "
+            "the default value is false (0) for all nodes.",
             AttributeProto::INTS,
             OPTIONAL_VALUE)
         .Attr("class_treeids", "The id of the tree that this node is in.", AttributeProto::INTS, OPTIONAL_VALUE)
@@ -118,22 +124,26 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
         .Attr("class_weights", "The weight for the class in class_id.", AttributeProto::FLOATS, OPTIONAL_VALUE)
         .Attr(
             "classlabels_strings",
-            "Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be defined.",
+            "Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
             AttributeProto::STRINGS,
             OPTIONAL_VALUE)
         .Attr(
             "classlabels_int64s",
-            "Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be defined.",
+            "Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
             AttributeProto::INTS,
             OPTIONAL_VALUE)
         .Attr(
             "post_transform",
-            "Indicates the transform to apply to the score. <br> One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT.'",
+            "Indicates the transform to apply to the score. <br> One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT.'",
             AttributeProto::STRING,
             std::string("NONE"))
         .Attr(
             "base_values",
-            "Base values for classification, added to final class score; the size must be the same as the classes or can be left unassigned (assumed 0)",
+            "Base values for classification, added to final class score; the size must be the same as the classes or "
+            "can be left unassigned (assumed 0)",
             AttributeProto::FLOATS,
             OPTIONAL_VALUE)
         .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
@@ -148,6 +158,173 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
           }
         }));
 
+static const char* TreeEnsembleClassifier_ver3_doc = R"DOC(
+    Tree Ensemble classifier. Returns the top class for each of N inputs.<br>
+    The attributes named 'nodes_X' form a sequence of tuples, associated by
+    index into the sequences, which must all be of equal length. These tuples
+    define the nodes.<br>
+    Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves.
+    A leaf may have multiple votes, where each vote is weighted by
+    the associated class_weights index.<br>
+    One and only one of classlabels_strings or classlabels_int64s
+    will be defined. The class_ids are indices into this list.
+    All fields ending with <i>_as_tensor</i> can be used instead of the
+    same parameter without the suffix if the element type is double and not float.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    TreeEnsembleClassifier,
+    3,
+    OpSchema()
+        .SetDoc(TreeEnsembleClassifier_ver3_doc)
+        .Input(0, "X", "Input of shape [N,F]", "T1")
+        .Output(0, "Y", "N, Top class for each point", "T2")
+        .Output(1, "Z", "The class score for each class, for each point, a tensor of shape [N,E].", "tensor(float)")
+        .TypeConstraint(
+            "T1",
+            {"tensor(float)", "tensor(double)", "tensor(int64)", "tensor(int32)"},
+            "The input type must be a tensor of a numeric type.")
+        .TypeConstraint(
+            "T2",
+            {"tensor(string)", "tensor(int64)"},
+            "The output type will be a tensor of strings or integers, depending on which of the classlabels_* "
+            "attributes is used.")
+        .Attr("nodes_treeids", "Tree id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_nodeids",
+            "Node id for each node. Ids may restart at zero for each tree, but it not required to.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_featureids", "Feature id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values_as_tensor",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates_as_tensor",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_modes",
+            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf "
+            "node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_truenodeids", "Child node if expression is true.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("nodes_falsenodeids", "Child node if expression is false.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_missing_value_tracks_true",
+            "For each node, define what to do in the presence of a missing value: if a value is missing (NaN), use the "
+            "'true' or 'false' branch based on the value in this array.<br>This attribute may be left undefined, and "
+            "the default value is false (0) for all nodes.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("class_treeids", "The id of the tree that this node is in.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_nodeids", "node id that this weight is for.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_ids", "The index of the class list that each weight is for.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_weights", "The weight for the class in class_id.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "class_weights_as_tensor",
+            "The weight for the class in class_id.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_strings",
+            "Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_int64s",
+            "Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br> One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT.'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr(
+            "base_values",
+            "Base values for classification, added to final class score; the size must be the same as the classes or "
+            "can be left unassigned (assumed 0)",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "base_values_as_tensor",
+            "Base values for classification, added to final class score; the size must be the same as the classes or "
+            "can be left unassigned (assumed 0)",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto* nodes_values = ctx.getAttribute("nodes_values");
+          auto* nodes_values_as_tensor = ctx.getAttribute("nodes_values_as_tensor");
+          auto* nodes_hitrates = ctx.getAttribute("nodes_hitrates");
+          auto* nodes_hitrates_as_tensor = ctx.getAttribute("nodes_hitrates_as_tensor");
+          auto* class_weights = ctx.getAttribute("class_weights");
+          auto* class_weights_as_tensor = ctx.getAttribute("class_weights_as_tensor");
+          auto* base_values = ctx.getAttribute("base_values");
+          auto* base_values_as_tensor = ctx.getAttribute("base_values_as_tensor");
+
+          if (nullptr != nodes_values && nullptr != nodes_values_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'nodes_values', 'nodes_values_as_tensor' should be specified.");
+          }
+          if (nullptr != nodes_hitrates && nullptr != nodes_hitrates_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'nodes_hitrates', 'nodes_hitrates_as_tensor' should be specified.");
+          }
+          if (nullptr != class_weights && nullptr != class_weights_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'class_weights', 'class_weights_as_tensor' should be specified.");
+          }
+          if (nullptr != base_values && nullptr != base_values_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'base_values', 'base_values_as_tensor' should be specified.");
+          }
+
+          std::vector<std::string> classlabels_strings;
+          auto result = getRepeatedAttribute(ctx, "classlabels_strings", classlabels_strings);
+          bool using_strings = (result && !classlabels_strings.empty());
+          if (using_strings) {
+            updateOutputElemType(ctx, 0, TensorProto::STRING);
+          } else {
+            updateOutputElemType(ctx, 0, TensorProto::INT64);
+          }
+          updateOutputElemType(ctx, 1, TensorProto::FLOAT);
+
+          checkInputRank(ctx, 0, 2);
+          Dim N, E;
+          unifyInputDim(ctx, 0, 0, N);
+
+          if (using_strings) {
+            unifyDim(E, classlabels_strings.size());
+          } else {
+            std::vector<int64_t> classlabels_int64s;
+            result = getRepeatedAttribute(ctx, "classlabels_int64s", classlabels_int64s);
+            if (!result || classlabels_int64s.empty()) {
+              fail_shape_inference("Non of classlabels_int64s or classlabels_strings is set.");
+            }
+            unifyDim(E, classlabels_int64s.size());
+          }
+          updateOutputShape(ctx, 0, {N});
+          updateOutputShape(ctx, 1, {N, E});
+        }));
+
 static const char* TreeEnsembleRegressor_ver1_doc = R"DOC(
     Tree Ensemble regressor.  Returns the regressed values for each input in N.<br>
     All args with nodes_ are fields of a tuple of tree nodes, and
@@ -191,14 +368,17 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
             OPTIONAL_VALUE)
         .Attr(
             "nodes_modes",
-            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
+            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf "
+            "node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
             AttributeProto::STRINGS,
             OPTIONAL_VALUE)
         .Attr("nodes_truenodeids", "Child node if expression is true", AttributeProto::INTS, OPTIONAL_VALUE)
         .Attr("nodes_falsenodeids", "Child node if expression is false", AttributeProto::INTS, OPTIONAL_VALUE)
         .Attr(
             "nodes_missing_value_tracks_true",
-            "For each node, define what to do in the presence of a NaN: use the 'true' (if the attribute value is 1) or 'false' (if the attribute value is 0) branch based on the value in this array.<br>This attribute may be left undefined and the default value is false (0) for all nodes.",
+            "For each node, define what to do in the presence of a NaN: use the 'true' (if the attribute value is 1) "
+            "or 'false' (if the attribute value is 0) branch based on the value in this array.<br>This attribute may "
+            "be left undefined and the default value is false (0) for all nodes.",
             AttributeProto::INTS,
             OPTIONAL_VALUE)
         .Attr("target_treeids", "The id of the tree that each node is in.", AttributeProto::INTS, OPTIONAL_VALUE)
@@ -208,7 +388,8 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
         .Attr("n_targets", "The total number of targets.", AttributeProto::INT, OPTIONAL_VALUE)
         .Attr(
             "post_transform",
-            "Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT'",
+            "Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT'",
             AttributeProto::STRING,
             std::string("NONE"))
         .Attr(
@@ -218,10 +399,145 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
             std::string("SUM"))
         .Attr(
             "base_values",
-            "Base values for classification, added to final class score; the size must be the same as the classes or can be left unassigned (assumed 0)",
+            "Base values for classification, added to final class score; the size must be the same as the classes or "
+            "can be left unassigned (assumed 0)",
             AttributeProto::FLOATS,
             OPTIONAL_VALUE));
 
+static const char* TreeEnsembleRegressor_ver3_doc = R"DOC(
+    Tree Ensemble regressor.  Returns the regressed values for each input in N.<br>
+    All args with nodes_ are fields of a tuple of tree nodes, and
+    it is assumed they are the same length, and an index i will decode the
+    tuple across these inputs.  Each node id can appear only once
+    for each tree id.<br>
+    All fields prefixed with target_ are tuples of votes at the leaves.<br>
+    A leaf may have multiple votes, where each vote is weighted by
+    the associated target_weights index.<br>
+    All fields ending with <i>_as_tensor</i> can be used instead of the
+    same parameter without the suffix if the element type is double and not float.
+    All trees must have their node ids start at 0 and increment by 1.<br>
+    Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    TreeEnsembleRegressor,
+    3,
+    OpSchema()
+        .SetDoc(TreeEnsembleRegressor_ver3_doc)
+        .Input(0, "X", "Input of shape [N,F]", "T")
+        .Output(0, "Y", "N classes", "tensor(float)")
+        .TypeConstraint(
+            "T",
+            {"tensor(float)", "tensor(double)", "tensor(int64)", "tensor(int32)"},
+            "The input type must be a tensor of a numeric type.")
+        .Attr("nodes_treeids", "Tree id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_nodeids",
+            "Node id for each node. Node ids must restart at zero for each tree and increase sequentially.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_featureids", "Feature id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values_as_tensor",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates_as_tensor",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_modes",
+            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf "
+            "node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_truenodeids", "Child node if expression is true", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("nodes_falsenodeids", "Child node if expression is false", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_missing_value_tracks_true",
+            "For each node, define what to do in the presence of a NaN: use the 'true' (if the attribute value is 1) "
+            "or 'false' (if the attribute value is 0) branch based on the value in this array.<br>This attribute may "
+            "be left undefined and the default value is false (0) for all nodes.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("target_treeids", "The id of the tree that each node is in.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_nodeids", "The node id of each weight", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_ids", "The index of the target that each weight is for", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_weights", "The weight for each target", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("target_weights_as_tensor", "The weight for each target", AttributeProto::TENSOR, OPTIONAL_VALUE)
+        .Attr("n_targets", "The total number of targets.", AttributeProto::INT, OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr(
+            "aggregate_function",
+            "Defines how to aggregate leaf values within a target. <br>One of 'AVERAGE,' 'SUM,' 'MIN,' 'MAX.'",
+            AttributeProto::STRING,
+            std::string("SUM"))
+        .Attr(
+            "base_values",
+            "Base values for regression, added to final prediction after applying aggregate_function; the size must be "
+            "the same as the classes or can be left unassigned (assumed 0)",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "base_values_as_tensor",
+            "Base values for regression, added to final prediction after applying aggregate_function; the size must be "
+            "the same as the classes or can be left unassigned (assumed 0)",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto* nodes_values = ctx.getAttribute("nodes_values");
+          auto* nodes_values_as_tensor = ctx.getAttribute("nodes_values_as_tensor");
+          auto* nodes_hitrates = ctx.getAttribute("nodes_hitrates");
+          auto* nodes_hitrates_as_tensor = ctx.getAttribute("nodes_hitrates_as_tensor");
+          auto* target_weights = ctx.getAttribute("target_weights");
+          auto* target_weights_as_tensor = ctx.getAttribute("target_weights_as_tensor");
+          auto* base_values = ctx.getAttribute("base_values");
+          auto* base_values_as_tensor = ctx.getAttribute("base_values_as_tensor");
+
+          if (nullptr != nodes_values && nullptr != nodes_values_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'nodes_values', 'nodes_values_as_tensor' should be specified.");
+          }
+          if (nullptr != nodes_hitrates && nullptr != nodes_hitrates_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'nodes_hitrates', 'nodes_hitrates_as_tensor' should be specified.");
+          }
+          if (nullptr != target_weights && nullptr != target_weights_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'target_weights', 'target_weights_as_tensor' should be specified.");
+          }
+          if (nullptr != base_values && nullptr != base_values_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'base_values', 'base_values_as_tensor' should be specified.");
+          }
+
+          checkInputRank(ctx, 0, 2);
+          Dim N, E;
+          unifyInputDim(ctx, 0, 0, N);
+          if (nullptr != ctx.getAttribute("n_targets")) {
+            unifyDim(E, ctx.getAttribute("n_targets")->i());
+          }
+          updateOutputElemType(ctx, 0, TensorProto::FLOAT);
+          updateOutputShape(ctx, 0, {N, E});
+        }));
+
 static const char* LabelEncoder_ver2_doc = R"DOC(
     Maps each element in the input tensor to another value.<br>
     The mapping is determined by the two parallel attributes, 'keys_*' and
@@ -337,6 +653,5 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
           // Input and output shapes are the same.
           propagateShapeFromInputToOutput(ctx, 0, 0);
         }));
-
 } // namespace ONNX_NAMESPACE
 #endif

onnx/defs/traditionalml/utils.h

@@ -0,0 +1,27 @@
+#include "onnx/defs/schema.h"
+#include "onnx/defs/shape_inference.h"
+
+namespace ONNX_NAMESPACE {
+
+void AssertAttributeProtoTypeAndLength(
+    const AttributeProto* attr_proto,
+    int expected_length,
+    TensorProto_DataType expected_type,
+    bool required) {
+  if (nullptr == attr_proto) {
+    if (required) {
+      fail_shape_inference("Unspecified required attribute.");
+    }
+    return;
+  }
+  const auto& [type, length] = getAttributeProtoElemTypeAndLength(attr_proto);
+  if (type != expected_type) {
+    fail_shape_inference(
+        "Attribute '", attr_proto->name(), "' must have type ", TensorProto_DataType_Name(expected_type), ".");
+  }
+  if (length != expected_length) {
+    fail_shape_inference("Attribute '", attr_proto->name(), "' must have ", expected_length, " elements.");
+  }
+}
+
+} // namespace ONNX_NAMESPACE

onnx/external_data_helper.py

@@ -8,6 +8,7 @@ import uuid
 from itertools import chain
 from typing import Callable, Iterable, Optional
 
+import onnx.onnx_cpp2py_export.checker as c_checker
 from onnx.onnx_pb import AttributeProto, GraphProto, ModelProto, TensorProto
 
 
@@ -30,8 +31,7 @@ class ExternalDataInfo:
 
 
 def load_external_data_for_tensor(tensor: TensorProto, base_dir: str) -> None:
-    """
-    Loads data from an external file for tensor.
+    """Loads data from an external file for tensor.
     Ideally TensorProto should not hold any raw data but if it does it will be ignored.
 
     Arguments:
@@ -39,9 +39,9 @@ def load_external_data_for_tensor(tensor: TensorProto, base_dir: str) -> None:
         base_dir: directory that contains the external data.
     """
     info = ExternalDataInfo(tensor)
-    file_location = _sanitize_path(info.location)
-    external_data_file_path = os.path.join(base_dir, file_location)
-
+    external_data_file_path = c_checker._resolve_external_data_location(  # type: ignore[attr-defined]
+        base_dir, info.location, tensor.name
+    )
     with open(external_data_file_path, "rb") as data_file:
         if info.offset:
             data_file.seek(info.offset)
@@ -53,8 +53,7 @@ def load_external_data_for_tensor(tensor: TensorProto, base_dir: str) -> None:
 
 
 def load_external_data_for_model(model: ModelProto, base_dir: str) -> None:
-    """
-    Loads external tensors into model
+    """Loads external tensors into model
 
     Arguments:
         model: ModelProto to load external data to
@@ -106,8 +105,7 @@ def convert_model_to_external_data(
     size_threshold: int = 1024,
     convert_attribute: bool = False,
 ) -> None:
-    """
-    Call to set all tensors with raw data as external data. This call should preceed 'save_model'.
+    """Call to set all tensors with raw data as external data. This call should precede 'save_model'.
     'save_model' saves all the tensors data as external data after calling this function.
 
     Arguments:
@@ -153,8 +151,7 @@ def convert_model_to_external_data(
 
 
 def convert_model_from_external_data(model: ModelProto) -> None:
-    """
-    Call to set all tensors which use external data as embedded data.
+    """Call to set all tensors which use external data as embedded data.
     save_model saves all the tensors data as embedded data after
     calling this function.
 
@@ -170,8 +167,7 @@ def convert_model_from_external_data(model: ModelProto) -> None:
 
 
 def save_external_data(tensor: TensorProto, base_path: str) -> None:
-    """
-    Writes tensor data to an external file according to information in the `external_data` field.
+    """Writes tensor data to an external file according to information in the `external_data` field.
 
     Arguments:
         tensor (TensorProto): Tensor object to be serialized
@@ -259,14 +255,6 @@ def _get_attribute_tensors(onnx_model_proto: ModelProto) -> Iterable[TensorProto
     yield from _get_attribute_tensors_from_graph(onnx_model_proto.graph)
 
 
-def _sanitize_path(path: str) -> str:
-    """Remove path components which would allow traversing up a directory tree from a base path.
-
-    Note: This method is currently very basic and should be expanded.
-    """
-    return path.lstrip("/.")
-
-
 def _is_valid_filename(filename: str) -> bool:
     """Utility to check whether the provided filename is valid."""
     exp = re.compile('^[^<>:;,?"*|/]+$')
@@ -276,15 +264,14 @@ def _is_valid_filename(filename: str) -> bool:
 
 def uses_external_data(tensor: TensorProto) -> bool:
     """Returns true if the tensor stores data in an external location."""
-    return (
+    return (  # type: ignore[no-any-return]
         tensor.HasField("data_location")
         and tensor.data_location == TensorProto.EXTERNAL
     )
 
 
 def remove_external_data_field(tensor: TensorProto, field_key: str) -> None:
-    """
-    Removes a field from a Tensor's external_data key-value store.
+    """Removes a field from a Tensor's external_data key-value store.
 
     Modifies tensor object in place.
 
@@ -298,8 +285,7 @@ def remove_external_data_field(tensor: TensorProto, field_key: str) -> None:
 
 
 def write_external_data_tensors(model: ModelProto, filepath: str) -> ModelProto:
-    """
-    Serializes data for all the tensors which have data location set to TensorProto.External.
+    """Serializes data for all the tensors which have data location set to TensorProto.External.
 
     Note: This function also strips basepath information from all tensors' external_data fields.