onnx 1.16.2__cp312-cp312-win_amd64.whl → 1.18.0__cp312-cp312-win_amd64.whl

onnx/subbyte.py

@@ -1,10 +1,16 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
-from typing import Tuple, Union
+import typing
 
 import numpy as np
+import numpy.typing as npt
+import typing_extensions
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Sequence
 
 INT4_MIN = -8
 INT4_MAX = 7
@@ -12,8 +18,16 @@ UINT4_MIN = 0
 UINT4_MAX = 15
 
 
-def float32_to_4bit_unpacked(
-    x: Union[np.ndarray, np.dtype, float], signed: bool
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def float32_to_4bit_unpacked(*args, **kwargs):
+    return _float32_to_4bit_unpacked(*args, **kwargs)
+
+
+def _float32_to_4bit_unpacked(
+    x: np.ndarray | np.dtype | float, signed: bool
 ) -> np.ndarray:
     """Cast to 4bit via rounding and clipping (without packing).
 
@@ -30,10 +44,19 @@ def float32_to_4bit_unpacked(
     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]
+    clipped = np.clip(x, clip_low, clip_high)
+    return np.rint(clipped).astype(dtype)  # type: ignore[no-any-return]
+
+
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def float32x2_to_4bitx2(*args, **kwargs):
+    return _float32x2_to_4bitx2(*args, **kwargs)
 
 
-def float32x2_to_4bitx2(
+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
@@ -46,15 +69,60 @@ def float32x2_to_4bitx2(
     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]
+    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
 
 
-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
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def unpack_4bitx2(*args, **kwargs):
+    return _unpack_4bitx2(*args, **kwargs)
+
+
+def _unpack_4bitx2(
+    x: npt.NDArray[np.uint8], dims: int | Sequence[int]
+) -> npt.NDArray[np.uint8]:
+    """Unpack an array of packed uint8 elements (4bitx2) into individual elements
+    (still represented as uint8)
+
+    Args:
+        x: Input data
+        dims: The shape of the output array.
+
+    Returns:
+        A array containing unpacked 4-bit elements (as int8/uint8)
+    """
+    res = np.empty([x.size * 2], dtype=np.uint8)
+    x_low = x & np.uint8(0x0F)
+    x_high = x & np.uint8(0xF0)
+    x_high >>= np.uint8(4)
+    res[0::2] = x_low
+    res[1::2] = x_high
+    if (
+        res.size == np.prod(dims) + 1
+    ):  # handle single-element padding due to odd number of elements
+        res = res.ravel()[:-1]
+    res = res.reshape(dims)
+    return res
+
+
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def unpack_single_4bitx2(*args, **kwargs):
+    return _unpack_single_4bitx2(*args, **kwargs)
+
+
+def _unpack_single_4bitx2(
+    x: np.ndarray | np.dtype | float, signed: bool
+) -> tuple[np.ndarray, np.ndarray]:
+    def unpack_signed(x):
+        return np.where((x >> 3) == 0, x, x | 0xF0)
+
     """Unpack a single byte 4bitx2 to two 4 bit elements
     Args:
         x: Input data
@@ -70,3 +138,57 @@ def unpack_single_4bitx2(
     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))
+
+
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def float32_to_float4e2m1_unpacked(*args, **kwargs):
+    return _float32_to_float4e2m1_unpacked(*args, **kwargs)
+
+
+def _float32_to_float4e2m1_unpacked(values: np.ndarray) -> np.ndarray:
+    """Cast float32 to float4e2m1 (without packing).
+
+    Args:
+        values: element or array to be converted
+
+    Returns:
+        An ndarray with unpacked float4e2m1 elements (as uint8)
+    """
+    sign = np.where(np.signbit(values), 0x8, 0x0).astype(np.uint8)
+    magnitude = np.abs(values)
+    res = np.zeros(values.shape, dtype=np.uint8)
+    res[(magnitude > 0.25) & (magnitude < 0.75)] = 0x1  # noqa: PLR2004
+    res[(magnitude >= 0.75) & (magnitude <= 1.25)] = 0x2  # noqa: PLR2004
+    res[(magnitude > 1.25) & (magnitude < 1.75)] = 0x3  # noqa: PLR2004
+    res[(magnitude >= 1.75) & (magnitude <= 2.5)] = 0x4  # noqa: PLR2004
+    res[(magnitude > 2.5) & (magnitude < 3.5)] = 0x5  # noqa: PLR2004
+    res[(magnitude >= 3.5) & (magnitude <= 5.0)] = 0x6  # noqa: PLR2004
+    res[magnitude > 5.0] = 0x7  # noqa: PLR2004
+    res |= sign
+    res[np.isnan(values)] = 0x7
+    return res
+
+
+@typing_extensions.deprecated(
+    "Deprecated since 1.18. Scheduled to remove in 1.20. Consider using libraries like ml_dtypes for dtype conversion",
+    category=DeprecationWarning,
+)
+def float32x2_to_float4e2m1x2(*args, **kwargs):
+    return _float32x2_to_float4e2m1x2(*args, **kwargs)
+
+
+def _float32x2_to_float4e2m1x2(val_low: np.ndarray, val_high: np.ndarray) -> np.ndarray:
+    """Cast two elements to float4e2m1 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
+
+    Returns:
+        An ndarray with uint8 elements, containing both float4e2m1 elements
+    """
+    i8_high = _float32_to_float4e2m1_unpacked(val_high)
+    i8_low = _float32_to_float4e2m1_unpacked(val_low)
+    return i8_high << 4 | i8_low & 0x0F

onnx/test/basic_test.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import io
 import os

onnx/test/checker_test.py

@@ -1,10 +1,12 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
 import os
 import tempfile
 import unittest
-from typing import Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -20,6 +22,9 @@ from onnx import (
     shape_inference,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 class TestChecker(unittest.TestCase):
     @property
@@ -797,7 +802,7 @@ class TestChecker(unittest.TestCase):
                             ],
                             outputs=[
                                 helper.make_tensor_value_info(
-                                    "cond___while_Identity_graph_outputs_Identity__3_0",
+                                    "cond___while_Less__13_0",
                                     TensorProto.BOOL,
                                     shape=[],
                                 ),
@@ -825,7 +830,7 @@ class TestChecker(unittest.TestCase):
                                     outputs=["cond___while_Less__13_0"],
                                     name="cond___while_Less__13",
                                     domain="",
-                                    to=TensorProto.FLOAT,
+                                    to=TensorProto.BOOL,
                                 ),
                             ],
                         ),
@@ -1076,6 +1081,39 @@ class TestChecker(unittest.TestCase):
             onnx.save(model, unicode_model_path)
             checker.check_model(unicode_model_path, full_check=True)
 
+    def test_graph_output_is_defined(self):
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[N] x) => (float[N] y, float[N] z)
+            {
+                y = Add(x, x)
+            }
+            # Error: z is not defined
+        """
+        )
+        self.assertRaises(checker.ValidationError, checker.check_model, model)
+
+    def test_graph_output_is_defined_within_sub_graph(self):
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[N] x, bool cond) => (float[N] y)
+            {
+                sum = Add (x, x)
+                prod = Mul (x, x)
+                y = If (cond) <
+                    then_branch = then_graph () => (sum) {},
+                    else_branch = else_graph () => (prod) {}
+                >
+            }
+            # Error: sum/prod are accessible inside if-then-else branches, but cannot
+            # be used as outputs of the then/else branch implicitly.
+            # An explicit "Identity(sum)" must be used to return sum as output.
+        """
+        )
+        self.assertRaises(checker.ValidationError, checker.check_model, model)
+
 
 if __name__ == "__main__":
     unittest.main()

onnx/test/compose_test.py

@@ -1,9 +1,10 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import unittest
-from typing import Callable, List, Optional, Sequence, Tuple
+from typing import TYPE_CHECKING, Callable
 
 import numpy as np
 
@@ -22,6 +23,9 @@ from onnx import (
     version_converter,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 def _load_model(m_def: str) -> ModelProto:
     """Parses a model from a string representation, including checking the model for correctness"""
@@ -35,7 +39,7 @@ def _prefixed(prefix: str, s: str) -> str:
     return prefix + s if len(s) > 0 else s
 
 
-def _get_shape(value_info: ValueInfoProto) -> List[int]:
+def _get_shape(value_info: ValueInfoProto) -> list[int]:
     """Returns a list of integers representing the shape of the provided ValueInfoProto"""
     return [
         value_info.type.tensor_type.shape.dim[d].dim_value
@@ -87,7 +91,7 @@ M2_DEF = """
     {
         C0 = Add(B01, B11)
         C1 = Sub(B11, B21)
-        M1 = Mul(C0, C1)
+        D0 = Mul(C0, C1)
     }
     """
 
@@ -97,12 +101,12 @@ class TestComposeFunctions(unittest.TestCase):
         self,
         m1def: str,
         m2def: str,
-        io_map: List[Tuple[str, str]],
+        io_map: list[tuple[str, str]],
         check_expectations: Callable[[GraphProto, GraphProto, GraphProto], None],
-        inputs: Optional[List[str]] = None,
-        outputs: Optional[List[str]] = None,
-        prefix1: Optional[str] = None,
-        prefix2: Optional[str] = None,
+        inputs: list[str] | None = None,
+        outputs: list[str] | None = None,
+        prefix1: str | None = None,
+        prefix2: str | None = None,
     ) -> None:
         m1, m2 = _load_model(m1def), _load_model(m2def)
         g3 = compose.merge_graphs(
@@ -767,9 +771,9 @@ class TestComposeFunctions(unittest.TestCase):
         def _make_function(
             domain: str,
             fname: str,
-            inputs: List[str],
-            outputs: List[str],
-            nodes: List[NodeProto],
+            inputs: list[str],
+            outputs: list[str],
+            nodes: list[NodeProto],
         ) -> FunctionProto:
             f = FunctionProto()
             f.domain = domain

onnx/test/cpp/data_propagation_test.cc

@@ -4,14 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <iostream>
-
 #include "gtest/gtest.h"
-#include "onnx/checker.h"
 #include "onnx/defs/parser.h"
 #include "onnx/defs/schema.h"
-#include "onnx/defs/shape_inference.h"
-#include "onnx/onnx_pb.h"
 #include "onnx/shape_inference/implementation.h"
 
 using namespace ONNX_NAMESPACE::shape_inference;
@@ -20,7 +15,7 @@ namespace ONNX_NAMESPACE {
 
 namespace Test {
 
-inline bool CompareShape(
+static bool CompareShape(
     const TensorShapeProto& inferredShape,
     const TensorShapeProto& expectedShape,
     bool checkSameParam = false) {
@@ -43,7 +38,7 @@ inline bool CompareShape(
   return true;
 }
 
-TensorShapeProto RunDataPropagation(const char* graphCode, int domainVersion = 15) {
+static TensorShapeProto RunDataPropagation(const char* graphCode, int domainVersion = 15) {
   // Parses the graph from graphCode
   GraphProto graph;
   OnnxParser parser(graphCode);
@@ -303,6 +298,23 @@ agraph (int32[1,2] x, int32[3,4] y) => (int32[4] w)
   EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
 }
 
+TEST(DataPropagationImplTest, DynamicConcatTest) {
+  const char* code = R"ONNX(
+agraph (float[32, 1024] x, int64[2] dynamic_shape) => (int64[4] z)
+{
+    xs = Shape(x)   # [32, 1024]
+    z = Concat<axis = 0>(xs, dynamic_shape)  # [32, 1024, ?, ?]
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(32);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(1024);
+  expected_tsp.mutable_dim()->Add();
+  expected_tsp.mutable_dim()->Add();
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
 TEST(DataPropagationImplTest, GatherTest) {
   const char* code = R"ONNX(
 agraph (int32[1,2,3,4,5,6] x) => (int32[3] w)

onnx/test/cpp/function_context_test.cc

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <iostream>
+#include <stdexcept>
 
 #include "gtest/gtest.h"
 #include "onnx/checker.h"
@@ -14,15 +14,12 @@
 
 using namespace ONNX_NAMESPACE::checker;
 
-#pragma warning(push)
-#pragma warning(disable : 4530)
-
 namespace ONNX_NAMESPACE {
 namespace Test {
 
 // Utilities. TODO: Turn them into reusable ONNX utilities for use by
 
-TensorProto ToTensor(double value, TensorProto_DataType elem_type) {
+static TensorProto ToTensor(double value, TensorProto_DataType elem_type) {
   TensorProto t;
   t.set_data_type(elem_type);
   switch (elem_type) {
@@ -42,9 +39,8 @@ TensorProto ToTensor(double value, TensorProto_DataType elem_type) {
   return t;
 }
 
-void BuildNodes(FunctionProto& functionProto, const std::vector<FunctionBodyHelper::NodeDef>& node_defs) {
-  for (size_t i = 0; i < node_defs.size(); i++) {
-    const FunctionBodyHelper::NodeDef& node = node_defs[i];
+static void BuildNodes(FunctionProto& functionProto, const std::vector<FunctionBodyHelper::NodeDef>& node_defs) {
+  for (const auto& node : node_defs) {
     auto* np = functionProto.add_node();
 
     np->set_op_type(node.op_type);
@@ -60,7 +56,7 @@ void BuildNodes(FunctionProto& functionProto, const std::vector<FunctionBodyHelp
   }
 }
 
-bool BuildFunctionProto(
+static bool BuildFunctionProto(
     FunctionProto& functionProto,
     const OpSchema& schema,
     const std::vector<FunctionBodyHelper::NodeDef>& node_defs) {
@@ -71,7 +67,7 @@ bool BuildFunctionProto(
 
 // A monomorphic context-dependent function test-case.
 static bool
-BuildFloatFunctionBody(const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) {
+BuildFloatFunctionBody(const FunctionBodyBuildContext& /*ctx*/, const OpSchema& schema, FunctionProto& functionProto) {
   // Create a scalar-tensor constant 2.0 of float type:
   auto two_as_tensor = ToTensor(2.0, TensorProto_DataType::TensorProto_DataType_FLOAT);
 
@@ -82,7 +78,7 @@ BuildFloatFunctionBody(const FunctionBodyBuildContext& ctx, const OpSchema& sche
   return BuildFunctionProto(functionProto, schema, body);
 }
 
-void RegisterCustomFuncFloatSchema() {
+static void RegisterCustomFuncFloatSchema() {
   ONNX_NAMESPACE::OpSchema schema;
   schema.SetName("CustomFuncFloat")
       .SetDomain(ONNX_DOMAIN)
@@ -141,7 +137,7 @@ BuildFunctionBody(const FunctionBodyBuildContext& ctx, const OpSchema& schema, F
   return BuildFunctionProto(functionProto, schema, body);
 }
 
-void RegisterCustomFunctionSchema() {
+static void RegisterCustomFunctionSchema() {
   ONNX_NAMESPACE::OpSchema schema;
   schema.SetName("CustomFunction")
       .SetDomain(ONNX_DOMAIN)
@@ -220,7 +216,7 @@ TEST(FunctionAPITest, VersionedFunctionBodyTest) {
   const auto* schema2 = OpSchemaRegistry::Schema("MySub", 2, ONNX_DOMAIN);
   EXPECT_TRUE(schema2);
   for (int model_opset_import = 2; model_opset_import < 9; model_opset_import++) {
-    try {
+    ONNX_TRY {
       bool validate = true;
       const FunctionProto* function = schema2->GetFunction(model_opset_import, validate);
       if (model_opset_import >= 6) { // function body should be updated at opset 6 where Sub is updated
@@ -228,19 +224,23 @@ TEST(FunctionAPITest, VersionedFunctionBodyTest) {
       } else {
         ASSERT_TRUE(function);
       }
-    } catch (std::runtime_error err) {
-      ASSERT_TRUE(model_opset_import == 6 || model_opset_import == 7 || model_opset_import == 8);
+    }
+    ONNX_CATCH(const std::runtime_error&) {
+      ONNX_HANDLE_EXCEPTION(
+          [&]() { ASSERT_TRUE(model_opset_import == 6 || model_opset_import == 7 || model_opset_import == 8); });
     }
   }
 
   const auto* schema9 = OpSchemaRegistry::Schema("MySub", 9, ONNX_DOMAIN);
   EXPECT_TRUE(schema9);
   for (int model_opset_import = 9; model_opset_import < 10; model_opset_import++) {
-    try {
+    ONNX_TRY {
       const FunctionProto* function = schema9->GetFunction(model_opset_import);
       ASSERT_TRUE(function);
-    } catch (std::runtime_error err) {
-      ASSERT_TRUE(model_opset_import == 13 || model_opset_import == 14 || model_opset_import == 15);
+    }
+    ONNX_CATCH(const std::runtime_error&) {
+      ONNX_HANDLE_EXCEPTION(
+          [&]() { ASSERT_TRUE(model_opset_import == 13 || model_opset_import == 14 || model_opset_import == 15); });
     }
   }
 }
@@ -276,4 +276,3 @@ TEST(FunctionAPITest, TypeContextTest) {
 
 } // namespace Test
 } // namespace ONNX_NAMESPACE
-#pragma warning(pop)