support neg converter

Author: bowang007

Diff for: py/torch_tensorrt/dynamo/conversion/aten_ops_converters.py

@@ -251,6 +251,24 @@ def aten_ops_rsqrt(
     )
 
 
+@dynamo_tensorrt_converter(torch.ops.aten.neg.default)
+def aten_ops_neg(
+    network: TRTNetwork,
+    target: Target,
+    args: Tuple[Argument, ...],
+    kwargs: Dict[str, Argument],
+    name: str,
+) -> Union[TRTTensor, Sequence[TRTTensor]]:
+
+    return impl.unary.neg(
+        network,
+        target,
+        SourceIR.ATEN,
+        name,
+        args[0],
+    )
+
+
 @dynamo_tensorrt_converter(torch.ops.aten.squeeze.dim)
 @dynamo_tensorrt_converter(torch.ops.aten.squeeze.dims)
 def aten_ops_squeeze(

Diff for: py/torch_tensorrt/dynamo/conversion/impl/unary/ops.py

@@ -96,3 +96,15 @@ def sign(
         double_floor_div_output,
         1,
     )
+
+
+def neg(
+    network: TRTNetwork,
+    target: Target,
+    source_ir: Optional[SourceIR],
+    name: str,
+    input_val: TRTTensor,
+) -> TRTTensor:
+    return convert_unary(
+        network, target, source_ir, name, trt.UnaryOperation.NEG, input_val
+    )

Diff for: tests/py/dynamo/converters/test_neg_aten.py

@@ -0,0 +1,50 @@
+import torch
+import torch.nn as nn
+from parameterized import parameterized
+from torch.testing._internal.common_utils import run_tests
+from torch_tensorrt.dynamo.test_utils import DispatchTestCase
+from torch_tensorrt import Input
+
+
+class TestNegConverter(DispatchTestCase):
+    @parameterized.expand(
+        [
+            ("2d_dim_dtype_float", (2, 2), torch.float),
+            ("3d_dim_dtype_float", (2, 2, 2), torch.float),
+        
+        ]
+    )
+    def test_neg_float(self, _, x, type):
+        class neg(nn.Module):
+            def forward(self, input):
+                return torch.neg(input)
+            
+        inputs = [torch.randn(x, dtype=type)]
+        self.run_test(
+            neg(),
+            inputs,
+            expected_ops={torch.ops.aten.neg.default},
+        )
+
+    @parameterized.expand(
+        [
+            ("2d_dim_dtype_int", (2, 2), torch.int32, 0, 5),
+            ("3d_dim_dtype_int", (2, 2, 2), torch.int32, 0, 5),
+        ]
+    )
+
+    def test_neg_int(self, _, x, type, min, max):
+        class neg(nn.Module):
+            def forward(self, input):
+                return torch.neg(input)
+            
+        inputs = [torch.randint(min, max, (x), dtype=type)]
+
+        self.run_test(
+            neg(),
+            inputs,
+            expected_ops={torch.ops.aten.neg.default},
+        )
+
+if __name__ == "__main__":
+    run_tests()