JSTprove 1.1.0__py3-none-macosx_11_0_arm64.whl → 1.3.0__py3-none-macosx_11_0_arm64.whl

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/test_integration.py

@@ -159,21 +159,22 @@ class TestIntegration(BaseQuantizerTest):
         quantized_input_names = [inp.name for inp in quantized_session.get_inputs()]
         quantized_output_name = quantized_session.get_outputs()[0].name
 
-        # For quantized model, scale the inputs
-        scaled_inputs = {}
+        # For the quantized model, cast inputs to float64 for ORT
+        quantized_inputs = {}
         for name in quantized_input_names:
             if name in dummy_inputs:
-                scaled_inputs[name] = (dummy_inputs[name]).astype(np.float64)
+                quantized_inputs[name] = dummy_inputs[name].astype(np.float64)
             else:
-                # If quantized model has different inputs, skip or handle
+                # If quantized model has different inputs, skip this case
                 pytest.skip(
                     f"Quantized model input mismatch for {layer_name}.{test_spec.name}",
                 )
 
         quantized_output = quantized_session.run(
             [quantized_output_name],
-            scaled_inputs,
+            quantized_inputs,
         )[0]
+
         quantized_output = quantized_output / (scale_base ** (scale_exponent))
 
         ratio = np.mean(quantized_output / (original_output + 1e-12))

python/tests/onnx_quantizer_tests/layers_tests/test_quantize.py

@@ -37,7 +37,10 @@ class TestQuantize(BaseQuantizerTest):
         scale_base: int = 10,
         *,
         rescale: bool = True,
-    ) -> tuple[onnx.NodeProto, tuple[str, LayerTestConfig, LayerTestSpec, NodeProto]]:
+    ) -> tuple[
+        list[onnx.NodeProto],
+        tuple[str, LayerTestConfig, LayerTestSpec, NodeProto],
+    ]:
         """Common setup for quantization tests"""
         layer_name, config, test_spec = test_case_data
 
@@ -65,6 +68,8 @@ class TestQuantize(BaseQuantizerTest):
             initializer_map=initializer_map,
         )
 
+        if not isinstance(result, list):
+            result = [result]
         return result, (layer_name, config, test_spec, node)
 
     @pytest.mark.unit
@@ -139,6 +144,8 @@ class TestQuantize(BaseQuantizerTest):
             node: NodeProto,
             result_node: NodeProto,
         ) -> bool:
+            if node.op_type == "BatchNormalization":
+                pytest.skip(f"{node.op_type} alters the node structure by design")
             if node.op_type in result_node.op_type:
                 # Assert there are no less attributes in the new node
                 assert len(node.attribute) <= len(result_node.attribute)

python/tests/onnx_quantizer_tests/test_registered_quantizers.py

@@ -49,11 +49,10 @@ def validate_quantized_node(node_result: onnx.NodeProto, op_type: str) -> None:
     assert node_result.output, f"Missing outputs for {op_type}"
 
     try:
-        # Create a minimal model with custom opset for validation
+        # Create a minimal graph with dummy IOs to satisfy ONNX requirements
         temp_graph = onnx.GraphProto()
         temp_graph.name = "temp_graph"
 
-        # Add dummy inputs/outputs to satisfy graph requirements
         for inp in node_result.input:
             if not any(vi.name == inp for vi in temp_graph.input):
                 temp_graph.input.append(
@@ -63,6 +62,7 @@ def validate_quantized_node(node_result: onnx.NodeProto, op_type: str) -> None:
                         [1],
                     ),
                 )
+
         for out in node_result.output:
             if not any(vi.name == out for vi in temp_graph.output):
                 temp_graph.output.append(
@@ -74,12 +74,16 @@ def validate_quantized_node(node_result: onnx.NodeProto, op_type: str) -> None:
                 )
 
         temp_graph.node.append(node_result)
-        temp_model = onnx.helper.make_model(temp_graph)
-        custom_domain = onnx.helper.make_operatorsetid(
-            domain="ai.onnx.contrib",
-            version=1,
+
+        # Explicit opset imports for default and contrib domains
+        temp_model = onnx.helper.make_model(
+            temp_graph,
+            opset_imports=[
+                onnx.helper.make_opsetid("", 22),
+                onnx.helper.make_opsetid("ai.onnx.contrib", 1),
+            ],
         )
-        temp_model.opset_import.append(custom_domain)
+
         onnx.checker.check_model(temp_model)
     except onnx.checker.ValidationError as e:
         pytest.fail(f"ONNX node validation failed for {op_type}: {e}")
@@ -117,5 +121,10 @@ def test_registered_quantizer_quantize(
         for node_result in result:
             validate_quantized_node(node_result, op_type)
     else:
-        assert result.input, f"Missing inputs for {op_type}"
+        if inputs:
+            # Only assert if this op actually requires inputs
+            assert (
+                result.input
+            ), f"Missing inputs for {op_type}; required_inputs={inputs}"
+
         validate_quantized_node(result, op_type)