From 8af85922d0facbe1480da7059369f38ffed93f15 Mon Sep 17 00:00:00 2001 From: huangjun12 <2399845970@qq.com> Date: Fri, 17 Apr 2020 19:00:30 +0800 Subject: [PATCH] Error message enhancement of 6 op (#23759) * enhance error message test=develop * fix CI test of 3 op test=develop * fix bug caused by the diff of long type in py2 and py3, test=develop --- paddle/fluid/operators/hinge_loss_op.cc | 51 ++++++++++++------- paddle/fluid/operators/huber_loss_op.cc | 22 ++++---- paddle/fluid/operators/lrn_op.cc | 30 +++++++---- paddle/fluid/operators/lrn_op.h | 23 ++++++--- .../fluid/operators/modified_huber_loss_op.cc | 51 ++++++++++++++----- paddle/fluid/operators/one_hot_op.cc | 17 ++++--- paddle/fluid/operators/one_hot_op.h | 15 ++++-- python/paddle/fluid/layers/loss.py | 8 ++- python/paddle/fluid/layers/nn.py | 3 ++ .../tests/unittests/test_huber_loss_op.py | 20 ++++++++ .../fluid/tests/unittests/test_lrn_op.py | 9 ++++ .../fluid/tests/unittests/test_one_hot_op.py | 24 +++++++++ 12 files changed, 203 insertions(+), 70 deletions(-) diff --git a/paddle/fluid/operators/hinge_loss_op.cc b/paddle/fluid/operators/hinge_loss_op.cc index 97b2d55bdc7..e60b1538eee 100644 --- a/paddle/fluid/operators/hinge_loss_op.cc +++ b/paddle/fluid/operators/hinge_loss_op.cc @@ -25,21 +25,31 @@ class HingeLossOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE(ctx->HasInput("Logits"), - "Input(Logits) must be initialized."); - PADDLE_ENFORCE(ctx->HasInput("Labels"), - "Input(Labels) must be initialized."); + OP_INOUT_CHECK(ctx->HasInput("Logits"), "Input", "Logits", "HingeLoss"); + OP_INOUT_CHECK(ctx->HasInput("Labels"), "Input", "Labels", "HingeLoss"); auto pred_dims = ctx->GetInputDim("Logits"); auto label_dims = ctx->GetInputDim("Labels"); - PADDLE_ENFORCE_EQ(pred_dims, label_dims); - PADDLE_ENFORCE_EQ(pred_dims.size(), 2, - "The rank of Input(Logits) must be 2 and the shape is " - "[batch_size, 1]."); + PADDLE_ENFORCE_EQ( + pred_dims, label_dims, + platform::errors::InvalidArgument( + "The Input(input) and Input(label) should have the same " + "shape, but received input shape [%s] != label shape [%s]", + pred_dims, label_dims)); + + PADDLE_ENFORCE_EQ( + pred_dims.size(), 2, + platform::errors::InvalidArgument("Input(input) rank should be 2, " + "but received input rank(%d) != 2", + pred_dims.size())); + PADDLE_ENFORCE_EQ(pred_dims[1], 1, - "Each row of Input(Logits) contains a real value, " - "so the 2nd dimension of Input(Logits) must be 1."); + platform::errors::InvalidArgument( + "The second dimension of Input(input) should be 1, " + "as each row of input contains a real value, " + "but received second dimension of input (%d) != 1", + pred_dims[1])); ctx->SetOutputDim("Loss", {pred_dims[0], 1}); ctx->ShareLoD("Logits", "Loss"); @@ -81,19 +91,22 @@ class HingeLossGradOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE(ctx->HasInput("Logits"), - "Input(Logits) should not be null."); - PADDLE_ENFORCE(ctx->HasInput("Labels"), - "Input(Labels) should not be null."); - PADDLE_ENFORCE(ctx->HasInput(framework::GradVarName("Loss")), - "Input(Loss@GRAD) should not be null."); - PADDLE_ENFORCE(ctx->HasOutput(framework::GradVarName("Logits")), - "Input(Logits@GRAD) should not be null."); + OP_INOUT_CHECK(ctx->HasInput("Logits"), "Input", "Logits", "HingeLossGrad"); + OP_INOUT_CHECK(ctx->HasInput("Labels"), "Input", "Labels", "HingeLossGrad"); + OP_INOUT_CHECK(ctx->HasInput(framework::GradVarName("Loss")), "Input", + "Loss@GRAD", "HingeLossGrad"); + OP_INOUT_CHECK(ctx->HasOutput(framework::GradVarName("Logits")), "Output", + "Logits@GRAD", "HingeLossGrad"); auto pred_dims = ctx->GetInputDim("Logits"); auto loss_grad_dims = ctx->GetInputDim(framework::GradVarName("Loss")); - PADDLE_ENFORCE_EQ(loss_grad_dims, pred_dims); + PADDLE_ENFORCE_EQ(loss_grad_dims, pred_dims, + platform::errors::InvalidArgument( + "The shape of loss gradient should be the same as " + "the shape of Input(input), but received the loss " + "gradient shape [%s] != input shape [%s]", + loss_grad_dims, pred_dims)); auto pred_grad_name = framework::GradVarName("Logits"); ctx->SetOutputDim(pred_grad_name, pred_dims); diff --git a/paddle/fluid/operators/huber_loss_op.cc b/paddle/fluid/operators/huber_loss_op.cc index fe186780cc2..85c686f9612 100644 --- a/paddle/fluid/operators/huber_loss_op.cc +++ b/paddle/fluid/operators/huber_loss_op.cc @@ -25,23 +25,27 @@ class HuberLossOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE_EQ(ctx->HasInput("X"), true, - "Input(X) must be initialized."); - PADDLE_ENFORCE_EQ(ctx->HasInput("Y"), true, - "Input(Y) must be initialized."); + OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "HuberLoss"); + OP_INOUT_CHECK(ctx->HasInput("Y"), "Input", "Y", "HuberLoss"); auto x_dims = ctx->GetInputDim("X"); auto y_dims = ctx->GetInputDim("Y"); PADDLE_ENFORCE_EQ(x_dims.size(), y_dims.size(), - "The rank of Input(X) should be equal to " - "the rank of Input(Y)."); + platform::errors::InvalidArgument( + "Input(input) rank and Input(label) rank should be " + "same, but received input rank(%d) != label rank(%d)", + x_dims.size(), y_dims.size())); + bool contain_unknown_dim = framework::contain_unknown_dim(x_dims) || framework::contain_unknown_dim(y_dims); if (ctx->IsRuntime() || !contain_unknown_dim) { PADDLE_ENFORCE_EQ( x_dims, y_dims, - "The Input(X) and Input(Label) should have the same shape."); + platform::errors::InvalidArgument( + "The Input(input) and Input(label) should have the same " + "shape, but received input shape [%s] != label shape [%s]", + x_dims, y_dims)); } auto out_dims = y_dims; @@ -99,8 +103,8 @@ class HuberLossGradOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE_EQ(ctx->HasInput(framework::GradVarName("Out")), true, - "Input(Out@GRAD) should not be null."); + OP_INOUT_CHECK(ctx->HasInputs(framework::GradVarName("Out")), "Input", + "Out@GRAD", "HuberLossGrad"); auto residual_dims = ctx->GetInputDim("Residual"); diff --git a/paddle/fluid/operators/lrn_op.cc b/paddle/fluid/operators/lrn_op.cc index d4aaafa80ad..fc9d61eb75b 100644 --- a/paddle/fluid/operators/lrn_op.cc +++ b/paddle/fluid/operators/lrn_op.cc @@ -169,17 +169,25 @@ class LRNOp : public framework::OperatorWithKernel { protected: void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) of LRNOp should not be null."); - PADDLE_ENFORCE(ctx->HasOutput("Out"), - "Output(Out) of LRNOp should not be null."); - PADDLE_ENFORCE(ctx->HasOutput("MidOut"), - "MidOut(Out) of LRNOp should not be null."); + OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "LRN"); + OP_INOUT_CHECK(ctx->HasOutput("Out"), "Output", "Out", "LRN"); + OP_INOUT_CHECK(ctx->HasOutput("MidOut"), "Output", "MidOut", "LRN"); auto x_dim = ctx->GetInputDim("X"); - PADDLE_ENFORCE_EQ(x_dim.size(), 4, "Input(X)'rank of LRNOp should be 4."); + PADDLE_ENFORCE_EQ(x_dim.size(), 4, platform::errors::InvalidArgument( + "Input(input) rank should be 4, " + "but received input rank (%d) != 4", + x_dim.size())); int n = ctx->Attrs().Get("n"); - PADDLE_ENFORCE(n > 0 && n % 2 == 1, "n should be positive odd value"); + PADDLE_ENFORCE_GT(n, 0UL, platform::errors::InvalidArgument( + "Argument(n) should be positive, " + "but received n(%d) not greater than 0", + n)); + PADDLE_ENFORCE_EQ(n % 2, 1UL, platform::errors::InvalidArgument( + "Argument(n) should be odd value, " + "but received n(%d) is not an odd value", + n)); ctx->SetOutputDim("Out", x_dim); ctx->ShareLoD("X", /*->*/ "Out"); @@ -317,10 +325,10 @@ class LRNOpGrad : public framework::OperatorWithKernel { protected: void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) should not be null"); - PADDLE_ENFORCE(ctx->HasInput("MidOut"), "Input(MidOut) should not be null"); - PADDLE_ENFORCE(ctx->HasInput(framework::GradVarName("Out")), - "Input(Out@GRAD) should not be null"); + OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "LRNGrad"); + OP_INOUT_CHECK(ctx->HasInput("MidOut"), "Input", "MidOu", "LRNGrad"); + OP_INOUT_CHECK(ctx->HasInput(framework::GradVarName("Out")), "Input", + "Out@GRAD", "LRNGrad"); auto x_dims = ctx->GetInputDim("X"); ctx->SetOutputDim(framework::GradVarName("X"), x_dims); diff --git a/paddle/fluid/operators/lrn_op.h b/paddle/fluid/operators/lrn_op.h index 44999970c20..bdf3ad81ddb 100644 --- a/paddle/fluid/operators/lrn_op.h +++ b/paddle/fluid/operators/lrn_op.h @@ -68,9 +68,18 @@ class LRNKernel : public framework::OpKernel { T beta = ctx.Attr("beta"); T k = ctx.Attr("k"); - PADDLE_ENFORCE(alpha >= 0.0, "alpha should >= 0.0"); - PADDLE_ENFORCE(beta >= 0.0, "beta should >= 0.0"); - PADDLE_ENFORCE(k >= 0.0, "k should >= 0.0"); + PADDLE_ENFORCE_GE(alpha, 0UL, platform::errors::InvalidArgument( + "Argument(alpha) should >= 0.0, " + "but received alpha(%d) less than 0", + alpha)); + PADDLE_ENFORCE_GE(beta, 0UL, platform::errors::InvalidArgument( + "Argument(beta) should >= 0.0, " + "but received beta(%d) less than 0", + beta)); + PADDLE_ENFORCE_GE(k, 0UL, platform::errors::InvalidArgument( + "Argument(k) should >= 0.0, " + "but received k(%d) less than 0", + k)); LRNFunctor f; f(ctx, x, out, mid, N, C, H, W, n, k, alpha, beta, data_layout); @@ -132,9 +141,11 @@ class LRNGradKernel : public framework::OpKernel { T alpha = ctx.Attr("alpha"); T beta = ctx.Attr("beta"); - PADDLE_ENFORCE( - !ctx.Attr("is_test"), - "is_test attribute should be set to False in training phase."); + PADDLE_ENFORCE_EQ( + !ctx.Attr("is_test"), true, + platform::errors::InvalidArgument( + "is_test attribute should be set to False in training phase. " + "but received is_test == True in training phase.")); LRNGradFunctor f; f(ctx, x, out, mid, x_g, out_g, N, C, H, W, n, alpha, beta, data_layout); diff --git a/paddle/fluid/operators/modified_huber_loss_op.cc b/paddle/fluid/operators/modified_huber_loss_op.cc index db6ab407798..7753ca43a78 100644 --- a/paddle/fluid/operators/modified_huber_loss_op.cc +++ b/paddle/fluid/operators/modified_huber_loss_op.cc @@ -23,21 +23,33 @@ class ModifiedHuberLossOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE(ctx->HasInput("X"), "X must be initialized."); - PADDLE_ENFORCE(ctx->HasInput("Y"), "Y must be initialized."); + OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "ModifiedHuberLoss"); + OP_INOUT_CHECK(ctx->HasInput("Y"), "Input", "Y", "ModifiedHuberLoss"); auto x_dims = ctx->GetInputDim("X"); auto y_dims = ctx->GetInputDim("Y"); - PADDLE_ENFORCE_EQ(x_dims.size(), 2, "The tensor rank of X must be 2."); + PADDLE_ENFORCE_EQ(x_dims.size(), 2, platform::errors::InvalidArgument( + "Input(input) rank should be 2, " + "but received input rank(%d) != 2", + x_dims.size())); + if (ctx->IsRuntime() || (framework::product(x_dims) > 0 && framework::product(y_dims) > 0)) { - PADDLE_ENFORCE_EQ(x_dims, y_dims, - "The shape of X and Y must be the same."); + PADDLE_ENFORCE_EQ( + x_dims, y_dims, + platform::errors::InvalidArgument( + "The Input(input) and Input(label) should have the same " + "shape, but received input shape [%s] != label shape [%s]", + x_dims, y_dims)); } if (ctx->IsRuntime()) { - PADDLE_ENFORCE_EQ(x_dims[1], 1, "The 2nd dimension of X must be 1."); + PADDLE_ENFORCE_EQ(x_dims[1], 1, + platform::errors::InvalidArgument( + "The second dimension of Input(input) should be 1, " + "but received second dimension of input (%d) != 1", + x_dims[1])); } ctx->SetOutputDim("IntermediateVal", x_dims); @@ -87,11 +99,11 @@ class ModifiedHuberLossGradOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE(ctx->HasInput("Y"), "Y must be initialized."); - PADDLE_ENFORCE(ctx->HasInput("IntermediateVal"), - "Intermediate value must not be null."); - PADDLE_ENFORCE(ctx->HasInput(framework::GradVarName("Out")), - "Input(Out@Grad) must not be null."); + OP_INOUT_CHECK(ctx->HasInput("Y"), "Input", "Y", "ModifiedHuberLossGrad"); + OP_INOUT_CHECK(ctx->HasInput("IntermediateVal"), "Input", "IntermediateVal", + "ModifiedHuberLossGrad"); + OP_INOUT_CHECK(ctx->HasInputs(framework::GradVarName("Out")), "Input", + "Out@GRAD", "ModifiedHuberLossGrad"); auto y_dims = ctx->GetInputDim("Y"); auto intermediate_dims = ctx->GetInputDim("IntermediateVal"); @@ -100,9 +112,20 @@ class ModifiedHuberLossGradOp : public framework::OperatorWithKernel { if (ctx->IsRuntime()) { PADDLE_ENFORCE_EQ( intermediate_dims, y_dims, - "The shape of X and intermediate value must be the same."); - PADDLE_ENFORCE_EQ(out_grad_dims, y_dims, - "The shape of Input(Out@Grad) and X must be the same."); + platform::errors::InvalidArgument( + "The shape of Intermediate variable which will be reused in " + "backward processing should the same as " + "the shape of Input(label), but received Intermediate variable " + "shape [%s] != label shape [%s]", + intermediate_dims, y_dims)); + + PADDLE_ENFORCE_EQ( + out_grad_dims, y_dims, + platform::errors::InvalidArgument( + "The shape of output gradient should be the same as " + "the shape of Input(label), but received the output gradient " + "shape [%s] != label shape [%s]", + out_grad_dims, y_dims)); } if (ctx->HasOutput(framework::GradVarName("X"))) { diff --git a/paddle/fluid/operators/one_hot_op.cc b/paddle/fluid/operators/one_hot_op.cc index 40f2dc697b2..9c321832f84 100644 --- a/paddle/fluid/operators/one_hot_op.cc +++ b/paddle/fluid/operators/one_hot_op.cc @@ -24,17 +24,22 @@ class OneHotOp : public framework::OperatorWithKernel { public: using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE(ctx->HasInput("X"), - "Input(X) of OneHotOp should not be null."); - PADDLE_ENFORCE(ctx->HasOutput("Out"), - "Output(Out) of OneHotOp should not be null."); + OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "OneHot"); + OP_INOUT_CHECK(ctx->HasOutput("Out"), "Output", "Out", "OneHot"); auto x_dims = ctx->GetInputDim("X"); PADDLE_ENFORCE_GE(x_dims.size(), 2, - "Rank of Input(X) should be at least 2."); + platform::errors::InvalidArgument( + "Input(input) rank should be at least 2, " + "but received input rank (%d) less than 2", + x_dims.size())); + if (ctx->IsRuntime() || x_dims[x_dims.size() - 1] > 0) { PADDLE_ENFORCE_GE(x_dims[x_dims.size() - 1], 1U, - "Last dimension of Input(X) should be 1."); + platform::errors::InvalidArgument( + "Last dimension of Input(input) should be 1, " + "but received input Last dimension(%d) != 1", + x_dims[x_dims.size() - 1])); } framework::DDim out_dims(x_dims); diff --git a/paddle/fluid/operators/one_hot_op.h b/paddle/fluid/operators/one_hot_op.h index 0e2284941b4..e671a1e99e7 100644 --- a/paddle/fluid/operators/one_hot_op.h +++ b/paddle/fluid/operators/one_hot_op.h @@ -51,11 +51,20 @@ struct OneHotOpFunctor { } } else { for (int i = 0; i < numel; ++i) { - PADDLE_ENFORCE_GE(p_in_data[i], 0, - "Illegal index value, should be at least 0."); + PADDLE_ENFORCE_GE( + p_in_data[i], 0, + platform::errors::InvalidArgument( + "Illegal index value, Input(input) value should be at least 0, " + "but received input (%d) less than 0", + p_in_data[i])); PADDLE_ENFORCE_LT( p_in_data[i], depth_, - "Illegal index value, should be less than depth (%d).", depth_); + platform::errors::InvalidArgument( + "Illegal index value, Input(input) value should be less than " + "Input(depth), " + "but received input (%d) not less than depth (%d)", + p_in_data[i], depth_)); + *(p_out_data + i * depth_ + p_in_data[i]) = 1.0; } } diff --git a/python/paddle/fluid/layers/loss.py b/python/paddle/fluid/layers/loss.py index 211dc231b21..767f5799a42 100644 --- a/python/paddle/fluid/layers/loss.py +++ b/python/paddle/fluid/layers/loss.py @@ -1525,8 +1525,8 @@ def huber_loss(input, label, delta): Args: - input (Variable): Predicted data, 2D-Tensor with the shape of [batch_size, 1]. The data type should be float32 or float64. - label (Variable): Ground truth label, 2D-Tensor with the shape of [batch_size, 1]. The data type should be float32 or float64. + input (Variable): Predicted data, 2D-Tensor with the shape of [batch_size, 1]. The data type should be float32. + label (Variable): Ground truth label, 2D-Tensor with the shape of [batch_size, 1]. The data type should be float32. delta (float): The threshold for Huber loss, which is used to control the balance between the linear error and square error. The data type should be float32. Returns: @@ -1555,6 +1555,10 @@ def huber_loss(input, label, delta): print(HuberLoss) #[[1.5], [0.5], [0.5], [0. ]], dtype=float32 """ helper = LayerHelper('huber_loss', **locals()) + check_variable_and_dtype(input, 'input', ['float32', 'float64'], + 'huber_loss') + check_variable_and_dtype(label, 'label', ['float32', 'float64'], + 'huber_loss') residual = helper.create_variable_for_type_inference( dtype=helper.input_dtype()) out = helper.create_variable_for_type_inference(dtype=helper.input_dtype()) diff --git a/python/paddle/fluid/layers/nn.py b/python/paddle/fluid/layers/nn.py index 74243574f78..ad9fcd537f2 100644 --- a/python/paddle/fluid/layers/nn.py +++ b/python/paddle/fluid/layers/nn.py @@ -5781,6 +5781,8 @@ def one_hot(input, depth, allow_out_of_range=False): return out helper = LayerHelper("one_hot", **locals()) + check_variable_and_dtype(input, 'input', ['int32', 'int64'], 'one_hot') + check_type(depth, 'depth', (six.integer_types, Variable), 'one_hot') one_hot_out = helper.create_variable_for_type_inference(dtype='float32') if not isinstance(depth, Variable): @@ -6392,6 +6394,7 @@ def lrn(input, n=5, k=1.0, alpha=1e-4, beta=0.75, name=None, print(lrn.dtype) # float32 """ helper = LayerHelper('lrn', **locals()) + check_variable_and_dtype(input, 'input', ['float32'], 'lrn') dtype = helper.input_dtype() input_shape = input.shape dims = len(input_shape) diff --git a/python/paddle/fluid/tests/unittests/test_huber_loss_op.py b/python/paddle/fluid/tests/unittests/test_huber_loss_op.py index 1c1b2f3ca33..2c8626cfd93 100644 --- a/python/paddle/fluid/tests/unittests/test_huber_loss_op.py +++ b/python/paddle/fluid/tests/unittests/test_huber_loss_op.py @@ -17,6 +17,8 @@ from __future__ import print_function import unittest import numpy as np from op_test import OpTest +import paddle.fluid as fluid +from paddle.fluid import compiler, Program, program_guard def huber_loss_forward(val, delta): @@ -79,5 +81,23 @@ def TestHuberLossOp2(TestHuberLossOp): return (6, 6, 1) +class TestHuberLossOpError(unittest.TestCase): + def test_errors(self): + with program_guard(Program(), Program()): + # the input and label must be Variable + xw = np.random.random((6, 6)).astype("float32") + xr = fluid.data(name='xr', shape=[None, 6], dtype="float32") + lw = np.random.random((6, 6)).astype("float32") + lr = fluid.data(name='lr', shape=[None, 6], dtype="float32") + self.assertRaises(TypeError, fluid.layers.huber_loss, xw, lr) + self.assertRaises(TypeError, fluid.layers.huber_loss, xr, lw) + + # the dtype of input and label must be float32 or float64 + xw2 = fluid.data(name='xw2', shape=[None, 6], dtype="int32") + lw2 = fluid.data(name='lw2', shape=[None, 6], dtype="int32") + self.assertRaises(TypeError, fluid.layers.huber_loss, xw2, lr) + self.assertRaises(TypeError, fluid.layers.huber_loss, xr, lw2) + + if __name__ == '__main__': unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_lrn_op.py b/python/paddle/fluid/tests/unittests/test_lrn_op.py index fa8dba980bb..da3b2b7a206 100644 --- a/python/paddle/fluid/tests/unittests/test_lrn_op.py +++ b/python/paddle/fluid/tests/unittests/test_lrn_op.py @@ -19,6 +19,7 @@ import numpy as np import paddle.fluid as fluid import paddle.fluid.core as core from op_test import OpTest +from paddle.fluid import compiler, Program, program_guard class TestLRNOp(OpTest): @@ -145,5 +146,13 @@ class TestLRNAPI(unittest.TestCase): self.assertRaises(ValueError, _input_dim_size) +class TestLRNOpError(unittest.TestCase): + def test_errors(self): + with program_guard(Program(), Program()): + # the input must be float32 + in_w = fluid.data(name="in_w", shape=[None, 3, 3, 3], dtype="int64") + self.assertRaises(TypeError, fluid.layers.lrn, in_w) + + if __name__ == "__main__": unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_one_hot_op.py b/python/paddle/fluid/tests/unittests/test_one_hot_op.py index b1884b7e7a9..34a1087c9ff 100644 --- a/python/paddle/fluid/tests/unittests/test_one_hot_op.py +++ b/python/paddle/fluid/tests/unittests/test_one_hot_op.py @@ -175,5 +175,29 @@ class TestOneHotOp_exception(unittest.TestCase): self.assertRaises(core.EnforceNotMet, run) +class TestOneHotOpError(unittest.TestCase): + def test_errors(self): + with program_guard(Program(), Program()): + # the input must be Variable + in_w = np.random.random((4, 1)).astype("int32") + self.assertRaises(TypeError, fluid.layers.one_hot, in_w) + # the input must be int32 or int 64 + in_w2 = fluid.layers.data( + name="in_w2", + shape=[4, 1], + append_batch_size=False, + dtype="float32") + self.assertRaises(TypeError, fluid.layers.one_hot, in_w2) + # the depth must be int, long or Variable + in_r = fluid.layers.data( + name="in_r", + shape=[4, 1], + append_batch_size=False, + dtype="int32") + depth_w = np.array([4]) + self.assertRaises(TypeError, fluid.layers.one_hot, in_r, 4.1) + self.assertRaises(TypeError, fluid.layers.one_hot, in_r, depth_w) + + if __name__ == '__main__': unittest.main() -- GitLab