From 90ee366653dbecddb527b1e024f02989fd8ac8dd Mon Sep 17 00:00:00 2001 From: Steffy-zxf <48793257+Steffy-zxf@users.noreply.github.com> Date: Sat, 15 Feb 2020 19:26:22 +0800 Subject: [PATCH] update ops's unittest data type from float32 to float64 and shape over 100 (#22544) * update ops's unittest of elementwise_pow, elementwise_max, elementwise_min, scale and sqrt 1. update elementwise_pow, elementwise_max and scale's unitests with input data type (float32 -> float64) 2. fix bug that the elementwise_pow doesn't meet threshold requirements with tackling float64 data 3. remove sqrt from op_accuracy_white_list.py 4. update the unittests of elementwise_pow, elementwise_max and elementwise_min ops that their input data shape over 100 5. test=develop * modify the writing style according suggestions test=develop --- paddle/fluid/operators/scale_op.h | 9 +-- .../unittests/test_elementwise_max_op.py | 58 ++++++++++--------- .../unittests/test_elementwise_min_op.py | 42 +++++++------- .../unittests/test_elementwise_pow_op.py | 45 +++++++------- .../fluid/tests/unittests/test_scale_op.py | 8 +-- .../white_list/check_shape_white_list.py | 3 - .../white_list/op_accuracy_white_list.py | 3 - .../white_list/op_threshold_white_list.py | 1 - 8 files changed, 85 insertions(+), 84 deletions(-) diff --git a/paddle/fluid/operators/scale_op.h b/paddle/fluid/operators/scale_op.h index 909bb3d0044..64ee868fb6d 100644 --- a/paddle/fluid/operators/scale_op.h +++ b/paddle/fluid/operators/scale_op.h @@ -20,12 +20,13 @@ limitations under the License. */ namespace paddle { namespace operators { -static inline float GetAttrFromTensor(const framework::Tensor* tensor) { - const float* tensor_data = tensor->data(); +template +static inline T GetAttrFromTensor(const framework::Tensor* tensor) { + const auto* tensor_data = tensor->data(); framework::Tensor cpu_tensor; if (platform::is_gpu_place(tensor->place())) { TensorCopySync(*tensor, platform::CPUPlace(), &cpu_tensor); - tensor_data = cpu_tensor.data(); + tensor_data = cpu_tensor.data(); } return tensor_data[0]; } @@ -43,7 +44,7 @@ class ScaleKernel : public framework::OpKernel { auto scale = static_cast(ctx.Attr("scale")); if (ctx.HasInput("ScaleTensor")) { auto* scale_tensor = ctx.Input("ScaleTensor"); - scale = GetAttrFromTensor(scale_tensor); + scale = GetAttrFromTensor(scale_tensor); } auto* out_var = ctx.OutputVar("Out"); diff --git a/python/paddle/fluid/tests/unittests/test_elementwise_max_op.py b/python/paddle/fluid/tests/unittests/test_elementwise_max_op.py index efe91886271..624619f499f 100644 --- a/python/paddle/fluid/tests/unittests/test_elementwise_max_op.py +++ b/python/paddle/fluid/tests/unittests/test_elementwise_max_op.py @@ -16,7 +16,7 @@ from __future__ import print_function import unittest import numpy as np -from op_test import OpTest +from op_test import OpTest, skip_check_grad_ci class TestElementwiseOp(OpTest): @@ -25,9 +25,9 @@ class TestElementwiseOp(OpTest): # If x and y have the same value, the max() is not differentiable. # So we generate test data by the following method # to avoid them being too close to each other. - x = np.random.uniform(0.1, 1, [13, 17]).astype("float32") - sgn = np.random.choice([-1, 1], [13, 17]).astype("float32") - y = x + sgn * np.random.uniform(0.1, 1, [13, 17]).astype("float32") + x = np.random.uniform(0.1, 1, [13, 17]).astype("float64") + sgn = np.random.choice([-1, 1], [13, 17]).astype("float64") + y = x + sgn * np.random.uniform(0.1, 1, [13, 17]).astype("float64") self.inputs = {'X': x, 'Y': y} self.outputs = {'Out': np.maximum(self.inputs['X'], self.inputs['Y'])} @@ -46,11 +46,13 @@ class TestElementwiseOp(OpTest): ['X'], 'Out', max_relative_error=0.005, no_grad_set=set('Y')) +@skip_check_grad_ci( + reason="[skip shape check] Use y_shape(1) to test broadcast.") class TestElementwiseMaxOp_scalar(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_max" - x = np.random.random_integers(-5, 5, [2, 3, 20]).astype("float32") - y = np.array([0.5]).astype("float32") + x = np.random.random_integers(-5, 5, [2, 3, 20]).astype("float64") + y = np.array([0.5]).astype("float64") self.inputs = {'X': x, 'Y': y} self.outputs = {'Out': np.maximum(self.inputs['X'], self.inputs['Y'])} @@ -58,9 +60,9 @@ class TestElementwiseMaxOp_scalar(TestElementwiseOp): class TestElementwiseMaxOp_Vector(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_max" - x = np.random.random((100, )).astype("float32") - sgn = np.random.choice([-1, 1], (100, )).astype("float32") - y = x + sgn * np.random.uniform(0.1, 1, (100, )).astype("float32") + x = np.random.random((100, )).astype("float64") + sgn = np.random.choice([-1, 1], (100, )).astype("float64") + y = x + sgn * np.random.uniform(0.1, 1, (100, )).astype("float64") self.inputs = {'X': x, 'Y': y} self.outputs = {'Out': np.maximum(self.inputs['X'], self.inputs['Y'])} @@ -68,73 +70,73 @@ class TestElementwiseMaxOp_Vector(TestElementwiseOp): class TestElementwiseMaxOp_broadcast_0(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_max" - x = np.random.uniform(0.5, 1, (2, 3, 20)).astype(np.float32) - sgn = np.random.choice([-1, 1], (2, )).astype(np.float32) + x = np.random.uniform(0.5, 1, (100, 5, 2)).astype(np.float64) + sgn = np.random.choice([-1, 1], (100, )).astype(np.float64) y = x[:, 0, 0] + sgn * \ - np.random.uniform(1, 2, (2, )).astype(np.float32) + np.random.uniform(1, 2, (100, )).astype(np.float64) self.inputs = {'X': x, 'Y': y} self.attrs = {'axis': 0} self.outputs = { 'Out': - np.maximum(self.inputs['X'], self.inputs['Y'].reshape(2, 1, 1)) + np.maximum(self.inputs['X'], self.inputs['Y'].reshape(100, 1, 1)) } class TestElementwiseMaxOp_broadcast_1(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_max" - x = np.random.uniform(0.5, 1, (2, 3, 20)).astype(np.float32) - sgn = np.random.choice([-1, 1], (3, )).astype(np.float32) + x = np.random.uniform(0.5, 1, (2, 100, 3)).astype(np.float64) + sgn = np.random.choice([-1, 1], (100, )).astype(np.float64) y = x[0, :, 0] + sgn * \ - np.random.uniform(1, 2, (3, )).astype(np.float32) + np.random.uniform(1, 2, (100, )).astype(np.float64) self.inputs = {'X': x, 'Y': y} self.attrs = {'axis': 1} self.outputs = { 'Out': - np.maximum(self.inputs['X'], self.inputs['Y'].reshape(1, 3, 1)) + np.maximum(self.inputs['X'], self.inputs['Y'].reshape(1, 100, 1)) } class TestElementwiseMaxOp_broadcast_2(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_max" - x = np.random.uniform(0.5, 1, (10, 3, 4)).astype(np.float32) - sgn = np.random.choice([-1, 1], (4, )).astype(np.float32) + x = np.random.uniform(0.5, 1, (1, 3, 100)).astype(np.float64) + sgn = np.random.choice([-1, 1], (100, )).astype(np.float64) y = x[0, 0, :] + sgn * \ - np.random.uniform(1, 2, (4, )).astype(np.float32) + np.random.uniform(1, 2, (100, )).astype(np.float64) self.inputs = {'X': x, 'Y': y} self.outputs = { 'Out': - np.maximum(self.inputs['X'], self.inputs['Y'].reshape(1, 1, 4)) + np.maximum(self.inputs['X'], self.inputs['Y'].reshape(1, 1, 100)) } class TestElementwiseMaxOp_broadcast_3(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_max" - x = np.random.uniform(0.5, 1, (2, 3, 4, 5)).astype(np.float32) - sgn = np.random.choice([-1, 1], (3, 4)).astype(np.float32) + x = np.random.uniform(0.5, 1, (2, 50, 2, 1)).astype(np.float64) + sgn = np.random.choice([-1, 1], (50, 2)).astype(np.float64) y = x[0, :, :, 0] + sgn * \ - np.random.uniform(1, 2, (3, 4)).astype(np.float32) + np.random.uniform(1, 2, (50, 2)).astype(np.float64) self.inputs = {'X': x, 'Y': y} self.attrs = {'axis': 1} self.outputs = { 'Out': - np.maximum(self.inputs['X'], self.inputs['Y'].reshape(1, 3, 4, 1)) + np.maximum(self.inputs['X'], self.inputs['Y'].reshape(1, 50, 2, 1)) } class TestElementwiseMaxOp_broadcast_4(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_max" - x = np.random.uniform(0.5, 1, (2, 3, 4, 5)).astype(np.float32) - sgn = np.random.choice([-1, 1], (2, 3, 1, 5)).astype(np.float32) + x = np.random.uniform(0.5, 1, (2, 3, 4, 5)).astype(np.float64) + sgn = np.random.choice([-1, 1], (2, 3, 1, 5)).astype(np.float64) y = x + sgn * \ - np.random.uniform(1, 2, (2, 3, 1, 5)).astype(np.float32) + np.random.uniform(1, 2, (2, 3, 1, 5)).astype(np.float64) self.inputs = {'X': x, 'Y': y} self.outputs = {'Out': np.maximum(self.inputs['X'], self.inputs['Y'])} diff --git a/python/paddle/fluid/tests/unittests/test_elementwise_min_op.py b/python/paddle/fluid/tests/unittests/test_elementwise_min_op.py index 9c6273393a5..8e17ce32ca8 100644 --- a/python/paddle/fluid/tests/unittests/test_elementwise_min_op.py +++ b/python/paddle/fluid/tests/unittests/test_elementwise_min_op.py @@ -16,7 +16,7 @@ from __future__ import print_function import unittest import numpy as np -from op_test import OpTest +from op_test import OpTest, skip_check_grad_ci class TestElementwiseOp(OpTest): @@ -46,6 +46,8 @@ class TestElementwiseOp(OpTest): ['X'], 'Out', max_relative_error=0.005, no_grad_set=set('Y')) +@skip_check_grad_ci( + reason="[skip shape check] Use y_shape(1) to test broadcast.") class TestElementwiseMinOp_scalar(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_min" @@ -68,73 +70,73 @@ class TestElementwiseMinOp_Vector(TestElementwiseOp): class TestElementwiseMinOp_broadcast_0(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_min" - x = np.random.uniform(0.5, 1, (2, 3, 4)).astype(np.float64) - sgn = np.random.choice([-1, 1], (2, )).astype(np.float64) + x = np.random.uniform(0.5, 1, (100, 3, 2)).astype(np.float64) + sgn = np.random.choice([-1, 1], (100, )).astype(np.float64) y = x[:, 0, 0] + sgn * \ - np.random.uniform(1, 2, (2, )).astype(np.float64) + np.random.uniform(1, 2, (100, )).astype(np.float64) self.inputs = {'X': x, 'Y': y} self.attrs = {'axis': 0} self.outputs = { 'Out': - np.minimum(self.inputs['X'], self.inputs['Y'].reshape(2, 1, 1)) + np.minimum(self.inputs['X'], self.inputs['Y'].reshape(100, 1, 1)) } class TestElementwiseMinOp_broadcast_1(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_min" - x = np.random.uniform(0.5, 1, (2, 3, 4)).astype(np.float64) - sgn = np.random.choice([-1, 1], (3, )).astype(np.float64) + x = np.random.uniform(0.5, 1, (2, 100, 3)).astype(np.float64) + sgn = np.random.choice([-1, 1], (100, )).astype(np.float64) y = x[0, :, 0] + sgn * \ - np.random.uniform(1, 2, (3, )).astype(np.float64) + np.random.uniform(1, 2, (100, )).astype(np.float64) self.inputs = {'X': x, 'Y': y} self.attrs = {'axis': 1} self.outputs = { 'Out': - np.minimum(self.inputs['X'], self.inputs['Y'].reshape(1, 3, 1)) + np.minimum(self.inputs['X'], self.inputs['Y'].reshape(1, 100, 1)) } class TestElementwiseMinOp_broadcast_2(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_min" - x = np.random.uniform(0.5, 1, (2, 3, 4)).astype(np.float64) - sgn = np.random.choice([-1, 1], (4, )).astype(np.float64) + x = np.random.uniform(0.5, 1, (2, 3, 100)).astype(np.float64) + sgn = np.random.choice([-1, 1], (100, )).astype(np.float64) y = x[0, 0, :] + sgn * \ - np.random.uniform(1, 2, (4, )).astype(np.float64) + np.random.uniform(1, 2, (100, )).astype(np.float64) self.inputs = {'X': x, 'Y': y} self.outputs = { 'Out': - np.minimum(self.inputs['X'], self.inputs['Y'].reshape(1, 1, 4)) + np.minimum(self.inputs['X'], self.inputs['Y'].reshape(1, 1, 100)) } class TestElementwiseMinOp_broadcast_3(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_min" - x = np.random.uniform(0.5, 1, (2, 3, 4, 5)).astype(np.float64) - sgn = np.random.choice([-1, 1], (3, 4)).astype(np.float64) + x = np.random.uniform(0.5, 1, (2, 25, 4, 1)).astype(np.float64) + sgn = np.random.choice([-1, 1], (25, 4)).astype(np.float64) y = x[0, :, :, 0] + sgn * \ - np.random.uniform(1, 2, (3, 4)).astype(np.float64) + np.random.uniform(1, 2, (25, 4)).astype(np.float64) self.inputs = {'X': x, 'Y': y} self.attrs = {'axis': 1} self.outputs = { 'Out': - np.minimum(self.inputs['X'], self.inputs['Y'].reshape(1, 3, 4, 1)) + np.minimum(self.inputs['X'], self.inputs['Y'].reshape(1, 25, 4, 1)) } class TestElementwiseMinOp_broadcast_4(TestElementwiseOp): def setUp(self): self.op_type = "elementwise_min" - x = np.random.uniform(0.5, 1, (2, 3, 4, 5)).astype(np.float64) - sgn = np.random.choice([-1, 1], (2, 3, 1, 5)).astype(np.float64) + x = np.random.uniform(0.5, 1, (2, 10, 2, 5)).astype(np.float64) + sgn = np.random.choice([-1, 1], (2, 10, 1, 5)).astype(np.float64) y = x + sgn * \ - np.random.uniform(1, 2, (2, 3, 1, 5)).astype(np.float64) + np.random.uniform(1, 2, (2, 10, 1, 5)).astype(np.float64) self.inputs = {'X': x, 'Y': y} self.outputs = {'Out': np.minimum(self.inputs['X'], self.inputs['Y'])} diff --git a/python/paddle/fluid/tests/unittests/test_elementwise_pow_op.py b/python/paddle/fluid/tests/unittests/test_elementwise_pow_op.py index b7bc96fd278..08ffb564484 100644 --- a/python/paddle/fluid/tests/unittests/test_elementwise_pow_op.py +++ b/python/paddle/fluid/tests/unittests/test_elementwise_pow_op.py @@ -15,7 +15,7 @@ from __future__ import print_function import unittest import numpy as np -from op_test import OpTest +from op_test import OpTest, skip_check_grad_ci import paddle.fluid as fluid @@ -23,8 +23,8 @@ class TestElementwisePowOp(OpTest): def setUp(self): self.op_type = "elementwise_pow" self.inputs = { - 'X': np.random.uniform(0.1, 1, [2, 3]).astype("float64"), - 'Y': np.random.uniform(0.1, 1, [2, 3]).astype("float64") + 'X': np.random.uniform(1, 2, [20, 5]).astype("float64"), + 'Y': np.random.uniform(1, 2, [20, 5]).astype("float64") } self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])} @@ -39,7 +39,7 @@ class TestElementwisePowOp_big_shape_1(TestElementwisePowOp): def setUp(self): self.op_type = "elementwise_pow" self.inputs = { - 'X': np.random.uniform(0.1, 1, [10, 10]).astype("float64"), + 'X': np.random.uniform(1, 2, [10, 10]).astype("float64"), 'Y': np.random.uniform(0.1, 1, [10, 10]).astype("float64") } self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])} @@ -49,12 +49,14 @@ class TestElementwisePowOp_big_shape_2(TestElementwisePowOp): def setUp(self): self.op_type = "elementwise_pow" self.inputs = { - 'X': np.random.uniform(0.1, 1, [10, 10]).astype("float64"), - 'Y': np.random.uniform(0.1, 1, [10, 10]).astype("float64") * 20 + 'X': np.random.uniform(1, 2, [10, 10]).astype("float64"), + 'Y': np.random.uniform(0.2, 2, [10, 10]).astype("float64") } self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])} +@skip_check_grad_ci( + reason="[skip shape check] Use y_shape(1) to test broadcast.") class TestElementwisePowOp_scalar(TestElementwisePowOp): def setUp(self): self.op_type = "elementwise_pow" @@ -69,8 +71,8 @@ class TestElementwisePowOp_tensor(TestElementwisePowOp): def setUp(self): self.op_type = "elementwise_pow" self.inputs = { - 'X': np.random.uniform(0.1, 1, [32]).astype("float64"), - 'Y': np.random.uniform(0.1, 1, [32]).astype("float64") + 'X': np.random.uniform(0.1, 1, [100]).astype("float64"), + 'Y': np.random.uniform(1, 3, [100]).astype("float64") } self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])} @@ -79,8 +81,8 @@ class TestElementwisePowOp_broadcast_0(TestElementwisePowOp): def setUp(self): self.op_type = "elementwise_pow" self.inputs = { - 'X': np.random.uniform(0.1, 1, [2, 3, 4]).astype("float64"), - 'Y': np.random.uniform(0.1, 1, [4]).astype("float64") + 'X': np.random.uniform(0.1, 1, [2, 1, 100]).astype("float64"), + 'Y': np.random.uniform(0.1, 1, [100]).astype("float64") } self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])} @@ -89,12 +91,12 @@ class TestElementwisePowOp_broadcast_1(TestElementwisePowOp): def setUp(self): self.op_type = "elementwise_pow" self.inputs = { - 'X': np.random.uniform(0.1, 1, [2, 3, 4]).astype("float64"), - 'Y': np.random.uniform(0.1, 1, [3]).astype("float64") + 'X': np.random.uniform(0.1, 1, [2, 100, 1]).astype("float64"), + 'Y': np.random.uniform(0.1, 1, [100]).astype("float64") } self.attrs = {'axis': 1} self.outputs = { - 'Out': np.power(self.inputs['X'], self.inputs['Y'].reshape(3, 1)) + 'Out': np.power(self.inputs['X'], self.inputs['Y'].reshape(100, 1)) } @@ -102,12 +104,13 @@ class TestElementwisePowOp_broadcast_2(TestElementwisePowOp): def setUp(self): self.op_type = "elementwise_pow" self.inputs = { - 'X': np.random.uniform(0.1, 1, [2, 3, 4]).astype("float64"), - 'Y': np.random.uniform(0.1, 1, [2]).astype("float64") + 'X': np.random.uniform(0.1, 1, [100, 3, 1]).astype("float64"), + 'Y': np.random.uniform(0.1, 1, [100]).astype("float64") } self.attrs = {'axis': 0} self.outputs = { - 'Out': np.power(self.inputs['X'], self.inputs['Y'].reshape(2, 1, 1)) + 'Out': + np.power(self.inputs['X'], self.inputs['Y'].reshape(100, 1, 1)) } @@ -115,12 +118,12 @@ class TestElementwisePowOp_broadcast_3(TestElementwisePowOp): def setUp(self): self.op_type = "elementwise_pow" self.inputs = { - 'X': np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype("float64"), - 'Y': np.random.uniform(0.1, 1, [3, 4]).astype("float64") + 'X': np.random.uniform(0.1, 1, [2, 20, 5, 1]).astype("float64"), + 'Y': np.random.uniform(0.1, 1, [20, 5]).astype("float64") } self.attrs = {'axis': 1} self.outputs = { - 'Out': np.power(self.inputs['X'], self.inputs['Y'].reshape(1, 3, 4, + 'Out': np.power(self.inputs['X'], self.inputs['Y'].reshape(1, 20, 5, 1)) } @@ -129,8 +132,8 @@ class TestElementwisePowOp_broadcast_4(TestElementwisePowOp): def setUp(self): self.op_type = "elementwise_pow" self.inputs = { - 'X': np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype("float64"), - 'Y': np.random.uniform(0.1, 1, [2, 3, 1, 5]).astype("float64") + 'X': np.random.uniform(0.1, 1, [2, 10, 3, 5]).astype("float64"), + 'Y': np.random.uniform(0.1, 1, [2, 10, 1, 5]).astype("float64") } self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])} diff --git a/python/paddle/fluid/tests/unittests/test_scale_op.py b/python/paddle/fluid/tests/unittests/test_scale_op.py index c53db9eb78c..f070fe5066f 100644 --- a/python/paddle/fluid/tests/unittests/test_scale_op.py +++ b/python/paddle/fluid/tests/unittests/test_scale_op.py @@ -24,7 +24,7 @@ from paddle.fluid.op import Operator class TestScaleOp(OpTest): def setUp(self): self.op_type = "scale" - self.dtype = np.float32 + self.dtype = np.float64 self.init_dtype_type() self.inputs = {'X': np.random.random((10, 10)).astype(self.dtype)} self.attrs = {'scale': -2.3} @@ -45,12 +45,12 @@ class TestScaleOp(OpTest): class TestScaleOpScaleVariable(OpTest): def setUp(self): self.op_type = "scale" - self.dtype = np.float32 + self.dtype = np.float64 self.init_dtype_type() self.scale = -2.3 self.inputs = { 'X': np.random.random((10, 10)).astype(self.dtype), - 'ScaleTensor': np.array([self.scale]).astype('float32') + 'ScaleTensor': np.array([self.scale]).astype('float64') } self.attrs = {} self.outputs = {'Out': self.inputs['X'] * self.dtype(self.scale)} @@ -72,7 +72,7 @@ class TestScaleOpSelectedRows(unittest.TestCase): def check_with_place(self, place, in_name, out_name): scope = core.Scope() - self.dtype = np.float32 + self.dtype = np.float64 self.init_dtype_type() # create and initialize Grad Variable diff --git a/python/paddle/fluid/tests/unittests/white_list/check_shape_white_list.py b/python/paddle/fluid/tests/unittests/white_list/check_shape_white_list.py index f2f70bf874b..34c58fda7e2 100644 --- a/python/paddle/fluid/tests/unittests/white_list/check_shape_white_list.py +++ b/python/paddle/fluid/tests/unittests/white_list/check_shape_white_list.py @@ -15,9 +15,6 @@ NEED_TO_FIX_OP_LIST = [ 'elementwise_mul', 'elementwise_div', - 'elementwise_max', - 'elementwise_min', - 'elementwise_pow', 'fused_elemwise_activation', 'bilinear_tensor_product', 'conv2d_transpose', diff --git a/python/paddle/fluid/tests/unittests/white_list/op_accuracy_white_list.py b/python/paddle/fluid/tests/unittests/white_list/op_accuracy_white_list.py index d0f43d8fdad..e5d65db236c 100644 --- a/python/paddle/fluid/tests/unittests/white_list/op_accuracy_white_list.py +++ b/python/paddle/fluid/tests/unittests/white_list/op_accuracy_white_list.py @@ -31,7 +31,6 @@ NO_FP64_CHECK_GRAD_OP_LIST = [ 'depthwise_conv2d', \ 'depthwise_conv2d_transpose', \ 'dropout', \ - 'elementwise_max', \ 'fused_elemwise_activation', \ 'hierarchical_sigmoid', \ 'hinge_loss', \ @@ -59,7 +58,6 @@ NO_FP64_CHECK_GRAD_OP_LIST = [ 'reshape2', \ 'roi_perspective_transform', \ 'row_conv', \ - 'scale', \ 'scatter', \ 'sequence_conv', \ 'sequence_pool', \ @@ -71,7 +69,6 @@ NO_FP64_CHECK_GRAD_OP_LIST = [ 'smooth_l1_loss', \ 'softmax', \ 'spectral_norm', \ - 'sqrt', \ 'squared_l2_distance', \ 'squared_l2_norm', \ 'tanh', \ diff --git a/python/paddle/fluid/tests/unittests/white_list/op_threshold_white_list.py b/python/paddle/fluid/tests/unittests/white_list/op_threshold_white_list.py index 23d986a1997..b83f21e26fd 100644 --- a/python/paddle/fluid/tests/unittests/white_list/op_threshold_white_list.py +++ b/python/paddle/fluid/tests/unittests/white_list/op_threshold_white_list.py @@ -20,7 +20,6 @@ NEED_FIX_FP64_CHECK_GRAD_THRESHOLD_OP_LIST = [ 'conv3d', \ 'cross_entropy', \ 'depthwise_conv2d_transpose', \ - 'elementwise_pow', \ 'grid_sampler', \ 'group_norm', \ 'gru', \ -- GitLab