Removing stride and device since - 1. converting to torch Tensor would lead to faketensor 2. Also get_trt_tensor in the forward pass while creating the engine does not retain the memory_format

Author: apbose

py/torch_tensorrt/dynamo/conversion/ops_evaluators.py

@@ -149,18 +149,4 @@ def aten_ops_empty(
     else:
         # default returns np.float64. Verify the correctness of this
         empty_np_tensor = np.empty(tuple(args[0]))
-
-    empty_tensor = torch.Tensor(empty_np_tensor)
-    # device
-    if kwargs.get("device") is not None:
-        empty_tensor = empty_tensor.to(device=kwargs.get("device"))
-
-    # memory_format. default is torch.contiguous_format
-    if memory_format == torch.channels_last:
-        # shape of args[0] must be 4
-        empty_tensor = empty_tensor.to(memory_format=torch.channels_last)
-    elif memory_format == torch.channels_last_3d:
-        # shape of args[0] must be 5
-        empty_tensor = empty_tensor.to(memory_format=torch.channels_last_3d)
-
-    return empty_tensor
+    return empty_np_tensor

tests/py/dynamo/conversion/test_empty_aten.py

@@ -12,76 +12,45 @@
         "empty_one_dimension",
         [1],
         None,
-        None,
-        None,
     ),
     (
         "empty_two_dimension",
         [1, 2],
         None,
-        None,
-        None,
     ),
     (
         "empty_three_dimension",
         [2, 3, 4],
         None,
-        None,
-        None,
     ),
     (
         "empty_one_dimension_dtype",
         [1],
         torch.float32,
-        None,
-        None,
     ),
     (
         "empty_two_dimension_dtype",
         [2, 3],
         torch.float32,
-        None,
-        None,
-    ),
-    (
-        "empty_one_dimension_dtype_device",
-        [1],
-        torch.float32,
-        "cuda",
-        None,
-    ),
-    (
-        "empty_two_dimension_dtype_device",
-        [2, 3],
-        torch.float32,
-        "cuda",
-        None,
     ),
     (
-        "empty_four_dimension_memformat",
+        "empty_four_dimension_dtype",
         [1, 2, 2, 1],
         torch.float32,
-        "cuda",
-        torch.channels_last,
     ),
     (
-        "empty_five_dimension_memformat",
+        "empty_five_dimension_dtype",
         [1, 2, 2, 2, 1],
         torch.float32,
-        "cuda",
-        torch.channels_last_3d,
     ),
 ]
 
 
 class TestEmptyConverter(DispatchTestCase):
     @parameterized.expand(
-        [
-            (empty_op[0], empty_op[1], empty_op[2], empty_op[3], empty_op[4])
-            for empty_op in empty_ops
-        ]
+        [(empty_op[0], empty_op[1], empty_op[2]) for empty_op in empty_ops]
     )
-    def test_empty(self, name, shape_or_input, data_type, device, memory_format):
+    def test_empty(self, name, shape_or_input, data_type):
         class TestModule(nn.Module):
             def __init__(self):
                 super().__init__()
@@ -91,42 +60,31 @@ def forward(self, x):
                 return torch.ops.aten.empty.memory_format(
                     shape_or_input,
                     dtype=data_type,
-                    memory_format=memory_format,
-                    device=device,
                 )
 
         empty_model = TestModule()
 
         inputs = [torch.randint(1, 3, shape_or_input, dtype=torch.int32)]
         comparator_shape_dtype_device = (
-            lambda x, y, check_dtype, check_device: x.shape == y.shape
+            lambda x, y, check_dtype: x.shape == y.shape
             and (x.stride() == y.stride())
             and (x.dtype == y.dtype if check_dtype else True)
-            and (x.get_device() == y.get_device() if check_device else True)
         )
         expected_ops = []
-        if "device" in name:
-            self.run_test_compare_tensor_attributes_only(
-                empty_model,
-                inputs,
-                expected_ops,
-                [(comparator_shape_dtype_device, [True, True])],
-                use_dynamo_tracer=True,
-            )
-        elif "dtype" in name:
+        if "dtype" in name:
             self.run_test_compare_tensor_attributes_only(
                 empty_model,
                 inputs,
                 expected_ops,
-                [(comparator_shape_dtype_device, [True, False])],
+                [(comparator_shape_dtype_device, [True])],
                 use_dynamo_tracer=True,
             )
         else:
             self.run_test_compare_tensor_attributes_only(
                 empty_model,
                 inputs,
                 expected_ops,
-                [(comparator_shape_dtype_device, [False, False])],
+                [(comparator_shape_dtype_device, [False])],
                 use_dynamo_tracer=True,
             )