Revert D23568330: [pytorch][PR] Moves some of TestTorchMathOps to OpInfos

Test Plan: revert-hammer

Differential Revision:
D23568330 (pytorch@a953a82)

Original commit changeset: 03e69fccdbfd

fbshipit-source-id: 04ec6843c5eb3c84ddf226dad0088172d9bed84d

Author: Elias Ellison

test/test_ops.py

@@ -102,8 +102,6 @@ def test_method_grad(self, device, dtype, op):
     @dtypes(torch.double, torch.cdouble)
     @ops(op_db)
     def test_inplace_grad(self, device, dtype, op):
-        if not op.test_inplace_grad:
-            self.skipTest("Skipped! Inplace gradcheck marked to skip.")
         self._grad_test_helper(device, dtype, op, self._get_safe_inplace(op.get_inplace()))
 
     # Test that gradients of gradients are computed correctly
@@ -120,8 +118,6 @@ def test_method_gradgrad(self, device, dtype, op):
     @dtypes(torch.double, torch.cdouble)
     @ops(op_db)
     def test_inplace_gradgrad(self, device, dtype, op):
-        if not op.test_inplace_grad:
-            self.skipTest("Skipped! Inplace gradgradcheck marked to skip.")
         self._gradgrad_test_helper(device, dtype, op, self._get_safe_inplace(op.get_inplace()))
 
 

test/test_torch.py

@@ -20307,7 +20307,19 @@ def __init__(self,
         self.dtypes = dtypes
         self.replace_inf_with_nan = replace_inf_with_nan
 
-torch_op_tests = [_TorchMathTestMeta('sqrt'),
+torch_op_tests = [_TorchMathTestMeta('asin', reffn='arcsin'),
+                  _TorchMathTestMeta('asinh', reffn='arcsinh'),
+                  _TorchMathTestMeta('sinh'),
+                  _TorchMathTestMeta('acosh', reffn='arccosh'),
+                  _TorchMathTestMeta('tan'),
+                  _TorchMathTestMeta('atan', reffn='arctan'),
+                  _TorchMathTestMeta('atanh', reffn='arctanh'),
+                  _TorchMathTestMeta('tanh'),
+                  _TorchMathTestMeta('log'),
+                  _TorchMathTestMeta('log10'),
+                  _TorchMathTestMeta('log1p'),
+                  _TorchMathTestMeta('log2'),
+                  _TorchMathTestMeta('sqrt'),
                   _TorchMathTestMeta('erf', ref_backend='scipy'),
                   _TorchMathTestMeta('erfc', ref_backend='scipy'),
                   _TorchMathTestMeta('exp'),

test/test_unary_ufuncs.py

@@ -19,21 +19,6 @@
 if TEST_NUMPY:
     import numpy as np
 
-# Tests for unary "universal functions (ufuncs)" that accept a single
-# tensor and have common properties like:
-#   - they are elementwise functions
-#   - the input shape is the output shape
-#   - they typically have method and inplace variants
-#   - they typically support the out kwarg
-#   - they typically have NumPy or SciPy references
-
-# See NumPy's universal function documentation
-# (https://numpy.org/doc/1.18/reference/ufuncs.html) for more details
-# about the concept of ufuncs.
-
-# Functions tested here:
-#
-
 # Interesting values and extremal values for different dtypes
 _unsigned_int_vals = (0, 1, 55, 127)
 _int_vals = (0, -1, 1, -55, 55, -127, 127, -128, 128)
@@ -132,13 +117,50 @@ def generate_numeric_tensors(device, dtype, *,
 
     return chain(empty_tensors, scalar_tensors, small_tensors, (medium_tensor,), (large_tensor,))
 
+# Tests for unary "universal functions (ufuncs)" that accept a single
+# tensor and have common properties like:
+#   - they are elementwise functions
+#   - the input shape is the output shape
+#   - they typically have method and inplace variants
+#   - they typically support the out kwarg
+#   - they typically have NumPy or SciPy references
+
+# See NumPy's universal function documentation
+# (https://numpy.org/doc/1.18/reference/ufuncs.html) for more details
+# about the concept of ufuncs.
+
 # TODO: port test_unary_out_op_mem_overlap
 # TODO: add out= tests (different devices, dtypes, mismatched sizes,
 #                       correct sizes, 0 size, broadcasted out)
 # TODO: add test for inplace variants erroring on broadcasted inputs
 class TestUnaryUfuncs(TestCase):
     exact_dtype = True
 
+    # Helper for comparing torch tensors and numpy arrays
+    # TODO: should this or assertEqual also validate that strides are equal?
+    def assertEqualHelper(self, actual, expected, *, dtype, exact_dtype=True, **kwargs):
+        assert isinstance(actual, torch.Tensor)
+
+        # Some NumPy functions return scalars, not arrays
+        if isinstance(expected, Number):
+            self.assertEqual(actual.item(), expected)
+        elif isinstance(expected, np.ndarray):
+            # Handles exact dtype comparisons between arrays and tensors
+            if exact_dtype:
+                # Allows array dtype to be float32 when comparing with bfloat16 tensors
+                #   since NumPy doesn't support the bfloat16 dtype
+                if expected.dtype == np.float32:
+                    assert actual.dtype in (torch.bfloat16, torch.float32)
+                else:
+                    assert expected.dtype == torch_to_numpy_dtype_dict[actual.dtype]
+
+            self.assertEqual(actual,
+                             torch.from_numpy(expected).to(actual.dtype),
+                             exact_device=False,
+                             **kwargs)
+        else:
+            self.assertEqual(actual, expected, exact_device=False, **kwargs)
+
     # Tests bool tensor negation raises the correct error
     def test_neg_error_message(self, device):
         msg = ("Negation, the `\\-` operator, on a bool tensor is not supported."
@@ -212,32 +234,6 @@ def _fn(t):
             actual = alt(t.clone())
             self.assertEqual(actual, expected, rtol=0, atol=0)
 
-    # Helper for comparing torch tensors and numpy arrays
-    # TODO: should this or assertEqual also validate that strides are equal?
-    def assertEqualHelper(self, actual, expected, msg, *, dtype, exact_dtype=True, **kwargs):
-        assert isinstance(actual, torch.Tensor)
-
-        # Some NumPy functions return scalars, not arrays
-        if isinstance(expected, Number):
-            self.assertEqual(actual.item(), expected)
-        elif isinstance(expected, np.ndarray):
-            # Handles exact dtype comparisons between arrays and tensors
-            if exact_dtype:
-                # Allows array dtype to be float32 when comparing with bfloat16 tensors
-                #   since NumPy doesn't support the bfloat16 dtype
-                if expected.dtype == np.float32:
-                    assert actual.dtype in (torch.bfloat16, torch.float32)
-                else:
-                    assert expected.dtype == torch_to_numpy_dtype_dict[actual.dtype]
-
-            self.assertEqual(actual,
-                             torch.from_numpy(expected).to(actual.dtype),
-                             msg,
-                             exact_device=False,
-                             **kwargs)
-        else:
-            self.assertEqual(actual, expected, msg, exact_device=False, **kwargs)
-
     # Tests that the function and its (array-accepting) reference produce the same
     #   values on a range of tensors, including empty tensors, scalar tensors,
     #   1D tensors and a large 2D tensor with interesting and extremal values
@@ -270,7 +266,7 @@ def test_reference_numerics(self, device, dtype, op):
             else:
                 msg = None
 
-            self.assertEqualHelper(actual, expected, msg, dtype=dtype)
+            self.assertEqualHelper(actual, expected, dtype=dtype, msg=msg)
 
     # Tests for testing (dis)contiguity consistency
 

torch/testing/_internal/common_device_type.py

@@ -229,45 +229,33 @@ def instantiate_test(cls, name, test, *, generic_cls=None):
 
         def instantiate_test_helper(cls, name, *, test, dtype, op):
 
-            # Constructs the test's name
-            test_name = _construct_test_name(name, op, cls.device_type, dtype)
-
-            # wraps instantiated test with op decorators
-            # NOTE: test_wrapper exists because we don't want to apply
-            #   op-specific decorators to the original test.
-            #   Test-sepcific decorators are applied to the original test,
-            #   however.
+            # wraps test with op decorators
             if op is not None and op.decorators is not None:
-                @wraps(test)
-                def test_wrapper(*args, **kwargs):
-                    return test(*args, **kwargs)
-
                 for decorator in op.decorators:
-                    test_wrapper = decorator(test_wrapper)
+                    test = decorator(test)
 
-                test_fn = test_wrapper
-            else:
-                test_fn = test
+            # Constructs the test's name
+            test_name = _construct_test_name(name, op, cls.device_type, dtype)
 
             # Constructs the test
             @wraps(test)
-            def instantiated_test(self, name=name, test=test_fn, dtype=dtype, op=op):
+            def instantiated_test(self, name=name, test=test, dtype=dtype, op=op):
                 if op is not None and op.should_skip(generic_cls.__name__, name,
                                                      self.device_type, dtype):
                     self.skipTest("Skipped!")
 
                 device_arg = cls.get_primary_device()
-                if hasattr(test_fn, 'num_required_devices'):
+                if hasattr(test, 'num_required_devices'):
                     device_arg = cls.get_all_devices()
 
                 # Sets precision and runs test
                 # Note: precision is reset after the test is run
                 guard_precision = self.precision
                 try:
-                    self.precision = self._get_precision_override(test_fn, dtype)
+                    self.precision = self._get_precision_override(test, dtype)
                     args = (device_arg, dtype, op)
                     args = (arg for arg in args if arg is not None)
-                    result = test_fn(self, *args)
+                    result = test(self, *args)
                 finally:
                     self.precision = guard_precision
 

torch/testing/_internal/common_methods_invocations.py

@@ -10,7 +10,7 @@
 from torch.testing import \
     (make_non_contiguous,
      _dispatch_dtypes,
-     floating_types, floating_types_and, floating_types_and_half,
+     floating_types, floating_types_and,
      floating_and_complex_types, floating_and_complex_types_and,
      all_types_and_complex_and)
 from torch.testing._internal.common_device_type import \
@@ -62,7 +62,6 @@ def __init__(self,
                  dtypesIfCPU=None,  # dtypes this function is expected to work with on CPU
                  dtypesIfCUDA=None,  # dtypes this function is expected to work with on CUDA
                  dtypesIfROCM=None,  # dtypes this function is expected to work with on ROCM
-                 test_inplace_grad=True,  # whether to gradcheck and gradgradcheck the inplace variant
                  skips=tuple(),  # information about which tests to skip
                  decorators=None):  # decorators to apply to generated tests
         # Validates the dtypes are generated from the dispatch-related functions
@@ -84,8 +83,6 @@ def __init__(self,
         inplace_name = name + "_"
         self.inplace_variant = getattr(torch.Tensor, inplace_name) if hasattr(torch.Tensor, name) else None
 
-        self.test_inplace_grad = test_inplace_grad
-
         self.skips = skips
         self.decorators = decorators
 
@@ -200,7 +197,7 @@ def sample_inputs(self, device, dtype, requires_grad=False):
 
 
 
-# Operator database (sorted alphabetically)
+# Operator database
 op_db = [
     # NOTE: CPU complex acos produces incorrect outputs (https://github.com/pytorch/pytorch/issues/42952)
     UnaryUfuncInfo('acos',
@@ -215,56 +212,13 @@ def sample_inputs(self, device, dtype, requires_grad=False):
                                 device_type='cpu', dtypes=[torch.cfloat, torch.cdouble]),
                        SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
                                 dtypes=[torch.cfloat, torch.cdouble], active_if=IS_WINDOWS),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cuda', dtypes=[torch.float16],
-                                active_if=TEST_WITH_ROCM),
                        SkipInfo('TestGradients', 'test_fn_grad',
                                 dtypes=[torch.cdouble], active_if=IS_WINDOWS),
                        SkipInfo('TestGradients', 'test_method_grad',
                                 dtypes=[torch.cdouble], active_if=IS_WINDOWS),
                        SkipInfo('TestGradients', 'test_inplace_grad',
                                 dtypes=[torch.cdouble], active_if=IS_WINDOWS),
                    )),
-    # NOTE: the derivative for inplace acosh is not implemented
-    UnaryUfuncInfo('acosh',
-                   ref=np.arccosh,
-                   domain=(1, float('inf')),
-                   dtypesIfCPU=floating_types(),
-                   dtypesIfCUDA=floating_types_and_half(),
-                   test_inplace_grad=False),
-    UnaryUfuncInfo('asin',
-                   ref=np.arcsin,
-                   domain=(-1, 1),
-                   decorators=(precisionOverride({torch.bfloat16: 1e-2}),),
-                   skips=(
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.cfloat, torch.cdouble]),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cuda', dtypes=[torch.cfloat, torch.cdouble],
-                                active_if=IS_WINDOWS),
-                   )),
-    # NOTE: derivative for inplace asinh is not implemented
-    UnaryUfuncInfo('asinh',
-                   ref=np.arcsinh,
-                   dtypesIfCPU=floating_types(),
-                   dtypesIfCUDA=floating_types_and_half(),
-                   test_inplace_grad=False),
-    UnaryUfuncInfo('atan',
-                   ref=np.arctan,
-                   decorators=(precisionOverride({torch.bfloat16: 1e-2}),),
-                   skips=(
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.cfloat, torch.cdouble]),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cuda', dtypes=[torch.cfloat, torch.cdouble],
-                                active_if=IS_WINDOWS),
-                   )),
-    UnaryUfuncInfo('atanh',
-                   ref=np.arctanh,
-                   domain=(-1, 1),
-                   dtypesIfCPU=floating_types(),
-                   dtypesIfCUDA=floating_types_and_half(),
-                   test_inplace_grad=False),
     UnaryUfuncInfo('cos',
                    ref=np.cos,
                    dtypesIfCUDA=floating_and_complex_types_and(torch.half, torch.bfloat16),
@@ -287,52 +241,6 @@ def sample_inputs(self, device, dtype, requires_grad=False):
                        SkipInfo('TestUnaryUfuncs', 'test_reference_numerics', device_type='cpu',
                                 dtypes=[torch.cfloat, torch.cdouble], active_if=IS_MACOS),
                    )),
-    UnaryUfuncInfo('log',
-                   ref=np.log,
-                   domain=(0, float('inf')),
-                   skips=(
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.bfloat16]),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cuda', dtypes=[torch.cfloat, torch.cdouble]),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.cfloat, torch.cdouble],
-                                active_if=IS_WINDOWS),
-                   )),
-    UnaryUfuncInfo('log10',
-                   ref=np.log10,
-                   domain=(0, float('inf')),
-                   decorators=(precisionOverride({torch.bfloat16: 1e-2}),),
-                   skips=(
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cuda', dtypes=[torch.cfloat, torch.cdouble]),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.cfloat, torch.cdouble],
-                                active_if=IS_WINDOWS),
-                   )),
-    UnaryUfuncInfo('log1p',
-                   ref=np.log1p,
-                   domain=(-1, float('inf')),
-                   dtypesIfCPU=floating_types_and(torch.bfloat16),
-                   dtypesIfCUDA=floating_types_and_half(),
-                   decorators=(precisionOverride({torch.bfloat16: 1e-1}),)),
-    UnaryUfuncInfo('log2',
-                   ref=np.log2,
-                   domain=(0, float('inf')),
-                   skips=(
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.bfloat16]),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cuda', dtypes=[torch.cfloat, torch.cdouble]),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.cfloat, torch.cdouble],
-                                active_if=IS_WINDOWS),
-                   )),
-    UnaryUfuncInfo('neg',
-                   ref=np.negative,
-                   dtypes=all_types_and_complex_and(torch.half, torch.bfloat16),
-                   dtypesIfCPU=all_types_and_complex_and(torch.half, torch.bfloat16),
-                   dtypesIfCUDA=all_types_and_complex_and(torch.half)),
     UnaryUfuncInfo('sin',
                    ref=np.sin,
                    handles_large_floats=False,
@@ -344,39 +252,11 @@ def sample_inputs(self, device, dtype, requires_grad=False):
                        SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
                                 dtypes=[torch.float], active_if=TEST_WITH_ROCM),
                    )),
-    UnaryUfuncInfo('sinh',
-                   ref=np.sinh,
-                   dtypesIfCPU=floating_and_complex_types(),
-                   decorators=(precisionOverride({torch.float16: 1e-2}),),
-                   skips=(
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.cfloat, torch.cdouble],
-                                active_if=(IS_MACOS or IS_WINDOWS)),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cuda', dtypes=[torch.cfloat, torch.cdouble],
-                                active_if=IS_WINDOWS),
-                   )),
-    UnaryUfuncInfo('tan',
-                   ref=np.tan,
-                   skips=(
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cuda', dtypes=[torch.cfloat, torch.cdouble]),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.bfloat16]),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.cfloat, torch.cdouble],
-                                active_if=(IS_MACOS or IS_WINDOWS)),
-                   )),
-    UnaryUfuncInfo('tanh',
-                   ref=np.tanh,
-                   decorators=(precisionOverride({torch.bfloat16: 1e-2}),),
-                   skips=(
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cuda', dtypes=[torch.cfloat, torch.cdouble]),
-                       SkipInfo('TestUnaryUfuncs', 'test_reference_numerics',
-                                device_type='cpu', dtypes=[torch.cfloat, torch.cdouble],
-                                active_if=(IS_MACOS or IS_WINDOWS)),
-                   )),
+    UnaryUfuncInfo('neg',
+                   ref=np.negative,
+                   dtypes=all_types_and_complex_and(torch.half, torch.bfloat16),
+                   dtypesIfCPU=all_types_and_complex_and(torch.half, torch.bfloat16),
+                   dtypesIfCUDA=all_types_and_complex_and(torch.half)),
 ]
 
 # Common operator groupings