onnx 1.15.0__cp39-cp39-win32.whl → 1.16.1__cp39-cp39-win32.whl

onnx/backend/test/case/node/dequantizelinear.py

@@ -149,3 +149,158 @@ class DequantizeLinear(Base):
             outputs=[y],
             name="test_dequantizelinear_e5m2",
         )
+
+    @staticmethod
+    def export_uint16() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array([30000, 31000, 32768, 33000]).astype(np.uint16)
+        x_scale = np.float32(2)
+        x_zero_point = np.uint16(32767)
+        y = np.array([-5534.0, -3534.0, 2.0, 466.0], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_uint16",
+        )
+
+    @staticmethod
+    def export_int16() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array([-300, -30, -1025, 1270]).astype(np.int16)
+        x_scale = np.float32(2)
+        x_zero_point = np.int16(-1024)
+        y = np.array([1448.0, 1988.0, -2.0, 4588.0], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_int16",
+        )
+
+    @staticmethod
+    def export_uint4() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.UINT4, [5], [0, 1, 7, 10, 15])
+        x_scale = np.float32(2)
+        x_zero_point = make_tensor("x_zero_point", TensorProto.UINT4, (1,), [1])
+        y = np.array([-2, 0, 12, 18, 28], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_uint4",
+        )
+
+    @staticmethod
+    def export_int4() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.INT4, [5], [0, 1, 7, -4, -8])
+        x_scale = np.float32(2)
+        x_zero_point = make_tensor("x_zero_point", TensorProto.INT4, (1,), [1])
+        y = np.array([-2, 0, 12, -10, -18], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_int4",
+        )
+
+    @staticmethod
+    def export_blocked() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+            axis=1,
+            block_size=2,
+        )
+
+        x = np.array(
+            [
+                [
+                    [[3, 89], [34, 200], [74, 59]],
+                    [[5, 24], [24, 87], [32, 13]],
+                    [[5, 12], [12, 33], [65, 42]],
+                    [[245, 99], [4, 142], [121, 102]],
+                ],
+            ],
+            dtype=np.uint8,
+        )
+
+        x_scale = np.array(
+            [
+                [
+                    [[3.0, 2.0], [4.0, 1.0], [2.0, 2.0]],
+                    [[5.0, 2.0], [4.0, 3.0], [5.0, 2.0]],
+                ],
+            ],
+            dtype=np.float32,
+        )
+        x_zero_point = np.array(
+            [
+                [
+                    [[1, 0], [0, 1], [2, 20]],
+                    [[3, 2], [4, 3], [15, 2]],
+                ],
+            ],
+            dtype=np.uint8,
+        )
+
+        # x.shape = (1, 4, 3, 2)
+        # x_scale.shape = (1, 2, 3, 2)
+        assert x_scale.shape == x_zero_point.shape
+        block_axis = 1
+        # The block shape is [x.shape[i] // x_scale.shape[i] for i in range(len(x.shape))] = (1, 2, 1, 1)
+        assert all(
+            x.shape[i] == x_scale.shape[i]
+            for i in range(len(x.shape))
+            if i != block_axis
+        )
+        assert x.shape[block_axis] % x_scale.shape[block_axis] == 0
+        repeats = x.shape[block_axis] // x_scale.shape[block_axis]
+
+        # Create element-wise scale and zero point
+        x_scale_elementwise = np.repeat(x_scale, repeats=repeats, axis=block_axis)
+        x_zero_point_elementwise = np.repeat(
+            x_zero_point, repeats=repeats, axis=block_axis
+        )
+
+        y = (
+            x.astype(np.float32) - x_zero_point_elementwise.astype(np.float32)
+        ) * x_scale_elementwise
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_blocked",
+        )

onnx/backend/test/case/node/groupnormalization.py

@@ -20,20 +20,21 @@ def _group_normalization(x, num_groups, scale, bias, epsilon=1e-5):
     axes = tuple(range(2, len(new_shape)))
     mean = np.mean(x_reshaped, axis=axes, keepdims=True)
     var = np.var(x_reshaped, axis=axes, keepdims=True)
-    dim_ones = (1,) * (len(new_shape) - 2)
+    x_normalized = ((x_reshaped - mean) / np.sqrt(var + epsilon)).reshape(x.shape)
+    dim_ones = (1,) * (len(x.shape) - 2)
     scale = scale.reshape(-1, *dim_ones)
     bias = bias.reshape(-1, *dim_ones)
-    res = scale * (x_reshaped - mean) / np.sqrt(var + epsilon) + bias
-    return res.reshape(x.shape)
+    return scale * x_normalized + bias
 
 
 class GroupNormalization(Base):
     @staticmethod
     def export() -> None:
-        x = np.random.randn(3, 4, 2, 2).astype(np.float32)
+        c = 4
         num_groups = 2
-        scale = np.random.randn(num_groups).astype(np.float32)
-        bias = np.random.randn(num_groups).astype(np.float32)
+        x = np.random.randn(3, c, 2, 2).astype(np.float32)
+        scale = np.random.randn(c).astype(np.float32)
+        bias = np.random.randn(c).astype(np.float32)
         y = _group_normalization(x, num_groups, scale, bias).astype(np.float32)
 
         node = onnx.helper.make_node(
@@ -50,10 +51,13 @@ class GroupNormalization(Base):
             name="test_group_normalization_example",
         )
 
-        x = np.random.randn(3, 4, 2, 2).astype(np.float32)
+    @staticmethod
+    def export_epsilon() -> None:
+        c = 4
         num_groups = 2
-        scale = np.random.randn(num_groups).astype(np.float32)
-        bias = np.random.randn(num_groups).astype(np.float32)
+        x = np.random.randn(3, c, 2, 2).astype(np.float32)
+        scale = np.random.randn(c).astype(np.float32)
+        bias = np.random.randn(c).astype(np.float32)
         epsilon = 1e-2
         y = _group_normalization(x, num_groups, scale, bias, epsilon).astype(np.float32)
 

onnx/backend/test/case/node/gru.py

@@ -37,7 +37,7 @@ class GRUHelper:
             hidden_size = params[R].shape[-1]
             batch_size = params[X].shape[1]
 
-            layout = params[LAYOUT] if LAYOUT in params else 0
+            layout = params.get(LAYOUT, 0)
             x = params[X]
             x = x if layout == 0 else np.swapaxes(x, 0, 1)
             b = (
@@ -46,7 +46,7 @@ class GRUHelper:
                 else np.zeros(2 * number_of_gates * hidden_size)
             )
             h_0 = params[H_0] if H_0 in params else np.zeros((batch_size, hidden_size))
-            lbr = params[LBR] if LBR in params else 0
+            lbr = params.get(LBR, 0)
 
             self.X = x
             self.W = params[W]

onnx/backend/test/case/node/isinf.py

@@ -18,7 +18,7 @@ class IsInf(Base):
             outputs=["y"],
         )
 
-        x = np.array([-1.2, np.nan, np.inf, 2.8, np.NINF, np.inf], dtype=np.float32)
+        x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float32)
         y = np.isinf(x)
         expect(node, inputs=[x], outputs=[y], name="test_isinf")
 
@@ -28,7 +28,7 @@ class IsInf(Base):
             "IsInf", inputs=["x"], outputs=["y"], detect_negative=0
         )
 
-        x = np.array([-1.7, np.nan, np.inf, 3.6, np.NINF, np.inf], dtype=np.float32)
+        x = np.array([-1.7, np.nan, np.inf, 3.6, -np.inf, np.inf], dtype=np.float32)
         y = np.isposinf(x)
         expect(node, inputs=[x], outputs=[y], name="test_isinf_positive")
 
@@ -38,7 +38,7 @@ class IsInf(Base):
             "IsInf", inputs=["x"], outputs=["y"], detect_positive=0
         )
 
-        x = np.array([-1.7, np.nan, np.inf, -3.6, np.NINF, np.inf], dtype=np.float32)
+        x = np.array([-1.7, np.nan, np.inf, -3.6, -np.inf, np.inf], dtype=np.float32)
         y = np.isneginf(x)
         expect(node, inputs=[x], outputs=[y], name="test_isinf_negative")
 
@@ -50,6 +50,6 @@ class IsInf(Base):
             outputs=["y"],
         )
 
-        x = np.array([-1.2, np.nan, np.inf, 2.8, np.NINF, np.inf], dtype=np.float16)
+        x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float16)
         y = np.isinf(x)
         expect(node, inputs=[x], outputs=[y], name="test_isinf_float16")

onnx/backend/test/case/node/isnan.py

@@ -18,7 +18,7 @@ class IsNaN(Base):
             outputs=["y"],
         )
 
-        x = np.array([-1.2, np.nan, np.inf, 2.8, np.NINF, np.inf], dtype=np.float32)
+        x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float32)
         y = np.isnan(x)
         expect(node, inputs=[x], outputs=[y], name="test_isnan")
 
@@ -30,6 +30,6 @@ class IsNaN(Base):
             outputs=["y"],
         )
 
-        x = np.array([-1.2, np.nan, np.inf, 2.8, np.NINF, np.inf], dtype=np.float16)
+        x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float16)
         y = np.isnan(x)
         expect(node, inputs=[x], outputs=[y], name="test_isnan_float16")

onnx/backend/test/case/node/lppool.py

@@ -18,8 +18,7 @@ from onnx.reference.ops.op_pool_common import (
 class LpPool(Base):
     @staticmethod
     def export_lppool_1d_default() -> None:
-        """
-        input_shape: [1, 3, 32]
+        """input_shape: [1, 3, 32]
         output_shape: [1, 3, 31]
         """
         p = 3
@@ -46,8 +45,7 @@ class LpPool(Base):
 
     @staticmethod
     def export_lppool_2d_default() -> None:
-        """
-        input_shape: [1, 3, 32, 32]
+        """input_shape: [1, 3, 32, 32]
         output_shape: [1, 3, 31, 31]
         """
         p = 4
@@ -73,8 +71,7 @@ class LpPool(Base):
 
     @staticmethod
     def export_lppool_3d_default() -> None:
-        """
-        input_shape: [1, 3, 32, 32, 32]
+        """input_shape: [1, 3, 32, 32, 32]
         output_shape: [1, 3, 31, 31, 31]
         """
         p = 3
@@ -100,8 +97,7 @@ class LpPool(Base):
 
     @staticmethod
     def export_lppool_2d_same_upper() -> None:
-        """
-        input_shape: [1, 3, 32, 32]
+        """input_shape: [1, 3, 32, 32]
         output_shape: [1, 3, 32, 32]
         pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
         """
@@ -141,8 +137,7 @@ class LpPool(Base):
 
     @staticmethod
     def export_lppool_2d_same_lower() -> None:
-        """
-        input_shape: [1, 3, 32, 32]
+        """input_shape: [1, 3, 32, 32]
         output_shape: [1, 3, 32, 32]
         pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
         """
@@ -182,8 +177,7 @@ class LpPool(Base):
 
     @staticmethod
     def export_lppool_2d_pads() -> None:
-        """
-        input_shape: [1, 3, 28, 28]
+        """input_shape: [1, 3, 28, 28]
         output_shape: [1, 3, 30, 30]
         pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
         """
@@ -217,8 +211,7 @@ class LpPool(Base):
 
     @staticmethod
     def export_lppool_2d_strides() -> None:
-        """
-        input_shape: [1, 3, 32, 32]
+        """input_shape: [1, 3, 32, 32]
         output_shape: [1, 3, 10, 10]
         """
         p = 2
@@ -245,8 +238,7 @@ class LpPool(Base):
 
     @staticmethod
     def export_lppool_2d_dilations() -> None:
-        """
-        input_shape: [1, 1, 4, 4]
+        """input_shape: [1, 1, 4, 4]
         output_shape: [1, 1, 2, 2]
         """
         p = 2

onnx/backend/test/case/node/lstm.py

@@ -39,7 +39,7 @@ class LSTMHelper:
             hidden_size = params[R].shape[-1]
             batch_size = params[X].shape[1]
 
-            layout = params[LAYOUT] if LAYOUT in params else 0
+            layout = params.get(LAYOUT, 0)
             x = params[X]
             x = x if layout == 0 else np.swapaxes(x, 0, 1)
             b = (

onnx/backend/test/case/node/maxpool.py

@@ -18,8 +18,7 @@ from onnx.reference.ops.op_pool_common import (
 class MaxPool(Base):
     @staticmethod
     def export_maxpool_2d_uint8() -> None:
-        """
-        input_shape: [1, 1, 5, 5]
+        """input_shape: [1, 1, 5, 5]
         output_shape: [1, 1, 5, 5]
         pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
         """
@@ -61,8 +60,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_2d_precomputed_pads() -> None:
-        """
-        input_shape: [1, 1, 5, 5]
+        """input_shape: [1, 1, 5, 5]
         output_shape: [1, 1, 5, 5]
         pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
         """
@@ -104,8 +102,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_with_argmax_2d_precomputed_pads() -> None:
-        """
-        input_shape: [1, 1, 5, 5]
+        """input_shape: [1, 1, 5, 5]
         output_shape: [1, 1, 5, 5]
         pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
         """
@@ -165,8 +162,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_2d_precomputed_strides() -> None:
-        """
-        input_shape: [1, 1, 5, 5]
+        """input_shape: [1, 1, 5, 5]
         output_shape: [1, 1, 2, 2]
         """
         node = onnx.helper.make_node(
@@ -193,8 +189,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_with_argmax_2d_precomputed_strides() -> None:
-        """
-        input_shape: [1, 1, 5, 5]
+        """input_shape: [1, 1, 5, 5]
         output_shape: [1, 1, 2, 2]
         """
         node = onnx.helper.make_node(
@@ -230,8 +225,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_2d_precomputed_same_upper() -> None:
-        """
-        input_shape: [1, 1, 5, 5]
+        """input_shape: [1, 1, 5, 5]
         output_shape: [1, 1, 3, 3]
         pad_shape: [2, 2] -> [1, 1, 1, 1] by axis
         """
@@ -264,8 +258,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_1d_default() -> None:
-        """
-        input_shape: [1, 3, 32]
+        """input_shape: [1, 3, 32]
         output_shape: [1, 3, 31]
         """
         node = onnx.helper.make_node(
@@ -289,8 +282,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_2d_default() -> None:
-        """
-        input_shape: [1, 3, 32, 32]
+        """input_shape: [1, 3, 32, 32]
         output_shape: [1, 3, 31, 31]
         """
         node = onnx.helper.make_node(
@@ -314,8 +306,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_3d_default() -> None:
-        """
-        input_shape: [1, 3, 32, 32, 32]
+        """input_shape: [1, 3, 32, 32, 32]
         output_shape: [1, 3, 31, 31, 31]
         """
         node = onnx.helper.make_node(
@@ -339,8 +330,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_2d_same_upper() -> None:
-        """
-        input_shape: [1, 3, 32, 32]
+        """input_shape: [1, 3, 32, 32]
         output_shape: [1, 3, 32, 32]
         pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
         """
@@ -378,8 +368,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_2d_same_lower() -> None:
-        """
-        input_shape: [1, 3, 32, 32]
+        """input_shape: [1, 3, 32, 32]
         output_shape: [1, 3, 32, 32]
         pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
         """
@@ -417,8 +406,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_2d_pads() -> None:
-        """
-        input_shape: [1, 3, 28, 28]
+        """input_shape: [1, 3, 28, 28]
         output_shape: [1, 3, 30, 30]
         pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
         """
@@ -451,8 +439,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_2d_strides() -> None:
-        """
-        input_shape: [1, 3, 32, 32]
+        """input_shape: [1, 3, 32, 32]
         output_shape: [1, 3, 10, 10]
         """
         node = onnx.helper.make_node(
@@ -473,8 +460,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_2d_ceil() -> None:
-        """
-        input_shape: [1, 1, 4, 4]
+        """input_shape: [1, 1, 4, 4]
         output_shape: [1, 1, 2, 2]
         """
         node = onnx.helper.make_node(
@@ -502,9 +488,31 @@ class MaxPool(Base):
         expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_ceil")
 
     @staticmethod
-    def export_maxpool_2d_dilations() -> None:
+    def export_maxpool_2d_ceil_output_size_reduce_by_one() -> None:
+        """input_shape: [1, 1, 2, 2]
+        output_shape: [1, 1, 1, 1]
         """
-        input_shape: [1, 1, 4, 4]
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[1, 1],
+            strides=[2, 2],
+            ceil_mode=True,
+        )
+        x = np.array([[[[1, 2], [3, 4]]]]).astype(np.float32)
+        y = np.array([[[[1]]]]).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_maxpool_2d_ceil_output_size_reduce_by_one",
+        )
+
+    @staticmethod
+    def export_maxpool_2d_dilations() -> None:
+        """input_shape: [1, 1, 4, 4]
         output_shape: [1, 1, 2, 2]
         """
         node = onnx.helper.make_node(
@@ -533,8 +541,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_3d_dilations() -> None:
-        """
-        input_shape: [1, 1, 4, 4, 4]
+        """input_shape: [1, 1, 4, 4, 4]
         output_shape: [1, 1, 2, 2, 2]
         """
         node = onnx.helper.make_node(
@@ -585,8 +592,7 @@ class MaxPool(Base):
 
     @staticmethod
     def export_maxpool_3d_dilations_use_ref_impl() -> None:
-        """
-        input_shape: [1, 1, 4, 4, 4]
+        """input_shape: [1, 1, 4, 4, 4]
         output_shape: [1, 1, 2, 2, 2]
         """
         dilations = [2, 2, 2]

onnx/backend/test/case/node/pow.py

@@ -9,7 +9,7 @@ from onnx.backend.test.case.base import Base
 from onnx.backend.test.case.node import expect
 
 
-def pow(x, y):  # type: ignore
+def pow(x, y):  # type: ignore  # noqa: A001
     z = np.power(x, y).astype(x.dtype)
     return z