fix inference prepare data bug

paddle/fluid/framework/operator.cc

@@ -1531,7 +1531,10 @@ Scope* OperatorWithKernel::PrepareData(
   // the rest iterations to save the elapsed time.
   // We do not support skipping PrepareData in while block, because the Op's
   // input may be changed by subsequent Ops, which may cause an error.
-  if (pre_scope_ == &scope && new_scope == nullptr) {
+
+  // For inference, ops that behind conditional branch aren't supported well,
+  // so disable prepare optimization conservatively.
+  if (pre_scope_ == &scope && new_scope == nullptr && !force_prepare_data_) {
     need_prepare_data_ = false;
   }
 

paddle/fluid/framework/operator.h

@@ -471,7 +471,10 @@ class OperatorWithKernel : public OperatorBase {
 
   OperatorWithKernel(const std::string& type, const VariableNameMap& inputs,
                      const VariableNameMap& outputs, const AttributeMap& attrs)
-      : OperatorBase(type, inputs, outputs, attrs) {}
+      : OperatorBase(type, inputs, outputs, attrs) {
+    force_prepare_data_ = HasAttr("inference_force_prepare") &&
+                          Attr<bool>("inference_force_prepare");
+  }
 
   static std::unordered_map<std::string /* op_type */, OpKernelMap>&
   AllOpKernels() {
@@ -572,6 +575,7 @@ class OperatorWithKernel : public OperatorBase {
   mutable std::unique_ptr<RuntimeContext> runtime_ctx_;
   mutable const Scope* pre_scope_ = nullptr;
   mutable bool need_prepare_data_ = true;
+  mutable bool force_prepare_data_ = false;
   mutable bool enable_cache_runtime_context_ = false;
   mutable bool all_kernels_must_compute_runtime_shape_ = false;
   mutable std::mutex cache_update_mutex_;

paddle/fluid/inference/api/analysis_predictor.cc

@@ -270,7 +270,47 @@ bool AnalysisPredictor::CreateExecutor() {
   executor_.reset(new paddle::framework::NaiveExecutor(place_));
   return true;
 }
+
+static bool Is_PrePareDate_Opt_Target_Op(framework::OpDesc *op) {
+  // here is prepare data optimization related bad cases:
+  // let's assume an op behind conditional_block and if conditional_block
+  // chooses branch 1, the op need to call prepare data. else the op don't need
+  // to
+  // to call prepare data. In running, if predictor chooses branch 2, then
+  // optimization
+  // takes effect, later issue is followed if predictor chooses branch 1,
+  // because
+  // the op lost chance to prepare data.
+  std::vector<std::string> op_type = {"conditional_block_infer",
+                                      "select_input"};
+  for (const auto &type : op_type) {
+    if (op->Type() == type) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static void Disable_PrePareDate_Opt(
+    std::shared_ptr<framework::ProgramDesc> inference_program, int block) {
+  bool disable_opt = false;
+  for (auto *op : inference_program->Block(block).AllOps()) {
+    if (disable_opt) {
+      op->SetAttr("inference_force_prepare", true);
+    }
+    if (op->HasAttr("sub_block")) {
+      int blockID = op->GetBlockAttrId("sub_block");
+      Disable_PrePareDate_Opt(inference_program, blockID);
+    }
+    if (Is_PrePareDate_Opt_Target_Op(op)) {
+      disable_opt = true;
+    }
+  }
+}
+
 bool AnalysisPredictor::PrepareExecutor() {
+  Disable_PrePareDate_Opt(inference_program_, 0);
+
   executor_->Prepare(sub_scope_, *inference_program_, 0,
                      config_.use_feed_fetch_ops_);