Added some extra tests for std_mean and var_mean for multiple dims. (#20650)

ifedan · facebook-github-bot · commit abd6cffe5528 · 2019-06-18T20:36:32.000-07:00
Summary: Added some extra tests for std_mean and var_mean for multiple dims. Some refactoring of previously created tests based on PR comments: #18731 Pull Request resolved: #20650 Differential Revision: D15396101 Pulled By: ifedan fbshipit-source-id: d15c3c2c7084a24d6cfea4018173552fcc9c03a9
diff --git a/test/common_methods_invocations.py b/test/common_methods_invocations.py
@@ -399,16 +399,16 @@ def method_tests():
         ('std', (S, S, S), (1, True, True), 'keepdim_dim', (True,), [0]),
         ('std', (S,), (0,), 'dim_1d', (True,), [0]),
         ('std', (S,), (0, True, True), 'keepdim_dim_1d', (True,), [0]),
-        ('__var_mean__', (S, S, S), NO_ARGS, ''),
-        ('__var_mean__', (S, S, S), (1,), 'dim', [0]),
-        ('__var_mean__', (S, S, S), (1, True, True), 'keepdim_dim', [0]),
-        ('__var_mean__', (S,), (0,), 'dim_1d', [0]),
-        ('__var_mean__', (S,), (0, True, True), 'keepdim_dim_1d', [0]),
-        ('__std_mean__', (S, S, S), NO_ARGS, ''),
-        ('__std_mean__', (S, S, S), (1,), 'dim', [0]),
-        ('__std_mean__', (S, S, S), (1, True, True), 'keepdim_dim', [0]),
-        ('__std_mean__', (S,), (0,), 'dim_1d', [0]),
-        ('__std_mean__', (S,), (0, True, True), 'keepdim_dim_1d', [0]),
+        ('var_mean', (S, S, S), NO_ARGS, ''),
+        ('var_mean', (S, S, S), (1,), 'dim', [0]),
+        ('var_mean', (S, S, S), (1, True, True), 'keepdim_dim', [0]),
+        ('var_mean', (S,), (0,), 'dim_1d', [0]),
+        ('var_mean', (S,), (0, True, True), 'keepdim_dim_1d', [0]),
+        ('std_mean', (S, S, S), NO_ARGS, ''),
+        ('std_mean', (S, S, S), (1,), 'dim', [0]),
+        ('std_mean', (S, S, S), (1, True, True), 'keepdim_dim', [0]),
+        ('std_mean', (S,), (0,), 'dim_1d', [0]),
+        ('std_mean', (S,), (0, True, True), 'keepdim_dim_1d', [0]),
         ('renorm', (S, S, S), (2, 1, 0.5), 'dim', (), [1]),
         ('renorm', (S, S, S), (1, 2, 3), 'norm_1'),
         ('renorm', (S, S, S), (inf, 2, 0.5), 'norm_inf'),
@@ -1086,6 +1086,16 @@ def exclude_tensor_method(name, test_name):
         'test_where_scalar',
         'test_where_scalar_broadcast_mask',
         'test_where_scalar_broadcast_non_mask',
+        'test_var_mean_keepdim_dim_1d',
+        'test_var_mean_keepdim_dim',
+        'test_var_mean_dim_1d',
+        'test_var_mean_dim',
+        'test_var_mean',
+        'test_std_mean_keepdim_dim_1d',
+        'test_std_mean_keepdim_dim',
+        'test_std_mean_dim_1d',
+        'test_std_mean_dim',
+        'test_std_mean',
     }
     # there are no out-of-place tensor equivalents for these
     exclude_outplace_tensor_method = {
diff --git a/test/test_autograd.py b/test/test_autograd.py
@@ -3314,21 +3314,21 @@ def check(name):
                 args_variable, kwargs_variable = create_input(args, requires_grad=not is_inplace, call_kwargs=kwargs)
                 self_tensor = deepcopy(self_variable.data)
                 args_tensor = deepcopy(unpack_variables(args_variable))
-                output_variable = getattr(self_variable, name)(*args_variable, **kwargs_variable)
                 if not exclude_tensor_method(name, test_name):
+                    output_variable = getattr(self_variable, name)(*args_variable, **kwargs_variable)
                     output_tensor = getattr(self_tensor, name)(*args_tensor, **kwargs_variable)
                     if not isinstance(output_tensor, torch.Tensor) and not istuple(output_tensor):
                         output_tensor = torch.DoubleTensor((output_tensor,))
                     self.assertEqual(unpack_variables(output_variable), output_tensor)
                     # TODO: check that both have changed after adding all inplace ops
 
-                def fn(*inputs):
-                    output = getattr(inputs[0], name)(*inputs[1:], **kwargs)
-                    return output_process_fn(output)
+                    def fn(*inputs):
+                        output = getattr(inputs[0], name)(*inputs[1:], **kwargs)
+                        return output_process_fn(output)
 
-                if not is_inplace and name not in EXCLUDE_GRADCHECK:
-                    run_grad_and_gradgrad_checks(self, name, test_name, fn,
-                                                 output_variable, (self_variable,) + args_variable)
+                    if not is_inplace and name not in EXCLUDE_GRADCHECK:
+                        run_grad_and_gradgrad_checks(self, name, test_name, fn,
+                                                     output_variable, (self_variable,) + args_variable)
 
                 # functional interface tests
                 if hasattr(torch, name) and name not in EXCLUDE_FUNCTIONAL:
@@ -3339,14 +3339,19 @@ def fn(*inputs):
                     f_args_variable = (self_variable,) + args_variable
                     f_args_tensor = (self_tensor,) + args_tensor
                     # could run the gradchecks again, but skip since we did it for the methods above.
+                    run_gradcheck = exclude_tensor_method(name, test_name) and not is_inplace and name not in EXCLUDE_GRADCHECK
                     run_functional_checks(self, test_name, name, fn,
-                                          False, f_args_variable, f_args_tensor)
+                                          run_gradcheck, f_args_variable, f_args_tensor)
 
                 # check for correct type of input.data and input.grad.data
                 if not is_inplace:
                     self_variable = create_input((self_size,), requires_grad=True)[0][0]
                     args_variable, kwargs_variable = create_input(args, requires_grad=False, call_kwargs=kwargs)
-                    output_variable = getattr(self_variable, name)(*args_variable, **kwargs_variable)
+                    if hasattr(self_variable, name):
+                        output_variable = getattr(self_variable, name)(*args_variable, **kwargs_variable)
+                    else:
+                        self_and_args_variable = (self_variable,) + args_variable
+                        output_variable = getattr(torch, name)(*self_and_args_variable, **kwargs_variable)
                     if isinstance(output_variable, torch.autograd.Variable):
                         if output_variable.is_sparse:
                             rand = randn_like(output_variable.to_dense()).to_sparse()
diff --git a/test/test_torch.py b/test/test_torch.py
@@ -2656,6 +2656,38 @@ def test_var_mean_all_dims(self):
                 self.assertEqual(var1, var2)
                 self.assertEqual(mean1, mean2)
 
+    def test_std_mean_some_dims(self):
+        sizes = (4, 6, 7, 5, 3)
+        dims = len(sizes)
+        for device in torch.testing.get_all_device_types():
+            x = torch.rand(sizes, device=device)
+            for num_of_dims in range(2, dims):
+                dim_list = list(combinations(list(range(dims)), r=num_of_dims))
+                for dim in dim_list:
+                    for unbiased in [False, True]:
+                        for keepdim in [False, True]:
+                            std1, mean1 = torch.std_mean(x, dim=dim, unbiased=unbiased, keepdim=keepdim)
+                            std2 = x.std(dim=dim, unbiased=unbiased, keepdim=keepdim)
+                            mean2 = x.mean(dim=dim, keepdim=keepdim)
+                            self.assertEqual(std1, std2)
+                            self.assertEqual(mean1, mean2)
+
+    def test_var_mean_some_dims(self):
+        sizes = (4, 6, 7, 5, 3)
+        dims = len(sizes)
+        for device in torch.testing.get_all_device_types():
+            x = torch.rand(sizes, device=device)
+            for num_of_dims in range(2, dims):
+                dim_list = list(combinations(list(range(dims)), r=num_of_dims))
+                for dim in dim_list:
+                    for unbiased in [False, True]:
+                        for keepdim in [False, True]:
+                            var1, mean1 = torch.var_mean(x, dim=dim, unbiased=unbiased, keepdim=keepdim)
+                            var2 = x.var(dim=dim, unbiased=unbiased, keepdim=keepdim)
+                            mean2 = x.mean(dim=dim, keepdim=keepdim)
+                            self.assertEqual(var1, var2)
+                            self.assertEqual(mean1, mean2)
+
     def test_zeros_like(self):
         expected = torch.zeros(100, 100)
 
diff --git a/torch/tensor.py b/torch/tensor.py
@@ -425,18 +425,6 @@ def __rfloordiv__(self, other):
     __ge__ = _C._TensorBase.ge
     __abs__ = _C._TensorBase.abs
 
-    def __std_mean__(self, dim=None, unbiased=True, keepdim=False):
-        if dim is None:
-            return _C._VariableFunctions.std_mean(self, unbiased)
-        else:
-            return _C._VariableFunctions.std_mean(self, dim, unbiased, keepdim)
-
-    def __var_mean__(self, dim=None, unbiased=True, keepdim=False):
-        if dim is None:
-            return _C._VariableFunctions.var_mean(self, unbiased)
-        else:
-            return _C._VariableFunctions.var_mean(self, dim, unbiased, keepdim)
-
     def __len__(self):
         if self.dim() == 0:
             raise TypeError("len() of a 0-d tensor")
