pytorch - 💡(How to fix) Fix DISABLED test_jacrev_two_tensors_argnums (__main__.FuncTorchHigherOrderOpTestsWithCompiledAutograd) [2 comments, 1 participants]

Traceback (most recent call last):
  File "/var/lib/jenkins/workspace/test/dynamo/test_higher_order_ops.py", line 4136, in test_jacrev_two_tensors_argnums
    self.assertExpectedInline(
  File "/opt/conda/envs/py_3.10/lib/python3.10/site-packages/torch/testing/_internal/common_utils.py", line 3387, in assertExpectedInline
    return super().assertExpectedInline(actual if isinstance(actual, str) else str(actual), expect, skip + 1)
  File "/opt/conda/envs/py_3.10/lib/python3.10/site-packages/expecttest/__init__.py", line 413, in assertExpectedInline
    assert_expected_inline(
  File "/opt/conda/envs/py_3.10/lib/python3.10/site-packages/expecttest/__init__.py", line 378, in assert_expected_inline
    assert_eq(expect, actual, msg=help_text)
  File "/opt/conda/envs/py_3.10/lib/python3.10/site-packages/expecttest/__init__.py", line 450, in assertMultiLineEqualMaybeCppStack
    self.assertMultiLineEqual(expect, actual, *args, **kwargs)
  File "/opt/conda/envs/py_3.10/lib/python3.10/unittest/case.py", line 1226, in assertMultiLineEqual
    self.fail(self._formatMessage(msg, standardMsg))
  File "/opt/conda/envs/py_3.10/lib/python3.10/unittest/case.py", line 675, in fail
    raise self.failureException(msg)
AssertionError: 'clas[1606 chars](12,))\n        cumsum: "i64[1]" = tensor.cums[1693 chars],)\n' != 'clas[1606 chars](12,), device = device(type=\'cpu\'))\n       [1730 chars],)\n'
  class GraphModule(torch.nn.Module):
      def forward(self, L_x_: "f32[4, 3]", L_y_: "f32[3, 4]"):
          l_x_ = L_x_
          l_y_ = L_y_
  
          _saved_tensors_hooks_disable = torch._C._autograd._saved_tensors_hooks_disable("torch.func.{grad, vjp, jacrev, hessian} don't yet support saved tensor hooks. Please open an issue with your use case.");  _saved_tensors_hooks_disable = None
          _grad_increment_nesting = torch._C._functorch._grad_increment_nesting();  _grad_increment_nesting = None
  
          _wrap_for_grad: "f32[4, 3]" = torch._C._functorch._wrap_for_grad(l_x_, 1);  l_x_ = _wrap_for_grad = None
          diff_primals: "f32[3, 4]" = torch._C._functorch._wrap_for_grad(l_y_, 1);  l_y_ = None
  
          set_inplace_requires_grad_allowed = torch._C._functorch.set_inplace_requires_grad_allowed(True);  set_inplace_requires_grad_allowed = None
  
          _set_tensor_requires_grad: "f32[3, 4]" = torch._functorch.eager_transforms._set_tensor_requires_grad(diff_primals);  _set_tensor_requires_grad = None
  
          set_inplace_requires_grad_allowed_1 = torch._C._functorch.set_inplace_requires_grad_allowed(False);  set_inplace_requires_grad_allowed_1 = None
  
          primals_out: "f32[3, 4]" = diff_primals.sin()
  
          results: "f32[3, 4]" = torch._C._functorch._unwrap_for_grad(primals_out, 1)
  
          _grad_decrement_nesting = torch._C._functorch._grad_decrement_nesting();  _grad_decrement_nesting = None
          _saved_tensors_hooks_enable = torch._C._autograd._saved_tensors_hooks_enable();  _saved_tensors_hooks_enable = None
  
-         tensor: "i64[1]" = torch.tensor((12,))
+         tensor: "i64[1]" = torch.tensor((12,), device = device(type='cpu'))
?                                              +++++++++++++++++++++++++++++
          cumsum: "i64[1]" = tensor.cumsum(dim = 0);  tensor = None
          getitem: "i64[0]" = cumsum[slice(None, -1, None)];  cumsum = None
          neg: "i64[0]" = getitem.neg();  getitem = None
          unbind = neg.unbind();  neg = unbind = None
- 
          chunk: "f32[12, 12]" = results.new_zeros(12, 12);  results = None
- 
          diagonal: "f32[12]" = chunk.diagonal(0)
          fill_: "f32[12]" = diagonal.fill_(1);  diagonal = fill_ = None
- 
          basis: "f32[12, 3, 4]" = chunk.view(12, 3, 4);  chunk = None
  
          lazy_load_decompositions = torch._functorch.predispatch.lazy_load_decompositions();  lazy_load_decompositions = None
  
          _vmap_increment_nesting = torch._functorch.predispatch._vmap_increment_nesting(12, 'error');  _vmap_increment_nesting = None
  
          _add_batch_dim: "f32[3, 4]" = torch._functorch.predispatch._add_batch_dim(basis, 0, 1);  basis = None
  
          _autograd_grad = torch._functorch.eager_transforms._autograd_grad([primals_out], [diff_primals], [_add_batch_dim], retain_graph = True, create_graph = True);  primals_out = diff_primals = _add_batch_dim = None
          batched_outputs: "f32[3, 4]" = _autograd_grad[0];  _autograd_grad = None
  
          chunked_result: "f32[12, 3, 4]" = torch._functorch.predispatch._remove_batch_dim(batched_outputs, 1, 12, 0);  batched_outputs = None
  
          _vmap_decrement_nesting = torch._functorch.predispatch._vmap_decrement_nesting();  _vmap_decrement_nesting = None
  
-         split = chunked_result.split((12,), dim = 0);  chunked_result = None
?                               ^^^^^^^
+         split = torch.Tensor.split(chunked_result, (12,), dim = 0);  chunked_result = None
?                 +++++++++++++++++++              ^^
          split_1: "f32[12, 3, 4]" = split[0];  split = None
- 
          output_input: "f32[3, 4, 3, 4]" = split_1.view((3, 4, 3, 4));  split_1 = None
          return (output_input,)
 : To accept the new output, re-run test with envvar EXPECTTEST_ACCEPT=1 (we recommend staging/committing your changes before doing this)

To execute this test, run the following from the base repo dir:
    python test/dynamo/test_higher_order_ops.py FuncTorchHigherOrderOpTestsWithCompiledAutograd.test_jacrev_two_tensors_argnums

This message can be suppressed by setting PYTORCH_PRINT_REPRO_ON_FAILURE=0