JSTprove 1.0.0__py3-none-macosx_11_0_arm64.whl → 1.2.0__py3-none-macosx_11_0_arm64.whl

python/tests/onnx_quantizer_tests/layers/gemm_config.py

@@ -0,0 +1,160 @@
+import numpy as np
+
+from python.core.model_processing.onnx_quantizer.exceptions import InvalidParamError
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    LayerTestSpec,
+    e2e_test,
+    error_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class GemmConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Gemm layers"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Gemm"
+
+    def get_config(self) -> LayerTestConfig:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return LayerTestConfig(
+            op_type="Gemm",
+            valid_inputs=["input", "gemm_weight", "gemm_bias"],
+            valid_attributes={"alpha": 1.0, "beta": 1.0, "transA": 0, "transB": 0},
+            required_initializers={
+                "gemm_weight": rng.normal(0, 1, (128, 256)),
+                "gemm_bias": rng.normal(0, 1, (1, 256)),
+            },
+            input_shapes={"input": [1, 128]},  # Match weight input dimension K=128
+            output_shapes={
+                "gemm_output": [1, 256],
+            },  # Match weight output dimension N=256
+        )
+
+    def get_test_specs(self) -> list[LayerTestSpec]:
+        """Return test specifications for Gemm layers"""
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic Gemm operation (no transposes, alpha=1, beta=1)")
+            .tags("basic")
+            .build(),
+            valid_test("transposed_weights")
+            .description("Gemm with transposed weight matrix (transB=1)")
+            .override_attrs(transB=1)
+            .override_initializer(
+                "gemm_weight",
+                rng.normal(0, 1, (256, 128)),
+            )  # Transposed shape
+            .tags("transpose", "transB")
+            .build(),
+            valid_test("transposed_input")
+            .description("Gemm with transposed input (transA=1)")
+            .override_attrs(transA=1)
+            .override_input_shapes(input=[128, 1])  # Aᵀ shape → (K, M)
+            .override_output_shapes(gemm_output=[1, 256])
+            .tags("transpose", "transA")
+            .build(),
+            valid_test("double_transpose")
+            .description("Gemm with transA=1 and transB=1")
+            .override_attrs(transA=1, transB=1)
+            .override_input_shapes(input=[128, 1])
+            .override_initializer("gemm_weight", rng.normal(0, 1, (256, 128)))
+            .override_output_shapes(gemm_output=[1, 256])
+            .tags("transpose", "transA", "transB")
+            .build(),
+            e2e_test("e2e_basic")
+            .description("End-to-end test for basic Gemm layer")
+            .override_attrs(alpha=1.0, beta=1.0, transA=0, transB=0)
+            .override_input_shapes(input=[1, 4])
+            .override_output_shapes(gemm_output=[1, 8])
+            .override_initializer("gemm_weight", rng.normal(0, 1, (4, 8)))
+            .override_initializer("gemm_bias", rng.normal(0, 1, (1, 8)))
+            .tags("e2e", "basic")
+            .build(),
+            e2e_test("e2e_transA_small")
+            .description("Small end-to-end Gemm test with transposed input (transA=1)")
+            .override_attrs(transA=1, transB=0, alpha=1.0, beta=1.0)
+            .override_input_shapes(input=[4, 1])  # A^T shape → (K, M)
+            .override_output_shapes(gemm_output=[1, 6])
+            .override_initializer("gemm_weight", rng.normal(0, 1, (4, 6)))
+            .override_initializer("gemm_bias", rng.normal(0, 1, (1, 6)))
+            .tags("e2e", "transpose", "transA", "small")
+            .build(),
+            e2e_test("e2e_transB_small")
+            .description(
+                "Small end-to-end Gemm test with transposed weights (transB=1)",
+            )
+            .override_attrs(transA=0, transB=1, alpha=1.0, beta=1.0)
+            .override_input_shapes(input=[1, 4])  # A shape
+            .override_output_shapes(gemm_output=[1, 6])
+            .override_initializer("gemm_weight", rng.normal(0, 1, (6, 4)))  # B^T shape
+            .override_initializer("gemm_bias", rng.normal(0, 1, (1, 6)))
+            .tags("e2e", "transpose", "transB", "small")
+            .build(),
+            e2e_test("e2e_transA_transB_small")
+            .description("Small end-to-end Gemm test with both matrices transposed")
+            .override_attrs(transA=1, transB=1, alpha=1.0, beta=1.0)
+            .override_input_shapes(input=[4, 1])  # A^T shape
+            .override_output_shapes(gemm_output=[1, 6])
+            .override_initializer("gemm_weight", rng.normal(0, 1, (6, 4)))  # B^T shape
+            .override_initializer("gemm_bias", rng.normal(0, 1, (1, 6)))
+            .tags("e2e", "transpose", "transA", "transB", "small")
+            .build(),
+            # --- ERROR TESTS ---
+            # Add check on weights matrix in check_supported
+            error_test("invalid_alpha_type")
+            .description("Invalid alpha type (should be numeric)")
+            .override_attrs(alpha=-1.0)
+            .expects_error(
+                InvalidParamError,
+                "alpha value of -1.0 not supported [Attribute: alpha] [Expected: 1.0]",
+            )
+            .tags("invalid_param", "alpha")
+            .build(),
+            error_test("no_bias")
+            .description("Gemm without bias term (beta=0 should ignore bias)")
+            .override_inputs("input", "gemm_weight")
+            .override_attrs(beta=0.0)
+            .expects_error(InvalidParamError, match="3 inputs")
+            .tags("no_bias")
+            .build(),
+            error_test("different_alpha_beta")
+            .description("Gemm with different alpha and beta scaling factors")
+            .override_attrs(alpha=0.5, beta=2.0)
+            .expects_error(
+                InvalidParamError,
+                "alpha value of 0.5 not supported [Attribute: alpha] [Expected: 1.0]",
+            )
+            .tags("scaling", "alpha_beta")
+            .build(),
+            error_test("invalid_transA_value")
+            .description("transA must be 0 or 1")
+            .override_attrs(transA=2)
+            .expects_error(InvalidParamError, "transA value of 2 not supported")
+            .tags("transpose", "invalid_attr")
+            .build(),
+            error_test("invalid_transB_value")
+            .description("transB must be 0 or 1")
+            .override_attrs(transB=-1)
+            .expects_error(InvalidParamError, "transB value of -1 not supported")
+            .tags("transpose", "invalid_attr")
+            .build(),
+            # --- EDGE CASE / SKIPPED TESTS ---
+            valid_test("large_matrix")
+            .description("Large matrix multiplication performance test")
+            .override_initializer("gemm_weight", rng.normal(0, 1, (1024, 2048)))
+            .override_initializer("gemm_bias", rng.normal(0, 1, (1, 2048)))
+            .override_input_shapes(input=[1, 1024])
+            .override_output_shapes(gemm_output=[1, 2048])
+            .tags("large", "performance")
+            .skip("Performance test, not run by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/maxpool_config.py

@@ -0,0 +1,82 @@
+from python.core.model_processing.onnx_quantizer.exceptions import InvalidParamError
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    error_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class MaxPoolConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for MaxPool layers"""
+
+    @property
+    def layer_name(self) -> str:
+        return "MaxPool"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="MaxPool",
+            valid_inputs=["input"],
+            valid_attributes={
+                "kernel_shape": [2, 2],
+                "strides": [2, 2],
+                "dilations": [1, 1],
+                "pads": [0, 0, 0, 0],
+            },
+            required_initializers={},
+        )
+
+    def get_test_specs(self) -> list:
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic MaxPool with 2x2 kernel and stride 2")
+            .tags("basic", "pool", "2d")
+            .build(),
+            valid_test("larger_kernel")
+            .description("MaxPool with 3x3 kernel and stride 1")
+            .override_attrs(kernel_shape=[3, 3], strides=[1, 1])
+            .tags("kernel_3x3", "stride_1", "pool")
+            .build(),
+            valid_test("dilated_pool")
+            .description("MaxPool with dilation > 1")
+            .override_attrs(dilations=[2, 2])
+            .tags("dilation", "pool")
+            .build(),
+            valid_test("stride_one")
+            .description("MaxPool with stride 1 (overlapping windows)")
+            .override_attrs(strides=[1, 1])
+            .tags("stride_1", "pool", "overlap")
+            .build(),
+            e2e_test("e2e_basic")
+            .description("End-to-end test for 2D MaxPool")
+            .override_input_shapes(input=[1, 3, 4, 4])
+            .override_output_shapes(maxpool_output=[1, 3, 2, 2])
+            .tags("e2e", "pool", "2d")
+            .build(),
+            # # --- ERROR TESTS ---
+            error_test("asymmetric_padding")
+            .description("MaxPool with asymmetric padding")
+            .override_attrs(pads=[1, 0, 2, 1])
+            .expects_error(InvalidParamError, "pads[2]=2 >= kernel[0]=2")
+            .tags("padding", "asymmetric", "pool")
+            .build(),
+            error_test("invalid_kernel_shape")
+            .description("Invalid kernel shape length (3D instead of 2D)")
+            .override_attrs(kernel_shape=[2, 2, 2])
+            .expects_error(InvalidParamError, "Currently only MaxPool2D is supported")
+            .tags("invalid_attr_length", "kernel_shape")
+            .build(),
+            # --- EDGE CASE / SKIPPED TEST ---
+            valid_test("large_input")
+            .description("Large MaxPool input (performance/stress test)")
+            .override_input_shapes(input=[1, 3, 64, 64])
+            .override_attrs(kernel_shape=[3, 3], strides=[2, 2])
+            .tags("large", "performance", "pool")
+            .skip("Performance test, skipped by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/mul_config.py

@@ -0,0 +1,102 @@
+import numpy as np
+
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+    LayerTestSpec,
+    e2e_test,
+    edge_case_test,
+    valid_test,
+)
+
+
+class MulConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Mul layer"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Mul"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="Mul",
+            valid_inputs=["A", "B"],
+            valid_attributes={},  # Mul has no layer-specific attributes
+            required_initializers={},
+            input_shapes={
+                "A": [1, 3, 4, 4],
+                "B": [1, 3, 4, 4],
+            },
+            output_shapes={
+                "mul_output": [1, 3, 4, 4],
+            },
+        )
+
+    def get_test_specs(self) -> list[LayerTestSpec]:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic elementwise Mul of two same-shaped tensors")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .tags("basic", "elementwise", "Mul")
+            .build(),
+            valid_test("broadcast_mul")
+            .description("mul with Numpy-style broadcasting along spatial dimensions")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .tags("broadcast", "elementwise", "mul", "onnx14")
+            .build(),
+            valid_test("initializer_mul")
+            .description(
+                "mul where second input (B) is a tensor initializer instead of input",
+            )
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", rng.normal(0, 1, (1, 3, 4, 4)))
+            .tags("initializer", "elementwise", "mul", "onnxruntime")
+            .build(),
+            valid_test("scalar_mul")
+            .description("mul scalar (initializer) to tensor")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", np.array([2.0], dtype=np.float32))
+            .tags("scalar", "elementwise", "mul")
+            .build(),
+            # # --- E2E TESTS ---
+            e2e_test("e2e_mul")
+            .description("End-to-end mul test with random inputs")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .override_output_shapes(mul_output=[1, 3, 4, 4])
+            .tags("e2e", "mul", "2d")
+            .build(),
+            e2e_test("e2e_initializer_mul")
+            .description(
+                "mul where second input (B) is a tensor initializer instead of input",
+            )
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", rng.normal(0, 1, (1, 3, 4, 4)))
+            .tags("initializer", "elementwise", "mul", "onnxruntime")
+            .build(),
+            e2e_test("e2e_broadcast_mul")
+            .description("mul with Numpy-style broadcasting along spatial dimensions")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .tags("broadcast", "elementwise", "mul", "onnx14")
+            .build(),
+            e2e_test("e2e_scalar_mul")
+            .description("mul scalar (initializer) to tensor")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", np.array([2.0], dtype=np.float32))
+            .tags("scalar", "elementwise", "mul")
+            .build(),
+            # # --- EDGE CASES ---
+            edge_case_test("empty_tensor")
+            .description("mul with empty tensor input (zero elements)")
+            .override_input_shapes(A=[0], B=[0])
+            .tags("edge", "empty", "mul")
+            .build(),
+            edge_case_test("large_tensor")
+            .description("Large tensor mul performance/stress test")
+            .override_input_shapes(A=[1, 64, 256, 256], B=[1, 64, 256, 256])
+            .tags("large", "performance", "mul")
+            .skip("Performance test, skipped by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/relu_config.py

@@ -0,0 +1,61 @@
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class ReluConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Relu layers"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Relu"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="Relu",
+            valid_inputs=["input"],
+            valid_attributes={},
+            required_initializers={},
+        )
+
+    def get_test_specs(self) -> list:
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic ReLU activation")
+            .tags("basic", "activation")
+            .build(),
+            valid_test("negative_inputs")
+            .description("ReLU should zero out negative input values")
+            .override_input_shapes(input=[1, 3, 4, 4])
+            .tags("activation", "negative_values")
+            .build(),
+            valid_test("high_dimension_input")
+            .description("ReLU applied to a 5D input tensor (NCHWT layout)")
+            .override_input_shapes(input=[1, 3, 4, 4, 2])
+            .tags("activation", "high_dim", "5d")
+            .build(),
+            valid_test("scalar_input")
+            .description("ReLU with scalar input (edge case)")
+            .override_input_shapes(input=[1])
+            .tags("activation", "scalar")
+            .build(),
+            e2e_test("e2e_basic")
+            .description("End-to-end test for ReLU activation")
+            .override_input_shapes(input=[1, 3, 4, 4])
+            .override_output_shapes(relu_output=[1, 3, 4, 4])
+            .tags("e2e", "activation")
+            .build(),
+            # --- EDGE CASE / SKIPPED TEST ---
+            valid_test("large_input")
+            .description("Large input tensor for ReLU (performance/stress test)")
+            .override_input_shapes(input=[1, 3, 512, 512])
+            .tags("large", "performance", "activation")
+            .skip("Performance test, skipped by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/reshape_config.py

@@ -0,0 +1,61 @@
+import numpy as np
+
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class ReshapeConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Reshape layers"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Reshape"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="Reshape",
+            valid_inputs=["input", "shape"],
+            valid_attributes={},
+            required_initializers={"shape": np.array([1, -1])},
+        )
+
+    def get_test_specs(self) -> list:
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic Reshape from (1,2,3,4) to (1,24)")
+            .tags("basic", "reshape")
+            .build(),
+            valid_test("reshape_expand_dims")
+            .description("Reshape expanding dimensions (1,24) → (1,3,8)")
+            .override_input_shapes(input=[1, 24])
+            .tags("reshape", "expand")
+            .build(),
+            valid_test("reshape_flatten")
+            .description("Reshape to flatten spatial dimensions (1,3,4,4) → (1,48)")
+            .override_input_shapes(input=[1, 24])
+            .override_initializer("shape", np.array([1, 3, -1]))
+            .tags("reshape", "flatten")
+            .build(),
+            e2e_test("e2e_basic")
+            .description("End-to-end test for Reshape layer")
+            .override_input_shapes(input=[1, 2, 3, 4])
+            .override_output_shapes(reshape_output=[1, 24])
+            .override_initializer("shape", np.array([1, -1]))
+            .tags("e2e", "reshape")
+            .build(),
+            # --- EDGE CASE / SKIPPED TEST ---
+            valid_test("large_input")
+            .description("Large reshape performance test")
+            .override_input_shapes(input=[1, 3, 256, 256])
+            .override_initializer("shape", np.array([1, -1]))
+            .tags("large", "performance", "reshape")
+            # .skip("Performance test, skipped by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/sub_config.py

@@ -0,0 +1,102 @@
+import numpy as np
+
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+    LayerTestSpec,
+    e2e_test,
+    edge_case_test,
+    valid_test,
+)
+
+
+class SubConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for Sub layer"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Sub"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="Sub",
+            valid_inputs=["A", "B"],
+            valid_attributes={},  # Sub has no layer-specific attributes
+            required_initializers={},
+            input_shapes={
+                "A": [1, 3, 4, 4],
+                "B": [1, 3, 4, 4],
+            },
+            output_shapes={
+                "sub_output": [1, 3, 4, 4],
+            },
+        )
+
+    def get_test_specs(self) -> list[LayerTestSpec]:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic elementwise Sub of two same-shaped tensors")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .tags("basic", "elementwise", "Sub")
+            .build(),
+            valid_test("broadcast_Sub")
+            .description("Sub with Numpy-style broadcasting along spatial dimensions")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .tags("broadcast", "elementwise", "Sub", "onnx14")
+            .build(),
+            valid_test("initializer_Sub")
+            .description(
+                "Sub where second input (B) is a tensor initializer instead of input",
+            )
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", rng.normal(0, 1, (1, 3, 4, 4)))
+            .tags("initializer", "elementwise", "Sub", "onnxruntime")
+            .build(),
+            valid_test("scalar_Sub")
+            .description("Sub scalar (initializer) to tensor")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", np.array([2.0], dtype=np.float32))
+            .tags("scalar", "elementwise", "Sub")
+            .build(),
+            # --- E2E TESTS ---
+            e2e_test("e2e_Sub")
+            .description("End-to-end Sub test with random inputs")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .override_output_shapes(sub_output=[1, 3, 4, 4])
+            .tags("e2e", "Sub", "2d")
+            .build(),
+            e2e_test("e2e_initializer_Sub")
+            .description(
+                "Sub where second input (B) is a tensor initializer instead of input",
+            )
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", rng.normal(0, 1, (1, 3, 4, 4)))
+            .tags("initializer", "elementwise", "Sub", "onnxruntime")
+            .build(),
+            e2e_test("e2e_broadcast_Sub")
+            .description("Sub with Numpy-style broadcasting along spatial dimensions")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .tags("broadcast", "elementwise", "Sub", "onnx14")
+            .build(),
+            e2e_test("e2e_scalar_Sub")
+            .description("Sub scalar (initializer) to tensor")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", np.array([2.0], dtype=np.float32))
+            .tags("scalar", "elementwise", "Sub")
+            .build(),
+            # # --- EDGE CASES ---
+            edge_case_test("empty_tensor")
+            .description("Sub with empty tensor input (zero elements)")
+            .override_input_shapes(A=[0], B=[0])
+            .tags("edge", "empty", "Sub")
+            .build(),
+            edge_case_test("large_tensor")
+            .description("Large tensor Sub performance/stress test")
+            .override_input_shapes(A=[1, 64, 256, 256], B=[1, 64, 256, 256])
+            .tags("large", "performance", "Sub")
+            .skip("Performance test, skipped by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers_tests/base_test.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+import pytest
+from onnx import TensorProto, helper
+
+if TYPE_CHECKING:
+    from onnx import ModelProto
+
+    from python.tests.onnx_quantizer_tests.layers.base import (
+        LayerTestConfig,
+        LayerTestSpec,
+    )
+from python.core.model_processing.onnx_quantizer.onnx_op_quantizer import (
+    ONNXOpQuantizer,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import TestLayerFactory
+
+
+class BaseQuantizerTest:
+    """Base test utilities for ONNX quantizer tests."""
+
+    __test__ = False  # Prevent pytest from collecting this class directly
+
+    _validation_failed_cases: ClassVar[set[str]] = set()
+
+    @pytest.fixture
+    def quantizer(self) -> ONNXOpQuantizer:
+        return ONNXOpQuantizer()
+
+    @pytest.fixture
+    def layer_configs(self) -> dict[str, LayerTestConfig]:
+        return TestLayerFactory.get_layer_configs()
+
+    @staticmethod
+    def _generate_test_id(
+        test_case_tuple: tuple[str, LayerTestConfig, LayerTestSpec],
+    ) -> str:
+        try:
+            layer_name, _, test_spec = test_case_tuple
+        except Exception:
+            return str(test_case_tuple)
+        else:
+            return f"{layer_name}_{test_spec.name}"
+
+    @classmethod
+    def _check_validation_dependency(
+        cls: BaseQuantizerTest,
+        test_case_data: tuple[str, LayerTestConfig, LayerTestSpec],
+    ) -> None:
+        layer_name, _, test_spec = test_case_data
+        test_case_id = f"{layer_name}_{test_spec.name}"
+        if test_case_id in cls._validation_failed_cases:
+            pytest.skip(f"Skipping because ONNX validation failed for {test_case_id}")
+
+    @staticmethod
+    def create_model_with_layers(
+        layer_types: list[str],
+        layer_configs: dict[str, LayerTestConfig],
+    ) -> ModelProto:
+        """Create a model composed of several layers."""
+        nodes, all_initializers = [], {}
+
+        for i, layer_type in enumerate(layer_types):
+            config = layer_configs[layer_type]
+            node = config.create_node(name_suffix=f"_{i}")
+            if i > 0:
+                prev_output = f"{layer_types[i-1].lower()}_output_{i-1}"
+                if node.input:
+                    node.input[0] = prev_output
+            nodes.append(node)
+            all_initializers.update(config.create_initializers())
+
+        graph = helper.make_graph(
+            nodes,
+            "test_graph",
+            [
+                helper.make_tensor_value_info(
+                    "input",
+                    TensorProto.FLOAT,
+                    [1, 16, 224, 224],
+                ),
+            ],
+            [
+                helper.make_tensor_value_info(
+                    f"{layer_types[-1].lower()}_output_{len(layer_types)-1}",
+                    TensorProto.FLOAT,
+                    [1, 10],
+                ),
+            ],
+            initializer=list(all_initializers.values()),
+        )
+        return helper.make_model(graph)