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

@@ -0,0 +1,190 @@
+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,
+    valid_test,
+)
+
+
+class BatchNormConfigProvider(BaseLayerConfigProvider):
+    """Test configuration provider for BatchNorm (ONNX BatchNormalization op)"""
+
+    @property
+    def layer_name(self) -> str:
+        return "BatchNormalization"
+
+    def get_config(self) -> LayerTestConfig:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+
+        # default shapes: N x C x H x W
+        default_input_shape = [1, 3, 4, 4]
+        c = default_input_shape[1]
+
+        # typical required initializers (scale, bias, mean, var) are length C
+        return LayerTestConfig(
+            op_type="BatchNormalization",
+            valid_inputs=["X", "scale", "B", "input_mean", "input_var"],
+            valid_attributes={
+                "epsilon": 1e-5,
+                "momentum": 0.9,
+                "training_mode": 0,
+            },
+            required_initializers={
+                # Defaults are stored as numpy arrays with shape (C,)
+                "scale": rng.normal(1.0, 0.5, c).astype(np.float32),
+                "B": rng.normal(0.0, 0.5, c).astype(np.float32),
+                "input_mean": rng.normal(0.0, 1.0, c).astype(np.float32),
+                "input_var": np.abs(rng.normal(1.0, 0.5, c)).astype(np.float32),
+            },
+            input_shapes={"X": default_input_shape},
+            output_shapes={"batchnormalization_output": default_input_shape},
+        )
+
+    def get_test_specs(self) -> list[LayerTestSpec]:
+        rng = np.random.default_rng(TEST_RNG_SEED)
+        c = 3
+
+        return [
+            # Basic valid tests
+            valid_test("basic_inference")
+            .description("Basic BatchNormalization inference: standard shapes")
+            .tags("basic", "inference", "batchnorm")
+            .build(),
+            valid_test("different_input_shape")
+            .description("Inference with different spatial dims")
+            .override_input_shapes(X=[2, c, 8, 8])
+            .override_output_shapes(batchnormalization_output=[2, c, 8, 8])
+            .tags("inference", "spatial")
+            .build(),
+            valid_test("epsilon_variation")
+            .description("Inference with larger epsilon for numerical stability")
+            .override_attrs(epsilon=1e-3)
+            .tags("epsilon")
+            .build(),
+            valid_test("momentum_variation")
+            .description(
+                "Inference with non-default momentum (has no effect in inference mode)",
+            )
+            .override_attrs(momentum=0.5)
+            .tags("momentum")
+            .build(),
+            valid_test("zero_mean_input")
+            .description("Input with zero mean")
+            .override_initializer("input_mean", np.zeros((c,), dtype=np.float32))
+            .tags("edge", "zero_mean")
+            .build(),
+            # Scalar / broadcast style tests
+            valid_test("per_channel_zero_variance")
+            .description(
+                "Edge case: very small variance values (clamped by epsilon), inference",
+            )
+            .override_initializer("input_var", np.full((c,), 1e-8, dtype=np.float32))
+            .override_attrs(epsilon=1e-5)
+            .tags("edge", "small_variance")
+            .build(),
+            # E2E tests that set explicit initializer values
+            e2e_test("e2e_inference")
+            .description("E2E inference test with explicit initializers")
+            .override_input_shapes(X=[1, c, 2, 2])
+            .override_output_shapes(batchnormalization_output=[1, c, 2, 2])
+            .override_initializer("scale", rng.normal(1.0, 0.1, c).astype(np.float32))
+            .override_initializer("B", rng.normal(0.0, 0.1, c).astype(np.float32))
+            .override_initializer(
+                "input_mean",
+                rng.normal(0.0, 0.1, c).astype(np.float32),
+            )
+            .override_initializer(
+                "input_var",
+                np.abs(rng.normal(0.5, 0.2, c)).astype(np.float32),
+            )
+            .tags("e2e", "inference")
+            .build(),
+            e2e_test("e2e_inference_small_2x2")
+            .description("E2E inference with small 2x2 spatial input")
+            .override_input_shapes(X=[1, 3, 2, 2])
+            .override_output_shapes(batchnormalization_output=[1, 3, 2, 2])
+            .override_initializer("scale", np.array([1.0, 0.9, 1.1], dtype=np.float32))
+            .override_initializer("B", np.array([0.0, 0.1, -0.1], dtype=np.float32))
+            .override_initializer(
+                "input_mean",
+                np.array([0.5, -0.5, 0.0], dtype=np.float32),
+            )
+            .override_initializer(
+                "input_var",
+                np.array([0.25, 0.5, 0.1], dtype=np.float32),
+            )
+            .tags("e2e", "small", "2x2")
+            .build(),
+            e2e_test("e2e_inference_wide_input")
+            .description("E2E inference with wider input shape (C=4, H=2, W=8)")
+            .override_input_shapes(X=[2, 4, 2, 8])
+            .override_output_shapes(batchnormalization_output=[2, 4, 2, 8])
+            .override_initializer(
+                "scale",
+                np.array([1.0, 0.8, 1.2, 0.9], dtype=np.float32),
+            )
+            .override_initializer(
+                "B",
+                np.array([0.0, 0.1, -0.1, 0.05], dtype=np.float32),
+            )
+            .override_initializer(
+                "input_mean",
+                np.array([0.0, 0.5, -0.5, 0.2], dtype=np.float32),
+            )
+            .override_initializer(
+                "input_var",
+                np.array([1.0, 0.5, 0.25, 0.1], dtype=np.float32),
+            )
+            .tags("e2e", "wide", "C4")
+            .build(),
+            e2e_test("e2e_inference_batch2_channels3")
+            .description("E2E inference with batch size 2 and 3 channels")
+            .override_input_shapes(X=[2, 3, 4, 4])
+            .override_output_shapes(batchnormalization_output=[2, 3, 4, 4])
+            .override_initializer("scale", np.array([0.5, 1.0, 1.5], dtype=np.float32))
+            .override_initializer("B", np.array([0.0, 0.0, 0.0], dtype=np.float32))
+            .override_initializer(
+                "input_mean",
+                np.array([-0.5, 0.0, 0.5], dtype=np.float32),
+            )
+            .override_initializer(
+                "input_var",
+                np.array([0.2, 0.5, 0.8], dtype=np.float32),
+            )
+            .tags("e2e", "batch2", "C3")
+            .build(),
+            e2e_test("e2e_inference_high_epsilon")
+            .description("E2E inference with high epsilon for numerical stability")
+            .override_input_shapes(X=[1, 2, 4, 4])
+            .override_output_shapes(batchnormalization_output=[1, 2, 4, 4])
+            .override_initializer("scale", np.array([1.0, 1.0], dtype=np.float32))
+            .override_initializer("B", np.array([0.1, -0.1], dtype=np.float32))
+            .override_initializer("input_mean", np.array([0.0, 0.5], dtype=np.float32))
+            .override_initializer(
+                "input_var",
+                np.array([0.0, 0.0], dtype=np.float32),
+            )  # tiny variance
+            .override_attrs(epsilon=1e-2)
+            .tags("e2e", "high_epsilon", "numerical_stability")
+            .build(),
+            e2e_test("e2e_inference_non_square")
+            .description("E2E inference with non-square spatial dimensions")
+            .override_input_shapes(X=[1, 3, 2, 5])
+            .override_output_shapes(batchnormalization_output=[1, 3, 2, 5])
+            .override_initializer("scale", np.array([1.0, 0.9, 1.1], dtype=np.float32))
+            .override_initializer("B", np.array([0.0, 0.1, -0.1], dtype=np.float32))
+            .override_initializer(
+                "input_mean",
+                np.array([0.1, -0.1, 0.0], dtype=np.float32),
+            )
+            .override_initializer(
+                "input_var",
+                np.array([0.5, 0.25, 0.75], dtype=np.float32),
+            )
+            .tags("e2e", "non_square", "C3")
+            .build(),
+        ]

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/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(),
+        ]