【Hackathon 6th Fundable Projects 3 No.106】dlnne_engine 2 (#65598)

co63oc · web-flow · commit 3ad33de3083a · 2024-07-02T11:02:41.000+08:00
diff --git a/paddle/fluid/inference/analysis/argument.h b/paddle/fluid/inference/analysis/argument.h
@@ -302,25 +302,6 @@ struct Argument {
                       TensorRtOpsRunFloat,
                       std::unordered_set<std::string>);
 
-  DECL_ARGUMENT_FIELD(use_dlnne, UseDlnne, bool);
-  DECL_ARGUMENT_FIELD(dlnne_min_subgraph_size, DlnneMinSubgraphSize, int);
-  DECL_ARGUMENT_FIELD(dlnne_max_batch_size, DlnneMaxBatchSize, int);
-  DECL_ARGUMENT_FIELD(dlnne_use_static_batch, DlnneUseStaticBatch, bool);
-  DECL_ARGUMENT_FIELD(dlnne_weight_share_mode,
-                      DlnneWeightShareMode,
-                      std::string);
-  DECL_ARGUMENT_FIELD(dlnne_disable_nodes_by_outputs,
-                      DlnneDisableNodesByOutputs,
-                      std::unordered_set<std::string>);
-  DECL_ARGUMENT_FIELD(dlnne_use_calib_mode, DlnneUseCalibMode, bool);
-  DECL_ARGUMENT_FIELD(dlnne_precision_mode, DlnnePrecisionMode, int);
-
-  using dlnne_input_shape_type = std::map<std::string, std::vector<int64_t>>;
-  DECL_ARGUMENT_FIELD(dlnne_input_shape_dict,
-                      DlnneInputShapeDict,
-                      dlnne_input_shape_type);
-  DECL_ARGUMENT_FIELD(dlnne_workspace_size, DlnneWorkspaceSize, int);
-
   DECL_ARGUMENT_FIELD(use_xpu, UseXpu, bool);
   DECL_ARGUMENT_FIELD(xpu_locked, XpuLocked, bool);
   DECL_ARGUMENT_FIELD(xpu_precision, XpuPrecision, std::string);
diff --git a/paddle/fluid/inference/api/analysis_config.cc b/paddle/fluid/inference/api/analysis_config.cc
@@ -45,7 +45,6 @@ namespace paddle {
 struct MkldnnQuantizerConfig;
 
 extern const std::vector<std::string> kTRTSubgraphPasses;
-extern const std::vector<std::string> kDlnneSubgraphPasses;
 
 AnalysisConfig::AnalysisConfig() {
   // NOTE(liuyuanle): Why put the following code here?
@@ -496,16 +495,6 @@ AnalysisConfig::AnalysisConfig(const AnalysisConfig &other) {
   CP_MEMBER(trt_optimization_level_);
   CP_MEMBER(trt_ops_run_float_);
   CP_MEMBER(trt_exclude_var_names_);
-  // Dlnne related
-  CP_MEMBER(use_dlnne_);
-  CP_MEMBER(dlnne_min_subgraph_size_);
-  CP_MEMBER(dlnne_max_batchsize_);
-  CP_MEMBER(dlnne_use_static_batch_);
-  CP_MEMBER(dlnne_weight_share_mode_);
-  CP_MEMBER(dlnne_use_calib_mode_);
-  CP_MEMBER(dlnne_precision_mode_);
-  CP_MEMBER(dlnne_disable_nodes_by_outputs_);
-  CP_MEMBER(dlnne_input_shape_dict_);
   // OneDNN related.
   CP_MEMBER(use_mkldnn_);
   CP_MEMBER(mkldnn_enabled_op_types_);
@@ -619,23 +608,6 @@ AnalysisConfig::AnalysisConfig(const AnalysisConfig &other) {
       pass_builder_->AppendPass(pass);
     }
   }
-  if (use_dlnne_) {
-    auto all_passes = kDlnneSubgraphPasses;
-    auto other_passes = other.pass_builder()->AllPasses();
-    // We should sort them, because the user may call the SwitchIrDebug
-    // interface, which will change the pass.
-    std::sort(all_passes.begin(), all_passes.end());
-    std::sort(other_passes.begin(), other_passes.end());
-    std::vector<std::string> deleted_passes;
-    std::set_difference(all_passes.begin(),
-                        all_passes.end(),
-                        other_passes.begin(),
-                        other_passes.end(),
-                        std::inserter(deleted_passes, deleted_passes.begin()));
-    for (auto const &ps : deleted_passes) {
-      pass_builder_->DeletePass(ps);
-    }
-  }
 
   for (auto &delete_pass : other.pass_builder()->GetAllDeletedPasses()) {
     pass_builder_->DeletePass(delete_pass);
@@ -822,27 +794,6 @@ void AnalysisConfig::EnableLowPrecisionIO(bool x) {
   enable_low_precision_io_ = x;
 }
 
-void AnalysisConfig::EnableDlnne(
-    int min_subgraph_size,
-    int max_batch_size,
-    bool use_static_batch,
-    std::string weight_share_mode,
-    std::unordered_set<std::string> disable_nodes_by_outputs,
-    std::map<std::string, std::vector<int64_t>> dlnne_input_shape_dict,
-    bool use_calib_mode,
-    Precision precision_mode) {
-  use_dlnne_ = true;
-  dlnne_min_subgraph_size_ = min_subgraph_size;
-  dlnne_max_batchsize_ = max_batch_size;
-  dlnne_use_static_batch_ = use_static_batch;
-  dlnne_weight_share_mode_ = weight_share_mode;
-  dlnne_disable_nodes_by_outputs_ = disable_nodes_by_outputs;
-  dlnne_input_shape_dict_ = dlnne_input_shape_dict;
-  dlnne_use_calib_mode_ = use_calib_mode;
-  dlnne_precision_mode_ = precision_mode;
-  Update();
-}
-
 void AnalysisConfig::SetTRTDynamicShapeInfo(
     std::map<std::string, std::vector<int>> min_input_shape,
     std::map<std::string, std::vector<int>> max_input_shape,
@@ -1022,13 +973,6 @@ void AnalysisConfig::Update() {
     }
   }
 
-  if (use_dlnne_) {
-    pass_builder()->ClearPasses();
-    for (const auto &pass : kDlnneSubgraphPasses) {
-      pass_builder()->AppendPass(pass);
-    }
-  }
-
   if (use_gpu() && use_cudnn_) {
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
     if (!enable_ir_optim_) {
@@ -1149,9 +1093,6 @@ std::string AnalysisConfig::SerializeInfoCache() {
   ss << ";";
   ss << trt_forbid_dynamic_op_;
 
-  ss << use_dlnne_;
-  ss << dlnne_min_subgraph_size_;
-
   for (auto &op : trt_disabled_ops_) ss << op.c_str();
   ss << ";";
 
diff --git a/paddle/fluid/inference/api/analysis_predictor.cc b/paddle/fluid/inference/api/analysis_predictor.cc
@@ -2061,21 +2061,6 @@ void AnalysisPredictor::PrepareArgument() {
     argument_->SetTensorRtOpsRunFloat(config_.trt_ops_run_float_);
   }
 
-  if (config_.dlnne_enabled()) {
-    LOG(INFO) << "Dlnne subgraph is enabled";
-    argument_->SetUseDlnne(true);
-    argument_->SetDlnneMinSubgraphSize(config_.dlnne_min_subgraph_size_);
-    argument_->SetDlnneMaxBatchSize(config_.dlnne_max_batchsize_);
-    argument_->SetDlnneUseStaticBatch(config_.dlnne_use_static_batch_);
-    argument_->SetDlnneWeightShareMode(config_.dlnne_weight_share_mode_);
-    argument_->SetDlnneDisableNodesByOutputs(
-        config_.dlnne_disable_nodes_by_outputs_);
-    argument_->SetDlnneInputShapeDict(config_.dlnne_input_shape_dict_);
-    argument_->SetDlnneUseCalibMode(config_.dlnne_use_calib_mode_);
-    argument_->SetDlnnePrecisionMode(static_cast<int>(
-        paddle::ConvertPrecision(config_.dlnne_precision_mode_)));
-  }
-
   argument_->SetUseXpu(config_.use_xpu_);
 
 #ifdef PADDLE_WITH_IPU
diff --git a/paddle/fluid/inference/api/paddle_analysis_config.h b/paddle/fluid/inference/api/paddle_analysis_config.h
@@ -889,18 +889,6 @@ struct PD_INFER_DECL AnalysisConfig {
   ///
   void UseOptimizedModel(bool x = true) { use_optimized_model_ = x; }
 
-  void EnableDlnne(
-      int min_subgraph_size = 3,
-      int max_batch_size = 1,
-      bool use_static_batch = false,
-      std::string weight_share_mode = "0",
-      std::unordered_set<std::string> disable_nodes_by_outputs = {},
-      std::map<std::string, std::vector<int64_t>> input_dict = {},
-      bool use_calib_mode = false,
-      Precision precision_mode = Precision::kFloat32);
-
-  bool dlnne_enabled() const { return use_dlnne_; }
-
   ///
   /// \brief Control whether to debug IR graph analysis phase.
   /// This will generate DOT files for visualizing the computation graph after
@@ -1300,17 +1288,6 @@ struct PD_INFER_DECL AnalysisConfig {
   bool collect_shape_range_info_{false};
   std::string shape_range_info_path_;
 
-  // dlnne related.
-  bool use_dlnne_{false};
-  int dlnne_min_subgraph_size_{3};
-  int dlnne_max_batchsize_{1};
-  std::unordered_set<std::string> dlnne_disable_nodes_by_outputs_;
-  bool dlnne_use_static_batch_{true};
-  std::string dlnne_weight_share_mode_;
-  std::map<std::string, std::vector<int64_t>> dlnne_input_shape_dict_{};
-  bool dlnne_use_calib_mode_{false};
-  Precision dlnne_precision_mode_{Precision::kFloat32};
-
   // memory reuse related.
   bool enable_memory_optim_{false};
   bool trt_engine_memory_sharing_{true};
diff --git a/paddle/fluid/inference/api/paddle_pass_builder.cc b/paddle/fluid/inference/api/paddle_pass_builder.cc
@@ -163,15 +163,6 @@ const std::vector<std::string> kTRTSubgraphPasses({
       "auto_mixed_precision_pass",
 });
 
-const std::vector<std::string> kDlnneSubgraphPasses({
-    "is_test_pass",                  //
-    "delete_dropout_op_pass",        //
-    "simplify_with_basic_ops_pass",  //
-    "conv_bn_fuse_pass",             //
-    "depthwise_conv_bn_fuse_pass",   //
-    "shuffle_channel_detect_pass",   //
-});
-
 // TODO(inference): Most of the existing pass fusion operators do not
 // support fp16/bf16 precision, temporarily use low precision pass to prevent
 // running errors. After fusion operator supports low precision, delete this.
diff --git a/paddle/fluid/inference/api/paddle_pass_builder.h b/paddle/fluid/inference/api/paddle_pass_builder.h
@@ -338,9 +338,6 @@ class PD_INFER_DECL IpuPassStrategy final : public PassStrategy {
 /// \brief List of tensorRT subgraph passes.
 PD_INFER_DECL extern const std::vector<std::string> kTRTSubgraphPasses;
 
-/// \brief List of dlnne subgraph passes.
-PD_INFER_DECL extern const std::vector<std::string> kDlnneSubgraphPasses;
-
 /// \brief List of cinn compiler passes.
 PD_INFER_DECL extern const std::vector<std::string> kCINNCompilerPasses;
 
diff --git a/paddle/fluid/inference/capi/pd_config.cc b/paddle/fluid/inference/capi/pd_config.cc
@@ -269,38 +269,6 @@ bool PD_TensorrtEngineEnabled(const PD_AnalysisConfig* config) {
   return config->config.tensorrt_engine_enabled();
 }
 
-void PD_EnableDlnne(
-    PD_AnalysisConfig* config,
-    int min_subgraph_size,
-    int max_batch_size,
-    bool use_static_batch,
-    std::string weight_share_mode,
-    std::unordered_set<std::string> disable_nodes_by_outputs,
-    std::map<std::string, std::vector<int64_t>> dlnne_input_shape_dict,
-    bool use_calib_mode,
-    PD_ACPrecision precision_mode) {
-  PADDLE_ENFORCE_NOT_NULL(
-      config,
-      paddle::platform::errors::InvalidArgument(
-          "The pointer of analysis configuration shouldn't be nullptr"));
-  config->config.EnableDlnne(min_subgraph_size,
-                             max_batch_size,
-                             use_static_batch,
-                             weight_share_mode,
-                             disable_nodes_by_outputs,
-                             dlnne_input_shape_dict,
-                             use_calib_mode,
-                             precision_mode);
-}
-
-bool PD_DlnneEnabled(const PD_AnalysisConfig* config) {
-  PADDLE_ENFORCE_NOT_NULL(
-      config,
-      paddle::platform::errors::InvalidArgument(
-          "The pointer of analysis configuration shouldn't be nullptr"));
-  return config->config.dlnne_enabled();
-}
-
 void PD_SwitchIrDebug(PD_AnalysisConfig* config, bool x) {
   PADDLE_ENFORCE_NOT_NULL(
       config,
diff --git a/paddle/fluid/pybind/inference_api.cc b/paddle/fluid/pybind/inference_api.cc
@@ -968,18 +968,6 @@ void BindAnalysisConfig(py::module *m) {
            &AnalysisConfig::SetTensorRtOptimizationLevel)
       .def("tensorrt_optimization_level",
            &AnalysisConfig::tensorrt_optimization_level)
-      .def("enable_dlnne",
-           &AnalysisConfig::EnableDlnne,
-           py::arg("min_subgraph_size") = 3,
-           py::arg("max_batch_size") = 1,
-           py::arg("use_static_batch") = false,
-           py::arg("weight_share_mode") = "0",
-           py::arg("disable_nodes_by_outputs") =
-               std::unordered_set<std::string>(),
-           py::arg("input_shape_dict") =
-               std::map<std::string, std::vector<int64_t>>(),
-           py::arg("use_calib_mode") = false,
-           py::arg("precision_mode") = AnalysisConfig::Precision::kFloat32)
       .def("switch_ir_debug",
            &AnalysisConfig::SwitchIrDebug,
            py::arg("x") = true,
