fix error log, test=develop (#24419)

* fix error log: resahpe, range, reverse.

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});
   }

paddle/fluid/operators/range_op.h

@@ -22,11 +22,21 @@ namespace operators {
 
 template <typename T>
 void GetSize(T start, T end, T step, int64_t* size) {
-  PADDLE_ENFORCE(!std::equal_to<T>()(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<T>::value
               ? ((std::abs(end - start) + std::abs(step) - 1) / std::abs(step))
               : std::ceil(std::abs((end - start) / step));

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<int64_t> 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");
     }

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<std::vector<int>>("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);
   }

paddle/fluid/operators/reverse_op.h

@@ -80,9 +80,9 @@ class ReverseKernel : public framework::OpKernel<T> {
         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."));
     }
   }
 };

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()});
   }

python/paddle/fluid/layers/nn.py

@@ -10798,7 +10798,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(

python/paddle/fluid/layers/tensor.py

@@ -1081,6 +1081,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())
@@ -1276,6 +1279,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',

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()