API/OP（sequence_first_step，sequence_last_step，sequence_mask，beam_search，beam_search_decode） error message enhancement ,test=release/1.8 (#24668)

Author: jinyuKING

paddle/fluid/operators/beam_search_decode_op.cc

@@ -128,14 +128,31 @@ class BeamSearchDecodeOp : public framework::OperatorBase {
     const LoDTensorArray* ids = ctx.Input<LoDTensorArray>("Ids");
     const LoDTensorArray* scores = ctx.Input<LoDTensorArray>("Scores");
     const size_t step_num = ids->size();
-    PADDLE_ENFORCE_GT(step_num, 0UL,
-                      "beam search steps should be larger than 0");
+    PADDLE_ENFORCE_GT(
+        step_num, 0UL,
+        platform::errors::InvalidArgument(
+            "beam search steps, which is the"
+            "size of Input(Ids) LoDTensorArray. beam search steps should "
+            "be larger than 0, but received %d. ",
+            step_num));
     const size_t source_num = ids->at(0).lod().at(0).size() - 1;
-    PADDLE_ENFORCE_GT(source_num, 0UL, "source num should be larger than 0");
+    PADDLE_ENFORCE_GT(
+        source_num, 0UL,
+        platform::errors::InvalidArgument(
+            "source_num is the sequence number of the"
+            "first decoding step, indicating by Input(Ids)[0].lod[0].size. "
+            "The number of source_num should be larger than"
+            "0, but received %d. ",
+            source_num));
 
     for (size_t i = 0; i < step_num; ++i) {
-      PADDLE_ENFORCE_EQ(ids->at(i).lod().size(), 2UL,
-                        "Level of LodTensor should be 2");
+      PADDLE_ENFORCE_EQ(
+          ids->at(i).lod().size(), 2UL,
+          platform::errors::InvalidArgument(
+              "For the i step in beam search steps,"
+              "the size of Input(Ids)[i].lod() should larger than 2,"
+              "but received %d. ",
+              ids->at(i).lod().size()));
     }
 
     size_t beam_size = ctx.Attr<int>("beam_size");
@@ -190,14 +207,14 @@ hypothesis has.
 class BeamSearchDecodeInferShape : public framework::InferShapeBase {
  public:
   void operator()(framework::InferShapeContext* context) const override {
-    PADDLE_ENFORCE(context->HasInput("Ids"),
-                   "BeamSearchDecodeOp must have input Ids");
-    PADDLE_ENFORCE(context->HasInput("Scores"),
-                   "BeamSearchDecodeOp must have input Scores");
-    PADDLE_ENFORCE(context->HasOutput("SentenceIds"),
-                   "BeamSearchDecodeOp must have output SentenceIds");
-    PADDLE_ENFORCE(context->HasOutput("SentenceScores"),
-                   "BeamSearchDecodeOp must have output SentenceScores");
+    OP_INOUT_CHECK(context->HasInput("Ids"), "Input", "Ids",
+                   "BeamSearchDecode");
+    OP_INOUT_CHECK(context->HasInput("Scores"), "Input", "Scores",
+                   "BeamSearchDecode");
+    OP_INOUT_CHECK(context->HasOutput("SentenceIds"), "Output", "SentenceIds",
+                   "BeamSearchDecode");
+    OP_INOUT_CHECK(context->HasOutput("SentenceScores"), "Output",
+                   "SentenceScores", "BeamSearchDecode");
   }
 };
 

paddle/fluid/operators/beam_search_decode_op.h

@@ -15,6 +15,7 @@ limitations under the License. */
 #pragma once
 
 #include <algorithm>
+#include <memory>
 #include <vector>
 
 #include "paddle/fluid/framework/lod_tensor_array.h"
@@ -82,7 +83,15 @@ void BeamSearchDecoder<T>::ConvertSentenceVectorToLodTensor(
     LoDTensor* score_tensor, bool reverse, bool sort_by_score) const {
   size_t src_num = sentence_vector_list.size();
 
-  PADDLE_ENFORCE_NE(src_num, 0, "src_num should not be 0");
+  PADDLE_ENFORCE_NE(
+      src_num, 0,
+      platform::errors::InvalidArgument(
+          "src_num is the sequence number of the first decoding step"
+          ", indicating by Input(Ids)[0].lod[0].size."
+          "src_num has wrong value."
+          "src_num should not be 0,"
+          "But received %d.",
+          src_num));
 
   std::vector<size_t> source_level_lod = {0};
   std::vector<size_t> sentence_level_lod = {0};
@@ -144,9 +153,16 @@ void BeamSearchDecoder<T>::Backtrace(const LoDTensorArray& step_ids,
                                      const LoDTensorArray& step_scores,
                                      LoDTensor* id_tensor,
                                      LoDTensor* score_tensor) const {
-  PADDLE_ENFORCE(!step_ids.empty(), "step num should be larger than 0");
-  PADDLE_ENFORCE_EQ(step_ids.size(), step_scores.size(),
-                    "step_ids and step_scores should be the same");
+  PADDLE_ENFORCE_NE(
+      step_ids.empty(), true,
+      platform::errors::InvalidArgument("Input(Ids) should not be empty."
+                                        "But the Input(Ids) is empty."));
+  PADDLE_ENFORCE_EQ(
+      step_ids.size(), step_scores.size(),
+      platform::errors::InvalidArgument(
+          "The size of Input(Ids) and Input(Scores) should be "
+          "the same. But the size of Input(Ids) and Input(Scores) "
+          "are not equal."));
   const size_t step_num = step_ids.size();
   const size_t src_num = step_ids.at(0).lod().at(kSourceLevel).size() - 1;
   std::vector<SentenceVector<T>> sentence_vector_list(

paddle/fluid/operators/beam_search_decode_op_test.cc

@@ -35,10 +35,17 @@ void GenerateExample(const std::vector<size_t>& level_0,
                      const std::vector<int>& data, LoDTensorArray* ids,
                      LoDTensorArray* scores) {
   PADDLE_ENFORCE_EQ(level_0.back(), level_1.size() - 1,
-                    "source level is used to describe candidate set");
+                    platform::errors::InvalidArgument(
+                        "source level is used to describe candidate set"
+                        ", so it's element should less than levle_1 length. "
+                        "And the value of source"
+                        "level is %d. ",
+                        level_1.size() - 1));
   PADDLE_ENFORCE_EQ(level_1.back(), data.size(),
-                    "the lowest level is used to describe data"
-                    ", so it's last element should be data length");
+                    platform::errors::InvalidArgument(
+                        "the lowest level is used to describe data"
+                        ", so it's last element should be data length %d. ",
+                        data.size()));
 
   CPUPlace place;
 

paddle/fluid/operators/beam_search_op.cc

@@ -89,13 +89,11 @@ class BeamSearchOp : public framework::OperatorWithKernel {
   void InferShape(framework::InferShapeContext *ctx) const override {
     for (const std::string &arg :
          std::vector<std::string>({"pre_ids", "scores"})) {
-      PADDLE_ENFORCE(ctx->HasInput(arg), "BeamSearch need input argument '%s'",
-                     arg);
+      OP_INOUT_CHECK(ctx->HasInput(arg), "Input", arg, "BeamSeach");
     }
     for (const std::string &arg :
          std::vector<std::string>({"selected_ids", "selected_scores"})) {
-      PADDLE_ENFORCE(ctx->HasOutput(arg),
-                     "BeamSearch need output argument '%s'", arg);
+      OP_INOUT_CHECK(ctx->HasOutput(arg), "Output", arg, "BeamSeach");
     }
   }
 

paddle/fluid/operators/beam_search_op.h

@@ -29,9 +29,15 @@ class BeamSearchOpKernel : public framework::OpKernel<T> {
     auto* pre_ids = context.Input<framework::LoDTensor>("pre_ids");
     auto* pre_scores = context.Input<framework::LoDTensor>("pre_scores");
 
-    PADDLE_ENFORCE_NOT_NULL(scores);
-    PADDLE_ENFORCE_NOT_NULL(pre_ids);
-    PADDLE_ENFORCE_NOT_NULL(pre_scores);
+    PADDLE_ENFORCE_NOT_NULL(scores,
+                            platform::errors::NotFound(
+                                "Input(scores) of BeamSearchOp is not found."));
+    PADDLE_ENFORCE_NOT_NULL(
+        pre_ids, platform::errors::NotFound(
+                     "Input(pre_ids) of BeamSearchOp is not found."));
+    PADDLE_ENFORCE_NOT_NULL(
+        pre_scores, platform::errors::NotFound(
+                        "Input(pre_scores) of BeamSearchOp is not found."));
 
     size_t level = context.Attr<int>("level");
     size_t beam_size = context.Attr<int>("beam_size");
@@ -42,8 +48,14 @@ class BeamSearchOpKernel : public framework::OpKernel<T> {
     auto selected_scores =
         context.Output<framework::LoDTensor>("selected_scores");
     auto* parent_idx = context.Output<framework::Tensor>("parent_idx");
-    PADDLE_ENFORCE_NOT_NULL(selected_ids);
-    PADDLE_ENFORCE_NOT_NULL(selected_scores);
+    PADDLE_ENFORCE_NOT_NULL(
+        selected_ids,
+        platform::errors::NotFound(
+            "Output(selected_scores) of BeamSearchOp is not found."));
+    PADDLE_ENFORCE_NOT_NULL(
+        selected_scores,
+        platform::errors::NotFound(
+            "Output(parent_idx) of BeamSearchOp is not found."));
 
     math::BeamSearchFunctor<DeviceContext, T> alg;
     alg(context.template device_context<DeviceContext>(), pre_ids, pre_scores,

paddle/fluid/operators/sequence_ops/sequence_mask_op.cc

@@ -23,8 +23,8 @@ class SequenceMaskOp : public framework::OperatorWithKernel {
   using framework::OperatorWithKernel::OperatorWithKernel;
 
   void InferShape(framework::InferShapeContext* ctx) const override {
-    PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) must exist");
-    PADDLE_ENFORCE(ctx->HasOutput("Y"), "Output(Y) must exist");
+    OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "SequenceMask");
+    OP_INOUT_CHECK(ctx->HasOutput("Y"), "Output", "Y", "SequenceMask");
 
     int maxlen = ctx->Attrs().Get<int>("maxlen");
     auto dim = framework::vectorize<int>(ctx->GetInputDim("X"));

paddle/fluid/operators/sequence_ops/sequence_mask_op.h

@@ -80,7 +80,10 @@ class SequenceMaskKernel : public framework::OpKernel<Tx> {
     int maxlen = ctx.Attr<int>("maxlen");
     if (ctx.HasInput("MaxLenTensor")) {
       auto max_len_tensor = ctx.Input<Tensor>("MaxLenTensor");
-      PADDLE_ENFORCE(max_len_tensor != NULL, "MaxLenTensor is NULL");
+      PADDLE_ENFORCE_NOT_NULL(max_len_tensor,
+                              platform::errors::InvalidArgument(
+                                  "Input(MaxLenTensor) should not be NULL."
+                                  "But received Input(MaxLenTensor) is NULL"));
       if (platform::is_gpu_place(max_len_tensor->place())) {
         framework::Tensor temp;
         TensorCopySync(*max_len_tensor, platform::CPUPlace(), &temp);
@@ -93,8 +96,12 @@ class SequenceMaskKernel : public framework::OpKernel<Tx> {
       y_dim.push_back(maxlen);
       y->Resize(framework::make_ddim(y_dim));
 
-      PADDLE_ENFORCE_GT(maxlen, 0,
-                        "MaxLenTensor value should be greater than 0");
+      PADDLE_ENFORCE_GT(
+          maxlen, 0,
+          platform::errors::InvalidArgument(
+              "Input(MaxLenTensor) value should be greater than 0. But "
+              "received Input(MaxLenTensor) value = %d.",
+              maxlen));
     }
 
     auto *x_data = x->data<Tx>();

python/paddle/fluid/layers/rnn.py

@@ -57,6 +57,7 @@
 
 class RNNCell(object):
     """
+
     RNNCell is the base class for abstraction representing the calculations
     mapping the input and state to the output and new state. It is suitable to
     and mostly used in RNN.
@@ -221,6 +222,7 @@ def state_dtype(self):
 
 class GRUCell(RNNCell):
     """
+
     Gated Recurrent Unit cell. It is a wrapper for 
     `fluid.contrib.layers.rnn_impl.BasicGRUUnit` to make it adapt to RNNCell.
 
@@ -317,6 +319,7 @@ def state_shape(self):
 
 class LSTMCell(RNNCell):
     """
+
     Long-Short Term Memory cell. It is a wrapper for 
     `fluid.contrib.layers.rnn_impl.BasicLSTMUnit` to make it adapt to RNNCell.
 
@@ -431,6 +434,7 @@ def rnn(cell,
         is_reverse=False,
         **kwargs):
     """
+
     rnn creates a recurrent neural network specified by RNNCell `cell`,
     which performs :code:`cell.call()` repeatedly until reaches to the maximum
     length of `inputs`.
@@ -575,6 +579,7 @@ def _switch_grad(x, stop=False):
 
 class Decoder(object):
     """
+
     Decoder is the base class for any decoder instance used in `dynamic_decode`.
     It provides interface for output generation for one time step, which can be
     used to generate sequences. 
@@ -664,6 +669,7 @@ def finalize(self, outputs, final_states, sequence_lengths):
 
 class BeamSearchDecoder(Decoder):
     """
+
     Decoder with beam search decoding strategy. It wraps a cell to get probabilities,
     and follows a beam search step to calculate scores and select candidate
     token ids for each decoding step.
@@ -1127,6 +1133,7 @@ def dynamic_decode(decoder,
                    return_length=False,
                    **kwargs):
     """
+
     Dynamic decoding performs :code:`decoder.step()` repeatedly until the returned
     Tensor indicating finished status contains all True values or the number of
     decoding step reaches to :attr:`max_step_num`.
@@ -1941,6 +1948,7 @@ def dynamic_lstm(input,
                  dtype='float32',
                  name=None):
     """
+
     **Note**:
         1. This OP only supports LoDTensor as inputs. If you need to deal with Tensor, please use :ref:`api_fluid_layers_lstm` .
         2. In order to improve efficiency, users must first map the input of dimension [T, hidden_size] to input of [T, 4 * hidden_size], and then pass it to this OP.
@@ -2111,6 +2119,7 @@ def lstm(input,
          default_initializer=None,
          seed=-1):
     """
+
     **Note**:
         This OP only supports running on GPU devices.
 
@@ -2296,6 +2305,7 @@ def dynamic_lstmp(input,
                   cell_clip=None,
                   proj_clip=None):
     """
+
     **Note**:
         1. In order to improve efficiency, users must first map the input of dimension [T, hidden_size] to input of [T, 4 * hidden_size], and then pass it to this OP.
 
@@ -2505,6 +2515,7 @@ def dynamic_gru(input,
                 h_0=None,
                 origin_mode=False):
     """
+
     **Note: The input type of this must be LoDTensor. If the input type to be
     processed is Tensor, use** :ref:`api_fluid_layers_StaticRNN` .
 
@@ -2665,6 +2676,7 @@ def gru_unit(input,
              gate_activation='sigmoid',
              origin_mode=False):
     """
+
     Gated Recurrent Unit (GRU) RNN cell. This operator performs GRU calculations for
     one time step and it supports these two modes:
 
@@ -2821,6 +2833,7 @@ def beam_search(pre_ids,
                 name=None,
                 return_parent_idx=False):
     """
+
     Beam search is a classical algorithm for selecting candidate words in a
     machine translation task.
 
@@ -2922,6 +2935,12 @@ def beam_search(pre_ids,
                 beam_size=beam_size,
                 end_id=end_id)
     """
+    check_variable_and_dtype(pre_ids, 'pre_ids', ['int64'], 'beam_search')
+    check_variable_and_dtype(pre_scores, 'pre_scores', ['float32', 'float64'],
+                             'beam_search')
+    check_type(ids, 'ids', (Variable, type(None)), 'beam_search')
+    check_variable_and_dtype(scores, 'scores', ['float32', 'float64'],
+                             'beam_search')
     helper = LayerHelper('beam_search', **locals())
     score_type = pre_scores.dtype
     id_type = pre_ids.dtype
@@ -2962,6 +2981,7 @@ def beam_search(pre_ids,
 
 def beam_search_decode(ids, scores, beam_size, end_id, name=None):
     """
+
     This operator is used after beam search has completed. It constructs the
     full predicted sequences for each sample by walking back along the search
     paths stored in lod of ``ids`` . The result sequences are stored in a
@@ -3015,6 +3035,9 @@ def beam_search_decode(ids, scores, beam_size, end_id, name=None):
             finished_ids, finished_scores = fluid.layers.beam_search_decode(
                 ids, scores, beam_size=5, end_id=0)
     """
+    check_variable_and_dtype(ids, 'ids', ['int64'], 'beam_search_encode')
+    check_variable_and_dtype(scores, 'scores', ['float32'],
+                             'beam_search_encode')
     helper = LayerHelper('beam_search_decode', **locals())
     sentence_ids = helper.create_variable_for_type_inference(dtype=ids.dtype)
     sentence_scores = helper.create_variable_for_type_inference(dtype=ids.dtype)
@@ -3041,6 +3064,7 @@ def lstm_unit(x_t,
               bias_attr=None,
               name=None):
     """
+
     Long-Short Term Memory (LSTM) RNN cell. This operator performs LSTM calculations for
     one time step, whose implementation is based on calculations described in `RECURRENT
     NEURAL NETWORK REGULARIZATION <http://arxiv.org/abs/1409.2329>`_  .