diff --git a/python/paddle/fluid/tests/unittests/xpu/test_adam_op_xpu.py b/python/paddle/fluid/tests/unittests/xpu/test_adam_op_xpu.py index a36c0bf071332e3d5c67843b3084787035118cba..6495c0af1a14dcedd5b9349faa1187e44011b575 100644 --- a/python/paddle/fluid/tests/unittests/xpu/test_adam_op_xpu.py +++ b/python/paddle/fluid/tests/unittests/xpu/test_adam_op_xpu.py @@ -23,163 +23,175 @@ from paddle.fluid.op import Operator import paddle.fluid as fluid import paddle +from op_test_xpu import XPUOpTest +from xpu.get_test_cover_info import create_test_class, get_xpu_op_support_types, XPUOpTestWrapper -class TestAdamOp1(OpTest): - def setUp(self): + +class XPUTestAdamOp(XPUOpTestWrapper): + def __init__(self): + self.op_name = 'adam' + self.use_dynamic_create_class = False + + class TestAdamOp(XPUOpTest): '''Test Adam Op with supplied attributes ''' - self.op_type = "adam" - param = np.random.uniform(-1, 1, (102, 105)).astype("float32") - grad = np.random.uniform(-1, 1, (102, 105)).astype("float32") - moment1 = np.random.uniform(-1, 1, (102, 105)).astype("float32") - # The second moment is positive - moment2 = np.random.random((102, 105)).astype("float32") - - learning_rate = 0.004 - beta1 = 0.78 - beta2 = 0.836 - epsilon = 1e-4 - beta1_pow = beta1**10 - beta2_pow = beta2**10 - - self.inputs = { - 'Param': param, - 'Grad': grad, - 'Moment1': moment1, - 'Moment2': moment2, - 'LearningRate': np.array([learning_rate]).astype("float32"), - 'Beta1Pow': np.array([beta1_pow]).astype("float32"), - 'Beta2Pow': np.array([beta2_pow]).astype("float32") - } - self.attrs = {'epsilon': epsilon, 'beta1': beta1, 'beta2': beta2} + def setUp(self): + self.init_dtype() + self.set_xpu() + self.op_type = "adam" + self.place = paddle.XPUPlace(0) + self.set_data() + self.set_attrs() + self.set_shape() + self.set_inputs() + self.set_steps() + param_out, moment1_out, \ + moment2_out = adam_step(self.inputs, self.attrs) - param_out, moment1_out, \ - moment2_out = adam_step(self.inputs, self.attrs) + self.outputs = { + 'Moment1Out': moment1_out, + 'Moment2Out': moment2_out, + 'ParamOut': param_out, + 'Beta1PowOut': + np.array([self.beta1_pow]).astype("float32") * self.beta1, + 'Beta2PowOut': + np.array([self.beta2_pow]).astype("float32") * self.beta2 + } - self.outputs = { - 'Moment1Out': moment1_out, - 'Moment2Out': moment2_out, - 'ParamOut': param_out, - 'Beta1PowOut': np.array([beta1_pow]).astype("float32") * beta1, - 'Beta2PowOut': np.array([beta2_pow]).astype("float32") * beta2 - } + def set_xpu(self): + self.__class__.use_xpu = True + self.__class__.no_need_check_grad = True + self.__class__.op_type = self.in_type - def test_check_output(self): - self.check_output_with_place(place=paddle.XPUPlace(0), atol=1e-2) + def init_dtype(self): + self.dtype = self.in_type + def set_attrs(self): + self.attrs = { + 'epsilon': self.epsilon, + 'beta1': self.beta1, + 'beta2': self.beta2 + } + + def set_data(self): + self.beta1 = 0.78 + self.beta2 = 0.836 + self.learning_rate = 0.004 + self.epsilon = 1e-4 + + def set_steps(self): + self.num_steps = 1 + + def set_shape(self): + self.shape = (102, 105) + + def set_inputs(self): + param = np.random.uniform(-1, 1, self.shape).astype(self.dtype) + grad = np.random.uniform(-1, 1, self.shape).astype(self.dtype) + moment1 = np.random.uniform(-1, 1, self.shape).astype(self.dtype) + # The second moment is positive + moment2 = np.random.random(self.shape).astype(self.dtype) + + self.beta1_pow = self.beta1**10 + self.beta2_pow = self.beta2**10 + + self.inputs = { + 'Param': param, + 'Grad': grad, + 'Moment1': moment1, + 'Moment2': moment2, + 'LearningRate': + np.array([self.learning_rate]).astype("float32"), + 'Beta1Pow': np.array([self.beta1_pow]).astype("float32"), + 'Beta2Pow': np.array([self.beta2_pow]).astype("float32") + } -class TestAdamOp2(OpTest): - def setUp(self): + def test_check_output(self): + self.check_output_with_place(place=paddle.XPUPlace(0), atol=1e-2) + + class TestAdamOp2(TestAdamOp): '''Test Adam Op with supplied attributes ''' - self.op_type = "adam" - param = np.random.uniform(-1, 1, (102, 105)).astype("float32") - grad = np.random.uniform(-1, 1, (102, 105)).astype("float32") - moment1 = np.random.uniform(-1, 1, (102, 105)).astype("float32") - # The second moment is positive - moment2 = np.random.random((102, 105)).astype("float32") - - learning_rate = 0.001 - beta1 = 0.9 - beta2 = 0.999 - epsilon = 1e-8 - beta1_pow = beta1**10 - beta2_pow = beta2**10 - - self.inputs = { - 'Param': param, - 'Grad': grad, - 'Moment1': moment1, - 'Moment2': moment2, - 'LearningRate': np.array([learning_rate]).astype("float32"), - 'Beta1Pow': np.array([beta1_pow]).astype("float32"), - 'Beta2Pow': np.array([beta2_pow]).astype("float32") - } - attributes = {'epsilon': epsilon, 'beta1': beta1, 'beta2': beta2} + def set_data(self): + self.beta1 = 0.9 + self.beta2 = 0.999 + self.learning_rate = 0.001 + self.epsilon = 1e-8 + + class TestAdamOp3(TestAdamOp2): + '''Test Adam Op with supplied attributes + ''' - param_out, moment1_out, \ - moment2_out = adam_step(self.inputs, attributes) + def set_shape(self): + self.shape = (101, 47) - self.outputs = { - 'Moment1Out': moment1_out, - 'Moment2Out': moment2_out, - 'ParamOut': param_out, - 'Beta1PowOut': np.array([beta1_pow]).astype("float32") * beta1, - 'Beta2PowOut': np.array([beta2_pow]).astype("float32") * beta2 - } + class TestAdamOp4(TestAdamOp2): + '''Test Adam Op with supplied attributes + ''' + + def set_shape(self): + self.shape = (512, 26) - def test_check_output(self): - self.check_output_with_place(place=paddle.XPUPlace(0), atol=1e-2) + class TestAdamOp5(TestAdamOp2): + '''Test Adam Op with supplied attributes + ''' + + def set_shape(self): + self.shape = (11, 1) + + class TestAdamOp6(TestAdamOp2): + '''Test Adam Op with beta as Variable + ''' + def set_shape(self): + self.shape = (10, 10) -class TestAdamOpMultipleSteps(OpTest): - def setUp(self): + def set_data(self): + self.beta1 = 0.85 + self.beta2 = 0.95 + self.learning_rate = 0.001 + self.epsilon = 1e-8 + + class TestAdamOpMultipleSteps(TestAdamOp2): '''Test Adam Operator with supplied attributes ''' - self.op_type = "adam" - self.num_steps = 10 - - param = np.random.uniform(-1, 1, (102, 105)).astype("float32") - grad = np.random.uniform(-1, 1, (102, 105)).astype("float32") - moment1 = np.random.uniform(-1, 1, (102, 105)).astype("float32") - # The second moment is positive - moment2 = np.random.random((102, 105)).astype("float32") - - learning_rate = 0.001 - self.beta1 = 0.9 - self.beta2 = 0.999 - epsilon = 1e-8 - self.beta1_pow = self.beta1**10 - self.beta2_pow = self.beta2**10 - - self.inputs = { - 'Param': param, - 'Grad': grad, - 'Moment1': moment1, - 'Moment2': moment2, - 'LearningRate': np.array([learning_rate]).astype("float32"), - 'Beta1Pow': np.array([self.beta1_pow]).astype("float32"), - 'Beta2Pow': np.array([self.beta2_pow]).astype("float32") - } - self.attrs = { - 'epsilon': epsilon, - 'beta1': self.beta1, - 'beta2': self.beta2 - } + def set_steps(self): + self.num_steps = 10 - def test_check_output(self): - for _ in range(self.num_steps): - param_out, moment1_out, \ - moment2_out = adam_step(self.inputs, self.attrs) + def test_check_output(self): + for _ in range(self.num_steps): + param_out, moment1_out, \ + moment2_out = adam_step(self.inputs, self.attrs) - beta1_pow_out = self.inputs['Beta1Pow'] * self.beta1 - beta2_pow_out = self.inputs['Beta2Pow'] * self.beta2 - self.outputs = { - 'Moment1Out': moment1_out, - 'Moment2Out': moment2_out, - 'ParamOut': param_out, - 'Beta1PowOut': beta1_pow_out, - 'Beta2PowOut': beta2_pow_out - } + beta1_pow_out = self.inputs['Beta1Pow'] * self.beta1 + beta2_pow_out = self.inputs['Beta2Pow'] * self.beta2 + self.outputs = { + 'Moment1Out': moment1_out, + 'Moment2Out': moment2_out, + 'ParamOut': param_out, + 'Beta1PowOut': beta1_pow_out, + 'Beta2PowOut': beta2_pow_out + } - # Verify output for this step - self.check_output_with_place(place=paddle.XPUPlace(0), atol=1e-2) + # Verify output for this step + self.check_output_with_place( + place=paddle.XPUPlace(0), atol=1e-2) - # Output of this step becomes input for next step - self.inputs['Param'] = param_out - self.inputs['Moment1'] = moment1_out - self.inputs['Moment2'] = moment2_out + # Output of this step becomes input for next step + self.inputs['Param'] = param_out + self.inputs['Moment1'] = moment1_out + self.inputs['Moment2'] = moment2_out - # Update powers of Beta1 and Beta2 for next time step - self.inputs['Beta1Pow'] = beta1_pow_out - self.inputs['Beta2Pow'] = beta2_pow_out + # Update powers of Beta1 and Beta2 for next time step + self.inputs['Beta1Pow'] = beta1_pow_out + self.inputs['Beta2Pow'] = beta2_pow_out - # Randomize gradient for next step - self.inputs['Grad'] = np.random.uniform( - -1, 1, (102, 105)).astype("float32") + # Randomize gradient for next step + self.inputs['Grad'] = np.random.uniform( + -1, 1, (102, 105)).astype("float32") def adam_step(inputs, attributes): @@ -354,52 +366,9 @@ class TestSparseAdamOp(unittest.TestCase): self.check_with_place(paddle.XPUPlace(0), False) -class TestAdamOpBetaVariable(OpTest): - def setUp(self): - '''Test Adam Op with beta as Variable - ''' - self.op_type = "adam" - param = np.random.uniform(-1, 1, (102, 105)).astype("float32") - grad = np.random.uniform(-1, 1, (102, 105)).astype("float32") - moment1 = np.random.uniform(-1, 1, (102, 105)).astype("float32") - # The second moment is positive - moment2 = np.random.random((102, 105)).astype("float32") - beta1 = 0.85 - beta2 = 0.95 - - learning_rate = 0.001 - epsilon = 1e-8 - beta1_pow = beta1**10 - beta2_pow = beta2**10 - - self.inputs = { - 'Param': param, - 'Grad': grad, - 'Moment1': moment1, - 'Moment2': moment2, - 'LearningRate': np.array([learning_rate]).astype("float32"), - 'Beta1Pow': np.array([beta1_pow]).astype("float32"), - 'Beta2Pow': np.array([beta2_pow]).astype("float32"), - "Beta1Tensor": np.array([beta1]).astype("float32"), - "Beta2Tensor": np.array([beta2]).astype("float32"), - } - - attributes = {'epsilon': epsilon, 'beta1': beta1, 'beta2': beta2} - - param_out, moment1_out, \ - moment2_out = adam_step(self.inputs, attributes) - - self.outputs = { - 'Moment1Out': moment1_out, - 'Moment2Out': moment2_out, - 'ParamOut': param_out, - 'Beta1PowOut': np.array([beta1_pow]).astype("float32") * beta1, - 'Beta2PowOut': np.array([beta2_pow]).astype("float32") * beta2 - } - - def test_check_output(self): - self.check_output_with_place(place=paddle.XPUPlace(0), atol=1e-2) - +support_types = get_xpu_op_support_types('adam') +for stype in support_types: + create_test_class(globals(), XPUTestAdamOp, stype) if __name__ == "__main__": paddle.enable_static() diff --git a/python/paddle/fluid/tests/unittests/xpu/test_concat_op_xpu.py b/python/paddle/fluid/tests/unittests/xpu/test_concat_op_xpu.py index b1a5e422acf26ed433e291e6a91b67e3f6dae37e..3f188e78f86c2d7f6805bf53e625ea8366706904 100644 --- a/python/paddle/fluid/tests/unittests/xpu/test_concat_op_xpu.py +++ b/python/paddle/fluid/tests/unittests/xpu/test_concat_op_xpu.py @@ -20,136 +20,131 @@ sys.path.append("..") import unittest import numpy as np -from op_test import OpTest, skip_check_grad_ci -from op_test_xpu import XPUOpTest import paddle.fluid as fluid from paddle.fluid import compiler, Program, program_guard, core import paddle - - -class TestConcatOp(XPUOpTest): - def setUp(self): - self.op_type = "concat" - self.dtype = self.get_dtype() - self.use_xpu = True - self.use_mkldnn = False - self.init_test_data() - self.inputs = {'X': [('x0', self.x0), ('x1', self.x1), ('x2', self.x2)]} - self.attrs = {'axis': self.axis} - if self.axis < 0: - self.actual_axis = self.axis + len(self.x0.shape) - self.actual_axis = self.actual_axis if self.actual_axis > 0 else 0 - else: - self.actual_axis = self.axis - - self.outputs = { - 'Out': np.concatenate( - (self.x0, self.x1, self.x2), axis=self.actual_axis) - } - - def get_dtype(self): - return "float32" - - def test_check_output(self): - if paddle.is_compiled_with_xpu(): - place = paddle.XPUPlace(0) - self.check_output_with_place(place) - - def test_check_grad(self): - if paddle.is_compiled_with_xpu(): - place = paddle.XPUPlace(0) - self.check_grad_with_place(place, ['x0'], 'Out') - self.check_grad_with_place(place, ['x1'], 'Out') - self.check_grad_with_place(place, ['x2'], 'Out') - - def init_test_data(self): - self.x0 = np.random.random((5, 1, 4, 5)).astype(self.dtype) - self.x1 = np.random.random((5, 2, 4, 5)).astype(self.dtype) - self.x2 = np.random.random((5, 3, 4, 5)).astype(self.dtype) - self.axis = 1 - - -class TestConcatOp2(TestConcatOp): - def init_test_data(self): - self.x0 = np.random.random((2, 3, 4, 5)).astype(self.dtype) - self.x1 = np.random.random((2, 3, 4, 5)).astype(self.dtype) - self.x2 = np.random.random((2, 3, 4, 5)).astype(self.dtype) - self.axis = 1 - - -@skip_check_grad_ci( - reason="The function 'check_grad' for large inputs is too slow.") -class TestConcatOp3(TestConcatOp): - def init_test_data(self): - self.x0 = np.random.random((1, 256, 170, 256)).astype(self.dtype) - self.x1 = np.random.random((1, 128, 170, 256)).astype(self.dtype) - self.x2 = np.random.random((1, 128, 170, 256)).astype(self.dtype) - self.axis = 1 - - def test_check_grad(self): - pass - - -@skip_check_grad_ci( - reason="This test will meet fetch error when there is a null grad. The detailed information is in PR#17015." -) -class TestConcatOp4(TestConcatOp): - def init_test_data(self): - self.x0 = np.random.random((2, 3, 4, 5)).astype(self.dtype) - self.x1 = np.random.random((2, 3, 4, 5)).astype(self.dtype) - self.x2 = np.random.random((0, 3, 4, 5)).astype(self.dtype) - self.axis = 0 - - def test_check_grad(self): - pass - - -class TestConcatOp5(TestConcatOp): - def init_test_data(self): - self.x0 = np.random.random((5, 1, 4, 5)).astype(self.dtype) - self.x1 = np.random.random((5, 2, 4, 5)).astype(self.dtype) - self.x2 = np.random.random((5, 3, 4, 5)).astype(self.dtype) - self.axis = -3 - - -class TestConcatOp6(TestConcatOp): - def setUp(self): - self.op_type = "concat" - self.dtype = self.get_dtype() - self.init_test_data() - self.lod = [[20, 80]] - self.out_lod = [[20, 80, 20, 80, 20, 80]] - self.inputs = { - 'X': [('x0', (self.x0, self.lod)), ('x1', (self.x1, self.lod)), - ('x2', (self.x2, self.lod))] - } - self.attrs = {'axis': self.axis} - if self.axis < 0: - self.actual_axis = self.axis + len(self.x0.shape) - self.actual_axis = self.actual_axis if self.actual_axis > 0 else 0 - else: - self.actual_axis = self.axis - out = np.concatenate((self.x0, self.x1, self.x2), axis=self.actual_axis) - self.outputs = {'Out': (out, self.out_lod)} - - def test_check_output(self): - if paddle.is_compiled_with_xpu(): - place = paddle.XPUPlace(0) - self.check_output_with_place(place, check_dygraph=False) - - def test_check_grad(self): - if paddle.is_compiled_with_xpu(): - place = paddle.XPUPlace(0) - self.check_grad_with_place(place, ['x0'], 'Out') - self.check_grad_with_place(place, ['x1'], 'Out') - self.check_grad_with_place(place, ['x2'], 'Out') - - def init_test_data(self): - self.x0 = np.random.random([100]).astype(self.dtype) - self.x1 = np.random.random([100]).astype(self.dtype) - self.x2 = np.random.random([100]).astype(self.dtype) - self.axis = 0 - +from op_test import OpTest, skip_check_grad_ci +from op_test_xpu import XPUOpTest +from xpu.get_test_cover_info import create_test_class, get_xpu_op_support_types, XPUOpTestWrapper + +paddle.enable_static() + + +class XPUTestConcatOp(XPUOpTestWrapper): + def __init__(self): + self.op_name = 'concat' + self.use_dynamic_create_class = False + + class TestConcatOp(XPUOpTest): + def setUp(self): + self.set_xpu() + self.op_type = "concat" + self.place = paddle.XPUPlace(0) + self.init_dtype() + self.init_axis() + self.set_inputs() + self.inputs = { + 'X': [('x0', self.x0), ('x1', self.x1), ('x2', self.x2)] + } + self.attrs = {'axis': self.axis} + if self.axis < 0: + self.actual_axis = self.axis + len(self.x0.shape) + self.actual_axis = self.actual_axis if self.actual_axis > 0 else 0 + else: + self.actual_axis = self.axis + + self.outputs = { + 'Out': np.concatenate( + (self.x0, self.x1, self.x2), axis=self.actual_axis) + } + + def set_inputs(self): + self.x0 = np.random.random((2, 3, 4, 5)).astype(self.dtype) + self.x1 = np.random.random((2, 3, 4, 5)).astype(self.dtype) + self.x2 = np.random.random((2, 3, 4, 5)).astype(self.dtype) + + def set_xpu(self): + self.__class__.use_xpu = True + self.__class__.no_need_check_grad = True + + def init_dtype(self): + self.dtype = self.in_type + + def init_axis(self): + self.axis = -1 + + def test_check_output(self): + self.check_output_with_place(self.place) + + def test_check_grad(self): + if paddle.is_compiled_with_xpu(): + place = paddle.XPUPlace(0) + self.check_grad_with_place(place, ['x0'], 'Out') + self.check_grad_with_place(place, ['x1'], 'Out') + self.check_grad_with_place(place, ['x2'], 'Out') + + class TestConcatOpAxis0XPU(TestConcatOp): + def init_axis(self): + self.axis = 0 + + class TestConcatOpAxis1XPU(TestConcatOp): + def set_inputs(self): + self.x0 = np.random.random((5, 1, 4, 5)).astype(self.dtype) + self.x1 = np.random.random((5, 2, 4, 5)).astype(self.dtype) + self.x2 = np.random.random((5, 3, 4, 5)).astype(self.dtype) + + def init_axis(self): + self.axis = 1 + + class TestConcatOpAxis2XPU(TestConcatOp): + def init_axis(self): + self.axis = 2 + + class TestConcatOpAxis3XPU(TestConcatOp): + def init_axis(self): + self.axis = 3 + + class TestConcatOpAxisNeg1XPU(TestConcatOp): + def init_axis(self): + self.axis = -1 + + class TestConcatOpAxisNeg2XPU(TestConcatOp): + def init_axis(self): + self.axis = -2 + + class TestConcatOpAxisNeg3XPU(TestConcatOp): + def init_axis(self): + self.axis = -3 + + @skip_check_grad_ci( + reason="The function 'check_grad' for large inputs is too slow.") + class TestConcatOp3(TestConcatOp): + def set_inputs(self): + self.x0 = np.random.random((1, 256, 170, 256)).astype(self.dtype) + self.x1 = np.random.random((1, 128, 170, 256)).astype(self.dtype) + self.x2 = np.random.random((1, 128, 170, 256)).astype(self.dtype) + self.axis = 1 + + def test_check_grad(self): + pass + + @skip_check_grad_ci( + reason="This test will meet fetch error when there is a null grad. The detailed information is in PR#17015." + ) + class TestConcatOp4(TestConcatOp): + def set_inputs(self): + self.x0 = np.random.random((2, 3, 4, 5)).astype(self.dtype) + self.x1 = np.random.random((2, 3, 4, 5)).astype(self.dtype) + self.x2 = np.random.random((0, 3, 4, 5)).astype(self.dtype) + self.axis = 0 + + def test_check_grad(self): + pass + + +support_types = get_xpu_op_support_types('concat') +for stype in support_types: + create_test_class(globals(), XPUTestConcatOp, stype) if __name__ == '__main__': paddle.enable_static()