From 163096c321c68a4a1e718cb24d71baa1a0da017d Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 03:49:47 +0530 Subject: [PATCH 01/10] refactor(rewriter): validate Conv weight and bias ranks in _ConvAffineFusionBase Signed-off-by: Hardik Kaurani --- .../rewriter/rules/common/_fuse_conv_affine.py | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py index 6d95b79a03..7146b2a0ef 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py @@ -27,10 +27,22 @@ def check( conv_out: ir.Value, ) -> MatchResult: check_result = MatchResult() - if get_const_value(w) is None: + w_val = get_const_value(w) + if w_val is None: return check_result.fail("The weight of Conv should be constant") - if get_const_value(b) is None: + b_val = get_const_value(b) + if b_val is None: return check_result.fail("The bias of Conv should be constant") + w_arr = w_val.numpy() + b_arr = b_val.numpy() + if w_arr.ndim < 3: + return check_result.fail("Conv weight tensor must have rank >= 3") + if b_arr.ndim != 1: + return check_result.fail("Conv bias tensor must have rank 1") + if w_arr.shape[0] != b_arr.shape[0]: + return check_result.fail( + f"Conv weight output channels ({w_arr.shape[0]}) does not match bias channels ({b_arr.shape[0]})" + ) if get_singleton_value(scale) is None: return check_result.fail("Operand for Mul should be constant scalar value") if get_singleton_value(offset) is None: From f81427ef7839fb89f52dcc2c7010b271ece67790 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 03:51:02 +0530 Subject: [PATCH 02/10] fix(rewriter): match omitted default pads in AffineConvFusion pattern Signed-off-by: Hardik Kaurani --- .../rules/common/_fuse_conv_affine.py | 24 ++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py index 7146b2a0ef..a2eda0548f 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py @@ -58,11 +58,33 @@ def pattern(self, op, x, w, b, scale, offset): x * scale + offset, w, b, - pads=[0, 0, 0, 0], _allow_other_attributes=True, _outputs=["conv_out"], ) + def check( + self, + context, + x: ir.Value, + w: ir.Value, + b: ir.Value, + scale: ir.Value, + offset: ir.Value, + conv_out: ir.Value, + ) -> MatchResult: + check_result = super().check(context, x, w, b, scale, offset, conv_out) + if not check_result: + return check_result + conv_node = conv_out.producer() + if conv_node is None: + return check_result.fail("Conv node not found") + pads_attr = conv_node.attributes.get("pads") + if pads_attr is not None: + pads = list(pads_attr.as_ints()) + if any(p != 0 for p in pads): + return check_result.fail(f"Conv has non-zero pads: {pads}") + return check_result + def rewrite( self, op, From aeab4989f3d4d080b8f68f68f880d3fc8be12ee7 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 03:51:23 +0530 Subject: [PATCH 03/10] fix(rewriter): validate auto_pad and reference attributes in AffineConvFusion Signed-off-by: Hardik Kaurani --- .../rules/common/_fuse_conv_affine.py | 25 ++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py index a2eda0548f..5e8f9afbb7 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py @@ -80,9 +80,28 @@ def check( return check_result.fail("Conv node not found") pads_attr = conv_node.attributes.get("pads") if pads_attr is not None: - pads = list(pads_attr.as_ints()) - if any(p != 0 for p in pads): - return check_result.fail(f"Conv has non-zero pads: {pads}") + if hasattr(pads_attr, "is_ref") and pads_attr.is_ref(): + return check_result.fail( + f"Conv 'pads' refers to reference attribute {pads_attr.ref_attr_name!r}" + ) + try: + pads = list(pads_attr.as_ints()) + if any(p != 0 for p in pads): + return check_result.fail(f"Conv has non-zero pads: {pads}") + except (TypeError, ValueError, AttributeError): + return check_result.fail("Conv 'pads' attribute could not be read as integers") + auto_pad_attr = conv_node.attributes.get("auto_pad") + if auto_pad_attr is not None: + if hasattr(auto_pad_attr, "is_ref") and auto_pad_attr.is_ref(): + return check_result.fail( + f"Conv 'auto_pad' refers to reference attribute {auto_pad_attr.ref_attr_name!r}" + ) + try: + auto_pad = auto_pad_attr.as_str() + if auto_pad not in {"NOTSET", "VALID"}: + return check_result.fail(f"Conv 'auto_pad' {auto_pad!r} introduces padding") + except (TypeError, ValueError, AttributeError): + return check_result.fail("Conv 'auto_pad' attribute could not be read as string") return check_result def rewrite( From 9257f7529a513e3f191d1c81f26748d0ac609fe8 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 03:51:46 +0530 Subject: [PATCH 04/10] fix(rewriter): support arbitrary spatial dimensions when folding pre-conv affine bias Signed-off-by: Hardik Kaurani --- onnxscript/rewriter/rules/common/_fuse_conv_affine.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py index 5e8f9afbb7..37b8d166a9 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py @@ -119,8 +119,9 @@ def rewrite( w_value = w.const_value.numpy() b_value = b.const_value.numpy() scaled_w_value = op.initializer(ir.tensor(w_value * scale_value), w.name + "_scaled") + axes = tuple(range(1, w_value.ndim)) offset_bias = ir.tensor( - b_value + np.sum(w_value * offset_value, axis=(1, 2, 3), keepdims=False) + b_value + np.sum(w_value * offset_value, axis=axes, keepdims=False) ) offset_bias = op.initializer(offset_bias, b.name + "_offset") conv_attributes = conv_out.producer().attributes From 7e4edbfefcfa5586f6a497708b3b38c536f9cdde Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 03:52:13 +0530 Subject: [PATCH 05/10] fix(rewriter): preserve weight and bias dtypes during Conv affine fusion Signed-off-by: Hardik Kaurani --- .../rewriter/rules/common/_fuse_conv_affine.py | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py index 37b8d166a9..bc37845aeb 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py @@ -118,10 +118,15 @@ def rewrite( offset_value = offset.const_value.numpy() w_value = w.const_value.numpy() b_value = b.const_value.numpy() - scaled_w_value = op.initializer(ir.tensor(w_value * scale_value), w.name + "_scaled") + scaled_w_value = op.initializer( + ir.tensor((w_value * scale_value).astype(w_value.dtype)), + w.name + "_scaled", + ) axes = tuple(range(1, w_value.ndim)) offset_bias = ir.tensor( - b_value + np.sum(w_value * offset_value, axis=axes, keepdims=False) + ( + b_value + np.sum(w_value * offset_value, axis=axes, keepdims=False) + ).astype(b_value.dtype) ) offset_bias = op.initializer(offset_bias, b.name + "_offset") conv_attributes = conv_out.producer().attributes @@ -151,8 +156,13 @@ def rewrite( offset_value = offset.const_value.numpy() w_value = w.const_value.numpy() b_value = b.const_value.numpy() - scaled_w_weight = op.initializer(ir.tensor(w_value * scale_value), w.name + "_scaled") - offset_bias = ir.tensor(b_value * scale_value + offset_value) + scaled_w_weight = op.initializer( + ir.tensor((w_value * scale_value).astype(w_value.dtype)), + w.name + "_scaled", + ) + offset_bias = ir.tensor( + (b_value * scale_value + offset_value).astype(b_value.dtype) + ) offset_bias = op.initializer(offset_bias, b.name + "_offset") conv_attributes = conv_out.producer().attributes return op.Conv(x, scaled_w_weight, offset_bias, **conv_attributes) From 5fa28865d1e657df0506fd8f7fb86114b0fda3cc Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 03:52:40 +0530 Subject: [PATCH 06/10] test(rewriter): add regression test for AffineConvFusion with omitted pads attribute Signed-off-by: Hardik Kaurani --- .../rules/common/_fuse_conv_affine_test.py | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine_test.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine_test.py index cbe8a8bf41..496f12e444 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine_test.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine_test.py @@ -106,6 +106,51 @@ def test_affine_conv_fusion_without_pad(self): ] testing.assert_numerically_equal(model, rewritten_model, inputs) + def test_affine_conv_fusion_omitted_pads(self): + """Conv with omitted pads attribute defaults to zero-padding and should be fused.""" + tape = ir.tape.Tape() + x = ir.val("x", dtype=ir.DataType.FLOAT, shape=ir.Shape([1, 3, 32, 32])) + w = tape.initializer(ir.tensor(np.ones((3, 3, 3, 3), dtype=np.float32), name="w")) + b = tape.initializer(ir.tensor(np.ones((3,), dtype=np.float32), name="b")) + scale = tape.initializer(ir.tensor(np.array([2.0], dtype=np.float32), name="scale")) + offset = tape.initializer(ir.tensor(np.array([3.0], dtype=np.float32), name="offset")) + + mul_out = tape.op("Mul", [x, scale]) + z = tape.op( + "Add", + [mul_out, offset], + output=ir.val( + "z", + dtype=ir.DataType.FLOAT, + shape=ir.Shape([1, 3, 32, 32]), + ), + ) + conv_out = tape.op("Conv", [z, w, b]) # Omitted pads attribute + + model = ir.Model( + ir.Graph( + inputs=[x], + outputs=[conv_out], + nodes=tape.nodes, + initializers=tape.initializers, + opset_imports={"": 17}, + ), + ir_version=8, + ) + rewritten_model = self.clone_model(model) + rewritten_model = rewrite( + rewritten_model, + pattern_rewrite_rules=[affine_conv_fusion_rule], + ) + self.assertEqual(model.graph.num_nodes() - 2, rewritten_model.graph.num_nodes()) + self.assertEqual([node.op_type for node in rewritten_model.graph], ["Conv"]) + + rng = np.random.default_rng(42) + inputs = [ + rng.random((1, 3, 32, 32), dtype=np.float32), + ] + testing.assert_numerically_equal(model, rewritten_model, inputs) + if __name__ == "__main__": unittest.main() From 4b92d9628ee06fd13b3d60185c4f13b365a149a2 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 03:56:31 +0530 Subject: [PATCH 07/10] test(rewriter): add regression tests for non-zero pads and auto_pad rejection in AffineConvFusion Signed-off-by: Hardik Kaurani --- .../rules/common/_fuse_conv_affine.py | 2 +- .../common/_fuse_conv_affine_extended_test.py | 43 +++++++++++++++++++ 2 files changed, 44 insertions(+), 1 deletion(-) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py index bc37845aeb..ad6f9e7b8c 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py @@ -97,7 +97,7 @@ def check( f"Conv 'auto_pad' refers to reference attribute {auto_pad_attr.ref_attr_name!r}" ) try: - auto_pad = auto_pad_attr.as_str() + auto_pad = auto_pad_attr.as_string() if auto_pad not in {"NOTSET", "VALID"}: return check_result.fail(f"Conv 'auto_pad' {auto_pad!r} introduces padding") except (TypeError, ValueError, AttributeError): diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py index 2d301b2808..f80ba4f078 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py @@ -150,6 +150,49 @@ def model_fn(x: FLOAT[1, 3, 32, 32]) -> FLOAT[1, 3, 32, 32]: inputs = [rng.random((1, 3, 32, 32), dtype=np.float32)] testing.assert_numerically_equal(model, rewritten, inputs) + def test_affine_conv_auto_pad_same_upper_rejected(self): + """Conv with auto_pad='SAME_UPPER' introduces padding and must be rejected.""" + + @script() + def model_fn(x: FLOAT[1, 3, 32, 32]) -> FLOAT[1, 3, 32, 32]: + w = op.Constant(value=_W_ONES) + b = op.Constant(value=_B_ONES) + scale = op.Constant(value_float=2.0) + offset = op.Constant(value_float=3.0) + affine_x = (x * scale) + offset + return op.Conv(affine_x, w, b, auto_pad="SAME_UPPER") + + model_proto = model_fn.to_model_proto() + model = ir.serde.deserialize_model(model_proto) + rewritten = self._clone(model) + rewritten = rewrite(rewritten, pattern_rewrite_rules=[affine_conv_fusion_rule]) + self.assertEqual(model.graph.num_nodes(), rewritten.graph.num_nodes()) + + def test_affine_conv_auto_pad_valid_accepted(self): + """Conv with auto_pad='VALID' has zero padding and should fuse into Conv.""" + + @script() + def model_fn(x: FLOAT[1, 3, 32, 32]) -> FLOAT[1, 3, 30, 30]: + w = op.Constant(value=_W_ONES) + b = op.Constant(value=_B_ONES) + scale = op.Constant(value_float=2.0) + offset = op.Constant(value_float=3.0) + affine_x = (x * scale) + offset + return op.Conv(affine_x, w, b, auto_pad="VALID") + + model_proto = model_fn.to_model_proto() + model = ir.serde.deserialize_model(model_proto) + rewritten = self._clone(model) + rewritten = rewrite(rewritten, pattern_rewrite_rules=[affine_conv_fusion_rule]) + rewritten_ops = [n.op_type for n in rewritten.graph] + self.assertNotIn("Mul", rewritten_ops) + self.assertNotIn("Add", rewritten_ops) + self.assertIn("Conv", rewritten_ops) + + rng = np.random.default_rng(42) + inputs = [rng.random((1, 3, 32, 32), dtype=np.float32)] + testing.assert_numerically_equal(model, rewritten, inputs) + if __name__ == "__main__": unittest.main() From ea2d13fa10f425a63234322fbdc0295995f5afd6 Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Sun, 15 Nov 2026 03:58:10 +0530 Subject: [PATCH 08/10] test(rewriter): add regression tests for dtype preservation and reference attribute rejection in Conv affine fusion Signed-off-by: Hardik Kaurani --- .../rules/common/_fuse_conv_affine.py | 18 +++-- .../common/_fuse_conv_affine_extended_test.py | 76 +++++++++++++++++++ 2 files changed, 86 insertions(+), 8 deletions(-) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py index ad6f9e7b8c..b81e5769f5 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py @@ -99,9 +99,13 @@ def check( try: auto_pad = auto_pad_attr.as_string() if auto_pad not in {"NOTSET", "VALID"}: - return check_result.fail(f"Conv 'auto_pad' {auto_pad!r} introduces padding") + return check_result.fail( + f"Conv 'auto_pad' {auto_pad!r} introduces padding" + ) except (TypeError, ValueError, AttributeError): - return check_result.fail("Conv 'auto_pad' attribute could not be read as string") + return check_result.fail( + "Conv 'auto_pad' attribute could not be read as string" + ) return check_result def rewrite( @@ -124,9 +128,9 @@ def rewrite( ) axes = tuple(range(1, w_value.ndim)) offset_bias = ir.tensor( - ( - b_value + np.sum(w_value * offset_value, axis=axes, keepdims=False) - ).astype(b_value.dtype) + (b_value + np.sum(w_value * offset_value, axis=axes, keepdims=False)).astype( + b_value.dtype + ) ) offset_bias = op.initializer(offset_bias, b.name + "_offset") conv_attributes = conv_out.producer().attributes @@ -160,9 +164,7 @@ def rewrite( ir.tensor((w_value * scale_value).astype(w_value.dtype)), w.name + "_scaled", ) - offset_bias = ir.tensor( - (b_value * scale_value + offset_value).astype(b_value.dtype) - ) + offset_bias = ir.tensor((b_value * scale_value + offset_value).astype(b_value.dtype)) offset_bias = op.initializer(offset_bias, b.name + "_offset") conv_attributes = conv_out.producer().attributes return op.Conv(x, scaled_w_weight, offset_bias, **conv_attributes) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py index f80ba4f078..0778f44f72 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py @@ -193,6 +193,82 @@ def model_fn(x: FLOAT[1, 3, 32, 32]) -> FLOAT[1, 3, 30, 30]: inputs = [rng.random((1, 3, 32, 32), dtype=np.float32)] testing.assert_numerically_equal(model, rewritten, inputs) + def test_conv_affine_mixed_precision_scale_offset_preserves_dtypes(self): + """Mixed precision scalar operands (e.g. float64) must not alter Conv weight/bias float32 dtypes.""" + tape = ir.tape.Tape() + x = ir.val("x", dtype=ir.DataType.FLOAT, shape=ir.Shape([1, 3, 32, 32])) + w = tape.initializer(ir.tensor(np.ones((3, 3, 3, 3), dtype=np.float32), name="w")) + b = tape.initializer(ir.tensor(np.ones((3,), dtype=np.float32), name="b")) + scale = tape.initializer(ir.tensor(np.array(2.0, dtype=np.float64), name="scale")) + offset = tape.initializer(ir.tensor(np.array(3.0, dtype=np.float64), name="offset")) + + conv_out = tape.op("Conv", [x, w, b], attributes={"pads": [1, 1, 1, 1]}) + mul_out = tape.op("Mul", [conv_out, scale]) + z = tape.op( + "Add", + [mul_out, offset], + output=ir.val( + "z", + dtype=ir.DataType.FLOAT, + shape=ir.Shape([1, 3, 32, 32]), + ), + ) + model = ir.Model( + ir.Graph( + inputs=[x], + outputs=[z], + nodes=tape.nodes, + initializers=tape.initializers, + opset_imports={"": 17}, + name="test_graph", + ), + ir_version=8, + ) + rewritten = self._clone(model) + rewritten = rewrite(rewritten, pattern_rewrite_rules=[conv_affine_fusion_rule]) + conv_node = next(n for n in rewritten.graph if n.op_type == "Conv") + self.assertEqual(conv_node.inputs[1].const_value.dtype, ir.DataType.FLOAT) + self.assertEqual(conv_node.inputs[2].const_value.dtype, ir.DataType.FLOAT) + + import onnx + + proto = ir.serde.serialize_model(rewritten) + onnx.checker.check_model(proto, full_check=True) + + def test_conv_affine_reference_attribute_pads_rejected(self): + """Conv with reference attribute for pads must be safely rejected.""" + tape = ir.tape.Tape() + x = ir.val("x", dtype=ir.DataType.FLOAT, shape=ir.Shape([1, 3, 32, 32])) + w = tape.initializer(ir.tensor(np.ones((3, 3, 3, 3), dtype=np.float32), name="w")) + b = tape.initializer(ir.tensor(np.ones((3,), dtype=np.float32), name="b")) + scale = tape.initializer(ir.tensor(np.array(2.0, dtype=np.float32), name="scale")) + offset = tape.initializer(ir.tensor(np.array(3.0, dtype=np.float32), name="offset")) + + mul_out = tape.op("Mul", [x, scale]) + affine_x = tape.op("Add", [mul_out, offset]) + ref_attr = ir.Attr( + name="pads", + type=ir.AttributeType.INTS, + value=None, + ref_attr_name="pads_val", + ) + conv_out = tape.op("Conv", [affine_x, w, b], attributes={"pads": ref_attr}) + + model = ir.Model( + ir.Graph( + inputs=[x], + outputs=[conv_out], + nodes=tape.nodes, + initializers=tape.initializers, + opset_imports={"": 17}, + name="test_graph", + ), + ir_version=8, + ) + count = affine_conv_fusion_rule.apply_to_model(model) + self.assertEqual(count, 0) + self.assertIn("Mul", [n.op_type for n in model.graph]) + if __name__ == "__main__": unittest.main() From 24b440de01f964ea658365040c5535172ad6204b Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Tue, 17 Nov 2026 03:24:16 +0530 Subject: [PATCH 09/10] fix(rewriter): validate Conv weight and bias shape metadata without loading tensor data Signed-off-by: Hardik Kaurani --- .../rules/common/_fuse_conv_affine.py | 26 +++++++++---------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py index b81e5769f5..9730d48fd8 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine.py @@ -27,26 +27,26 @@ def check( conv_out: ir.Value, ) -> MatchResult: check_result = MatchResult() + if get_singleton_value(scale) is None: + return check_result.fail("Operand for Mul should be constant scalar value") + if get_singleton_value(offset) is None: + return check_result.fail("Operand for Add should be constant scalar value") w_val = get_const_value(w) if w_val is None: return check_result.fail("The weight of Conv should be constant") b_val = get_const_value(b) if b_val is None: return check_result.fail("The bias of Conv should be constant") - w_arr = w_val.numpy() - b_arr = b_val.numpy() - if w_arr.ndim < 3: + w_shape = w_val.shape + b_shape = b_val.shape + if len(w_shape) < 3: return check_result.fail("Conv weight tensor must have rank >= 3") - if b_arr.ndim != 1: + if len(b_shape) != 1: return check_result.fail("Conv bias tensor must have rank 1") - if w_arr.shape[0] != b_arr.shape[0]: + if w_shape[0] != b_shape[0]: return check_result.fail( - f"Conv weight output channels ({w_arr.shape[0]}) does not match bias channels ({b_arr.shape[0]})" + f"Conv weight output channels ({w_shape[0]}) does not match bias channels ({b_shape[0]})" ) - if get_singleton_value(scale) is None: - return check_result.fail("Operand for Mul should be constant scalar value") - if get_singleton_value(offset) is None: - return check_result.fail("Operand for Add should be constant scalar value") return check_result @@ -72,9 +72,7 @@ def check( offset: ir.Value, conv_out: ir.Value, ) -> MatchResult: - check_result = super().check(context, x, w, b, scale, offset, conv_out) - if not check_result: - return check_result + check_result = MatchResult() conv_node = conv_out.producer() if conv_node is None: return check_result.fail("Conv node not found") @@ -106,7 +104,7 @@ def check( return check_result.fail( "Conv 'auto_pad' attribute could not be read as string" ) - return check_result + return super().check(context, x, w, b, scale, offset, conv_out) def rewrite( self, From 061277e889c8727c181d51f572d144c6cef85f7b Mon Sep 17 00:00:00 2001 From: Hardik Kaurani Date: Tue, 17 Nov 2026 03:24:22 +0530 Subject: [PATCH 10/10] test(rewriter): add regression tests for external weights in Conv affine fusion Signed-off-by: Hardik Kaurani --- .../common/_fuse_conv_affine_extended_test.py | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+) diff --git a/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py b/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py index 0778f44f72..fa6ff7158b 100644 --- a/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py +++ b/onnxscript/rewriter/rules/common/_fuse_conv_affine_extended_test.py @@ -269,6 +269,92 @@ def test_conv_affine_reference_attribute_pads_rejected(self): self.assertEqual(count, 0) self.assertIn("Mul", [n.op_type for n in model.graph]) + def test_conv_affine_external_weights_nonconstant_scale_rejected_without_filenotfound( + self, + ): + """ConvAffineFusion with external weights and non-constant scale must reject without FileNotFoundError.""" + tape = ir.tape.Tape() + x = ir.val("x", dtype=ir.DataType.FLOAT, shape=ir.Shape([1, 3, 32, 32])) + scale = ir.val("scale", dtype=ir.DataType.FLOAT, shape=ir.Shape([1])) + offset = tape.initializer(ir.tensor(np.array(3.0, dtype=np.float32), name="offset")) + b = tape.initializer(ir.tensor(np.ones((3,), dtype=np.float32), name="b")) + w = tape.initializer( + ir.ExternalTensor( + location="nonexistent_weights.bin", + offset=0, + length=100, + dtype=ir.DataType.FLOAT, + shape=ir.Shape([3, 3, 3, 3]), + name="w", + ) + ) + + conv_out = tape.op("Conv", [x, w, b], attributes={"pads": [0, 0, 0, 0]}) + mul_out = tape.op("Mul", [conv_out, scale]) + z = tape.op( + "Add", + [mul_out, offset], + output=ir.val( + "z", + dtype=ir.DataType.FLOAT, + shape=ir.Shape([1, 3, 32, 32]), + ), + ) + + model = ir.Model( + ir.Graph( + inputs=[x, scale], + outputs=[z], + nodes=tape.nodes, + initializers=tape.initializers, + opset_imports={"": 17}, + name="test_graph", + ), + ir_version=8, + ) + count = conv_affine_fusion_rule.apply_to_model(model) + self.assertEqual(count, 0) + self.assertIn("Mul", [n.op_type for n in model.graph]) + + def test_affine_conv_external_weights_with_padding_rejected_without_filenotfound( + self, + ): + """AffineConvFusion with external weights and padding must reject without FileNotFoundError.""" + tape = ir.tape.Tape() + x = ir.val("x", dtype=ir.DataType.FLOAT, shape=ir.Shape([1, 3, 32, 32])) + scale = tape.initializer(ir.tensor(np.array(2.0, dtype=np.float32), name="scale")) + offset = tape.initializer(ir.tensor(np.array(3.0, dtype=np.float32), name="offset")) + b = tape.initializer(ir.tensor(np.ones((3,), dtype=np.float32), name="b")) + w = tape.initializer( + ir.ExternalTensor( + location="nonexistent_weights.bin", + offset=0, + length=100, + dtype=ir.DataType.FLOAT, + shape=ir.Shape([3, 3, 3, 3]), + name="w", + ) + ) + + mul_out = tape.op("Mul", [x, scale]) + affine_x = tape.op("Add", [mul_out, offset]) + conv_out = tape.op("Conv", [affine_x, w, b], attributes={"pads": [1, 1, 1, 1]}) + + model = ir.Model( + ir.Graph( + inputs=[x], + outputs=[conv_out], + nodes=tape.nodes, + initializers=tape.initializers, + opset_imports={"": 17}, + name="test_graph", + ), + ir_version=8, + ) + count = affine_conv_fusion_rule.apply_to_model(model) + self.assertEqual(count, 0) + self.assertIn("Mul", [n.op_type for n in model.graph]) + if __name__ == "__main__": unittest.main()