diff --git a/paddle/fluid/operators/prelu_op.cc b/paddle/fluid/operators/prelu_op.cc index 66717298a288d2c0d4b46e71e80edf69ac188ce1..c822c4b7896885dc10d491695b4967878e99ea55 100644 --- a/paddle/fluid/operators/prelu_op.cc +++ b/paddle/fluid/operators/prelu_op.cc @@ -31,10 +31,11 @@ class PReluOp : public framework::OperatorWithKernel { auto x_dim = ctx->GetInputDim("X"); std::string mode = ctx->Attrs().Get("mode"); if (mode == "all") { - PADDLE_ENFORCE_EQ( - product(ctx->GetInputDim("Alpha")), 1, - platform::errors::InvalidArgument( - "For mode 'all', size of weight Alpha must be one.")); + PADDLE_ENFORCE_EQ(product(ctx->GetInputDim("Alpha")), 1, + platform::errors::InvalidArgument( + "For mode 'all', size of weight Alpha must be one. " + "But recevied alpha's size: %d.", + product(ctx->GetInputDim("Alpha")))); } else if (mode == "channel") { PADDLE_ENFORCE_EQ(product(ctx->GetInputDim("Alpha")), x_dim[1], platform::errors::InvalidArgument( @@ -67,7 +68,11 @@ class PReluOp : public framework::OperatorWithKernel { "x's size: %d.", alpha_product, x_product)); } else { - PADDLE_THROW("Unkown mode %s", mode); + PADDLE_THROW(platform::errors::InvalidArgument( + "Attr(mode) of prelu must be one of 'all', 'channel', or 'element'. " + "But recevied " + "mode: '%s'.", + mode)); } ctx->ShareDim("X", /*->*/ "Out"); ctx->ShareLoD("X", /*->*/ "Out"); diff --git a/python/paddle/fluid/tests/unittests/test_activation_op.py b/python/paddle/fluid/tests/unittests/test_activation_op.py index 48fe1ca2ca11dc2878c081b0e1625de09bc0d121..8dbdd2921b9a0683b60ed1b1a133381db90c73c9 100644 --- a/python/paddle/fluid/tests/unittests/test_activation_op.py +++ b/python/paddle/fluid/tests/unittests/test_activation_op.py @@ -463,7 +463,7 @@ class TestReluOpError(unittest.TestCase): def test_errors(self): with program_guard(Program()): # The input type must be Variable. - self.assertRaises(TypeError, fluid.layers.sqrt, 1) + self.assertRaises(TypeError, fluid.layers.relu, 1) # The input dtype must be float16, float32, float64. x_int32 = fluid.data(name='x_int32', shape=[12, 10], dtype='int32') self.assertRaises(TypeError, fluid.layers.relu, x_int32) diff --git a/python/paddle/fluid/tests/unittests/test_prelu_op.py b/python/paddle/fluid/tests/unittests/test_prelu_op.py index a2ee49e594318dfc6710d7bb6c0896c75d77a4c5..2f44fc44b54802cdfe630d1bcb06a3f76aa2b3e1 100644 --- a/python/paddle/fluid/tests/unittests/test_prelu_op.py +++ b/python/paddle/fluid/tests/unittests/test_prelu_op.py @@ -23,21 +23,18 @@ from paddle.fluid import Program, program_guard from op_test import OpTest, skip_check_grad_ci -class TestPReluAPIError(unittest.TestCase): +class TestPReluOpError(unittest.TestCase): def test_errors(self): - with fluid.program_guard(fluid.Program(), fluid.Program()): - layer = fluid.PRelu( - mode='all', - param_attr=fluid.ParamAttr( - initializer=fluid.initializer.Constant(1.0))) - # the input must be Variable. - x0 = fluid.create_lod_tensor( - np.array([-1, 3, 5, 5]), [[1, 1, 1, 1]], fluid.CPUPlace()) - self.assertRaises(TypeError, layer, x0) - # the input dtype must be float32 - data_t = fluid.data( - name="input", shape=[5, 200, 100, 100], dtype="float64") - self.assertRaises(TypeError, layer, data_t) + with program_guard(Program()): + # The input type must be Variable. + self.assertRaises(TypeError, fluid.layers.prelu, 0.1, 'all') + # The input dtype must be float16, float32, float64. + x_int32 = fluid.data(name='x_int32', shape=[12, 10], dtype='int32') + self.assertRaises(TypeError, fluid.layers.prelu, x_int32, 'all') + # support the input dtype is float32 + x_fp16 = fluid.layers.data( + name='x_fp16', shape=[12, 10], dtype='float32') + fluid.layers.prelu(x_fp16, 'all') class PReluTest(OpTest): @@ -79,39 +76,55 @@ class PReluTest(OpTest): self.check_grad(['X', 'Alpha'], 'Out') -# TODO(minqiyang): Resume these test cases after fixing Python3 CI job issues -if six.PY2: - - @skip_check_grad_ci( - reason="[skip shape check] Input(Alpha) must be 1-D and only has one data in 'all' mode" - ) - class TestModeAll(PReluTest): - def init_input_shape(self): - self.x_shape = (2, 3, 4, 5) - - def init_attr(self): - self.attrs = {'mode': "all"} +@skip_check_grad_ci( + reason="[skip shape check] Input(Alpha) must be 1-D and only has one data in 'all' mode" +) +class TestModeAll(PReluTest): + def init_input_shape(self): + self.x_shape = (2, 3, 4, 5) - class TestModeElt(PReluTest): - def init_input_shape(self): - self.x_shape = (3, 2, 5, 10) + def init_attr(self): + self.attrs = {'mode': "all"} - def init_attr(self): - self.attrs = {'mode': "element"} +class TestModeElt(PReluTest): + def init_input_shape(self): + self.x_shape = (3, 2, 5, 10) -class TestPReluOpError(unittest.TestCase): - def test_errors(self): - with program_guard(Program()): - # The input type must be Variable. - self.assertRaises(TypeError, fluid.layers.prelu, 1, 'all') - # The input dtype must be float16, float32, float64. - x_int32 = fluid.data(name='x_int32', shape=[12, 10], dtype='int32') - self.assertRaises(TypeError, fluid.layers.prelu, x_int32, 'all') - # support the input dtype is float32 - x_fp16 = fluid.layers.data( - name='x_fp16', shape=[12, 10], dtype='float32') - fluid.layers.prelu(x_fp16, 'all') + def init_attr(self): + self.attrs = {'mode': "element"} + + +def prelu_t(x, mode, param_attr=None, name=None): + helper = fluid.layer_helper.LayerHelper('prelu', **locals()) + alpha_shape = [1, x.shape[1], 1, 1] + dtype = helper.input_dtype(input_param_name='x') + alpha = helper.create_parameter( + attr=helper.param_attr, + shape=alpha_shape, + dtype='float32', + is_bias=False, + default_initializer=fluid.initializer.ConstantInitializer(0.25)) + out = helper.create_variable_for_type_inference(dtype) + helper.append_op( + type="prelu", + inputs={"X": x, + 'Alpha': alpha}, + attrs={"mode": mode}, + outputs={"Out": out}) + return out + + +# error message test if mode is not one of 'all', 'channel', 'element' +class TestModeError(unittest.TestCase): + def test_mode_error(self): + main_program = Program() + with fluid.program_guard(main_program, Program()): + x = fluid.data(name='x', shape=[2, 3, 4, 5]) + try: + y = prelu_t(x, 'any') + except Exception as e: + assert (e.args[0].find('InvalidArgumentError') != -1) if __name__ == "__main__": diff --git a/python/paddle/nn/functional/activation.py b/python/paddle/nn/functional/activation.py index 47cac5517b42a28477eab44dd8afb67a01b4676f..64d5c7f449229d29f903140ff352a157b83af957 100644 --- a/python/paddle/nn/functional/activation.py +++ b/python/paddle/nn/functional/activation.py @@ -206,8 +206,10 @@ def relu(input, inplace=False, name=None): ) return core.ops.relu(input) - helper = LayerHelper('relu', **locals()) + check_variable_and_dtype(input, 'input', ['float16', 'float32', 'float64'], + 'relu') + helper = LayerHelper('relu', **locals()) outs = input if inplace else helper.create_variable_for_type_inference( input.dtype) helper.append_op(type='relu', inputs={'X': [input]}, outputs={'Out': outs}) @@ -263,7 +265,7 @@ def sigmoid(input, inplace=False, name=None): ) return core.ops.sigmoid(input) - check_variable_and_dtype(input, 'X', ['float16', 'float32', 'float64'], + check_variable_and_dtype(input, 'input', ['float16', 'float32', 'float64'], 'sigmoid') helper = LayerHelper("sigmoid", **locals()) outputs = helper.create_variable_for_type_inference(input.dtype) @@ -329,8 +331,11 @@ def log_softmax(input, axis=None, dtype=None, name=None): False) return core.ops.log(outs_softmax) - helper = LayerHelper("log_softmax", **locals()) + if dtype is None: + check_variable_and_dtype( + input, 'input', ['float16', 'float32', 'float64'], 'log_softmax') + helper = LayerHelper("log_softmax", **locals()) outs_cast = input if dtype is not None: outs_cast = helper.create_variable_for_type_inference(dtype)