Refactor tests part 2 (pytorch#11811)

Summary:
Followup to the [first refactor](pytorch#11350). Increase coverage of tests
Pull Request resolved: pytorch#11811

Reviewed By: houseroad

Differential Revision: D9923074

Pulled By: ajyu

fbshipit-source-id: 0f899bb9e9a75bf7ed939e06cc9b028daa7f6bd9

Author: ajyu

caffe2/python/operator_test/rank_loss_operator_test.py

@@ -2,14 +2,16 @@
 from __future__ import division
 from __future__ import print_function
 from __future__ import unicode_literals
+
 from caffe2.python import core, workspace
 from hypothesis import given
 import caffe2.python.hypothesis_test_util as hu
+import caffe2.python.serialized_test.serialized_test_util as serial
 import hypothesis.strategies as st
 import numpy as np
 
 
-class TestPairWiseLossOps(hu.HypothesisTestCase):
+class TestPairWiseLossOps(serial.SerializedTestCase):
     @given(X=hu.arrays(dims=[2, 1],
                        elements=st.floats(min_value=0.0, max_value=10.0)),
            label=hu.arrays(dims=[2, 1],
@@ -98,7 +100,7 @@ def test_pair_wise_loss_gradient(self, X, label, dY, gc, dc):
                 (up_output_pred[0] - down_output_pred[0]) / delta),
             rtol=1e-2, atol=1e-2)
 
-    @given(n=st.integers(0, 10), k=st.integers(1, 5), **hu.gcs_cpu_only)
+    @serial.given(n=st.integers(0, 10), k=st.integers(1, 5), **hu.gcs_cpu_only)
     def test_pair_wise_loss_batch(self, n, k, gc, dc):
         lengths = np.random.randint(k, size=n).astype(np.int32) + 1
         X = np.random.rand(sum(lengths)).astype(np.float32)

caffe2/python/operator_test/recurrent_network_test.py

@@ -7,13 +7,14 @@
 from caffe2.python.model_helper import ModelHelper
 from hypothesis import given
 import caffe2.python.hypothesis_test_util as hu
+import caffe2.python.serialized_test.serialized_test_util as serial
 import hypothesis.strategies as st
 import numpy as np
 
-import unittest
 import os
+import unittest
 
-class RecurrentNetworkTest(hu.HypothesisTestCase):
+class RecurrentNetworkTest(serial.SerializedTestCase):
     @unittest.skipIf("IN_CIRCLECI" in os.environ, "FIXME: flaky test in CircleCI")
     @given(T=st.integers(1, 4),
            n=st.integers(1, 5),
@@ -34,7 +35,7 @@ def test_sum_mul(self, T, n, d):
         self.simple_rnn(T, n, d, model, step, input_t, output_t, output_t_prev,
                         input_blob, initial_input_blob)
 
-    @given(T=st.integers(1, 4),
+    @serial.given(T=st.integers(1, 4),
            n=st.integers(1, 5),
            d=st.integers(1, 5))
     def test_mul(self, T, n, d):

caffe2/python/operator_test/reduce_ops_test.py

@@ -7,12 +7,13 @@
 from hypothesis import given
 
 import caffe2.python.hypothesis_test_util as hu
+import caffe2.python.serialized_test.serialized_test_util as serial
 import hypothesis.strategies as st
 import numpy as np
 import itertools as it
 
 
-class TestReduceOps(hu.HypothesisTestCase):
+class TestReduceOps(serial.SerializedTestCase):
     def run_reduce_op_test_impl(
             self, op_name, X, axes, keepdims, ref_func, gc, dc):
         if axes is None:
@@ -54,8 +55,9 @@ def run_reduce_op_test(
                 self.run_reduce_op_test_impl(
                     op_name, X, axes, keepdims, ref_func, gc, dc)
 
-    @given(X=hu.tensor(max_dim=3, dtype=np.float32), keepdims=st.booleans(),
-           num_axes=st.integers(1, 3), **hu.gcs)
+    @serial.given(
+        X=hu.tensor(max_dim=3, dtype=np.float32), keepdims=st.booleans(),
+        num_axes=st.integers(1, 3), **hu.gcs)
     def test_reduce_min(self, X, keepdims, num_axes, gc, dc):
         X_dims = X.shape
         X_size = X.size
@@ -65,8 +67,9 @@ def test_reduce_min(self, X, keepdims, num_axes, gc, dc):
         self.run_reduce_op_test(
             "ReduceMin", X, keepdims, num_axes, np.min, gc, dc)
 
-    @given(X=hu.tensor(max_dim=3, dtype=np.float32), keepdims=st.booleans(),
-           num_axes=st.integers(1, 3), **hu.gcs)
+    @serial.given(
+        X=hu.tensor(max_dim=3, dtype=np.float32), keepdims=st.booleans(),
+        num_axes=st.integers(1, 3), **hu.gcs)
     def test_reduce_max(self, X, keepdims, num_axes, gc, dc):
         X_dims = X.shape
         X_size = X.size
@@ -84,7 +87,7 @@ def test_reduce_sum(self, n, m, k, t, keepdims, num_axes, gc, dc):
         self.run_reduce_op_test(
             "ReduceSum", X, keepdims, num_axes, np.sum, gc, dc)
 
-    @given(X=hu.tensor(dtype=np.float32), keepdims=st.booleans(),
+    @serial.given(X=hu.tensor(dtype=np.float32), keepdims=st.booleans(),
            num_axes=st.integers(1, 4), **hu.gcs)
     def test_reduce_mean(self, X, keepdims, num_axes, gc, dc):
         self.run_reduce_op_test(
@@ -99,7 +102,7 @@ def test_reduce_l1(self, n, m, k, keepdims, num_axes, gc, dc):
         self.run_reduce_op_test(
             "ReduceL1", X, keepdims, num_axes, getNorm(1), gc, dc)
 
-    @given(n=st.integers(1, 5), m=st.integers(1, 5), k=st.integers(1, 5),
+    @serial.given(n=st.integers(1, 5), m=st.integers(1, 5), k=st.integers(1, 5),
            keepdims=st.booleans(), num_axes=st.integers(1, 3), **hu.gcs_cpu_only)
     def test_reduce_l2(self, n, m, k, keepdims, num_axes, gc, dc):
         X = np.random.randn(n, m, k).astype(np.float32)
@@ -119,7 +122,7 @@ def norm(X, axis, keepdims):
     return norm
 
 
-class TestReduceFrontReductions(hu.HypothesisTestCase):
+class TestReduceFrontReductions(serial.SerializedTestCase):
     def grad_variant_input_test(self, grad_op_name, X, ref, num_reduce_dim):
         workspace.ResetWorkspace()
 
@@ -200,7 +203,7 @@ def reduce_op_test(self, op_name, op_ref, in_data, in_names,
         self.assertGradientChecks(
             device, op, in_data, 0, [0], stepsize=1e-2, threshold=1e-2)
 
-    @given(num_reduce_dim=st.integers(0, 4), **hu.gcs)
+    @serial.given(num_reduce_dim=st.integers(0, 4), **hu.gcs)
     def test_reduce_front_sum(self, num_reduce_dim, gc, dc):
         X = np.random.rand(7, 4, 3, 5).astype(np.float32)
 
@@ -265,7 +268,7 @@ def ref_sum(X, lengths):
             "ReduceFrontSum", ref_sum, [X, lengths], ["input", "lengths"],
             num_reduce_dim, gc)
 
-    @given(num_reduce_dim=st.integers(0, 4), **hu.gcs)
+    @serial.given(num_reduce_dim=st.integers(0, 4), **hu.gcs)
     def test_reduce_front_mean(self, num_reduce_dim, gc, dc):
         X = np.random.rand(6, 7, 8, 2).astype(np.float32)
 
@@ -296,7 +299,7 @@ def ref_mean(X, lengths):
             "ReduceFrontMean", ref_mean, [X, lengths], ["input", "lengths"],
             num_reduce_dim, gc)
 
-    @given(num_reduce_dim=st.integers(0, 4), **hu.gcs)
+    @serial.given(num_reduce_dim=st.integers(0, 4), **hu.gcs)
     def test_reduce_front_max(self, num_reduce_dim, gc, dc):
         X = np.random.rand(6, 7, 8, 2).astype(np.float32)
 
@@ -325,7 +328,7 @@ def ref_max(X, lengths):
             "ReduceFrontMax", num_reduce_dim, gc, dc, [X, lengths],
             ["X", "lengths"], ref_max)
 
-    @given(num_reduce_dim=st.integers(0, 4), **hu.gcs)
+    @serial.given(num_reduce_dim=st.integers(0, 4), **hu.gcs)
     def test_reduce_back_max(self, num_reduce_dim, gc, dc):
         X = np.random.rand(6, 7, 8, 2).astype(np.float32)
 
@@ -386,7 +389,7 @@ def ref_sum(X, lengths):
             "ReduceBackSum", ref_sum, [X, lengths], ["input", "lengths"],
             num_reduce_dim, gc)
 
-    @given(num_reduce_dim=st.integers(0, 4), **hu.gcs)
+    @serial.given(num_reduce_dim=st.integers(0, 4), **hu.gcs)
     def test_reduce_back_mean(self, num_reduce_dim, dc, gc):
         X = np.random.rand(6, 7, 8, 2).astype(np.float32)
 

caffe2/python/operator_test/reduction_ops_test.py

@@ -3,17 +3,18 @@
 from __future__ import print_function
 from __future__ import unicode_literals
 
+from caffe2.proto import caffe2_pb2
 from caffe2.python import core
 from hypothesis import assume, given
 import caffe2.python.hypothesis_test_util as hu
+import caffe2.python.serialized_test.serialized_test_util as serial
 import hypothesis.strategies as st
 import numpy as np
-from caffe2.proto import caffe2_pb2
 
 
-class TestReductionOps(hu.HypothesisTestCase):
+class TestReductionOps(serial.SerializedTestCase):
 
-    @given(n=st.integers(5, 8), **hu.gcs)
+    @serial.given(n=st.integers(5, 8), **hu.gcs)
     def test_elementwise_sum(self, n, gc, dc):
         X = np.random.rand(n).astype(np.float32)
 
@@ -41,7 +42,7 @@ def sum_op(X):
             outputs_with_grads=[0],
         )
 
-    @given(n=st.integers(5, 8), **hu.gcs)
+    @serial.given(n=st.integers(5, 8), **hu.gcs)
     def test_elementwise_int_sum(self, n, gc, dc):
         X = np.random.rand(n).astype(np.int32)
 
@@ -61,7 +62,7 @@ def sum_op(X):
             reference=sum_op,
         )
 
-    @given(n=st.integers(1, 65536),
+    @serial.given(n=st.integers(1, 65536),
            dtype=st.sampled_from([np.float32, np.float16]),
            **hu.gcs)
     def test_elementwise_sqrsum(self, n, dtype, gc, dc):
@@ -120,7 +121,7 @@ def avg_op(X):
             outputs_with_grads=[0],
         )
 
-    @given(batch_size=st.integers(1, 3),
+    @serial.given(batch_size=st.integers(1, 3),
            m=st.integers(1, 3),
            n=st.integers(1, 4),
            **hu.gcs)
@@ -143,7 +144,7 @@ def rowwise_max(X):
             reference=rowwise_max,
         )
 
-    @given(batch_size=st.integers(1, 3),
+    @serial.given(batch_size=st.integers(1, 3),
            m=st.integers(1, 3),
            n=st.integers(1, 4),
            **hu.gcs)

caffe2/python/operator_test/segment_ops_test.py

@@ -12,6 +12,7 @@
 
 from caffe2.python import core, workspace
 import caffe2.python.hypothesis_test_util as hu
+import caffe2.python.serialized_test.serialized_test_util as serial
 
 
 class TesterBase:
@@ -418,7 +419,7 @@ def test_unsorted_means_large(self, gc, dc):
         op = core.CreateOperator("UnsortedSegmentMean", ["X", "segments"], "out")
         self.assertDeviceChecks(dc, op, [X, segments], [0])
 
-    @given(
+    @serial.given(
         inputs=hu.lengths_tensor(
             dtype=np.float32,
             min_value=1,
@@ -447,7 +448,7 @@ def ref(D, L):
         self.assertDeviceChecks(dc, op, [X, Y], [0])
         self.assertGradientChecks(gc, op, [X, Y], 0, [0])
 
-    @given(
+    @serial.given(
         inputs=hu.sparse_lengths_tensor(
             dtype=np.float32,
             min_value=1,
@@ -476,7 +477,7 @@ def ref(D, I, L):
         self.assertDeviceChecks(dc, op, [X, Y, Z], [0])
         self.assertGradientChecks(gc, op, [X, Y, Z], 0, [0])
 
-    @given(
+    @serial.given(
         inputs=hu.lengths_tensor(
             dtype=np.float32,
             min_value=1,
@@ -511,7 +512,7 @@ def ref(D, L):
         self.assertDeviceChecks(dc, op, [X, Y], [0])
         self.assertGradientChecks(gc, op, [X, Y], 0, [0])
 
-    @given(
+    @serial.given(
         inputs=hu.sparse_lengths_tensor(
             dtype=np.float32,
             min_value=1,
@@ -547,7 +548,7 @@ def ref(D, I, L):
         self.assertDeviceChecks(dc, op, [X, Y, Z], [0])
         self.assertGradientChecks(gc, op, [X, Y, Z], 0, [0])
 
-    @given(
+    @serial.given(
         grad_on_weights=st.booleans(),
         inputs=hu.sparse_lengths_tensor(
             dtype=np.float32,
@@ -635,7 +636,7 @@ def test_sparse_lengths_sum_invalid_index(self, gc, dc):
         with self.assertRaises(RuntimeError):
             workspace.RunOperatorOnce(op)
 
-    @given(**hu.gcs_cpu_only)
+    @serial.given(**hu.gcs_cpu_only)
     def test_sparse_lengths_positional_weighted_sum(
             self, gc, dc):
         D = np.random.rand(50, 3, 4, 5).astype(np.float32)

caffe2/python/operator_test/selu_op_test.py

@@ -5,16 +5,17 @@
 
 from caffe2.python import core
 from hypothesis import given
-import hypothesis.strategies as st
 import caffe2.python.hypothesis_test_util as hu
+import caffe2.python.serialized_test.serialized_test_util as serial
+import hypothesis.strategies as st
 import numpy as np
 
 import unittest
 
 
-class TestSelu(hu.HypothesisTestCase):
+class TestSelu(serial.SerializedTestCase):
 
-    @given(X=hu.tensor(),
+    @serial.given(X=hu.tensor(),
            engine=st.sampled_from(["", "CUDNN"]),
             **hu.gcs)
     def test_selu_1(self, X, gc, dc, engine):

caffe2/python/operator_test/sequence_ops_test.py

@@ -2,14 +2,16 @@
 from __future__ import division
 from __future__ import print_function
 from __future__ import unicode_literals
+
 from caffe2.python import core
+from functools import partial
 from hypothesis import given
 import caffe2.python.hypothesis_test_util as hu
+import caffe2.python.serialized_test.serialized_test_util as serial
 import hypothesis.strategies as st
 import numpy as np
 import unittest
 import os
-from functools import partial
 
 
 def _gen_test_add_padding(with_pad_data=True,
@@ -99,8 +101,8 @@ def _gather_padding_ref(start_pad_width, end_pad_width, data, lengths):
     return (start_padding, end_padding)
 
 
-class TestSequenceOps(hu.HypothesisTestCase):
-    @given(start_pad_width=st.integers(min_value=1, max_value=2),
+class TestSequenceOps(serial.SerializedTestCase):
+    @serial.given(start_pad_width=st.integers(min_value=1, max_value=2),
            end_pad_width=st.integers(min_value=0, max_value=2),
            args=_gen_test_add_padding(with_pad_data=True),
            ret_lengths=st.booleans(),
@@ -187,7 +189,7 @@ def test_remove_padding(self, start_pad_width, end_pad_width, args, gc, dc):
             reference=partial(_remove_padding_ref, start_pad_width, end_pad_width))
 
     @unittest.skipIf("IN_CIRCLECI" in os.environ, "FIXME: flaky test in CircleCI")
-    @given(start_pad_width=st.integers(min_value=0, max_value=2),
+    @serial.given(start_pad_width=st.integers(min_value=0, max_value=2),
            end_pad_width=st.integers(min_value=0, max_value=2),
            args=_gen_test_add_padding(with_pad_data=True),
            **hu.gcs)
@@ -208,7 +210,7 @@ def test_gather_padding(self, start_pad_width, end_pad_width, args, gc, dc):
             inputs=[padded_data, padded_lengths],
             reference=partial(_gather_padding_ref, start_pad_width, end_pad_width))
 
-    @given(data=hu.tensor(min_dim=3, max_dim=3, dtype=np.float32,
+    @serial.given(data=hu.tensor(min_dim=3, max_dim=3, dtype=np.float32,
                           elements=st.floats(min_value=-np.inf,
                                              max_value=np.inf),
                           min_value=1, max_value=10),
@@ -242,7 +244,7 @@ def op_grad_ref(grad_out, outputs, inputs):
             output_to_grad='reversed_data',
             grad_reference=op_grad_ref)
 
-    @given(data=hu.tensor(min_dim=1, max_dim=3, dtype=np.float32,
+    @serial.given(data=hu.tensor(min_dim=1, max_dim=3, dtype=np.float32,
                           elements=st.floats(min_value=-np.inf,
                                              max_value=np.inf),
                           min_value=10, max_value=10),
@@ -270,7 +272,7 @@ def op_ref(data, indices):
             inputs=[data, indices],
             reference=op_ref)
 
-    @given(elements=st.lists(st.integers(min_value=0, max_value=9),
+    @serial.given(elements=st.lists(st.integers(min_value=0, max_value=9),
                              min_size=0,
                              max_size=10),
            **hu.gcs_cpu_only)

caffe2/python/operator_test/sinusoid_position_encoding_op_test.py

@@ -6,6 +6,7 @@
 from caffe2.python import core
 from hypothesis import given
 import caffe2.python.hypothesis_test_util as hu
+import caffe2.python.serialized_test.serialized_test_util as serial
 import hypothesis.strategies as st
 import numpy as np
 import math
@@ -19,8 +20,8 @@
 MAX_TEST_AMPLITUDE = 10.0
 
 
-class TestSinusoidPositionEncodingOp(hu.HypothesisTestCase):
-    @given(
+class TestSinusoidPositionEncodingOp(serial.SerializedTestCase):
+    @serial.given(
         positions_vec=hu.arrays(
             dims=[MAX_TEST_SEQUENCE_LENGTH],
             dtype=np.int32,