[Reland][pytorch] Patch the _is_conv_node function

Summary: Add the conv padding ops in pytorch, the corresponding pr in torch ao is pytorch/ao#2257

Test Plan:
```
buck test 'fbcode//mode/opt' fbcode//caffe2/test:quantization_pt2e -- --exact 'caffe2/test:quantization_pt2e - test_conv_padding_bn_relu (quantization.pt2e.test_quantize_pt2e.TestQuantizePT2E)'
```

Differential Revision: D75494468

Author: cccclai

test/quantization/pt2e/test_quantize_pt2e.py

@@ -2333,6 +2333,118 @@ def validate(self, model: torch.fx.GraphModule) -> None:
             node_list,
         )
 
+def test_conv_padding_bn_relu(self):
+    class BackendAQuantizer(Quantizer):
+        def annotate(self, model: torch.fx.GraphModule) -> torch.fx.GraphModule:
+            act_qspec = QuantizationSpec(
+                dtype=torch.uint8,
+                quant_min=0,
+                quant_max=255,
+                qscheme=torch.per_tensor_affine,
+                is_dynamic=False,
+                observer_or_fake_quant_ctr=observer.default_observer,
+            )
+            weight_qspec = QuantizationSpec(
+                dtype=torch.int8,
+                quant_min=-128,
+                quant_max=127,
+                qscheme=torch.per_tensor_affine,
+                is_dynamic=False,
+                observer_or_fake_quant_ctr=observer.default_weight_observer,
+            )
+            bias_qspec = QuantizationSpec(
+                dtype=torch.float32,
+                is_dynamic=False,
+                observer_or_fake_quant_ctr=observer.PlaceholderObserver,
+            )
+
+            for n in model.graph.nodes:
+                if (
+                    n.op != "call_function"
+                    or n.target != torch.ops.aten.relu.default
+                ):
+                    continue
+                relu_node = n
+                n = n.args[0]
+
+                # Check for any of the conv operations
+                conv_ops = [
+                    torch.ops.aten.conv1d.padding,
+                    torch.ops.aten.conv2d.padding,
+                    torch.ops.aten.conv3d.padding,
+                ]
+                if n.op != "call_function" or n.target not in conv_ops:
+                    continue
+
+                conv_node = n
+                input_act = conv_node.args[0]
+                weight = conv_node.args[1]
+                bias = conv_node.args[2]
+                conv_node.meta["quantization_annotation"] = QuantizationAnnotation(
+                    input_qspec_map={
+                        input_act: act_qspec,
+                        weight: weight_qspec,
+                        bias: bias_qspec,
+                    },
+                    _annotated=True,
+                )
+                relu_node.meta["quantization_annotation"] = QuantizationAnnotation(
+                    output_qspec=act_qspec,
+                    _annotated=True,
+                )
+
+        def validate(self, model: torch.fx.GraphModule) -> None:
+            pass
+
+    # Test cases for Conv1d, Conv2d, Conv3d
+    test_cases = [
+        {
+            "dim": 1,
+            "example_input": torch.randn(1, 3, 5),
+            "conv_op": torch.ops.aten.conv1d.padding,
+        },
+        {
+            "dim": 2,
+            "example_input": torch.randn(1, 3, 5, 5),
+            "conv_op": torch.ops.aten.conv2d.padding,
+        },
+        {
+            "dim": 3,
+            "example_input": torch.randn(1, 3, 5, 5, 5),
+            "conv_op": torch.ops.aten.conv3d.padding,
+        },
+    ]
+
+    for test_case in test_cases:
+        with self.subTest(dim=test_case["dim"]):
+            model = TestHelperModules(
+                relu=True,
+                dim=test_case["dim"],
+                bn=True,
+                bias=True,
+                padding="same"  # This will trigger the .padding variants
+            ).eval()
+            
+            node_occurrence = {
+                torch.ops.quantized_decomposed.quantize_per_tensor.default: 2,
+                torch.ops.quantized_decomposed.dequantize_per_tensor.default: 3,
+            }
+            node_list = [
+                torch.ops.quantized_decomposed.dequantize_per_tensor.default,
+                torch.ops.quantized_decomposed.dequantize_per_tensor.default,
+                test_case["conv_op"],
+                torch.ops.aten.relu.default,
+                torch.ops.quantized_decomposed.quantize_per_tensor.default,
+            ]
+
+            self._test_quantizer(
+                model,
+                test_case["example_input"],
+                BackendAQuantizer(),
+                node_occurrence,
+                node_list,
+            )
+
     def test_multi_users_without_output_observer(self):
         """
         Test the case in which a node is used by multiple users,

torch/ao/quantization/pt2e/utils.py

@@ -167,7 +167,11 @@ def _is_conv_node(n: Node):
     """
     return n.op == "call_function" and n.target in [
         torch.ops.aten.conv1d.default,
+        torch.ops.aten.conv1d.padding,
         torch.ops.aten.conv2d.default,
+        torch.ops.aten.conv2d.padding,
+        torch.ops.aten.conv3d.default,
+        torch.ops.aten.conv3d.padding,
     ]
 
 

torch/testing/_internal/common_quantization.py

@@ -3183,13 +3183,14 @@ def forward(self, x):
             x = self.adaptive_avg_pool2d(x)
             return x
 
+	
     class ConvWithBNRelu(torch.nn.Module):
-        def __init__(self, relu, dim=2, bn=True, bias=True):
+        def __init__(self, relu, dim=2, bn=True, bias=True, padding=0):
             super().__init__()
-            convs = {1: torch.nn.Conv1d, 2: torch.nn.Conv2d}
-            bns = {1: torch.nn.BatchNorm1d, 2: torch.nn.BatchNorm2d}
-            self.conv = convs[dim](3, 3, 3, bias=bias)
-
+            convs = {1: torch.nn.Conv1d, 2: torch.nn.Conv2d, 3: torch.nn.Conv3d}
+            bns = {1: torch.nn.BatchNorm1d, 2: torch.nn.BatchNorm2d, 3: torch.nn.BatchNorm3d}
+            self.conv = convs[dim](3, 3, 3, bias=bias, padding=padding)
+            
             if bn:
                 self.bn = bns[dim](3)
             else: