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

onnx/shape_inference/implementation.cc

@@ -69,6 +69,7 @@ std::string GetElemTypeString(const TypeProto_SparseTensor& type) {
 inline bool IsOnnxDomainOp(const NodeProto& node, const std::string& op_type) {
   return (IsOnnxDomain(node.domain()) && (node.op_type() == op_type));
 }
+
 } // namespace
 
 template <class T>
@@ -249,13 +250,100 @@ void MaterializeSymbolicShape(TypeProto* inferred_type, SymbolTable& symbol_tabl
   }
 }
 
-std::string GetModelLocalFunctionsMapIdentifier(const std::string& domain, const std::string& func_name) {
-  return domain + ":" + func_name;
+std::string GetFunctionIdentifier(const FunctionProto& function) {
+  // Note: Models with IR version < 10 do not have the overload attribute.
+  // However, that will be mapped to an empty identifier.
+  std::string overload = function.overload();
+  if (overload.empty()) {
+    return function.domain() + ":" + function.name();
+  }
+  return function.domain() + ":" + function.name() + ":" + overload;
+}
+
+std::string GetFunctionIdentifier(const NodeProto& node) {
+  // Note: Models with IR version < 10 do not have the overload attribute.
+  // However, that will be mapped to an empty identifier.
+  std::string overload = node.overload();
+  if (overload.empty()) {
+    return node.domain() + ":" + node.op_type();
+  }
+  return node.domain() + ":" + node.op_type() + ":" + overload;
+}
+
+// InferredTypes: abstracts the differences between FunctionProto and GraphProto
+// for inference. For GraphProto, inferred types are stored in the GraphProto
+// but FunctionProto does not have a place to store inferred types. So, we
+// use a temporary vector (for the duration of inference) to store these.
+class InferredTypes {
+ public:
+  explicit InferredTypes(GraphProto* graph = nullptr) : graph_ptr(graph) {}
+
+  TypeProto* Add(const std::string& var_name, const TypeProto& type) {
+    if (graph_ptr != nullptr) {
+      auto* p = graph_ptr->add_value_info();
+      p->set_name(var_name);
+      *p->mutable_type() = type;
+      return p->mutable_type();
+    } else {
+      auto* p = new TypeProto(type);
+      types.push_back(p);
+      return p;
+    }
+  }
+
+  ~InferredTypes() {
+    for (auto* p : types) {
+      delete p;
+    }
+  }
+
+ private:
+  std::vector<TypeProto*> types;
+  GraphProto* graph_ptr;
+  ONNX_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(InferredTypes);
+};
+
+// 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;
+      }
+    }
+  }
 }
 
 class ShapeInferenceImplBase {
  public:
-  void updateType(const std::string& name, TypeProto* inferred_type) {
+  void UpdateType(const std::string& name, TypeProto* inferred_type) {
     if (inferred_type->value_case() == TypeProto::ValueCase::VALUE_NOT_SET) {
       return;
     }
@@ -268,14 +356,10 @@ class ShapeInferenceImplBase {
     // then check for compatibility with the inferred
     // information. Otherwise, initialize it in an empty state.
     auto iter = value_types_by_name.find(name);
-    TypeProto* existing_type = nullptr;
     if (iter != value_types_by_name.end()) {
-      existing_type = iter->second;
+      mergeShapesAndTypes(*inferred_type, iter->second);
     } else {
-      // Create a new value_info if defined type does not exist
-      auto vi = g.add_value_info(); // TODO: clean this up
-      vi->set_name(name);
-      existing_type = vi->mutable_type();
+      value_types_by_name[name] = inferred_types.Add(name, *inferred_type);
       // For undefined output type, update both value_info and output for now
       // Update existing output with undefined type: assign inferred type to it
       iter = undefined_value_types_by_name.find(name);
@@ -283,16 +367,9 @@ class ShapeInferenceImplBase {
         *iter->second = *inferred_type;
       }
     }
-
-    // TODO: cleanup this by merging with previous if-else
-    // Now we can merge pre-existing and inferred info
-    mergeShapesAndTypes(*inferred_type, existing_type);
-
-    // Make merged info available to further inference.
-    value_types_by_name[name] = existing_type;
   }
 
-  void updateType(ValueInfoProto& valueInfo) {
+  void UpdateType(ValueInfoProto& valueInfo) {
     if (valueInfo.has_type()) {
       value_types_by_name[valueInfo.name()] = valueInfo.mutable_type();
     } else {
@@ -301,15 +378,13 @@ class ShapeInferenceImplBase {
   }
 
   template <typename T>
-  void addTemporaryConstant(const std::string& name, const T& vector) {
+  void AddTemporaryConstant(const std::string& name, const T& vector) {
     input_data_by_name_holder[name] = ToTensor(vector);
     input_data_by_name[name] = &input_data_by_name_holder[name];
   }
 
-  void preprocess(const NodeProto& n) {
-    if (checker::check_is_experimental_op(n)) {
-      has_experimental_op = true;
-    } else if (IsOnnxDomainOp(n, "Constant") && n.output().size() == 1) {
+  void ProcessConstant(const NodeProto& n) {
+    if (IsOnnxDomainOp(n, "Constant") && n.output().size() == 1) {
       const std::string& output_name = n.output(0);
       for (const auto& attr : n.attribute()) {
         if (attr.name() == "value") {
@@ -329,22 +404,22 @@ class ShapeInferenceImplBase {
           switch (attr.type()) {
             case AttributeProto::INTS: {
               std::vector<int64_t> ints{attr.ints().begin(), attr.ints().end()};
-              addTemporaryConstant(output_name, ints);
+              AddTemporaryConstant(output_name, ints);
               break;
             }
             case AttributeProto::INT: {
               std::vector<int64_t> ints({attr.i()});
-              addTemporaryConstant(output_name, ints);
+              AddTemporaryConstant(output_name, ints);
               break;
             }
             case AttributeProto::FLOATS: {
               std::vector<float> floats{attr.floats().begin(), attr.floats().end()};
-              addTemporaryConstant(output_name, floats);
+              AddTemporaryConstant(output_name, floats);
               break;
             }
             case AttributeProto::FLOAT: {
               std::vector<float> floats({attr.f()});
-              addTemporaryConstant(output_name, floats);
+              AddTemporaryConstant(output_name, floats);
               break;
             }
             default:
@@ -355,57 +430,19 @@ 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) {
+  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);
+      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);
+      BindValuesOnReturn(callee_value_map, callee, *generated_shape_data_by_name, caller);
     }
   }
 
-  void process(NodeProto& n) {
+  void Process(NodeProto& n) {
     // Resolve domain for node
     auto dit = opset_imports.find(n.domain());
     if (dit == opset_imports.end()) {
@@ -439,15 +476,16 @@ class ShapeInferenceImplBase {
         if (schema->has_type_and_shape_inference_function()) {
           schema->GetTypeAndShapeInferenceFunction()(ctx);
         } else if (schema->HasFunction()) {
-          processCall(n, *(schema->GetFunction()), ctx);
-        } else {
-          // Continue with inference for remaining nodes
-          return;
+          ProcessCall(n, *(schema->GetFunction()), ctx);
+        } // else: rely on schema->CheckInputOutputType() down below.
+        // check type-constraints specified via type variables
+        if (options.check_type) {
+          schema->CheckInputOutputType(ctx);
         }
       } else if (model_local_functions_map.size() > 0) {
-        auto iter = model_local_functions_map.find(GetModelLocalFunctionsMapIdentifier(n.domain(), n.op_type()));
+        auto iter = model_local_functions_map.find(GetFunctionIdentifier(n));
         if (iter != model_local_functions_map.end()) {
-          processCall(n, *(iter->second), ctx);
+          ProcessCall(n, *(iter->second), ctx);
         } else {
           has_unsupported_op = true;
           return;
@@ -456,34 +494,15 @@ class ShapeInferenceImplBase {
         has_unsupported_op = true;
         return;
       }
-    }
-    ONNX_CATCH(const ONNX_NAMESPACE::InferenceError& ex) {
-      ONNX_HANDLE_EXCEPTION([&]() {
-        // onnx does not support unsupported/experimental operators
-        // so it won't consider it as an error
-        if (!has_unsupported_op && !has_experimental_op) {
-          inference_errors.push_back(GetErrorWithNodeInfo(n, ex));
-        }
-      });
-      // Continue with inference for remaining nodes
-      return;
-    }
-
-    ONNX_TRY {
-      // check the type-equality for input and output
-      if (options.check_type && schema) {
-        schema->CheckInputOutputType(ctx);
-      }
-
       for (int i = 0; i < n.output_size(); ++i) {
         // skip type and shape propagation for missing optional outputs.
         if (!n.output(i).empty())
-          updateType(n.output(i), ctx.getOutputType(i));
+          UpdateType(n.output(i), ctx.getOutputType(i));
       }
-
-      preprocess(n);
-
-      // If data propagation is enabled, propagate shape data if it exists.
+      // Constant values are tracked to improve inference/checking for subsequent nodes.
+      ProcessConstant(n);
+      // If data-propagation is enabled, partial-evaluation (aka data-propagation) is performed
+      // to improve inference/checking for subsequent nodes.
       if (options.enable_data_propagation && schema && schema->has_data_propagation_function()) {
         if (generated_shape_data_by_name == nullptr) {
           fail_shape_inference(
@@ -494,14 +513,32 @@ class ShapeInferenceImplBase {
         schema->GetDataPropagationFunction()(data_propagation_ctx);
       }
     }
+    ONNX_CATCH(const ONNX_NAMESPACE::InferenceError& ex) {
+      ONNX_HANDLE_EXCEPTION([&]() {
+        // Note: The following special handling is to accommodate custom-ops. Ideally, custom-ops
+        // should be registered with a schema in the schema registry, allowing inference to handle
+        // them. As things stand, this special handling is somewhat fragile and is not fully
+        // general either. Eg., a custom-op suppresses error-messages for subsequent nodes, but
+        // this does not work across graphs. If special handling is required, a user-option may
+        // be a better way to do it. The fragility comes from the fact that the types of the
+        // returned-values of the custom-op are unknown, and subsequent node-level inference
+        // may fail because of this.
+        if (!has_unsupported_op) {
+          inference_errors.push_back(GetErrorWithNodeInfo(n, ex));
+        }
+      });
+    }
     ONNX_CATCH(const std::runtime_error& err) {
+      // TODO: Fix this. Unclear if this should be remapped to a shape inference error.
+      // Need to rationalize the different types of exceptions that can be thrown.
+      // See: https://github.com/onnx/onnx/pull/5519
       ONNX_HANDLE_EXCEPTION([&]() { fail_shape_inference(GetErrorWithNodeInfo(n, err)); });
     }
   }
 
   // TypeProto_Tensor or TypeProto_SparseTensor
   template <typename T>
-  void processInitializer(
+  void ProcessInitializer(
       const std::string& name,
       const T& tensorValue,
       TypeProto& initializer_type,
@@ -523,18 +560,18 @@ class ShapeInferenceImplBase {
     }
   }
 
-  void process(GraphProto& graph) {
+  void Process(GraphProto& graph) {
     if (symbol_table) {
       TraverseGraphsToAddExistingSymbols(graph, *symbol_table);
     }
     for (auto& vi : *graph.mutable_value_info()) {
-      updateType(vi);
+      UpdateType(vi);
     }
     for (auto& vi : *graph.mutable_input()) {
-      updateType(vi);
+      UpdateType(vi);
     }
     for (auto& vi : *graph.mutable_output()) {
-      updateType(vi);
+      UpdateType(vi);
     }
     for (const auto& tp : graph.initializer()) {
       TypeProto initializer_type;
@@ -545,7 +582,7 @@ class ShapeInferenceImplBase {
       for (int i = 0; i < tp.dims_size(); ++i) {
         shape->add_dim()->set_dim_value(tp.dims(i));
       }
-      processInitializer(tp.name(), tp, initializer_type, input_data_by_name);
+      ProcessInitializer(tp.name(), tp, initializer_type, input_data_by_name);
     }
     for (const auto& tp : graph.sparse_initializer()) {
       TypeProto initializer_type;
@@ -556,20 +593,20 @@ class ShapeInferenceImplBase {
       for (int i = 0; i < tp.dims_size(); ++i) {
         shape->add_dim()->set_dim_value(tp.dims(i));
       }
-      processInitializer(tp.values().name(), tp, initializer_type, input_sparse_data_by_name);
+      ProcessInitializer(tp.values().name(), tp, initializer_type, input_sparse_data_by_name);
     }
     for (auto& n : *graph.mutable_node()) {
-      process(n);
+      Process(n);
     }
   }
 
-  void process(const NodeProto& n, internal::AttributeBinder& attribute_binder) {
+  void Process(const NodeProto& n, internal::AttributeBinder& attribute_binder) {
     NodeProto copy_n(n);
     attribute_binder.VisitNode(&copy_n);
-    process(copy_n);
+    Process(copy_n);
   }
 
-  void process(const FunctionProto& func_proto, InferenceContext& ctx) {
+  void Process(const FunctionProto& func_proto, InferenceContext& ctx) {
     // Ensure Constant node tensor-attributes are copied
     bool old_reuse_constant_tensors = reuse_constant_tensors;
     reuse_constant_tensors = false;
@@ -618,7 +655,7 @@ class ShapeInferenceImplBase {
 
     internal::AttributeBinder attribute_binder(attr_map);
     for (auto& n : func_proto.node()) {
-      process(n, attribute_binder);
+      Process(n, attribute_binder);
     }
 
     for (int i = 0; i < func_proto.output_size(); ++i) {
@@ -638,7 +675,7 @@ class ShapeInferenceImplBase {
 
  public:
   ShapeInferenceImplBase(
-      GraphProto* g_in,
+      GraphProto* graph, // nullptr for FunctionProto inference
       const std::unordered_map<std::string, TypeProto*>& outer_scope_value_types_by_name_in,
       const std::unordered_map<std::string, int>& opset_imports_in,
       const ShapeInferenceOptions& options_in,
@@ -648,7 +685,7 @@ class ShapeInferenceImplBase {
       DataValueMap* generated_shape_data_by_name_in = nullptr,
       const int ir_version_in = IR_VERSION // default the latest one
       )
-      : g(*g_in),
+      : inferred_types(graph),
         value_types_by_name(outer_scope_value_types_by_name_in),
         opset_imports(opset_imports_in),
         options(options_in),
@@ -671,7 +708,7 @@ class ShapeInferenceImplBase {
     }
   }
 
-  void finalizeShapeInference() {
+  void FinalizeShapeInference() {
     auto& errors = getErrors();
     // Throw shape inference error if any. Error mode right now only supports 0 and 1.
     // When set to 0, any node level shape inference errors are not thrown. This is to support backward compatiblity
@@ -691,7 +728,7 @@ class ShapeInferenceImplBase {
   }
 
  private:
-  GraphProto& g;
+  InferredTypes inferred_types;
   std::unordered_map<std::string, TypeProto*> value_types_by_name;
   const std::unordered_map<std::string, int>& opset_imports;
 
@@ -708,7 +745,6 @@ class ShapeInferenceImplBase {
   std::unordered_map<std::string, TensorProto> input_data_by_name_holder;
   std::unordered_map<std::string, const SparseTensorProto*> input_sparse_data_by_name;
 
-  bool has_experimental_op = false;
   bool has_unsupported_op = false;
 
   std::vector<std::string> inference_errors;
@@ -745,8 +781,8 @@ static void InferShapesImpl(
       schema_registry,
       generated_shape_data_by_name,
       ir_version);
-  base.process(*g);
-  base.finalizeShapeInference();
+  base.Process(*g);
+  base.FinalizeShapeInference();
 }
 
 // Either ModelProto or FunctionProto
@@ -785,8 +821,7 @@ void InferShapes(
   SymbolTableImpl symbol_table;
   ModelLocalFunctionsMap model_local_functions_by_id;
   for (const auto& function_proto : m.functions()) {
-    model_local_functions_by_id.insert(
-        {GetModelLocalFunctionsMapIdentifier(function_proto.domain(), function_proto.name()), &function_proto});
+    model_local_functions_by_id.insert({GetFunctionIdentifier(function_proto), &function_proto});
   }
   InferShapesImpl(
       m.mutable_graph(),
@@ -832,9 +867,8 @@ void InferShapeForFunctionNode(
     const std::unordered_map<std::string, const FunctionProto*>& model_local_functions_map,
     SymbolTable* symbol_table,
     DataValueMap* generated_shape_data_by_name) {
-  GraphProto g;
   ShapeInferenceImplBase base(
-      &g,
+      nullptr, // no graph
       {}, // outer_scope_value_types_by_name
       func_opset_imports,
       options,
@@ -842,8 +876,8 @@ void InferShapeForFunctionNode(
       model_local_functions_map,
       schema_registry,
       generated_shape_data_by_name);
-  base.process(func_proto, ctx);
-  base.finalizeShapeInference();
+  base.Process(func_proto, ctx);
+  base.FinalizeShapeInference();
 }
 
 void InferShapeForFunctionNode(
@@ -953,9 +987,8 @@ std::vector<TypeProto> InferFunctionOutputTypes(
   ShapeInferenceOptions options{true, 1, false};
   FunctionInferenceContext ctx(function_proto, input_types, attributes, options);
   auto opset_imports = GetOpsetImportsFromProto(function_proto);
-  GraphProto g;
   ShapeInferenceImplBase base(
-      &g,
+      nullptr, // no graph
       {}, // outer_scope_value_types_by_name
       opset_imports,
       options,
@@ -963,8 +996,8 @@ std::vector<TypeProto> InferFunctionOutputTypes(
       /*model_local_functions_map*/ {},
       /*schema_registry*/ OpSchemaRegistry::Instance(),
       /*generated_shape_data_by_name*/ nullptr);
-  base.process(function_proto, ctx);
-  base.finalizeShapeInference();
+  base.Process(function_proto, ctx);
+  base.FinalizeShapeInference();
   return ctx.popOutputTypes();
 }
 

onnx/shape_inference.py

@@ -32,11 +32,11 @@ def infer_shapes(
     bug in shape inference), and the result is unspecified.
 
     Arguments:
-        model (Union[ModelProto, bytes], bool, bool, bool) -> ModelProto
-        check_type (bool): Checks the type-equality for input and output
-        strict_mode (bool): Stricter shape inference, it will throw errors if any;
-            Otherwise, simply stop if any error
-        data_prop (bool): Enables data propagation for limited operators to perform shape computation
+        model: ModelProto.
+        check_type: Checks the type-equality for input and output.
+        strict_mode: Stricter shape inference, it will throw errors if any;
+            Otherwise, simply stop if any error.
+        data_prop: Enables data propagation for limited operators to perform shape computation.
 
     Returns:
         (ModelProto) model with inferred shape information
@@ -65,9 +65,11 @@ def infer_shapes_path(
     strict_mode: bool = False,
     data_prop: bool = False,
 ) -> None:
-    """
-    Take model path for shape_inference same as infer_shape; it support >2GB models
-    Directly output the inferred model to the output_path; Default is the original model path
+    """Take model path for shape_inference.
+
+    This function is the same as :func:`infer_shape` but supports >2GB models.
+    The function outputs the inferred model to the `output_path`. The original model path
+    is used if not specified.
     """
     if isinstance(model_path, ModelProto):
         raise TypeError(
@@ -149,8 +151,7 @@ def infer_function_output_types(
     input_types: Sequence[TypeProto],
     attributes: Sequence[AttributeProto],
 ) -> list[TypeProto]:
-    """
-    Apply type-and-shape-inference to given function body, with given input types
+    """Apply type-and-shape-inference to given function body, with given input types
     and given input attribute values.
     """
     result = C.infer_function_output_types(

onnx/subbyte.py

@@ -0,0 +1,72 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Tuple, Union
+
+import numpy as np
+
+INT4_MIN = -8
+INT4_MAX = 7
+UINT4_MIN = 0
+UINT4_MAX = 15
+
+
+def float32_to_4bit_unpacked(
+    x: Union[np.ndarray, np.dtype, float], signed: bool
+) -> np.ndarray:
+    """Cast to 4bit via rounding and clipping (without packing).
+
+    Args:
+        x: element to be converted
+        signed: boolean, whether to convert to signed int4.
+
+    Returns:
+        An ndarray with a single int4 element (sign-extended to int8/uint8)
+    """
+    dtype = np.int8 if signed else np.uint8
+    clip_low = INT4_MIN if signed else UINT4_MIN
+    clip_high = INT4_MAX if signed else UINT4_MAX
+    if not isinstance(x, np.ndarray):
+        x = np.asarray(x)
+
+    return np.rint(np.clip(x, clip_low, clip_high)).astype(dtype)  # type: ignore[no-any-return]
+
+
+def float32x2_to_4bitx2(
+    val_low: np.dtype, val_high: np.dtype, signed: bool
+) -> np.ndarray:
+    """Cast two elements to 4bit (via rounding and clipping) and pack
+    to a single byte
+    Args:
+        val_low: element to be packed in the 4 LSB
+        val_high: element to be packed in the 4 MSB
+        signed: boolean, whether to convert to signed int4.
+
+    Returns:
+        An ndarray with a single int8/uint8 element, containing both int4 elements
+    """
+    i8_high = float32_to_4bit_unpacked(val_high, signed)
+    i8_low = float32_to_4bit_unpacked(val_low, signed)
+    return i8_high << 4 | i8_low & 0x0F  # type: ignore[operator]
+
+
+def unpack_single_4bitx2(
+    x: Union[np.ndarray, np.dtype, float], signed: bool
+) -> Tuple[np.ndarray, np.ndarray]:
+    unpack_signed = lambda x: np.where((x >> 3) == 0, x, x | 0xF0)  # noqa: E731
+    """Unpack a single byte 4bitx2 to two 4 bit elements
+    Args:
+        x: Input data
+        signed: boolean, whether to interpret as signed int4.
+    Returns:
+        A tuple of ndarrays containing int4 elements (sign-extended to int8/uint8)
+    """
+    if not isinstance(x, np.ndarray):
+        x = np.asarray(x)
+    x_low = x & 0x0F
+    x_high = x >> 4
+    x_low = unpack_signed(x_low) if signed else x_low
+    x_high = unpack_signed(x_high) if signed else x_high
+    dtype = np.int8 if signed else np.uint8
+    return (x_low.astype(dtype), x_high.astype(dtype))

onnx/test/__init__.pyi

@@ -0,0 +1,6 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# This file needs to be here to enable mypy type checking for this folder.
+# It doesn't make this a python module for installation purposes as a __init__.pyi would.

onnx/test/checker_test.py

@@ -1,6 +1,8 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+import os
+import tempfile
 import unittest
 from typing import Sequence
 
@@ -98,8 +100,10 @@ class TestChecker(unittest.TestCase):
         ctx.ir_version = 3
         ctx.opset_imports = {"": onnx.defs.onnx_opset_version()}
 
+        lex_ctx = checker.C.LexicalScopeContext()
+
         def check_ir_version_3(g: GraphProto) -> None:
-            checker.check_graph(g, ctx)
+            checker.check_graph(g, ctx, lex_ctx)
 
         node = helper.make_node("Relu", ["X"], ["Y"], name="test")
         graph = helper.make_graph(
@@ -1056,6 +1060,22 @@ class TestChecker(unittest.TestCase):
         # Should not throw an error
         checker.check_model(model, full_check=True)
 
+    def test_check_model_supports_unicode_path(self):
+        input_tensor = helper.make_tensor_value_info(
+            "input", onnx.TensorProto.FLOAT, [1]
+        )
+        output_tensor = helper.make_tensor_value_info(
+            "output", onnx.TensorProto.FLOAT, [1]
+        )
+        node = helper.make_node("Identity", ["input"], ["output"])
+        graph = helper.make_graph([node], "test", [input_tensor], [output_tensor])
+        model = helper.make_model(graph, producer_name="test")
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            unicode_model_path = os.path.join(temp_dir, "模型モデル모델✨.onnx")
+            onnx.save(model, unicode_model_path)
+            checker.check_model(unicode_model_path, full_check=True)
+
 
 if __name__ == "__main__":
     unittest.main()