onnx 1.17.0__cp311-cp311-win32.whl → 1.19.0__cp311-cp311-win32.whl

onnx/subbyte.py

@@ -3,7 +3,14 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
+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
@@ -11,9 +18,11 @@ UINT4_MIN = 0
 UINT4_MAX = 15
 
 
-def float32_to_4bit_unpacked(
-    x: np.ndarray | np.dtype | float, signed: bool
-) -> np.ndarray:
+@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(x: np.ndarray | float, signed: bool) -> np.ndarray:
     """Cast to 4bit via rounding and clipping (without packing).
 
     Args:
@@ -33,6 +42,10 @@ def float32_to_4bit_unpacked(
     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(
     val_low: np.dtype, val_high: np.dtype, signed: bool
 ) -> np.ndarray:
@@ -46,15 +59,52 @@ 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)  # type: ignore[arg-type]
+    i8_low = float32_to_4bit_unpacked(val_low, signed)  # type: ignore[arg-type]
+    return i8_high << 4 | i8_low & 0x0F
+
+
+@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(
+    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(
     x: 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
+    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 +120,49 @@ 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(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(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/checker_test.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import os
 import tempfile
 import unittest
-from typing import Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -22,6 +22,9 @@ from onnx import (
     shape_inference,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 class TestChecker(unittest.TestCase):
     @property

onnx/test/compose_test.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 import unittest
-from typing import Callable, Sequence
+from typing import TYPE_CHECKING, Callable
 
 import numpy as np
 
@@ -23,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"""
@@ -390,7 +393,96 @@ class TestComposeFunctions(unittest.TestCase):
         m3 = compose.merge_models(m1, m2, io_map=io_map)
         checker.check_model(m3)
 
-    # FIXME: This function should be removed, as tests should not contain a copy of the tested logic.
+    def test_add_prefix_to_inputs_outputs(self) -> None:
+        """Tests prefixing inputs and outputs nodes."""
+        input_graph = """
+            <
+                ir_version: 6,
+                opset_import: [ "": 13]
+            >
+            agraph (float[N, 128] X, float[128, 10] W, float[10] B) => (float[N, 10] C)
+            {
+                T = MatMul(X, W)
+                S = Add(T, B)
+                C = Softmax(S)
+            }
+            """
+        input_model = _load_model(input_graph)
+        prefix = "pre_"
+        prefixed_model = compose.add_prefix(
+            model=input_model,
+            prefix=prefix,
+            rename_inputs=True,
+            rename_outputs=True,
+            rename_edges=True,
+        )
+
+        checker.check_graph(prefixed_model.graph)
+
+        for i in prefixed_model.graph.input:
+            self.assertTrue(i.name.startswith(prefix))
+        for o in prefixed_model.graph.output:
+            self.assertTrue(o.name.startswith(prefix))
+
+    def test_add_prefix_wo_inputs_outputs(self) -> None:
+        """Tests prefixing input and output nodes, when renaming of inputs/outputs is deactivated."""
+        input_graph = """
+            <
+                ir_version: 6,
+                opset_import: [ "": 13]
+            >
+            agraph (float[2,2] A) => (float[2,2] B)
+            {
+            B = Identity(A)
+            }
+            """
+        input_model = _load_model(input_graph)
+        prefix = "pre_"
+        prefixed_model = compose.add_prefix(
+            model=input_model,
+            prefix=prefix,
+            rename_inputs=False,
+            rename_outputs=False,
+            rename_edges=True,
+        )
+
+        checker.check_graph(prefixed_model.graph)
+        self.assertEqual(input_model.graph.input, prefixed_model.graph.input)
+        self.assertEqual(input_model.graph.output, prefixed_model.graph.output)
+
+    def test_add_prefix_with_loose_inputs_outputs(self) -> None:
+        """Tests prefixing of graphs with loose inputs."""
+        input_graph = """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 13 ]
+            >
+            agraph (bool b, float[128] X, float[128] Y, bool unused_input) => (float[128] Z)
+            {
+            Z = If (b) <
+                then_branch = g1 () => (float[128] z_then) { z_then = Add(X, X) },
+                else_branch = g2 () => (float[128] z_else) { z_else = Sub(Y, Y) }
+                >
+            }
+            """
+        input_model = _load_model(input_graph)
+        prefix = "pre_"
+        prefixed_model = compose.add_prefix(
+            model=input_model,
+            prefix=prefix,
+            rename_inputs=True,
+            rename_outputs=True,
+            rename_edges=True,
+        )
+        checker.check_graph(prefixed_model.graph)
+
+        # Check if all inputs are prefixed even if input is not connected to node. e.g., 'unused_input'.
+        for i in prefixed_model.graph.input:
+            self.assertTrue(i.name.startswith(prefix))
+
+        for graph_output in prefixed_model.graph.output:
+            self.assertTrue(graph_output.name.startswith(prefix))
+
     def _test_add_prefix(
         self,
         rename_nodes: bool = False,
@@ -513,7 +605,9 @@ class TestComposeFunctions(unittest.TestCase):
 
     def test_add_prefix_edges(self) -> None:
         """Tests prefixing nodes edges. This will also rename inputs/outputs, since the names are shared"""
-        self._test_add_prefix(rename_edges=True)
+        self._test_add_prefix(
+            rename_edges=True, rename_inputs=True, rename_outputs=True
+        )
 
     def test_add_prefix_inputs(self) -> None:
         """Tests prefixing graph inputs only. Relevant node edges should be renamed as well"""

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,18 +67,19 @@ 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);
 
-  std::vector<FunctionBodyHelper::NodeDef> body{// nodes: {outputs, op, inputs, attributes}
-                                                {{"Two"}, "Constant", {}, {{"value", two_as_tensor}}},
-                                                {{"Y"}, "Mul", {"X", "Two"}}};
+  std::vector<FunctionBodyHelper::NodeDef> body{
+      // nodes: {outputs, op, inputs, attributes}
+      {{"Two"}, "Constant", {}, {{"value", two_as_tensor}}},
+      {{"Y"}, "Mul", {"X", "Two"}}};
 
   return BuildFunctionProto(functionProto, schema, body);
 }
 
-void RegisterCustomFuncFloatSchema() {
+static void RegisterCustomFuncFloatSchema() {
   ONNX_NAMESPACE::OpSchema schema;
   schema.SetName("CustomFuncFloat")
       .SetDomain(ONNX_DOMAIN)
@@ -96,7 +93,7 @@ void RegisterCustomFuncFloatSchema() {
   (void)unused;
 }
 
-// Test for Context dependant function without type context
+// Test for Context dependent function without type context
 TEST(FunctionAPITest, ContextDependentFunctionTest) {
   RegisterCustomFuncFloatSchema();
 
@@ -134,14 +131,15 @@ BuildFunctionBody(const FunctionBodyBuildContext& ctx, const OpSchema& schema, F
   auto elem_type = (TensorProto_DataType)tp->tensor_type().elem_type();
   auto two_as_tensor = ToTensor(2.0, elem_type);
 
-  std::vector<FunctionBodyHelper::NodeDef> body{// nodes: {outputs, op, inputs, attributes}
-                                                {{"Two"}, "Constant", {}, {{"value", two_as_tensor}}},
-                                                {{"Y"}, "Mul", {"X", "Two"}}};
+  std::vector<FunctionBodyHelper::NodeDef> body{
+      // nodes: {outputs, op, inputs, attributes}
+      {{"Two"}, "Constant", {}, {{"value", two_as_tensor}}},
+      {{"Y"}, "Mul", {"X", "Two"}}};
 
   return BuildFunctionProto(functionProto, schema, body);
 }
 
-void RegisterCustomFunctionSchema() {
+static void RegisterCustomFunctionSchema() {
   ONNX_NAMESPACE::OpSchema schema;
   schema.SetName("CustomFunction")
       .SetDomain(ONNX_DOMAIN)
@@ -220,7 +218,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 +226,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 +278,3 @@ TEST(FunctionAPITest, TypeContextTest) {
 
 } // namespace Test
 } // namespace ONNX_NAMESPACE
-#pragma warning(pop)