From cd1de0e2c5e2d1f7588907fb7b2b84ac325a5dc4 Mon Sep 17 00:00:00 2001 From: ceci3 Date: Sun, 12 Apr 2020 13:14:53 +0800 Subject: [PATCH] API/OP error message enhancement (#23691) * error enhance,test=develop * update,test=develop * update type, test=develop * replace inout_check, test=develop --- paddle/fluid/operators/batch_norm_op.cc | 118 +++++++--------- paddle/fluid/operators/cos_sim_op.cc | 34 +++-- paddle/fluid/operators/dropout_op.cc | 25 ++-- paddle/fluid/operators/instance_norm_op.cc | 133 ++++++++++-------- python/paddle/fluid/layers/loss.py | 6 + python/paddle/fluid/layers/nn.py | 4 + .../fluid/tests/unittests/test_cos_sim_op.py | 18 +++ .../tests/unittests/test_instance_norm_op.py | 14 ++ .../tests/unittests/test_npair_loss_op.py | 70 +++++++++ 9 files changed, 275 insertions(+), 147 deletions(-) diff --git a/paddle/fluid/operators/batch_norm_op.cc b/paddle/fluid/operators/batch_norm_op.cc index fbb9cfb75ad..ec9f9e9c7dc 100644 --- a/paddle/fluid/operators/batch_norm_op.cc +++ b/paddle/fluid/operators/batch_norm_op.cc @@ -25,49 +25,32 @@ namespace paddle { namespace operators { void BatchNormOp::InferShape(framework::InferShapeContext *ctx) const { - PADDLE_ENFORCE_EQ(ctx->HasInput("X"), true, - platform::errors::InvalidArgument( - "Input(X) of BatchNormOp should not be null.")); - PADDLE_ENFORCE_EQ(ctx->HasInput("Scale"), true, - platform::errors::InvalidArgument( - "Input(Scale) of BatchNormOp should not be null.")); - PADDLE_ENFORCE_EQ(ctx->HasInput("Bias"), true, - platform::errors::InvalidArgument( - "Input(Bias) of BatchNormOp should not be null.")); - PADDLE_ENFORCE_EQ(ctx->HasInput("Mean"), true, - platform::errors::InvalidArgument( - "Input(Mean) of BatchNormOp should not be null.")); - PADDLE_ENFORCE_EQ(ctx->HasInput("Variance"), true, - platform::errors::InvalidArgument( - "Input(Variance) of BatchNormOp should not be null.")); - PADDLE_ENFORCE_EQ(ctx->HasOutput("Y"), true, - platform::errors::InvalidArgument( - "Output(Y) of BatchNormOp should not be null.")); + OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "BatchNorm"); + OP_INOUT_CHECK(ctx->HasInput("Scale"), "Input", "Scale", "BatchNorm"); + OP_INOUT_CHECK(ctx->HasInput("Bias"), "Input", "Bias", "BatchNorm"); + OP_INOUT_CHECK(ctx->HasInput("Mean"), "Input", "Mean", "BatchNorm"); + OP_INOUT_CHECK(ctx->HasInput("Variance"), "Input", "Variance", "BatchNorm"); + OP_INOUT_CHECK(ctx->HasOutput("Y"), "Output", "Y", "BatchNorm"); + bool is_test = ctx->Attrs().Get("is_test"); if (!is_test) { - PADDLE_ENFORCE_EQ( - ctx->HasOutput("MeanOut"), true, - platform::errors::InvalidArgument( - "Output(MeanOut) of BatchNormOp should not be null.")); - PADDLE_ENFORCE_EQ( - ctx->HasOutput("VarianceOut"), true, - platform::errors::InvalidArgument( - "Output(VarianceOut) of BatchNormOp should not be null.")); - PADDLE_ENFORCE_EQ( - ctx->HasOutput("SavedMean"), true, - platform::errors::InvalidArgument( - "Output(SavedMean) of BatchNormOp should not be null.")); - PADDLE_ENFORCE_EQ( - ctx->HasOutput("SavedVariance"), true, - platform::errors::InvalidArgument( - "Output(SavedVariance) of BatchNormOp should not be null.")); + OP_INOUT_CHECK(ctx->HasOutput("MeanOut"), "Output", "MeanOut", "BatchNorm"); + OP_INOUT_CHECK(ctx->HasOutput("VarianceOut"), "Output", "VarianceOut", + "BatchNorm"); + OP_INOUT_CHECK(ctx->HasOutput("SavedMean"), "Output", "SavedMean", + "BatchNorm"); + OP_INOUT_CHECK(ctx->HasOutput("SavedVariance"), "Output", "SavedVariance", + "BatchNorm"); } // make sure Mean/MeanOut and Variance/VarianceOut share memory in Python PADDLE_ENFORCE_EQ(ctx->Inputs("Mean")[0], ctx->Outputs("MeanOut")[0], - "Mean and MeanOut should share the same memory"); - PADDLE_ENFORCE_EQ(ctx->Inputs("Variance")[0], ctx->Outputs("VarianceOut")[0], - "Variance and VarianceOut should share the same memory"); + platform::errors::InvalidArgument( + "Mean and MeanOut should share the same memory")); + PADDLE_ENFORCE_EQ( + ctx->Inputs("Variance")[0], ctx->Outputs("VarianceOut")[0], + platform::errors::InvalidArgument( + "Variance and VarianceOut should share the same memory")); const auto x_dims = ctx->GetInputDim("X"); const DataLayout data_layout = framework::StringToDataLayout( @@ -103,16 +86,19 @@ void BatchNormOp::InferShape(framework::InferShapeContext *ctx) const { auto scale_dim = ctx->GetInputDim("Scale"); auto bias_dim = ctx->GetInputDim("Bias"); - PADDLE_ENFORCE_EQ(scale_dim.size(), 1UL, - "ShapeError: the dimension of scale must equal to 1." - "But received: the shape of scale is [%s], the dimension " - "of scale is [%d]", - scale_dim, scale_dim.size()); PADDLE_ENFORCE_EQ( - bias_dim.size(), 1UL, - "ShapeError: the dimension of bias must equal to 1." - "But received: the shape of bias is [%s],the dimension of bias is [%d]", - bias_dim, bias_dim.size()); + scale_dim.size(), 1UL, + platform::errors::InvalidArgument( + "ShapeError: the dimension of scale must equal to 1." + "But received: the shape of scale is [%s], the dimension " + "of scale is [%d]", + scale_dim, scale_dim.size())); + PADDLE_ENFORCE_EQ(bias_dim.size(), 1UL, + platform::errors::InvalidArgument( + "ShapeError: the dimension of bias must equal to 1." + "But received: the shape of bias is [%s],the dimension " + "of bias is [%d]", + bias_dim, bias_dim.size())); bool check = true; if ((!ctx->IsRuntime()) && (framework::product(scale_dim) <= 0 || @@ -122,13 +108,15 @@ void BatchNormOp::InferShape(framework::InferShapeContext *ctx) const { if (check) { PADDLE_ENFORCE_EQ(scale_dim[0], C, - "ShapeError: the shape of scale must equal to [%d]" - "But received: the shape of scale is [%d]", - C, scale_dim[0]); + platform::errors::InvalidArgument( + "ShapeError: the shape of scale must equal to [%d]" + "But received: the shape of scale is [%d]", + C, scale_dim[0])); PADDLE_ENFORCE_EQ(bias_dim[0], C, - "ShapeError: the shape of bias must equal to [%d]" - "But received: the shape of bias is [%d]", - C, bias_dim[0]); + platform::errors::InvalidArgument( + "ShapeError: the shape of bias must equal to [%d]" + "But received: the shape of bias is [%d]", + C, bias_dim[0])); } ctx->SetOutputDim("Y", x_dims); ctx->SetOutputDim("MeanOut", {C}); @@ -449,27 +437,23 @@ class BatchNormKernel void BatchNormGradOp::InferShape(framework::InferShapeContext *ctx) const { // check input - PADDLE_ENFORCE_EQ( - ctx->HasInput("Scale"), true, - platform::errors::InvalidArgument("Input(scale) should not be null.")); - PADDLE_ENFORCE_EQ( - ctx->HasInput(framework::GradVarName("Y")), true, - platform::errors::InvalidArgument("Input(Y@GRAD) should not be null.")); - PADDLE_ENFORCE_EQ(ctx->HasInput("SavedMean"), true, - platform::errors::InvalidArgument( - "Input(SavedMean) should not be null.")); - PADDLE_ENFORCE_EQ(ctx->HasInput("SavedVariance"), true, - platform::errors::InvalidArgument( - "Input(SavedVariance) should not be null")); + OP_INOUT_CHECK(ctx->HasInput("Scale"), "Input", "Scale", "BatchNormGrad"); + OP_INOUT_CHECK(ctx->HasInput(framework::GradVarName("Y")), "Input", + framework::GradVarName("Y"), "BatchNormGrad"); + OP_INOUT_CHECK(ctx->HasInput("SavedMean"), "Input", "SavedMean", + "BatchNormGrad"); + OP_INOUT_CHECK(ctx->HasInput("SavedVariance"), "Input", "SavedVariance", + "BatchNormGrad"); // check output - PADDLE_ENFORCE(ctx->HasOutput(framework::GradVarName("X")), ""); + OP_INOUT_CHECK(ctx->HasOutput(framework::GradVarName("X")), "Output", + framework::GradVarName("X"), "BatchNormGrad"); const bool has_scale_grad = ctx->HasOutput(framework::GradVarName("Scale")); const bool has_bias_grad = ctx->HasOutput(framework::GradVarName("Bias")); PADDLE_ENFORCE_EQ((has_scale_grad == has_bias_grad), true, - platform::errors::InvalidArgument( + platform::errors::NotFound( "Output(Scale@GRAD) and Output(Bias@GRAD) must be null " "or not be null at same time. But now, " "has Scale@Grad=[%d], has Bias@GRAD=[%d]", @@ -489,7 +473,7 @@ void BatchNormGradOp::InferShape(framework::InferShapeContext *ctx) const { // so only infer shape in run time here. if (ctx->IsRuntime()) { PADDLE_ENFORCE_EQ(ctx->HasInput("X") || ctx->HasInput("Y"), true, - platform::errors::InvalidArgument( + platform::errors::NotFound( "Input(X) and Input(Y) should not be all null.")); auto input_name = "Y"; if (ctx->HasInput("X")) input_name = "X"; diff --git a/paddle/fluid/operators/cos_sim_op.cc b/paddle/fluid/operators/cos_sim_op.cc index 5532a02d4f1..f20c6dfcf5d 100644 --- a/paddle/fluid/operators/cos_sim_op.cc +++ b/paddle/fluid/operators/cos_sim_op.cc @@ -46,21 +46,24 @@ class CosSimOp : public framework::OperatorWithKernel { PADDLE_ENFORCE_EQ( x_dims.size(), y_dims.size(), platform::errors::InvalidArgument( - "Ranks of Input(X) [%s] and Input(Y) [%s] must be equal.", x_dims, - y_dims)); + "ShapeError: Ranks of Input(X) and Input(Y) must be equal." + "But received: Ranks of Input(X) is [%d], Ranks of Input(Y) is " + "[%d]", + x_dims.size(), y_dims.size())); PADDLE_ENFORCE_GE( x_dims.size(), 2, platform::errors::InvalidArgument( - "Rank of Input(X) %d must not be less than 2.", x_dims.size())); + "ShapeError: Rank of Input(X) must not be less than 2." + "But received: Ranks of Input(X) is [%d]", + x_dims.size())); PADDLE_ENFORCE_EQ( framework::slice_ddim(x_dims, 1, x_dims.size()), framework::slice_ddim(y_dims, 1, y_dims.size()), platform::errors::InvalidArgument( - "All dimensions except the 1st of Input(X) [%s] and Input(Y) [%s]" - "must be equal.", - x_dims, y_dims)); - PADDLE_ENFORCE( - x_dims[0] == y_dims[0] || y_dims[0] == 1, + "All dimensions except the 1st of Input(X) and Input(Y) " + "must be equal.")); + PADDLE_ENFORCE_EQ( + x_dims[0] == y_dims[0] || y_dims[0] == 1, true, platform::errors::InvalidArgument( "The 1st dimension of Input(Y) %d must be equal to Input(X) %d or" " just 1 (which will be broadcasted to match Input(X)).", @@ -136,14 +139,19 @@ class CosSimOpGrad : public framework::OperatorWithKernel { auto out_dims = ctx->GetInputDim("Out"); auto out_grad_dims = ctx->GetInputDim(framework::GradVarName("Out")); - PADDLE_ENFORCE_GE(x_dims.size(), y_dims.size(), - platform::errors::InvalidArgument( - "Ranks of Input(X) %d and Input(Y) %d must be equal.", - x_dims.size(), y_dims.size())); + PADDLE_ENFORCE_GE( + x_dims.size(), y_dims.size(), + platform::errors::InvalidArgument( + "ShapeError: Ranks of Input(X) and Input(Y) must be equal." + "But received: Ranks of Input(X) is [%d], Ranks of Input(Y) is " + "[%d]", + x_dims.size(), y_dims.size())); PADDLE_ENFORCE_GE( x_dims.size(), 2, platform::errors::InvalidArgument( - "Rank of Input(X) %d must not be less than 2.", x_dims.size())); + "ShapeError: Rank of Input(X) must not be less than 2." + "But received: Ranks of Input(X) is [%d]", + x_dims.size())); PADDLE_ENFORCE_EQ( framework::slice_ddim(x_dims, 1, x_dims.size()), framework::slice_ddim(y_dims, 1, y_dims.size()), diff --git a/paddle/fluid/operators/dropout_op.cc b/paddle/fluid/operators/dropout_op.cc index 9ec4bc22c1f..6ee19c939f2 100644 --- a/paddle/fluid/operators/dropout_op.cc +++ b/paddle/fluid/operators/dropout_op.cc @@ -26,7 +26,7 @@ class DropoutOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) must not be null."); + OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "Dropout"); auto x_dims = ctx->GetInputDim("X"); ctx->SetOutputDim("Out", x_dims); @@ -58,8 +58,9 @@ class DropoutOpMaker : public framework::OpProtoAndCheckerMaker { AddAttr("dropout_prob", "Probability of setting units to zero.") .SetDefault(.5f) .AddCustomChecker([](const float& drop_p) { - PADDLE_ENFORCE(drop_p >= 0.0f && drop_p <= 1.0f, - "'dropout_prob' must be between 0.0 and 1.0."); + PADDLE_ENFORCE_EQ(drop_p >= 0.0f && drop_p <= 1.0f, true, + platform::errors::InvalidArgument( + "'dropout_prob' must be between 0.0 and 1.0.")); }); AddAttr("is_test", "(bool, default false) Set to true for inference only, false " @@ -91,10 +92,11 @@ class DropoutOpMaker : public framework::OpProtoAndCheckerMaker { "efficient") .SetDefault("downgrade_in_infer") .AddCustomChecker([](const std::string& type) { - PADDLE_ENFORCE( - type == "downgrade_in_infer" || type == "upscale_in_train", - "dropout_implementation can only be downgrade_in_infer or " - "upscale_in_train"); + PADDLE_ENFORCE_EQ( + type == "downgrade_in_infer" || type == "upscale_in_train", true, + platform::errors::InvalidArgument( + "dropout_implementation can only be downgrade_in_infer or " + "upscale_in_train")); }); AddComment(R"DOC( @@ -116,11 +118,12 @@ class DropoutOpGrad : public framework::OperatorWithKernel { void InferShape(framework::InferShapeContext* ctx) const override { PADDLE_ENFORCE_EQ(ctx->Attrs().Get("is_test"), false, - "GradOp is only callable when is_test is false"); + platform::errors::InvalidArgument( + "GradOp is only callable when is_test is false")); - PADDLE_ENFORCE(ctx->HasInput("Mask"), "Mask must not be null."); - PADDLE_ENFORCE(ctx->HasInput(framework::GradVarName("Out")), - "Input(Out@GRAD) must not be null."); + OP_INOUT_CHECK(ctx->HasInput("Mask"), "Input", "Mask", "DropoutGrad"); + OP_INOUT_CHECK(ctx->HasInput(framework::GradVarName("Out")), "Input", + framework::GradVarName("Out"), "DropoutGrad"); auto out_dims = ctx->GetInputDim(framework::GradVarName("Out")); diff --git a/paddle/fluid/operators/instance_norm_op.cc b/paddle/fluid/operators/instance_norm_op.cc index 10c7a04eeeb..127987a1789 100644 --- a/paddle/fluid/operators/instance_norm_op.cc +++ b/paddle/fluid/operators/instance_norm_op.cc @@ -23,27 +23,30 @@ namespace paddle { namespace operators { void InstanceNormOp::InferShape(framework::InferShapeContext *ctx) const { - PADDLE_ENFORCE_EQ(ctx->HasInput("X"), true, - "Input(X) of Instance Norm Op should not be null."); - PADDLE_ENFORCE_EQ(ctx->HasInput("Scale"), true, - "Input(Scale) of Instance Norm Op should not be null."); - PADDLE_ENFORCE_EQ(ctx->HasInput("Bias"), true, - "Input(Bias) of Instance Norm Op should not be null."); - PADDLE_ENFORCE_EQ(ctx->HasOutput("Y"), true, - "Output(Y) of Instance Norm Op should not be null."); - - PADDLE_ENFORCE_EQ( - ctx->HasOutput("SavedMean"), true, - "Output(SavedMean) of Instance Norm Op should not be null."); - PADDLE_ENFORCE_EQ( - ctx->HasOutput("SavedVariance"), true, - "Output(SavedVariance) of Instance Norm Op should not be null."); + OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "InstanceNorm"); + OP_INOUT_CHECK(ctx->HasInput("Scale"), "Input", "Scale", "InstanceNorm"); + OP_INOUT_CHECK(ctx->HasInput("Bias"), "Input", "Bias", "InstanceNorm"); + OP_INOUT_CHECK(ctx->HasOutput("Y"), "Output", "Y", "InstanceNorm"); + OP_INOUT_CHECK(ctx->HasOutput("SavedMean"), "Output", "SavedMean", + "InstanceNorm"); + OP_INOUT_CHECK(ctx->HasOutput("SavedVariance"), "Output", "SavedVariance", + "InstanceNorm"); const auto x_dims = ctx->GetInputDim("X"); - PADDLE_ENFORCE_GE(x_dims.size(), 2, - "the dimension of input X must greater than or equal to 2"); - PADDLE_ENFORCE_LE(x_dims.size(), 5, - "the dimension of input X must smaller than or equal to 5"); + PADDLE_ENFORCE_GE( + x_dims.size(), 2, + platform::errors::InvalidArgument( + "ShapeError: the dimension of input X must " + "greater than or equal to 2. But received: the shape of input " + "X = [%s], the dimension of input X =[%d]", + x_dims, x_dims.size())); + PADDLE_ENFORCE_LE( + x_dims.size(), 5, + platform::errors::InvalidArgument( + "ShapeError: the dimension of input X must " + "smaller than or equal to 5, But received: the shape of input " + "X = [%s], the dimension of input X = [%d]", + x_dims, x_dims.size())); auto N = x_dims[0]; auto C = x_dims[1]; auto NxC = N * C; @@ -51,15 +54,34 @@ void InstanceNormOp::InferShape(framework::InferShapeContext *ctx) const { auto scale_dim = ctx->GetInputDim("Scale"); auto bias_dim = ctx->GetInputDim("Bias"); - PADDLE_ENFORCE_EQ(scale_dim.size(), 1UL); - PADDLE_ENFORCE_EQ(bias_dim.size(), 1UL); + PADDLE_ENFORCE_EQ( + scale_dim.size(), 1UL, + platform::errors::InvalidArgument( + "ShapeError: the dimension of scale must equal to 1." + "But received: the shape of scale is [%s], the dimension " + "of scale is [%d]", + scale_dim, scale_dim.size())); + PADDLE_ENFORCE_EQ(bias_dim.size(), 1UL, + platform::errors::InvalidArgument( + "ShapeError: the dimension of bias must equal to 1." + "But received: the shape of bias is [%s],the dimension " + "of bias is [%d]", + bias_dim, bias_dim.size())); bool check = !((!ctx->IsRuntime()) && (framework::product(scale_dim) <= 0 || framework::product(bias_dim) <= 0)); if (check) { - PADDLE_ENFORCE_EQ(scale_dim[0], C); - PADDLE_ENFORCE_EQ(bias_dim[0], C); + PADDLE_ENFORCE_EQ(scale_dim[0], C, + platform::errors::InvalidArgument( + "ShapeError: the shape of scale must equal to [%d]" + "But received: the shape of scale is [%d]", + C, scale_dim[0])); + PADDLE_ENFORCE_EQ(bias_dim[0], C, + platform::errors::InvalidArgument( + "ShapeError: the shape of bias must equal to [%d]" + "But received: the shape of bias is [%d]", + C, bias_dim[0])); } ctx->SetOutputDim("Y", x_dims); @@ -78,10 +100,12 @@ framework::OpKernelType InstanceNormOp::GetExpectedKernelType( if (input_data_type == framework::proto::VarType::FP64) { in_param_type = framework::proto::VarType::FP64; } - PADDLE_ENFORCE_EQ(in_param_type, ctx.Input("Scale")->type(), - "Scale input should be of float type"); - PADDLE_ENFORCE_EQ(in_param_type, ctx.Input("Bias")->type(), - "Bias input should be of float type"); + PADDLE_ENFORCE_EQ( + in_param_type, ctx.Input("Scale")->type(), + platform::errors::InvalidArgument("Scale input should be of float type")); + PADDLE_ENFORCE_EQ( + in_param_type, ctx.Input("Bias")->type(), + platform::errors::InvalidArgument("Bias input should be of float type")); return framework::OpKernelType(input_data_type, ctx.GetPlace()); } @@ -91,7 +115,8 @@ void InstanceNormOpMaker::Make() { .SetDefault(1e-5) .AddCustomChecker([](const float &epsilon) { PADDLE_ENFORCE_EQ(epsilon >= 0.0f && epsilon <= 0.001f, true, - "'epsilon' should be between 0.0 and 0.001."); + platform::errors::InvalidArgument( + "'epsilon' should be between 0.0 and 0.001.")); }); AddInput("X", "The input tensor"); AddInput("Scale", @@ -193,24 +218,21 @@ class InstanceNormKernel }; void InstanceNormGradOp::InferShape(framework::InferShapeContext *ctx) const { - PADDLE_ENFORCE_EQ(ctx->HasInput("X"), true, "Input(X) should not be null"); - PADDLE_ENFORCE_EQ(ctx->HasInput("Scale"), true, - "Input(scale) should not be null"); - - PADDLE_ENFORCE_EQ(ctx->HasInput(framework::GradVarName("Y")), true, - "Input(Y@GRAD) should not be null"); - PADDLE_ENFORCE_EQ(ctx->HasInput("SavedMean"), true, - "Input(SavedMean) should not be null"); - PADDLE_ENFORCE_EQ(ctx->HasInput("SavedVariance"), true, - "Input(SavedVariance) should not be null"); + OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "InstanceNormGrad"); + OP_INOUT_CHECK(ctx->HasInput("Scale"), "Input", "Scale", "InstanceNormGrad"); + OP_INOUT_CHECK(ctx->HasInput(framework::GradVarName("Y")), "Input", + framework::GradVarName("Y"), "InstanceNormGrad"); + OP_INOUT_CHECK(ctx->HasInput("SavedMean"), "Input", "SavedMean", + "InstanceNormGrad"); + OP_INOUT_CHECK(ctx->HasInput("SavedVariance"), "Input", "SavedVariance", + "InstanceNormGrad"); // check output - PADDLE_ENFORCE_EQ(ctx->HasOutput(framework::GradVarName("X")), true, - "Output(x@GRAD) should not be null"); + OP_INOUT_CHECK(ctx->HasOutput(framework::GradVarName("X")), "Output", + framework::GradVarName("X"), "InstanceNormGrad"); if (ctx->HasOutput(framework::GradVarName("Scale"))) { - PADDLE_ENFORCE_EQ(ctx->HasOutput(framework::GradVarName("Bias")), true, - "Output(Scale@GRAD) and Output(Bias@GRAD) should not be " - "null at the same time"); + OP_INOUT_CHECK(ctx->HasOutput(framework::GradVarName("Bias")), "Output", + framework::GradVarName("Bias"), "InstanceNormGrad"); } const auto x_dims = ctx->GetInputDim("X"); const int C = x_dims[1]; @@ -333,21 +355,20 @@ class InstanceNormGradKernel void InstanceNormDoubleGradOp::InferShape( framework::InferShapeContext *ctx) const { - PADDLE_ENFORCE_EQ(ctx->HasInput("X"), true, "Input(X) should not be null"); - PADDLE_ENFORCE_EQ(ctx->HasInput("Scale"), true, - "Input(Scale) should not be null."); - PADDLE_ENFORCE_EQ(ctx->HasInput("SavedMean"), true, - "Input(SavedMean) should not be null"); - PADDLE_ENFORCE_EQ(ctx->HasInput("SavedVariance"), true, - "Input(SavedVariance) should not be null"); - PADDLE_ENFORCE_EQ(ctx->HasInput("DDX"), true, - "Input(DDX) should not be null."); - PADDLE_ENFORCE_EQ(ctx->HasInput("DY"), true, - "Input(Y@GRAD) should not be null"); + OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "InstanceNormDoubleGrad"); + OP_INOUT_CHECK(ctx->HasInput("Scale"), "Input", "Scale", + "InstanceNormDoubleGrad"); + OP_INOUT_CHECK(ctx->HasInput("SavedMean"), "Input", "SavedMean", + "InstanceNormDoubleGrad"); + OP_INOUT_CHECK(ctx->HasInput("SavedVariance"), "Input", "SavedVariance", + "InstanceNormDoubleGrad"); + OP_INOUT_CHECK(ctx->HasInput("DDX"), "Input", "DDX", + "InstanceNormDoubleGrad"); + OP_INOUT_CHECK(ctx->HasInput("DY"), "Input", "DY", "InstanceNormDoubleGrad"); // check output - PADDLE_ENFORCE_EQ(ctx->HasOutput("DX"), true, - "Output(DX) should not be null"); + OP_INOUT_CHECK(ctx->HasOutput("DX"), "Output", "DX", + "InstanceNormDoubleGrad"); const auto x_dims = ctx->GetInputDim("X"); const int C = x_dims[1]; diff --git a/python/paddle/fluid/layers/loss.py b/python/paddle/fluid/layers/loss.py index 6fbc9c78b6a..284ee8e3893 100644 --- a/python/paddle/fluid/layers/loss.py +++ b/python/paddle/fluid/layers/loss.py @@ -1633,6 +1633,12 @@ def npair_loss(anchor, positive, labels, l2_reg=0.002): npair_loss = fluid.layers.npair_loss(anchor, positive, labels, l2_reg = 0.002) ''' + check_variable_and_dtype(anchor, 'anchor', ['float32', 'float64'], + 'npair_loss') + check_variable_and_dtype(positive, 'positive', ['float32', 'float64'], + 'positive') + check_variable_and_dtype(labels, 'labels', ['float32', 'float64', 'int64'], + 'labels') Beta = 0.25 batch_size = labels.shape[0] diff --git a/python/paddle/fluid/layers/nn.py b/python/paddle/fluid/layers/nn.py index 3b984bacc64..7dab3532af1 100644 --- a/python/paddle/fluid/layers/nn.py +++ b/python/paddle/fluid/layers/nn.py @@ -894,6 +894,8 @@ def cos_sim(X, Y): y = fluid.data(name='y', shape=[1, 7], dtype='float32') out = fluid.layers.cos_sim(x, y) """ + check_variable_and_dtype(X, 'X', ['float32'], 'cos_sim') + check_variable_and_dtype(Y, 'Y', ['float32'], 'cos_sim') helper = LayerHelper('cos_sim', **locals()) out = helper.create_variable_for_type_inference(dtype=X.dtype) xnorm = helper.create_variable_for_type_inference(dtype=X.dtype) @@ -3090,6 +3092,8 @@ def instance_norm(input, hidden1 = fluid.layers.fc(input=x, size=200, param_attr='fc1.w') hidden2 = fluid.layers.instance_norm(input=hidden1) """ + check_variable_and_dtype(input, 'input', ['float32', 'float64'], + 'instance_norm') assert bias_attr is not False, "bias_attr should not be False in instance_norm." helper = LayerHelper('instance_norm', **locals()) dtype = helper.input_dtype() diff --git a/python/paddle/fluid/tests/unittests/test_cos_sim_op.py b/python/paddle/fluid/tests/unittests/test_cos_sim_op.py index 46f8420be01..23b0fcc691a 100644 --- a/python/paddle/fluid/tests/unittests/test_cos_sim_op.py +++ b/python/paddle/fluid/tests/unittests/test_cos_sim_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 Program, program_guard class TestCosSimOp(OpTest): @@ -105,5 +107,21 @@ class TestCosSimOp4(TestCosSimOp): } +class TestCosSimOpError(unittest.TestCase): + def test_errors(self): + with program_guard(Program(), Program()): + # the input of batch_norm must be Variable. + x1 = fluid.create_lod_tensor( + np.array([-1, 3, 5, 5]), [[1, 1, 1, 1]], fluid.CPUPlace()) + x2 = fluid.create_lod_tensor( + np.array([-1, 3, 5, 5]), [[1, 1, 1, 1]], fluid.CPUPlace()) + self.assertRaises(TypeError, fluid.layers.cos_sim, x1, x2) + + # the input dtype of batch_norm must be float32 + x3 = fluid.layers.data(name='x3', shape=[3, 4, 5, 6], dtype="int32") + x4 = fluid.layers.data(name='x4', shape=[3, 4, 5, 6], dtype="int64") + self.assertRaises(TypeError, fluid.layers.cos_sim, x3, x4) + + if __name__ == '__main__': unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_instance_norm_op.py b/python/paddle/fluid/tests/unittests/test_instance_norm_op.py index c58c830c2c5..39e994873dc 100644 --- a/python/paddle/fluid/tests/unittests/test_instance_norm_op.py +++ b/python/paddle/fluid/tests/unittests/test_instance_norm_op.py @@ -19,6 +19,7 @@ import paddle.fluid.core as core import paddle.fluid as fluid from paddle.fluid.op import Operator from op_test import OpTest +from paddle.fluid import Program, program_guard def _reference_instance_norm_naive(x, scale, bias, epsilon, mean, var): @@ -200,5 +201,18 @@ class TestInstanceNormOpTrainingCase2(TestInstanceNormOpTraining): self.fetch_list = ['y', 'saved_mean', 'saved_variance', 'x@GRAD'] +class TestInstanceNormOpError(unittest.TestCase): + def test_errors(self): + with program_guard(Program(), Program()): + # the input of instance_norm must be Variable. + x1 = fluid.create_lod_tensor( + np.array([-1, 3, 5, 5]), [[1, 1, 1, 1]], fluid.CPUPlace()) + self.assertRaises(TypeError, fluid.layers.instance_norm, x1) + + # the input dtype of instance_norm must be float32 or float64 + x2 = fluid.layers.data(name='x2', shape=[3, 4, 5, 6], dtype="int32") + self.assertRaises(TypeError, fluid.layers.instance_norm, x2) + + if __name__ == '__main__': unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_npair_loss_op.py b/python/paddle/fluid/tests/unittests/test_npair_loss_op.py index de9a4366342..c6d7e0300d0 100644 --- a/python/paddle/fluid/tests/unittests/test_npair_loss_op.py +++ b/python/paddle/fluid/tests/unittests/test_npair_loss_op.py @@ -18,6 +18,7 @@ import unittest import paddle.fluid as fluid import paddle.fluid.core as core import numpy as np +from paddle.fluid import Program, program_guard def npairloss(anchor, positive, labels, l2_reg=0.002): @@ -106,5 +107,74 @@ class TestNpairLossOp(unittest.TestCase): atol=1e-3) +class TestNpairLossOpError(unittest.TestCase): + def test_errors(self): + with program_guard(Program(), Program()): + anchor_np = np.random.random((2, 4)).astype("float32") + positive_np = np.random.random((2, 4)).astype("float32") + labels_np = np.random.random((2)).astype("float32") + anchor_data = fluid.data( + name='anchor', shape=[2, 4], dtype='float32') + positive_data = fluid.data( + name='positive', shape=[2, 4], dtype='float32') + labels_data = fluid.data(name='labels', shape=[2], dtype='float32') + + def test_anchor_Variable(): + # the anchor type must be Variable + fluid.layers.npair_loss( + anchor=anchor_np, + positive=positive_data, + labels=labels_data) + + def test_positive_Variable(): + # the positive type must be Variable + fluid.layers.npair_loss( + anchor=anchor_data, + positive=positive_np, + labels=labels_data) + + def test_labels_Variable(): + # the labels type must be Variable + fluid.layers.npair_loss( + anchor=anchor_data, + positive=positive_data, + labels=labels_np) + + self.assertRaises(TypeError, test_anchor_Variable) + self.assertRaises(TypeError, test_positive_Variable) + self.assertRaises(TypeError, test_labels_Variable) + + def test_anchor_type(): + # dtype must be float32 or float64 + anchor_data1 = fluid.data( + name='anchor1', shape=[2, 4], dtype='int32') + fluid.layers.npair_loss( + anchor=anchor_data, + positive=positive_data, + labels=labels_np) + + def test_positive_type(): + # dtype must be float32 or float64 + positive_data1 = fluid.data( + name='positive1', shape=[2, 4], dtype='int32') + fluid.layers.npair_loss( + anchor=anchor_data, + positive=positive_data1, + labels=labels_np) + + def test_labels_type(): + # dtype must be float32 or float64 + labels_data1 = fluid.data( + name='labels1', shape=[2], dtype='int32') + fluid.layers.npair_loss( + anchor=anchor_data, + positive=positive_data, + labels=labels_data1) + + self.assertRaises(TypeError, test_anchor_type) + self.assertRaises(TypeError, test_positive_type) + self.assertRaises(TypeError, test_labels_type) + + if __name__ == '__main__': unittest.main() -- GitLab