From e01e77d7fb3ddfa2c8b83030eb92288bc5e447a0 Mon Sep 17 00:00:00 2001 From: mapingshuo Date: Wed, 13 May 2020 13:01:55 +0800 Subject: [PATCH] fix error log, test=develop (#24419) (#24462) * fix error log: resahpe, range, reverse. --- paddle/fluid/operators/range_op.cc | 38 ++++++++++++++++--- paddle/fluid/operators/range_op.h | 20 +++++++--- paddle/fluid/operators/reshape_op.cc | 28 +++++++++----- paddle/fluid/operators/reverse_op.cc | 18 ++++++--- paddle/fluid/operators/reverse_op.h | 6 +-- paddle/fluid/operators/shape_op.cc | 10 +++-- python/paddle/fluid/layers/nn.py | 3 +- python/paddle/fluid/layers/tensor.py | 6 +++ .../fluid/tests/unittests/test_reverse_op.py | 29 ++++++++++++-- 9 files changed, 120 insertions(+), 38 deletions(-) diff --git a/paddle/fluid/operators/range_op.cc b/paddle/fluid/operators/range_op.cc index ee8c68fd008..31ef777e5f0 100644 --- a/paddle/fluid/operators/range_op.cc +++ b/paddle/fluid/operators/range_op.cc @@ -24,18 +24,44 @@ class RangeOp : public framework::OperatorWithKernel { void InferShape(framework::InferShapeContext *ctx) const override { if (ctx->HasInput("Start")) { auto s_dims = ctx->GetInputDim("Start"); - PADDLE_ENFORCE((s_dims.size() == 1) && (s_dims[0] == 1), - "The shape of Input(Start) should be [1]."); + PADDLE_ENFORCE_EQ( + s_dims.size(), 1, + platform::errors::InvalidArgument( + "The dim of the shape of Input(Start) should be 1, but got %d", + s_dims.size())); + + PADDLE_ENFORCE_EQ(s_dims[0], 1, + platform::errors::InvalidArgument( + "The first dim of the shape of Input(Start) should " + "be 1, but got %d", + s_dims[0])); } if (ctx->HasInput("End")) { auto e_dims = ctx->GetInputDim("End"); - PADDLE_ENFORCE((e_dims.size() == 1) && (e_dims[0] == 1), - "The shape of Input(End) should be [1]."); + PADDLE_ENFORCE_EQ( + e_dims.size(), 1, + platform::errors::InvalidArgument( + "The dim of the shape of Input(End) should be 1, but got %d", + e_dims.size())); + + PADDLE_ENFORCE_EQ(e_dims[0], 1, platform::errors::InvalidArgument( + "The first dim of the shape of " + "Input(End) should be 1, but got %d", + e_dims[0])); } if (ctx->HasInput("Step")) { auto step_dims = ctx->GetInputDim("Step"); - PADDLE_ENFORCE((step_dims.size() == 1) && (step_dims[0] == 1), - "The shape of Input(Step) should be [1]."); + PADDLE_ENFORCE_EQ( + step_dims.size(), 1, + platform::errors::InvalidArgument( + "The dim of the shape of Input(Step) should be 1, but got %d", + step_dims.size())); + + PADDLE_ENFORCE_EQ(step_dims[0], 1, + platform::errors::InvalidArgument( + "The first dim of the shape of Input(Step) should " + "be 1, but got %d", + step_dims[0])); } ctx->SetOutputDim("Out", {-1}); } diff --git a/paddle/fluid/operators/range_op.h b/paddle/fluid/operators/range_op.h index fce58b45c96..a793d12f522 100644 --- a/paddle/fluid/operators/range_op.h +++ b/paddle/fluid/operators/range_op.h @@ -22,11 +22,21 @@ namespace operators { template void GetSize(T start, T end, T step, int64_t* size) { - PADDLE_ENFORCE(!std::equal_to()(step, 0), - "The step of range op should not be 0."); - PADDLE_ENFORCE(((start < end) && (step > 0)) || ((start > end) && (step < 0)), - "The step should be greater than 0 while start < end. And the " - "step should be less than 0 while start > end."); + PADDLE_ENFORCE_NE(step, 0, platform::errors::InvalidArgument( + "The step of range op should not be 0.")); + + if (start < end) { + PADDLE_ENFORCE_GT( + step, 0, platform::errors::InvalidArgument( + "The step should be greater than 0 while start < end.")); + } + + if (start > end) { + PADDLE_ENFORCE_LT(step, 0, + platform::errors::InvalidArgument( + "step should be less than 0 while start > end.")); + } + *size = std::is_integral::value ? ((std::abs(end - start) + std::abs(step) - 1) / std::abs(step)) : std::ceil(std::abs((end - start) / step)); diff --git a/paddle/fluid/operators/reshape_op.cc b/paddle/fluid/operators/reshape_op.cc index 9835da40d22..8eba5b888ec 100644 --- a/paddle/fluid/operators/reshape_op.cc +++ b/paddle/fluid/operators/reshape_op.cc @@ -56,9 +56,11 @@ class ReshapeOp : public framework::OperatorWithKernel { void InferShape(framework::InferShapeContext *ctx) const override { PADDLE_ENFORCE_EQ(ctx->HasInput("X"), true, - "Input(X) of ReshapeOp should not be null."); + platform::errors::InvalidArgument( + "Input(X) of ReshapeOp should not be null.")); PADDLE_ENFORCE_EQ(ctx->HasOutput("Out"), true, - "Output(Out) of ReshapeOp should not be null."); + platform::errors::InvalidArgument( + "Output(Out) of ReshapeOp should not be null.")); if (ctx->HasInputs("ShapeTensor")) { // top prority shape @@ -304,9 +306,12 @@ class ReshapeGradOp : public framework::OperatorWithKernel { : OperatorWithKernel(type, inputs, outputs, attrs) {} void InferShape(framework::InferShapeContext *ctx) const override { - PADDLE_ENFORCE_EQ(ctx->HasInput("X"), true, "Input(X) shouldn't be null."); + PADDLE_ENFORCE_EQ( + ctx->HasInput("X"), true, + platform::errors::InvalidArgument("Input(X) shouldn't be null.")); PADDLE_ENFORCE_EQ(ctx->HasInput(framework::GradVarName("Out")), true, - "Input(Out@GRAD) shouldn't be null."); + platform::errors::InvalidArgument( + "Input(Out@GRAD) shouldn't be null.")); ctx->SetOutputDim(framework::GradVarName("X"), ctx->GetInputDim("X")); } @@ -403,7 +408,8 @@ class Reshape2Op : public ReshapeOp { void InferShape(framework::InferShapeContext *ctx) const override { PADDLE_ENFORCE_EQ(ctx->HasOutput("XShape"), true, - "Output(XShape) of ReshapeOp should not be null."); + platform::errors::InvalidArgument( + "Output(XShape) of ReshapeOp should not be null.")); const auto &x_dims = ctx->GetInputDim("X"); std::vector xshape_dims(x_dims.size() + 1); xshape_dims[0] = 0; @@ -472,10 +478,12 @@ class Reshape2GradOp : public framework::OperatorWithKernel { : OperatorWithKernel(type, inputs, outputs, attrs) {} void InferShape(framework::InferShapeContext *ctx) const override { - PADDLE_ENFORCE_EQ(ctx->HasInput("XShape"), true, - "Input(XShape) shouldn't be null."); + PADDLE_ENFORCE_EQ( + ctx->HasInput("XShape"), true, + platform::errors::InvalidArgument("Input(XShape) shouldn't be null.")); PADDLE_ENFORCE_EQ(ctx->HasInput(framework::GradVarName("Out")), true, - "Input(Out@GRAD) shouldn't be null."); + platform::errors::InvalidArgument( + "Input(Out@GRAD) shouldn't be null.")); auto xshape_dims = ctx->GetInputDim("XShape"); auto x_dims = framework::slice_ddim(xshape_dims, 1, xshape_dims.size()); ctx->SetOutputDim(framework::GradVarName("X"), x_dims); @@ -511,8 +519,8 @@ class Reshape2DoubleGradOp : public framework::OperatorWithKernel { void InferShape(framework::InferShapeContext *ctx) const override { PADDLE_ENFORCE_EQ(ctx->HasInput("DDX"), true, - "Input(X@GRAD_GRAD) shouldn't be null."); - + platform::errors::InvalidArgument( + "Input(X@GRAD_GRAD) shouldn't be null.")); if (ctx->HasOutput("DDOut") && ctx->HasInput("DDX")) { ctx->ShareDim("DOut", "DDOut"); } diff --git a/paddle/fluid/operators/reverse_op.cc b/paddle/fluid/operators/reverse_op.cc index 10122e0b4f9..1f018419747 100644 --- a/paddle/fluid/operators/reverse_op.cc +++ b/paddle/fluid/operators/reverse_op.cc @@ -24,20 +24,28 @@ class ReverseOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext* ctx) const override { - PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) should not be null"); - PADDLE_ENFORCE(ctx->HasOutput("Out"), "Output(Out) should not be null"); + PADDLE_ENFORCE_EQ( + ctx->HasInput("X"), true, + platform::errors::InvalidArgument("Input(X) should not be null")); + PADDLE_ENFORCE_EQ( + ctx->HasOutput("Out"), true, + platform::errors::InvalidArgument("Output(Out) should not be null")); const auto& x_dims = ctx->GetInputDim("X"); const auto& axis = ctx->Attrs().Get>("axis"); - PADDLE_ENFORCE(!axis.empty(), "'axis' can not be empty."); + PADDLE_ENFORCE_NE(axis.empty(), true, platform::errors::InvalidArgument( + "'axis' can not be empty.")); for (int a : axis) { PADDLE_ENFORCE_LT(a, x_dims.size(), paddle::platform::errors::OutOfRange( - "The axis must be less than input tensor's rank.")); + "The axis must be less than input tensor's rank. " + "but got %d >= %d", + a, x_dims.size())); PADDLE_ENFORCE_GE( a, -x_dims.size(), paddle::platform::errors::OutOfRange( "The axis must be greater than the negative number of " - "input tensor's rank.")); + "input tensor's rank, but got %d < %d", + a, -x_dims.size())); } ctx->SetOutputDim("Out", x_dims); } diff --git a/paddle/fluid/operators/reverse_op.h b/paddle/fluid/operators/reverse_op.h index c5535a6dc2d..24489e618db 100644 --- a/paddle/fluid/operators/reverse_op.h +++ b/paddle/fluid/operators/reverse_op.h @@ -80,9 +80,9 @@ class ReverseKernel : public framework::OpKernel { functor6(dev_ctx, *x, out, axis); break; default: - PADDLE_THROW( - "Reserve operator doesn't supports tensors whose ranks are greater " - "than 6."); + PADDLE_THROW(paddle::platform::errors::OutOfRange( + "The reserve operator does not support input tensors" + "whose ranks are greater than 6.")); } } }; diff --git a/paddle/fluid/operators/shape_op.cc b/paddle/fluid/operators/shape_op.cc index edc538c5056..62bffe63048 100644 --- a/paddle/fluid/operators/shape_op.cc +++ b/paddle/fluid/operators/shape_op.cc @@ -24,10 +24,12 @@ class ShapeOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext *ctx) const override { - PADDLE_ENFORCE(ctx->HasInput("Input"), - "Input (Input) of get_shape op should not be null."); - PADDLE_ENFORCE(ctx->HasOutput("Out"), - "Output (Out) of get_shape op should not be null."); + PADDLE_ENFORCE_EQ(ctx->HasInput("Input"), true, + platform::errors::InvalidArgument( + "Input (Input) of get_shape op should not be null.")); + PADDLE_ENFORCE_EQ(ctx->HasOutput("Out"), true, + platform::errors::InvalidArgument( + "Output (Out) of get_shape op should not be null.")); auto in_dim = ctx->GetInputDim("Input"); ctx->SetOutputDim("Out", {in_dim.size()}); } diff --git a/python/paddle/fluid/layers/nn.py b/python/paddle/fluid/layers/nn.py index 99694b97267..198c4f4e39e 100644 --- a/python/paddle/fluid/layers/nn.py +++ b/python/paddle/fluid/layers/nn.py @@ -12056,7 +12056,8 @@ def shape(input): res = exe.run(fluid.default_main_program(), feed={'x':img}, fetch_list=[output]) print(res) # [array([ 3, 100, 100], dtype=int32)] """ - + check_variable_and_dtype(input, 'input', + ['float32', 'float64', 'int32', 'int64'], 'shape') helper = LayerHelper('shape', **locals()) out = helper.create_variable_for_type_inference(dtype='int32') helper.append_op( diff --git a/python/paddle/fluid/layers/tensor.py b/python/paddle/fluid/layers/tensor.py index 49b5c0ebd26..cd93eca35ff 100644 --- a/python/paddle/fluid/layers/tensor.py +++ b/python/paddle/fluid/layers/tensor.py @@ -1108,6 +1108,9 @@ def reverse(x, axis): result1 = fluid.layers.reverse(data, 0) # [[6., 7., 8.], [3., 4., 5.], [0., 1., 2.]] result2 = fluid.layers.reverse(data, [0, 1]) # [[8., 7., 6.], [5., 4., 3.], [2., 1., 0.]] """ + check_variable_and_dtype( + x, 'x', ('float32', 'float64', 'int32', 'int64', 'uint8'), 'reverse') + check_type(axis, 'axis', (int, tuple, list), 'reverse') if isinstance(axis, int): axis = [axis] helper = LayerHelper("reverse", **locals()) @@ -1303,6 +1306,9 @@ def range(start, end, step, dtype): data = fluid.layers.range(0, 10, 2, 'int32') """ + check_type(start, 'start', (float, int, Variable), 'range') + check_type(end, 'end', (float, int, Variable), 'range') + check_type(step, 'step', (float, int, Variable), 'range') helper = LayerHelper("range", **locals()) check_dtype(dtype, 'create data type', diff --git a/python/paddle/fluid/tests/unittests/test_reverse_op.py b/python/paddle/fluid/tests/unittests/test_reverse_op.py index 80f05621320..21d15b05715 100644 --- a/python/paddle/fluid/tests/unittests/test_reverse_op.py +++ b/python/paddle/fluid/tests/unittests/test_reverse_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 core class TestReverseOp(OpTest): @@ -47,7 +49,7 @@ class TestCase0(TestReverseOp): self.axis = [1] -class TestCase0(TestReverseOp): +class TestCase0_neg(TestReverseOp): def initTestCase(self): self.x = np.random.random((3, 40)).astype('float64') self.axis = [-1] @@ -59,7 +61,7 @@ class TestCase1(TestReverseOp): self.axis = [0, 1] -class TestCase0(TestReverseOp): +class TestCase1_neg(TestReverseOp): def initTestCase(self): self.x = np.random.random((3, 40)).astype('float64') self.axis = [0, -1] @@ -71,7 +73,7 @@ class TestCase2(TestReverseOp): self.axis = [0, 2] -class TestCase2(TestReverseOp): +class TestCase2_neg(TestReverseOp): def initTestCase(self): self.x = np.random.random((3, 4, 10)).astype('float64') self.axis = [0, -2] @@ -83,11 +85,30 @@ class TestCase3(TestReverseOp): self.axis = [1, 2] -class TestCase3(TestReverseOp): +class TestCase3_neg(TestReverseOp): def initTestCase(self): self.x = np.random.random((3, 4, 10)).astype('float64') self.axis = [-1, -2] +class TestCase4(unittest.TestCase): + def test_error(self): + place = fluid.CPUPlace() + exe = fluid.Executor(place) + + train_program = fluid.Program() + startup_program = fluid.Program() + with fluid.program_guard(train_program, startup_program): + label = fluid.layers.data( + name="label", shape=[1, 1, 1, 1, 1, 1, 1, 1], dtype="int64") + rev = fluid.layers.reverse(label, axis=[-1, -2]) + + def _run_program(): + x = np.random.random(size=(10, 1, 1, 1, 1, 1, 1)).astype('int64') + exe.run(train_program, feed={"label": x}) + + self.assertRaises(core.EnforceNotMet, _run_program) + + if __name__ == '__main__': unittest.main() -- GitLab