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

python/tests/onnx_quantizer_tests/layers/clip_config.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import numpy as np
+
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    edge_case_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class ClipConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for elementwise Clip."""
+
+    @property
+    def layer_name(self) -> str:
+        return "Clip"
+
+    def get_config(self) -> LayerTestConfig:
+        # Treat min / max as optional extra inputs, scalar-shaped by default.
+        # Scalars are encoded as shape [1] for the test harness; ONNX/ORT
+        # will still broadcast them over A.
+        return LayerTestConfig(
+            op_type="Clip",
+            valid_inputs=["A", "min", "max"],
+            valid_attributes={},  # no Clip-specific attrs
+            required_initializers={},  # by default, all three can be dynamic inputs
+            input_shapes={
+                "A": [1, 3, 4, 4],
+                "min": [1],  # scalar-ish bound
+                "max": [1],  # scalar-ish bound
+            },
+            output_shapes={
+                "clip_output": [1, 3, 4, 4],
+            },
+        )
+
+    def get_test_specs(self) -> list:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+
+        return [
+            # --- VALID TESTS ---
+            # Basic Clip with scalar min/max as dynamic inputs.
+            valid_test("basic_scalar_bounds")
+            .description("Clip with A, min, max all as inputs; min/max are scalars.")
+            .override_input_shapes(A=[1, 3, 4, 4], min=[1], max=[1])
+            .override_output_shapes(clip_output=[1, 3, 4, 4])
+            .tags("basic", "elementwise", "clip")
+            .build(),
+            # This keeps the name used by the integration tests:
+            # Clip_broadcast_bounds
+            # Broadcasting here is just scalar → full tensor broadcast.
+            valid_test("broadcast_bounds")
+            .description(
+                "Clip with scalar bounds broadcast over all elements of A "
+                "(mirrors Max/Min broadcast tests but respects ORT's scalar bound "
+                "rules).",
+            )
+            .override_input_shapes(A=[1, 3, 2, 4], min=[1], max=[1])
+            .override_output_shapes(clip_output=[1, 3, 2, 4])
+            .tags("broadcast", "elementwise", "clip", "onnxruntime")
+            .build(),
+            # This keeps the name used by the integration tests:
+            # Clip_initializer_bounds
+            valid_test("initializer_bounds")
+            .description(
+                "Clip where min/max are scalar initializers instead of inputs.",
+            )
+            .override_input_shapes(A=[1, 3, 4, 4])  # only A is a true input
+            # Scalar numpy values → ONNX initializers with shape ()
+            .override_initializer(
+                "min",
+                np.array(rng.uniform(-1.0, 0.0), dtype=np.float64),
+            )
+            .override_initializer(
+                "max",
+                np.array(rng.uniform(0.0, 2.0), dtype=np.float64),
+            )
+            .override_output_shapes(clip_output=[1, 3, 4, 4])
+            .tags("initializer", "elementwise", "clip", "onnxruntime")
+            .build(),
+            # --- E2E TESTS ---
+            e2e_test("e2e_small").description(
+                "End-to-end Clip with small random tensor and scalar bounds.",
+            )
+            # All three are treated as runtime inputs here;
+            # min/max are scalar-shaped [1].
+            .override_input_shapes(
+                A=[1, 3, 4, 4],
+                min=[1],
+                max=[1],
+            )
+            .override_output_shapes(clip_output=[1, 3, 4, 4])
+            .tags("e2e", "clip")
+            .build(),
+            e2e_test("e2e_initializer_bounds").description(
+                "End-to-end Clip where min/max are scalar initializers "
+                "instead of inputs.",
+            )
+            # Only A is a true runtime input; min/max are scalar initializers.
+            .override_input_shapes(
+                A=[1, 3, 4, 4],
+            )
+            .override_initializer(
+                "min",
+                np.array(rng.uniform(-1.0, 0.0), dtype=np.float64),
+            )
+            .override_initializer(
+                "max",
+                np.array(rng.uniform(0.0, 2.0), dtype=np.float64),
+            )
+            .override_output_shapes(clip_output=[1, 3, 4, 4])
+            .tags("e2e", "initializer", "clip")
+            .build(),
+            # --- EDGE / STRESS ---
+            edge_case_test("empty_tensor")
+            .description("Clip with empty tensor input and scalar bounds.")
+            .override_input_shapes(A=[0], min=[1], max=[1])
+            .override_output_shapes(clip_output=[0])
+            .tags("edge", "empty", "clip")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/max_config.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import numpy as np
+
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    edge_case_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class MaxConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for elementwise Max"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Max"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="Max",
+            valid_inputs=["A", "B"],
+            valid_attributes={},  # Max has no layer-specific attributes
+            required_initializers={},  # default: both A and B are dynamic inputs
+            input_shapes={
+                "A": [1, 3, 4, 4],
+                "B": [1, 3, 4, 4],
+            },
+            output_shapes={
+                "max_output": [1, 3, 4, 4],
+            },
+        )
+
+    def get_test_specs(self) -> list:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic elementwise Max of two same-shaped tensors")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .tags("basic", "elementwise", "max")
+            .build(),
+            valid_test("broadcast_max")
+            .description("Max with Numpy-style broadcasting along spatial dimensions")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .tags("broadcast", "elementwise", "max", "onnx14")
+            .build(),
+            valid_test("initializer_max")
+            .description("Max where B is an initializer instead of an input")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer(
+                "B",
+                rng.normal(0, 1, (1, 3, 4, 4)).astype(np.float32),
+            )
+            .tags("initializer", "elementwise", "max", "onnxruntime")
+            .build(),
+            # --- E2E TESTS ---
+            e2e_test("e2e_max")
+            .description("End-to-end Max test with random inputs")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .override_output_shapes(max_output=[1, 3, 4, 4])
+            .tags("e2e", "max", "2d")
+            .build(),
+            e2e_test("e2e_broadcast_max")
+            .description(
+                "End-to-end Max with Numpy-style broadcasting along spatial dimensions",
+            )
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .override_output_shapes(max_output=[1, 3, 4, 4])
+            .tags("e2e", "broadcast", "elementwise", "max", "onnx14")
+            .build(),
+            e2e_test("e2e_initializer_max")
+            .description("End-to-end Max where B is an initializer")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer(
+                "B",
+                rng.normal(0, 1, (1, 3, 4, 4)).astype(np.float32),
+            )
+            .override_output_shapes(max_output=[1, 3, 4, 4])
+            .tags("e2e", "initializer", "elementwise", "max", "onnxruntime")
+            .build(),
+            # --- EDGE / STRESS ---
+            edge_case_test("empty_tensor")
+            .description("Max with empty tensor input (zero elements)")
+            .override_input_shapes(A=[0], B=[0])
+            .override_output_shapes(max_output=[0])
+            .tags("edge", "empty", "max")
+            .build(),
+            valid_test("large_tensor")
+            .description("Large tensor max performance/stress test")
+            .override_input_shapes(A=[1, 64, 256, 256], B=[1, 64, 256, 256])
+            .tags("large", "performance", "max")
+            .skip("Performance test, skipped by default")
+            .build(),
+        ]

python/tests/onnx_quantizer_tests/layers/min_config.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import numpy as np
+
+from python.tests.onnx_quantizer_tests import TEST_RNG_SEED
+from python.tests.onnx_quantizer_tests.layers.base import (
+    e2e_test,
+    edge_case_test,
+    valid_test,
+)
+from python.tests.onnx_quantizer_tests.layers.factory import (
+    BaseLayerConfigProvider,
+    LayerTestConfig,
+)
+
+
+class MinConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for elementwise Min"""
+
+    @property
+    def layer_name(self) -> str:
+        return "Min"
+
+    def get_config(self) -> LayerTestConfig:
+        return LayerTestConfig(
+            op_type="Min",
+            valid_inputs=["A", "B"],
+            valid_attributes={},  # Min has no layer-specific attributes
+            required_initializers={},  # default: both A and B are dynamic inputs
+            input_shapes={
+                "A": [1, 3, 4, 4],
+                "B": [1, 3, 4, 4],
+            },
+            output_shapes={
+                "min_output": [1, 3, 4, 4],
+            },
+        )
+
+    def get_test_specs(self) -> list:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        return [
+            # --- VALID TESTS ---
+            valid_test("basic")
+            .description("Basic elementwise Min of two same-shaped tensors")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .tags("basic", "elementwise", "min")
+            .build(),
+            valid_test("broadcast_min")
+            .description("Min with Numpy-style broadcasting along spatial dimensions")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .tags("broadcast", "elementwise", "min", "onnx14")
+            .build(),
+            valid_test("initializer_min")
+            .description("Min where B is an initializer instead of an input")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", rng.normal(0, 1, (1, 3, 4, 4)))
+            .tags("initializer", "elementwise", "min", "onnxruntime")
+            .build(),
+            # --- E2E TESTS ---
+            e2e_test("e2e_min")
+            .description("End-to-end Min test with random inputs")
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 4, 4])
+            .override_output_shapes(min_output=[1, 3, 4, 4])
+            .tags("e2e", "min", "2d")
+            .build(),
+            e2e_test("e2e_broadcast_min")
+            .description(
+                "End-to-end Min with Numpy-style broadcasting along spatial dimensions",
+            )
+            .override_input_shapes(A=[1, 3, 4, 4], B=[1, 3, 1, 1])
+            .override_output_shapes(min_output=[1, 3, 4, 4])
+            .tags("e2e", "broadcast", "elementwise", "min", "onnx14")
+            .build(),
+            e2e_test("e2e_initializer_min")
+            .description("End-to-end Min where B is an initializer")
+            .override_input_shapes(A=[1, 3, 4, 4])
+            .override_initializer("B", rng.normal(0, 1, (1, 3, 4, 4)))
+            .override_output_shapes(min_output=[1, 3, 4, 4])
+            .tags("e2e", "initializer", "elementwise", "min", "onnxruntime")
+            .build(),
+            # --- EDGE / STRESS ---
+            edge_case_test("empty_tensor")
+            .description("Min with empty tensor input (zero elements)")
+            .override_input_shapes(A=[0], B=[0])
+            .override_output_shapes(min_output=[0])
+            .tags("edge", "empty", "min")
+            .build(),
+            valid_test("large_tensor")
+            .description("Large tensor min performance/stress test")
+            .override_input_shapes(A=[1, 64, 256, 256], B=[1, 64, 256, 256])
+            .tags("large", "performance", "min")
+            .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

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)