[3] Update the precision of some op tests from fp32 to fp64

python/paddle/fluid/tests/unittests/test_sequence_concat.py

@@ -26,8 +26,8 @@ def setLoD(self):
         self.out_lod = [19, 11]
 
     def setUp(self):
-        x1 = np.random.random(size=(10, 80)).astype('float32')
-        x2 = np.random.random(size=(20, 80)).astype('float32')
+        x1 = np.random.random(size=(10, 80)).astype('float64')
+        x2 = np.random.random(size=(20, 80)).astype('float64')
         self.setLoD()
 
         out = np.concatenate((x1[0:self.lod1[0]], x2[0:self.lod2[0]],

python/paddle/fluid/tests/unittests/test_sequence_expand.py

@@ -21,8 +21,8 @@
 
 class TestSequenceExpand(OpTest):
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [3, 40]).astype('float32')
-        y_data = np.random.uniform(0.1, 1, [8, 1]).astype('float32')
+        x_data = np.random.uniform(0.1, 1, [3, 40]).astype('float64')
+        y_data = np.random.uniform(0.1, 1, [8, 1]).astype('float64')
         y_lod = [[1, 3, 4]]
         self.inputs = {'X': x_data, 'Y': (y_data, y_lod)}
 
@@ -80,56 +80,56 @@ def test_check_grad(self):
 
 class TestSequenceExpandCase1(TestSequenceExpand):
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [5, 1]).astype('float32')
-        y_data = np.random.uniform(0.1, 1, [13, 1]).astype('float32')
+        x_data = np.random.uniform(0.1, 1, [5, 1]).astype('float64')
+        y_data = np.random.uniform(0.1, 1, [13, 1]).astype('float64')
         y_lod = [[2, 3], [2, 2, 3, 3, 3]]
         self.inputs = {'X': x_data, 'Y': (y_data, y_lod)}
         self.attrs = {'ref_level': 1}
 
 
 class TestSequenceExpandCase2(TestSequenceExpand):
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [1, 2, 2]).astype('float32')
+        x_data = np.random.uniform(0.1, 1, [1, 2, 2]).astype('float64')
         x_lod = [[1]]
-        y_data = np.random.uniform(0.1, 1, [2, 2, 2]).astype('float32')
+        y_data = np.random.uniform(0.1, 1, [2, 2, 2]).astype('float64')
         y_lod = [[2], [1, 1]]
         self.inputs = {'X': (x_data, x_lod), 'Y': (y_data, y_lod)}
         self.attrs = {'ref_level': 0}
 
 
 class TestSequenceExpandCase3(TestSequenceExpand):
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [4, 1]).astype('float32')
+        x_data = np.random.uniform(0.1, 1, [4, 1]).astype('float64')
         x_lod = [[1, 1, 1, 1]]
-        y_data = np.random.uniform(0.1, 1, [8, 1]).astype('float32')
+        y_data = np.random.uniform(0.1, 1, [8, 1]).astype('float64')
         y_lod = [[2, 2, 2, 2]]
         self.inputs = {'X': (x_data, x_lod), 'Y': (y_data, y_lod)}
 
 
 class TestSequenceExpandCase4(TestSequenceExpand):
     def set_data(self):
         data = np.random.uniform(0.1, 1, [5 * 2, 1])
-        x_data = np.array(data).reshape([5, 2]).astype('float32')
+        x_data = np.array(data).reshape([5, 2]).astype('float64')
         x_lod = [[2, 3]]
-        y_data = np.random.uniform(0.1, 1, [5, 1]).astype('float32')
+        y_data = np.random.uniform(0.1, 1, [5, 1]).astype('float64')
         y_lod = [[2], [2, 3]]
         self.inputs = {'X': (x_data, x_lod), 'Y': (y_data, y_lod)}
 
 
 class TestSequenceExpandCase5(TestSequenceExpand):
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [6, 1]).astype('float32')
-        y_data = np.random.uniform(0.1, 1, [13, 1]).astype('float32')
+        x_data = np.random.uniform(0.1, 1, [6, 1]).astype('float64')
+        y_data = np.random.uniform(0.1, 1, [13, 1]).astype('float64')
         y_lod = [[2, 4], [2, 2, 3, 0, 3, 3]]
         self.inputs = {'X': x_data, 'Y': (y_data, y_lod)}
         self.attrs = {'ref_level': 1}
 
 
 class TestSequenceExpandCase6(TestSequenceExpand):
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [4, 1]).astype('float32')
+        x_data = np.random.uniform(0.1, 1, [4, 1]).astype('float64')
         x_lod = [[1, 1, 0, 1, 1]]
-        y_data = np.random.uniform(0.1, 1, [8, 1]).astype('float32')
+        y_data = np.random.uniform(0.1, 1, [8, 1]).astype('float64')
         y_lod = [[0, 2, 4, 2, 0]]
         self.inputs = {'X': (x_data, x_lod), 'Y': (y_data, y_lod)}
 

python/paddle/fluid/tests/unittests/test_sequence_expand_as.py

@@ -26,8 +26,8 @@ def setUp(self):
         self.compute()
 
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [3, 40]).astype('float32')
-        y_data = np.random.uniform(0.1, 1, [8, 1]).astype('float32')
+        x_data = np.random.uniform(0.1, 1, [3, 40]).astype('float64')
+        y_data = np.random.uniform(0.1, 1, [8, 1]).astype('float64')
         y_lod = [[1, 3, 4]]
         self.inputs = {'X': x_data, 'Y': (y_data, y_lod)}
 
@@ -57,27 +57,27 @@ def test_check_grad(self):
 
 class TestSequenceExpandAsCase1(TestSequenceExpandAs):
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [5, 1]).astype('float32')
+        x_data = np.random.uniform(0.1, 1, [5, 1]).astype('float64')
         x_lod = [[2, 3]]
-        y_data = np.random.uniform(0.1, 1, [10, 1]).astype('float32')
+        y_data = np.random.uniform(0.1, 1, [10, 1]).astype('float64')
         y_lod = [[2, 2, 0, 3, 3]]
         self.inputs = {'X': (x_data, x_lod), 'Y': (y_data, y_lod)}
 
 
 class TestSequenceExpandAsCase2(TestSequenceExpandAs):
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [5, 1]).astype('float32')
+        x_data = np.random.uniform(0.1, 1, [5, 1]).astype('float64')
         x_lod = [[2, 3]]
-        y_data = np.random.uniform(0.1, 1, [10, 1]).astype('float32')
+        y_data = np.random.uniform(0.1, 1, [10, 1]).astype('float64')
         y_lod = [[0, 4, 0, 6, 0]]
         self.inputs = {'X': (x_data, x_lod), 'Y': (y_data, y_lod)}
 
 
 class TestSequenceExpandAsCase3(TestSequenceExpandAs):
     def set_data(self):
-        x_data = np.random.uniform(0.1, 1, [1, 2, 2]).astype('float32')
+        x_data = np.random.uniform(0.1, 1, [1, 2, 2]).astype('float64')
         x_lod = [[1]]
-        y_data = np.random.uniform(0.1, 1, [2, 2, 2]).astype('float32')
+        y_data = np.random.uniform(0.1, 1, [2, 2, 2]).astype('float64')
         y_lod = [[2]]
         self.inputs = {'X': (x_data, x_lod), 'Y': (y_data, y_lod)}
 

python/paddle/fluid/tests/unittests/test_sequence_pad_op.py

@@ -23,7 +23,7 @@ def set_attr(self):
         self.x_len_lod = [[2, 3, 4, 3]]
         self.pad_value = [1.0]
         self.padded_length = -1
-        self.dtype = 'float32'
+        self.dtype = 'float64'
 
     def set_data(self):
         x_data = np.random.uniform(0.1, 0.5, self.x_shape).astype(self.dtype)
@@ -84,7 +84,7 @@ def set_attr(self):
         self.x_len_lod = [[2, 3, 4, 3]]
         self.pad_value = [1.0, 2.0, 3.0, 4.0]
         self.padded_length = -1
-        self.dtype = 'float32'
+        self.dtype = 'float64'
 
 
 class TestSequencePadOp3(TestSequencePadOp):
@@ -93,7 +93,7 @@ def set_attr(self):
         self.x_len_lod = [[2, 3, 4, 3]]
         self.pad_value = [1.0]
         self.padded_length = 7
-        self.dtype = 'float32'
+        self.dtype = 'float64'
 
 
 class TestSequencePadOp4(TestSequencePadOp):
@@ -102,7 +102,7 @@ def set_attr(self):
         self.x_len_lod = [[2, 3, 4, 3]]
         self.pad_value = [1.0, 2.0, 3.0, 4.0]
         self.padded_length = 7
-        self.dtype = 'float32'
+        self.dtype = 'float64'
 
 
 class TestSequencePadOp5(TestSequencePadOp):
@@ -111,7 +111,7 @@ def set_attr(self):
         self.x_len_lod = [[2, 3, 4, 3]]
         self.pad_value = [1.0]
         self.padded_length = -1
-        self.dtype = 'float32'
+        self.dtype = 'float64'
 
 
 class TestSequencePadOp6(TestSequencePadOp):
@@ -120,7 +120,7 @@ def set_attr(self):
         self.x_len_lod = [[2, 3, 4, 3]]
         self.pad_value = [[1.0, 2.0], [3.0, 4.0]]
         self.padded_length = -1
-        self.dtype = 'float32'
+        self.dtype = 'float64'
 
 
 class TestSequencePadOp7(TestSequencePadOp):
@@ -129,7 +129,7 @@ def set_attr(self):
         self.x_len_lod = [[2, 3, 4, 3]]
         self.pad_value = [1.0]
         self.padded_length = 7
-        self.dtype = 'float32'
+        self.dtype = 'float64'
 
 
 class TestSequencePadOp8(TestSequencePadOp):
@@ -138,7 +138,7 @@ def set_attr(self):
         self.x_len_lod = [[0, 8, 0, 4, 0]]
         self.pad_value = [1.0]
         self.padded_length = 10
-        self.dtype = 'float32'
+        self.dtype = 'float64'
 
 
 if __name__ == '__main__':

python/paddle/fluid/tests/unittests/test_sequence_reshape.py

@@ -24,7 +24,7 @@ class TestSequenceReshape(OpTest):
     def init_data(self):
         self.dimension = 12
         self.x_lod = [[4, 1, 3, 3]]
-        self.x = np.random.uniform(0.1, 1, [11, 24]).astype('float32')
+        self.x = np.random.uniform(0.1, 1, [11, 24]).astype('float64')
 
     def setUp(self):
         self.init_data()
@@ -42,7 +42,7 @@ def compute_output(self, x, x_lod, dimension):
             offset = (seq_len * x_width) / dimension
             assert int(offset) * dimension == seq_len * x_width
             out_lod[0].append(int(offset))
-        out = np.zeros(shape=(sum(out_lod[0]), dimension)).astype('float32')
+        out = np.zeros(shape=(sum(out_lod[0]), dimension)).astype('float64')
         out.ravel()[:] = x.ravel()[:]
         return out, out_lod
 
@@ -57,28 +57,28 @@ class TestSequenceReshape_reduce(TestSequenceReshape):
     def init_data(self):
         self.dimension = 24
         self.x_lod = [[4, 2, 2, 4]]
-        self.x = np.random.uniform(0.1, 1, [12, 12]).astype('float32')
+        self.x = np.random.uniform(0.1, 1, [12, 12]).astype('float64')
 
 
 class TestSequenceReshape_same(TestSequenceReshape):
     def init_data(self):
         self.dimension = 12
         self.x_lod = [[4, 2, 2, 4]]
-        self.x = np.random.uniform(0.1, 1, [12, 12]).astype('float32')
+        self.x = np.random.uniform(0.1, 1, [12, 12]).astype('float64')
 
 
 class TestSequenceReshape_reduce_seq_len0(TestSequenceReshape):
     def init_data(self):
         self.dimension = 24
         self.x_lod = [[0, 6, 0, 2, 4]]
-        self.x = np.random.uniform(0.1, 1, [12, 12]).astype('float32')
+        self.x = np.random.uniform(0.1, 1, [12, 12]).astype('float64')
 
 
 class TestSequenceReshape_reduce_seq_len0_case1(TestSequenceReshape):
     def init_data(self):
         self.dimension = 24
         self.x_lod = [[0, 2, 8, 2, 0]]
-        self.x = np.random.uniform(0.1, 1, [12, 12]).astype('float32')
+        self.x = np.random.uniform(0.1, 1, [12, 12]).astype('float64')
 
 
 if __name__ == '__main__':

python/paddle/fluid/tests/unittests/test_sequence_scatter_op.py

@@ -24,12 +24,12 @@ def init_lod(self):
     def setUp(self):
         self.op_type = "sequence_scatter"
 
-        X_data = np.random.uniform(0.1, 1.0, [3, 6]).astype('float32')
+        X_data = np.random.uniform(0.1, 1.0, [3, 6]).astype('float64')
         Ids_data = np.array([[0], [1], [2], [5], [4], [3], [0], [1], [3], [2],
                              [5], [4]]).astype('int64')
         Ids_lod = self.init_lod()
 
-        Updates_data = np.random.uniform(0.1, 1.0, [12, 1]).astype('float32')
+        Updates_data = np.random.uniform(0.1, 1.0, [12, 1]).astype('float64')
         Updates_lod = Ids_lod
 
         Out_data = np.copy(X_data)

python/paddle/fluid/tests/unittests/test_sequence_softmax_op.py

@@ -27,9 +27,9 @@ def setUp(self):
         self.use_cudnn = False
         self.init_op_type()
 
-        x = np.random.uniform(0.1, 1, (110, 1)).astype("float32")
+        x = np.random.uniform(0.1, 1, (110, 1)).astype("float64")
         self.init_lod()
-        out = np.zeros((110, 1)).astype("float32")
+        out = np.zeros((110, 1)).astype("float64")
         offset = 0
         for i in range(len(self.lod[0])):
             if (self.lod[0][i] == 0):

python/paddle/fluid/tests/unittests/test_sequence_unpad_op.py

@@ -22,7 +22,7 @@ class TestSequenceUnpadOp(OpTest):
     def init(self):
         self.length = [2, 3, 4]
         self.x_shape = (3, 40)
-        self.dtype = "float32"
+        self.dtype = "float64"
 
     def compute(self):
         assert len(self.length) == self.x_shape[0]
@@ -58,7 +58,7 @@ class TestSequenceUnpadOp2(TestSequenceUnpadOp):
     def init(self):
         self.length = [2, 3, 4]
         self.x_shape = (3, 5, 4, 3)
-        self.dtype = "float32"
+        self.dtype = "float64"
 
 
 class TestSequenceUnpadOp3(TestSequenceUnpadOp):

python/paddle/fluid/tests/unittests/test_sigmoid_cross_entropy_with_logits_op.py

@@ -33,9 +33,9 @@ def setUp(self):
         self.inputs = {
             'X': logit(
                 np.random.uniform(0, 1, (batch_size, num_classes))
-                .astype("float32")),
+                .astype("float64")),
             'Label': np.random.randint(0, 2, (batch_size, num_classes))
-            .astype("float32")
+            .astype("float64")
         }
 
         # Fw Pass is implemented as elementwise sigmoid followed by
@@ -65,9 +65,9 @@ def setUp(self):
         self.inputs = {
             'X': logit(
                 np.random.uniform(0, 1, (batch_size, num_classes))
-                .astype("float32")),
+                .astype("float64")),
             'Label': np.random.randint(-1, 2, (batch_size, num_classes))
-            .astype("float32")
+            .astype("float64")
         }
         self.attrs = {'ignore_index': ignore_index, }
         # Fw Pass is implemented as elementwise sigmoid followed by
@@ -98,9 +98,9 @@ def setUp(self):
         self.inputs = {
             'X': logit(
                 np.random.uniform(0, 1, (batch_size, num_classes))
-                .astype("float32")),
+                .astype("float64")),
             'Label': np.random.uniform(0, 1, (batch_size, num_classes))
-            .astype("float32")
+            .astype("float64")
         }
 
         # Fw Pass is implemented as elementwise sigmoid followed by
@@ -127,9 +127,9 @@ def setUp(self):
         self.inputs = {
             'X': logit(
                 np.random.uniform(0, 1, (batch_size, num_classes))
-                .astype("float32")),
+                .astype("float64")),
             'Label': np.random.randint(-1, 2, (batch_size, num_classes))
-            .astype("float32")
+            .astype("float64")
         }
         self.attrs = {'ignore_index': ignore_index, 'normalize': True}
         sigmoid_X = expit(self.inputs['X'])
@@ -160,9 +160,9 @@ def setUp(self):
         self.inputs = {
             'X': logit(
                 np.random.uniform(0, 1, tuple(batch_size + [num_classes]))
-                .astype("float32")),
+                .astype("float64")),
             'Label': np.random.uniform(0, 1, tuple(batch_size + [num_classes]))
-            .astype("float32")
+            .astype("float64")
         }
 
         # Fw Pass is implemented as elementwise sigmoid followed by
@@ -189,9 +189,9 @@ def setUp(self):
         self.inputs = {
             'X': logit(
                 np.random.uniform(0, 1, tuple(batch_size + [num_classes]))
-                .astype("float32")),
+                .astype("float64")),
             'Label': np.random.randint(-1, 2, tuple(batch_size + [num_classes]))
-            .astype("float32")
+            .astype("float64")
         }
         self.attrs = {'ignore_index': ignore_index, 'normalize': True}
         sigmoid_X = expit(self.inputs['X'])
@@ -222,9 +222,9 @@ def setUp(self):
         self.inputs = {
             'X': logit(
                 np.random.uniform(0, 1, tuple(batch_size + [num_classes]))
-                .astype("float32")),
+                .astype("float64")),
             'Label': np.random.randint(0, 2, tuple(batch_size + [num_classes]))
-            .astype("float32")
+            .astype("float64")
         }
 
         # Fw Pass is implemented as elementwise sigmoid followed by