onnx 1.15.0__cp38-cp38-win_amd64.whl → 1.16.1__cp38-cp38-win_amd64.whl

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

@@ -11,112 +11,146 @@ from onnx.backend.test.case.node import expect
 
 class QLinearMatMul(Base):
     @staticmethod
-    def export() -> None:
-        node = onnx.helper.make_node(
-            "QLinearMatMul",
-            inputs=[
-                "a",
-                "a_scale",
-                "a_zero_point",
-                "b",
-                "b_scale",
-                "b_zero_point",
-                "y_scale",
-                "y_zero_point",
-            ],
-            outputs=["y"],
-        )
-
-        # 2D
-        a = np.array(
-            [
-                [208, 236, 0, 238],
-                [3, 214, 255, 29],
-            ],
-            dtype=np.uint8,
-        )
-
-        a_scale = np.array([0.0066], dtype=np.float32)
-        a_zero_point = np.array([113], dtype=np.uint8)
-
-        b = np.array(
-            [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
-            dtype=np.uint8,
-        )
-
-        b_scale = np.array([0.00705], dtype=np.float32)
-        b_zero_point = np.array([114], dtype=np.uint8)
-
-        y_scale = np.array([0.0107], dtype=np.float32)
-        y_zero_point = np.array([118], dtype=np.uint8)
-
-        output = np.array(
-            [
-                [168, 115, 255],
-                [1, 66, 151],
-            ],
-            dtype=np.uint8,
-        )
-
-        expect(
-            node,
-            inputs=[
-                a,
-                a_scale,
-                a_zero_point,
-                b,
-                b_scale,
-                b_zero_point,
-                y_scale,
-                y_zero_point,
-            ],
-            outputs=[output],
-            name="test_qlinearmatmul_2D",
-        )
-
-        # 3D
-        a = np.array(
-            [
-                [[208, 236, 0, 238], [3, 214, 255, 29]],
-                [[208, 236, 0, 238], [3, 214, 255, 29]],
-            ],
-            dtype=np.uint8,
-        )
-
-        a_scale = np.array([0.0066], dtype=np.float32)
-        a_zero_point = np.array([113], dtype=np.uint8)
-
-        b = np.array(
-            [
-                [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
-                [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
-            ],
-            dtype=np.uint8,
-        )
-
-        b_scale = np.array([0.00705], dtype=np.float32)
-        b_zero_point = np.array([114], dtype=np.uint8)
-
-        y_scale = np.array([0.0107], dtype=np.float32)
-        y_zero_point = np.array([118], dtype=np.uint8)
-
-        output = np.array(
-            [[[168, 115, 255], [1, 66, 151]], [[168, 115, 255], [1, 66, 151]]],
-            dtype=np.uint8,
-        )
-
-        expect(
-            node,
-            inputs=[
-                a,
-                a_scale,
-                a_zero_point,
-                b,
-                b_scale,
-                b_zero_point,
-                y_scale,
-                y_zero_point,
-            ],
-            outputs=[output],
-            name="test_qlinearmatmul_3D",
-        )
+    def export_int() -> None:
+        for quant_type_name in ["uint8", "int8"]:
+            quant_type = getattr(np, quant_type_name)
+            for dtype_name in ["float32", "float16"]:
+                dtype = getattr(np, dtype_name)
+                node = onnx.helper.make_node(
+                    "QLinearMatMul",
+                    inputs=[
+                        "a",
+                        "a_scale",
+                        "a_zero_point",
+                        "b",
+                        "b_scale",
+                        "b_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    outputs=["y"],
+                )
+
+                # 2D
+                a = np.array([[208, 236, 0, 238], [3, 214, 255, 29]])
+                if quant_type == np.int8:
+                    a -= 127
+                a = a.astype(quant_type)
+
+                a_scale = np.array([0.0066], dtype=dtype)
+                a_zero_point = np.array(
+                    [113 - 127] if quant_type == np.int8 else [113], dtype=quant_type
+                )
+
+                b = np.array(
+                    [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]]
+                )
+                if quant_type == np.int8:
+                    b -= 127
+                b = b.astype(quant_type)
+
+                b_scale = np.array([0.00705], dtype=dtype)
+                b_zero_point = np.array(
+                    [114 - 127] if quant_type == np.int8 else [114], dtype=quant_type
+                )
+
+                y_scale = np.array([0.0107], dtype=dtype)
+                y_zero_point = np.array(
+                    [118 - 127] if quant_type == np.int8 else [118], dtype=quant_type
+                )
+
+                if quant_type == np.int8:
+                    output = np.array([[41, -12, -9], [1, -75, 20]])
+                else:
+                    output = np.array([[168, 115, 255], [1, 66, 151]])
+                output = output.astype(quant_type)
+
+                expect(
+                    node,
+                    inputs=[
+                        a,
+                        a_scale,
+                        a_zero_point,
+                        b,
+                        b_scale,
+                        b_zero_point,
+                        y_scale,
+                        y_zero_point,
+                    ],
+                    outputs=[output],
+                    name=f"test_qlinearmatmul_2D_{quant_type_name}_{dtype_name}",
+                )
+
+                # 3D
+                a = np.array(
+                    [
+                        [[208, 236, 0, 238], [3, 214, 255, 29]],
+                        [[208, 236, 0, 238], [3, 214, 255, 29]],
+                    ],
+                )
+                if quant_type == np.int8:
+                    a -= 127
+                a = a.astype(quant_type)
+
+                a_scale = np.array([0.0066], dtype=dtype)
+                a_zero_point = np.array(
+                    [113 - 127] if quant_type == np.int8 else [113], dtype=quant_type
+                )
+
+                b = np.array(
+                    [
+                        [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
+                        [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
+                    ],
+                )
+                if quant_type == np.int8:
+                    b -= 127
+                b = b.astype(quant_type)
+
+                b_scale = np.array([0.00705], dtype=dtype)
+                b_zero_point = np.array([114], dtype=quant_type)
+
+                y_scale = np.array([0.0107], dtype=dtype)
+                y_zero_point = np.array(
+                    [118 - 127] if quant_type == np.int8 else [118], dtype=quant_type
+                )
+
+                if quant_type == np.int8:
+                    if dtype == np.float32:
+                        output = np.array(
+                            [
+                                [[-86, 117, 120], [115, 39, -121]],
+                                [[-86, 117, 120], [115, 39, -121]],
+                            ]
+                        )
+                    else:
+                        output = np.array(
+                            [
+                                [[-86, 116, 119], [115, 39, -121]],
+                                [[-86, 116, 119], [115, 39, -121]],
+                            ]
+                        )
+                else:
+                    output = np.array(
+                        [
+                            [[168, 115, 255], [1, 66, 151]],
+                            [[168, 115, 255], [1, 66, 151]],
+                        ]
+                    )
+                output = output.astype(quant_type)
+
+                expect(
+                    node,
+                    inputs=[
+                        a,
+                        a_scale,
+                        a_zero_point,
+                        b,
+                        b_scale,
+                        b_zero_point,
+                        y_scale,
+                        y_zero_point,
+                    ],
+                    outputs=[output],
+                    name=f"test_qlinearmatmul_3D_{quant_type_name}_{dtype_name}",
+                )

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

@@ -73,10 +73,8 @@ class QuantizeLinear(Base):
 
         x = np.array([0.0, 1.0, 2.0, 100000.0, 200.0]).astype(np.float32)
         y_scale = np.float32(2)
-        y_zero_point = make_tensor("zero_point", TensorProto.FLOAT8E4M3FN, [1], [0])
-        y = make_tensor(
-            "zero_point", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, 96]
-        )
+        y_zero_point = make_tensor("y_zero_point", TensorProto.FLOAT8E4M3FN, [1], [0])
+        y = make_tensor("y", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, 96])
 
         expect(
             node,
@@ -95,14 +93,307 @@ class QuantizeLinear(Base):
 
         x = np.array([0.0, 1.0, 2.0, 100000.0, 200.0]).astype(np.float32)
         y_scale = np.float32(2)
-        y_zero_point = make_tensor("zero_point", TensorProto.FLOAT8E5M2, [1], [0.0])
+        y_zero_point = make_tensor("y_zero_point", TensorProto.FLOAT8E5M2, [1], [0.0])
+        y = make_tensor("y", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, 96])
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_e5m2",
+        )
+
+    @staticmethod
+    def export_uint16() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array(
+            [
+                0.0,
+                -128.0,
+                3.0,
+                -3.0,
+                2.9,
+                -2.9,
+                3.1,
+                -3.1,
+                65536.0,
+                -65534.0,
+                70000.0,
+                -70000.0,
+            ]
+        ).astype(np.float32)
+        y_scale = np.float32(2.0)
+        y_zero_point = np.uint16(32767)
+        y = np.array(
+            [
+                32767,
+                32703,
+                32769,
+                32765,
+                32768,
+                32766,
+                32769,
+                32765,
+                65535,
+                0,
+                65535,
+                0,
+            ]
+        ).astype(np.uint16)
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_uint16",
+        )
+
+    @staticmethod
+    def export_int16() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array(
+            [
+                0.0,
+                -514.0,
+                3.0,
+                -3.0,
+                2.9,
+                -2.9,
+                3.1,
+                -3.1,
+                65022.0,
+                -66046.0,
+                65023.0,
+                -66047.0,
+                65024.0,
+                -66048.0,
+                70000.0,
+                -70000.0,
+            ]
+        ).astype(np.float32)
+        y_scale = np.float32(2.0)
+        y_zero_point = np.int16(256)
+        y = np.array(
+            [
+                256,
+                -1,
+                258,
+                254,
+                257,
+                255,
+                258,
+                254,
+                32767,
+                -32767,
+                32767,
+                -32768,
+                32767,
+                -32768,
+                32767,
+                -32768,
+            ]
+        ).astype(np.int16)
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_int16",
+        )
+
+    @staticmethod
+    def export_uint4() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        x = np.array(
+            [
+                [0.0, 2.5, 4.8, 8.6],
+                [-30, -20, 6, 9],
+                [12, 15, 16, 40],
+            ]
+        ).astype(np.float32)
+
+        y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+        y_zero_point = make_tensor(
+            "y_zero_point", TensorProto.UINT4, y_scale.shape, np.ones_like(y_scale)
+        )
         y = make_tensor(
-            "zero_point", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, 96]
+            "y", TensorProto.UINT4, x.shape, [1, 2, 3, 5, -1, -1, 3, 4, 4, 5, 5, 11]
         )
 
         expect(
             node,
             inputs=[x, y_scale, y_zero_point],
             outputs=[y],
-            name="test_quantizelinear_e5m2",
+            name="test_quantizelinear_uint4",
+        )
+
+    @staticmethod
+    def export_int4() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        x = np.array(
+            [
+                [0.0, 2.5, 4.8, 8.6],
+                [-30, -20, 6, 9],
+                [12, 15, 16, 40],
+            ]
+        ).astype(np.float32)
+
+        y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+        y_zero_point = make_tensor(
+            "y_zero_point", TensorProto.INT4, y_scale.shape, np.ones_like(y_scale)
+        )
+        y = make_tensor(
+            "y", TensorProto.INT4, x.shape, [1, 2, 3, 5, -8, -6, 3, 4, 4, 5, 5, 7]
+        )
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_int4",
+        )
+
+    @staticmethod
+    def export_blocked_asymmetric() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+            axis=1,
+            block_size=2,
+        )
+
+        x = np.array(
+            [
+                [6.0, 12.0, 50.0, 5.0],
+                [1.0, 8.0, 4.0, 5.0],
+                [0.0, 20.0, 10.0, 4.0],
+            ],
+            dtype=np.float32,
+        )
+        y_scale = np.array(
+            [
+                [1.5, 2.5],
+                [3.0, 4.9],
+                [5.1, 6.9],
+            ],
+            dtype=np.float32,
+        )
+        y_zero_point = np.array(
+            [
+                [0, 1],
+                [1, 0],
+                [2, 3],
+            ],
+            dtype=np.uint8,
+        )
+        # x.shape = (3, 4)
+        # y_scale.shape = (3, 2)
+        assert y_scale.shape == y_zero_point.shape
+        block_axis = 1
+        # The block shape is [x.shape[i] // y_scale.shape[i] for i in range(len(x.shape))] = (1, 2)
+        assert all(
+            x.shape[i] == y_scale.shape[i]
+            for i in range(len(x.shape))
+            if i != block_axis
+        )
+        assert x.shape[block_axis] % y_scale.shape[block_axis] == 0
+        repeats = x.shape[block_axis] // y_scale.shape[block_axis]
+
+        # Create element-wise scale and zero point
+        y_scale_elementwise = np.repeat(y_scale, repeats=repeats, axis=block_axis)
+        y_zero_point_elementwise = np.repeat(
+            y_zero_point, repeats=repeats, axis=block_axis
+        )
+
+        y = np.rint(x / y_scale_elementwise + y_zero_point_elementwise).astype(np.uint8)
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_blocked_asymmetric",
+        )
+
+    @staticmethod
+    def export_blocked_symmetric() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale"],
+            outputs=["y"],
+            axis=1,
+            block_size=2,
+            output_dtype=TensorProto.INT16,
+        )
+
+        x = np.array(
+            [
+                [6.0, -8, -10, 5.0],
+                [1.0, 8.0, 4.0, 5.0],
+                [0.0, 20.0, 10.0, 4.0],
+            ],
+            dtype=np.float32,
+        )
+
+        y_scale = np.array(
+            [
+                [1.5, 2.5],
+                [3.0, 4.9],
+                [5.1, 6.9],
+            ],
+            dtype=np.float32,
+        )
+
+        # x.shape = (3, 4)
+        # y_scale.shape = (3, 2)
+
+        block_axis = 1
+        # The block shape is [x.shape[i] // y_scale.shape[i] for i in range(len(x.shape))] = (1, 2)
+        assert all(
+            x.shape[i] == y_scale.shape[i]
+            for i in range(len(x.shape))
+            if i != block_axis
+        )
+        assert x.shape[block_axis] % y_scale.shape[block_axis] == 0
+        repeats = x.shape[block_axis] // y_scale.shape[block_axis]
+
+        # Create element-wise scale and zero point
+        y_scale_elementwise = np.repeat(y_scale, repeats=repeats, axis=block_axis)
+
+        y_val = np.clip(
+            np.rint(x / y_scale_elementwise), a_min=-32768, a_max=32767
+        ).astype(np.int16)
+        y = make_tensor(
+            "y",
+            TensorProto.INT16,
+            x.shape,
+            y_val,
+        )
+        expect(
+            node,
+            inputs=[x, y_scale],
+            outputs=[y],
+            name="test_quantizelinear_blocked_symmetric",
         )

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

@@ -202,3 +202,29 @@ class ReduceMax(Base):
             outputs=[reduced],
             name="test_reduce_max_bool_inputs",
         )
+
+    @staticmethod
+    def export_empty_set() -> None:
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 1, 4]
+
+        node = onnx.helper.make_node(
+            "ReduceMax",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([1], dtype=np.int64)
+        one = np.array(np.ones(reduced_shape, dtype=np.float32))
+        zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+        reduced = -(one / zero)  # -inf
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_min_empty_set",
+        )

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

@@ -35,7 +35,7 @@ class RNNHelper:
             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/scan.py

@@ -20,7 +20,9 @@ class Scan(Base):
         sum_in = onnx.helper.make_tensor_value_info(
             "sum_in", onnx.TensorProto.FLOAT, [2]
         )
-        next = onnx.helper.make_tensor_value_info("next", onnx.TensorProto.FLOAT, [2])
+        next = onnx.helper.make_tensor_value_info(  # noqa: A001
+            "next", onnx.TensorProto.FLOAT, [2]
+        )
         sum_out = onnx.helper.make_tensor_value_info(
             "sum_out", onnx.TensorProto.FLOAT, [2]
         )
@@ -71,7 +73,9 @@ class Scan(Base):
         sum_in = onnx.helper.make_tensor_value_info(
             "sum_in", onnx.TensorProto.FLOAT, [2]
         )
-        next = onnx.helper.make_tensor_value_info("next", onnx.TensorProto.FLOAT, [2])
+        next = onnx.helper.make_tensor_value_info(  # noqa: A001
+            "next", onnx.TensorProto.FLOAT, [2]
+        )
         sum_out = onnx.helper.make_tensor_value_info(
             "sum_out", onnx.TensorProto.FLOAT, [2]
         )

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

@@ -59,7 +59,7 @@ def scatter_elements(data, indices, updates, axis=0, reduction="none"):  # type:
         idx, updates_idx = make_indices_for_duplicate(idx), make_indices_for_duplicate(
             updates_idx
         )
-        for iter, idx_set in enumerate(idx):
+        for iter, idx_set in enumerate(idx):  # noqa: A001
             if reduction == "add":
                 scattered[idx_set] += updates[updates_idx[iter]]
             elif reduction == "mul":

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

@@ -58,7 +58,7 @@ class TopK(Base):
     def export_top_k_smallest() -> None:
         axis = 1
         largest = 0
-        sorted = 1
+        sorted = 1  # noqa: A001
         k = 3
 
         node = onnx.helper.make_node(

onnx/backend/test/case/utils.py

@@ -27,9 +27,7 @@ all_numeric_dtypes = [
 
 
 def import_recursive(package: ModuleType) -> None:
-    """
-    Takes a package and imports all modules underneath it
-    """
+    """Takes a package and imports all modules underneath it."""
     pkg_dir: Optional[List[str]] = None
     pkg_dir = package.__path__  # type: ignore
     module_location = package.__name__