Merge pull request #16933 from phlrain/pick_many_infer_fix

Pick many infer fix

paddle/fluid/operators/attention_lstm_op.cc

@@ -64,13 +64,20 @@ void AttentionLSTMOp::InferShape(framework::InferShapeContext* ctx) const {
 
   auto c_dims = ctx->GetInputDim("C0");
   PADDLE_ENFORCE_EQ(c_dims.size(), 2, "Input(C0)'s rank must be 2.");
+  if (ctx->IsRuntime()) {
     PADDLE_ENFORCE_EQ(c_dims[1], D, "C0 dims should be N x %d.", D);
+  }
+
   if (ctx->HasInput("H0")) {
     auto h_dims = ctx->GetInputDim("H0");
+    PADDLE_ENFORCE_EQ(h_dims.size(), 2UL, "Input(H0)'s rank must be 2.");
+    if (ctx->IsRuntime() ||
+        (framework::product(c_dims) > 0 && framework::product(h_dims) > 0)) {
       PADDLE_ENFORCE(h_dims == c_dims,
                      "The dimension of Input(H0) and Input(C0) "
                      "should be the same.");
     }
+  }
 
   auto atten_w_dims = ctx->GetInputDim("AttentionWeight");
   PADDLE_ENFORCE_EQ(atten_w_dims.size(), 2,
@@ -79,6 +86,7 @@ void AttentionLSTMOp::InferShape(framework::InferShapeContext* ctx) const {
                     "AttentionWeight shapes must be (%d + %d) * 1.", M, D);
   PADDLE_ENFORCE_EQ(atten_w_dims[1], 1,
                     "AttentionWeight shapes must be (%d + %d) * 1.", M, D);
+
   if (ctx->HasInput("AttentionBias")) {
     auto atten_b_dims = ctx->GetInputDim("AttentionBias");
     PADDLE_ENFORCE_EQ(atten_b_dims.size(), 2,

paddle/fluid/operators/bpr_loss_op.cc

@@ -32,10 +32,14 @@ class BprLossOp : public framework::OperatorWithKernel {
     int rank = x_dims.size();
     PADDLE_ENFORCE_EQ(rank, label_dims.size(),
                       "Input(X) and Input(Label) shall have the same rank.");
+
+    if (ctx->IsRuntime() || (framework::product(x_dims) > 0 &&
+                             framework::product(label_dims) > 0)) {
       PADDLE_ENFORCE_EQ(framework::slice_ddim(x_dims, 0, rank - 1),
                         framework::slice_ddim(label_dims, 0, rank - 1),
                         "Input(X) and Input(Label) shall have the same shape "
                         "except the last dimension.");
+    }
 
     auto y_dims = x_dims;
     y_dims[rank - 1] = 1;

paddle/fluid/operators/conv_shift_op.cc

@@ -36,11 +36,14 @@ class ConvShiftOp : public framework::OperatorWithKernel {
     auto y_dims = ctx->GetInputDim("Y");
     PADDLE_ENFORCE_EQ(x_dims.size(), 2, "Input(X)'s rank should be 2.");
     PADDLE_ENFORCE_EQ(y_dims.size(), 2, "Input(Y)'s rank should be 2.");
+    if (ctx->IsRuntime() || (x_dims[0] > 0 && y_dims[0] > 0))
       PADDLE_ENFORCE_EQ(x_dims[0], y_dims[0],
                         "The 1st dimension of Input(X) and Input(Y) should "
                         "be equal.");
+    if (ctx->IsRuntime() || y_dims[1] > 0)
       PADDLE_ENFORCE_EQ(y_dims[1] % 2, 1,
                         "The 2nd dimension of Input(Y) should be odd.");
+    if (ctx->IsRuntime() || (x_dims[1] > 0 && y_dims[1] > 0))
       PADDLE_ENFORCE_LE(y_dims[1], x_dims[1],
                         "The 2nd dimension of Input(Y) should be less than or "
                         "equal to the 2nd dimension of Input(X).");

paddle/fluid/operators/merge_lod_tensor_op.cc

@@ -164,7 +164,9 @@ class MergeLoDTensorInferShape : public framework::InferShapeBase {
 
     auto mask_dim = context->GetInputDim("Mask");
     PADDLE_ENFORCE_EQ(mask_dim.size(), 2);
+    if (context->IsRuntime() || mask_dim[1] > 0) {
       PADDLE_ENFORCE_EQ(mask_dim[1], 1);
+    }
 
     context->SetOutputDim("Out", context->GetInputDim("InTrue"));
   }

paddle/fluid/operators/positive_negative_pair_op.cc

@@ -61,23 +61,31 @@ class PositiveNegativePairOp : public framework::OperatorWithKernel {
     auto query_dim = ctx->GetInputDim("QueryID");
     PADDLE_ENFORCE_EQ(score_dim.size(), 2, "Score should be a 2-D tensor.");
     PADDLE_ENFORCE_EQ(label_dim.size(), 2, "Label should be a 2-D tensor.");
+
+    if (ctx->IsRuntime() ||
+        (score_dim[0] > 0 && label_dim[0] > 0 && query_dim[0] > 0)) {
       PADDLE_ENFORCE_EQ(
           label_dim[0], score_dim[0],
           "Tensor Score and Label should have the same height (batch size).");
+
       PADDLE_ENFORCE_EQ(label_dim[1], 1,
                         "The width of Label should be 1, i.e. each item should "
                         "have a scalar label.");
+
       PADDLE_ENFORCE(query_dim == label_dim,
                      "QueryID should have the same shape as Label.");
+
       if (ctx->HasInput("Weight")) {
         PADDLE_ENFORCE(ctx->GetInputDim("Weight") == label_dim,
                        "Weight should have the same shape as Label.");
       }
+
       int column = ctx->Attrs().Get<int>("column");
       auto depth = score_dim[1];
       PADDLE_ENFORCE(column < depth && column >= -depth,
                      "Attribute column should be in the range of [-%l, %l)",
                      depth, depth);
+    }
 
     ctx->SetOutputDim("PositivePair", scalar_dim);
     ctx->SetOutputDim("NegativePair", scalar_dim);

paddle/fluid/operators/scatter_op.cc

@@ -42,10 +42,6 @@ class ScatterOp : public framework::OperatorWithKernel {
     PADDLE_ENFORCE_EQ(ctx->GetInputDim("Updates")[0],
                       ctx->GetInputDim("Ids")[0],
                       "Updates and Ids should have same batch-size.");
-    framework::DDim data_dim(updates_dims);
-    for (int i = 1; i < data_dim.size(); ++i) {
-      PADDLE_ENFORCE_EQ(data_dim[i], updates_dims[i]);
-    }
     ctx->SetOutputDim("Out", ref_dims);
   }
 

paddle/fluid/operators/split_lod_tensor_op.cc

@@ -157,7 +157,9 @@ class SplitLoDTensorInferShape : public framework::InferShapeBase {
 
     auto mask_dim = context->GetInputDim("Mask");
     PADDLE_ENFORCE_EQ(mask_dim.size(), 2);
+    if (context->IsRuntime()) {
       PADDLE_ENFORCE_EQ(mask_dim[1], 1);
+    }
 
     context->SetOutputDim("OutTrue", context->GetInputDim("X"));
     context->SetOutputDim("OutFalse", context->GetInputDim("X"));

paddle/fluid/operators/sum_op.cc

@@ -65,7 +65,21 @@ class SumOp : public framework::OperatorWithKernel {
       if (framework::product(in_dim) == 0) {
         in_dim = x_dim;
       } else {
-        PADDLE_ENFORCE_EQ(in_dim, x_dim, "Input tensors must have same shape");
+        if (ctx->IsRuntime()) {
+          PADDLE_ENFORCE_EQ(in_dim, x_dim,
+                            "Input tensors must have same shape");
+        } else {
+          PADDLE_ENFORCE_EQ(in_dim.size(), x_dim.size(),
+                            "Input tensors must have same shape size");
+          // if in_dim or x_dim has -1, not check equal
+          for (int i = 0; i < x_dim.size(); ++i) {
+            if (x_dim[i] == -1 || in_dim[i] == -1) {
+              continue;
+            }
+            PADDLE_ENFORCE_EQ(in_dim[i], x_dim[i],
+                              "Input tensors must have same shape if not -1");
+          }
+        }
       }
     }
     ctx->SetOutputDim("Out", in_dim);

paddle/fluid/operators/teacher_student_sigmoid_loss_op.cc

@@ -34,12 +34,14 @@ class TeacherStudentSigmoidLossOp : public framework::OperatorWithKernel {
     PADDLE_ENFORCE_EQ(x_dims.size(), 2UL, "Input(X)'s rank should be 2.");
     PADDLE_ENFORCE_EQ(label_dims.size(), 2UL,
                       "Input(Label)'s rank should be 2.");
+    if (ctx->IsRuntime()) {
       PADDLE_ENFORCE_EQ(x_dims[0], label_dims[0],
                         "The 1st dimension of Input(X) and Input(Label) should "
                         "be equal.");
       PADDLE_ENFORCE_EQ(label_dims[1], 1UL,
                         "The 2nd dimension of "
                         "Input(Label) should be 1.");
+    }
     ctx->SetOutputDim("Y", {x_dims[0], 1});
     ctx->ShareLoD("X", /*->*/ "Y");
   }
@@ -74,10 +76,12 @@ class TeacherStudentSigmoidLossGradientOp
     PADDLE_ENFORCE_EQ(x_dims.size(), 2, "Input(X)'s rank should be 2.");
     PADDLE_ENFORCE_EQ(dy_dims.size(), 2, "Input(Y@Grad)'s rank should be 2.");
     PADDLE_ENFORCE_EQ(label_dims.size(), 2, "Input(Label)'s rank should be 2.");
+    if (ctx->IsRuntime()) {
       PADDLE_ENFORCE_EQ(x_dims[0], label_dims[0],
                         "The 1st dimension of Input(X) and Input(Label) should "
                         "be equal.");
-    PADDLE_ENFORCE_EQ(x_dims[0], dy_dims[0],
+      PADDLE_ENFORCE_EQ(
+          x_dims[0], dy_dims[0],
           "The 1st dimension of Input(X) and Input(Y@Grad) should "
           "be equal.");
       PADDLE_ENFORCE_EQ(dy_dims[1], 1,
@@ -85,6 +89,7 @@ class TeacherStudentSigmoidLossGradientOp
       PADDLE_ENFORCE_EQ(label_dims[1], 1,
                         "When Attr(soft_label) == false, the 2nd dimension of "
                         "Input(Label) should be 1.");
+    }
     ctx->SetOutputDim(framework::GradVarName("X"), x_dims);
     ctx->ShareLoD("X", framework::GradVarName("X"));
   }