【pir_save_load】modify test_Static_save_load and test_paddle_save_load (#65359)

xiaoguoguo626807 · yuanlehome · web-flow · commit 55e6ab0577a1 · 2024-06-22T10:25:21.000+08:00
* add new test

* add new test

* nouse

* add predictor(pir) delete pass api

* add delete pass

* recover reset test

* modify delete pass

* modify static_save_load

* add test_build_strategy

---------

Co-authored-by: yuanlehome &lt;yuanlehome@163.com&gt;
diff --git a/paddle/fluid/inference/api/analysis_config.cc b/paddle/fluid/inference/api/analysis_config.cc
@@ -583,6 +583,7 @@ AnalysisConfig::AnalysisConfig(const AnalysisConfig &other) {
   CP_MEMBER(custom_pass_only_);
   CP_MEMBER(pm_opt_level_);
   CP_MEMBER(ir_debug_passes_);
+  CP_MEMBER(deleted_passes_);
 
   if (use_gpu_) {
     PADDLE_ENFORCE_EQ(use_xpu_,
@@ -1570,6 +1571,10 @@ void AnalysisConfig::EnableCustomPasses(const std::vector<std::string> &passes,
   custom_pass_only_ = custom_pass_only;
 }
 
+void AnalysisConfig::DeletePass(const std::vector<std::string> &passes) {
+  deleted_passes_ = passes;
+}
+
 void AnalysisConfig::SetOptimizationLevel(int opt_level) {
   pm_opt_level_ = opt_level;
 }
diff --git a/paddle/fluid/inference/api/analysis_predictor.cc b/paddle/fluid/inference/api/analysis_predictor.cc
@@ -849,7 +849,11 @@ void AnalysisPredictor::OptimizeInferencePirProgram() {
       // gpu
       if (!config_.custom_pass_only_) {
         for (const auto &gpu_pass : kPirGpuPasses) {
-          pass_pm.AddPass(pir::PassRegistry::Instance().Get(gpu_pass));
+          if (std::find(config_.deleted_passes_.begin(),
+                        config_.deleted_passes_.end(),
+                        gpu_pass) == config_.deleted_passes_.end()) {
+            pass_pm.AddPass(pir::PassRegistry::Instance().Get(gpu_pass));
+          }
         }
       }
 
@@ -858,8 +862,12 @@ void AnalysisPredictor::OptimizeInferencePirProgram() {
       // xpu
       if (!config_.custom_pass_only_) {
         for (const auto &xpu_pass : kPirXpuPasses) {
-          pass_pm.AddPass(
-              std::move(pir::PassRegistry::Instance().Get(xpu_pass)));
+          if (std::find(config_.deleted_passes_.begin(),
+                        config_.deleted_passes_.end(),
+                        xpu_pass) == config_.deleted_passes_.end()) {
+            pass_pm.AddPass(
+                std::move(pir::PassRegistry::Instance().Get(xpu_pass)));
+          }
         }
       }
 #endif
@@ -869,15 +877,23 @@ void AnalysisPredictor::OptimizeInferencePirProgram() {
       // mkldnn
       if (!config_.custom_pass_only_) {
         for (const auto &mkldnn_pass : kPirMkldnnPasses) {
-          pass_pm.AddPass(pir::PassRegistry::Instance().Get(mkldnn_pass));
+          if (std::find(config_.deleted_passes_.begin(),
+                        config_.deleted_passes_.end(),
+                        mkldnn_pass) == config_.deleted_passes_.end()) {
+            pass_pm.AddPass(pir::PassRegistry::Instance().Get(mkldnn_pass));
+          }
         }
       }
 #endif
     } else {
       // cpu
       if (!config_.custom_pass_only_) {
         for (const auto &cpu_pass : kPirCpuPasses) {
-          pass_pm.AddPass(pir::PassRegistry::Instance().Get(cpu_pass));
+          if (std::find(config_.deleted_passes_.begin(),
+                        config_.deleted_passes_.end(),
+                        cpu_pass) == config_.deleted_passes_.end()) {
+            pass_pm.AddPass(pir::PassRegistry::Instance().Get(cpu_pass));
+          }
         }
       }
     }
@@ -915,21 +931,43 @@ void AnalysisPredictor::OptimizeInferencePirProgram() {
   // Apply some basic passes required by the framework
   ::pir::PassManager basic_pass_pm(::pir::IrContext::Instance(),
                                    config_.pm_opt_level_);
-  basic_pass_pm.AddPass(::pir::CreateCommonSubexpressionEliminationPass());
+  auto common_subexpression_elimination_pass =
+      ::pir::CreateCommonSubexpressionEliminationPass();
+  if (std::find(config_.deleted_passes_.begin(),
+                config_.deleted_passes_.end(),
+                common_subexpression_elimination_pass->name()) ==
+      config_.deleted_passes_.end()) {
+    basic_pass_pm.AddPass(std::move(common_subexpression_elimination_pass));
+  }
   auto params_sync_among_devices_pass =
       ::pir::CreateParamsSyncAmongDevicesPass();
-  params_sync_among_devices_pass->SetNotOwned(pir::Pass::kPlaceAttr, &place_);
-  params_sync_among_devices_pass->SetNotOwned(pir::Pass::kParamScopeAttr,
-                                              sub_scope_);
-  basic_pass_pm.AddPass(std::move(params_sync_among_devices_pass));
+  if (std::find(config_.deleted_passes_.begin(),
+                config_.deleted_passes_.end(),
+                params_sync_among_devices_pass->name()) ==
+      config_.deleted_passes_.end()) {
+    params_sync_among_devices_pass->SetNotOwned(pir::Pass::kPlaceAttr, &place_);
+    params_sync_among_devices_pass->SetNotOwned(pir::Pass::kParamScopeAttr,
+                                                sub_scope_);
+    basic_pass_pm.AddPass(std::move(params_sync_among_devices_pass));
+  }
   auto constant_folding_pass = ::pir::CreateConstantFoldingPass();
-  constant_folding_pass->SetNotOwned(pir::Pass::kPlaceAttr, &place_);
-  constant_folding_pass->SetNotOwned(pir::Pass::kParamScopeAttr, sub_scope_);
-  basic_pass_pm.AddPass(std::move(constant_folding_pass));
+  if (std::find(config_.deleted_passes_.begin(),
+                config_.deleted_passes_.end(),
+                constant_folding_pass->name()) ==
+      config_.deleted_passes_.end()) {
+    constant_folding_pass->SetNotOwned(pir::Pass::kPlaceAttr, &place_);
+    constant_folding_pass->SetNotOwned(pir::Pass::kParamScopeAttr, sub_scope_);
+    basic_pass_pm.AddPass(std::move(constant_folding_pass));
+  }
   auto dead_code_elimination_pass = ::pir::CreateDeadCodeEliminationPass();
-  dead_code_elimination_pass->SetNotOwned(pir::Pass::kParamScopeAttr,
-                                          sub_scope_);
-  basic_pass_pm.AddPass(std::move(dead_code_elimination_pass));
+  if (std::find(config_.deleted_passes_.begin(),
+                config_.deleted_passes_.end(),
+                dead_code_elimination_pass->name()) ==
+      config_.deleted_passes_.end()) {
+    dead_code_elimination_pass->SetNotOwned(pir::Pass::kParamScopeAttr,
+                                            sub_scope_);
+    basic_pass_pm.AddPass(std::move(dead_code_elimination_pass));
+  }
   basic_pass_pm.AddPass(::pir::CreateReplaceFetchWithShadowOutputPass());
   if (!config_.glog_info_disabled()) {
     basic_pass_pm.EnablePrintStatistics();
@@ -1221,6 +1259,7 @@ bool AnalysisPredictor::PrepareExecutor() {
     execution_config.skip_gc_vars.insert(output_names.begin(),
                                          output_names.end());
 
+    VLOG(1) << "predictor program " << *pir_program_;
     if (config_.new_ir_enabled()) {
       executor_->PrepareInterpreterCore(
           sub_scope_, *pir_program_, execution_config);
diff --git a/paddle/fluid/inference/api/paddle_analysis_config.h b/paddle/fluid/inference/api/paddle_analysis_config.h
@@ -1188,6 +1188,8 @@ struct PD_INFER_DECL AnalysisConfig {
   void EnableCustomPasses(const std::vector<std::string>& passes,
                           bool custom_pass_only = false);
 
+  void DeletePass(const std::vector<std::string>& passes);
+
   ///
   /// \brief Set pir Optimization level.
   /// \param opt_level The optimization level
@@ -1419,6 +1421,7 @@ struct PD_INFER_DECL AnalysisConfig {
   bool custom_pass_only_{false};
   int pm_opt_level_{2};
   std::vector<std::string> ir_debug_passes_;
+  std::vector<std::string> deleted_passes_;
 };
 
 }  // namespace paddle
diff --git a/paddle/fluid/pybind/inference_api.cc b/paddle/fluid/pybind/inference_api.cc
@@ -1032,6 +1032,7 @@ void BindAnalysisConfig(py::module *m) {
            [](AnalysisConfig &self, const std::string &pass) {
              self.pass_builder()->DeletePass(pass);
            })
+      .def("delete_pass", &AnalysisConfig::DeletePass)
       .def(
           "pass_builder",
           [](AnalysisConfig &self) {
diff --git a/python/paddle/static/io.py b/python/paddle/static/io.py
@@ -1527,9 +1527,6 @@ def load(program, model_path, executor=None, var_list=None):
             >>> static.save(prog, "./temp")
             >>> static.load(prog, "./temp")
     """
-    if in_pir_mode():
-        return load_pir(program, model_path, executor, var_list)
-
     assert executor is None or isinstance(executor, Executor)
 
     model_prefix = model_path
@@ -1539,6 +1536,11 @@ def load(program, model_path, executor=None, var_list=None):
         model_prefix = model_prefix[:-6]
     elif model_prefix.endswith(".pdmodel"):
         model_prefix = model_prefix[:-8]
+    elif model_prefix.endswith(".json"):
+        model_prefix = model_prefix[:-5]
+
+    if in_pir_mode():
+        return load_pir(program, model_prefix, executor, var_list)
 
     parameter_file_name = model_prefix + ".pdparams"
 
diff --git a/python/paddle/static/pir_io.py b/python/paddle/static/pir_io.py
@@ -635,7 +635,7 @@ def get_tensor(var):
 
 
 @static_only
-def load_pir(program, model_path, executor=None, var_list=None):
+def load_pir(program, model_prefix, executor=None, var_list=None):
     """
     :api_attr: PIR Static Graph
 
@@ -648,7 +648,7 @@ def load_pir(program, model_path, executor=None, var_list=None):
 
     Args:
         program(Program): The program to be loaded
-        model_path(str): The file prefix to store the program
+        model_prefix(str): The file prefix to store the program
         executor(Executor, optional): The executor used for initializing the parameter
                                       when startup program is not run.
         var_list(list|tuple, optional): The Tensor list/tuple to load a single model file saved with
@@ -661,14 +661,6 @@ def load_pir(program, model_path, executor=None, var_list=None):
 
     assert executor is None or isinstance(executor, Executor)
 
-    model_prefix = model_path
-    if model_prefix.endswith(".pdparams"):
-        model_prefix = model_prefix[:-9]
-    elif model_prefix.endswith(".pdopt"):
-        model_prefix = model_prefix[:-6]
-    elif model_prefix.endswith(".json"):
-        model_prefix = model_prefix[:-5]
-
     parameter_file_name = model_prefix + ".pdparams"
 
     # TODO(chenzhiyang):if not os.path.exists(parameter_file_name): load_vars
diff --git a/test/dygraph_to_static/predictor_utils.py b/test/dygraph_to_static/predictor_utils.py
@@ -63,6 +63,8 @@ def _load_model_and_set_config(self):
         if use_pir_api():
             config.enable_new_ir()
             config.enable_new_executor()
+            if os.name == 'nt':
+                config.delete_pass(["conv2d_bn_fuse_pass"])
 
         return config
 
diff --git a/test/dygraph_to_static/test_build_strategy.py b/test/dygraph_to_static/test_build_strategy.py
@@ -24,7 +24,6 @@
 from test_resnet import ResNetHelper
 
 import paddle
-from paddle.framework import use_pir_api
 
 
 class TestResnetWithPass(Dy2StTestBase):
@@ -59,14 +58,13 @@ def verify_predict(self):
             rtol=1e-05,
             err_msg=f'dy_jit_pre:\n {dy_jit_pre}\n, st_pre: \n{st_pre}.',
         )
-        if not use_pir_api():
-            predictor_pre = self.resnet_helper.predict_analysis_inference(image)
-            np.testing.assert_allclose(
-                predictor_pre,
-                st_pre,
-                rtol=1e-05,
-                err_msg=f'predictor_pre:\n {predictor_pre}\n, st_pre: \n{st_pre}.',
-            )
+        predictor_pre = self.resnet_helper.predict_analysis_inference(image)
+        np.testing.assert_allclose(
+            predictor_pre,
+            st_pre,
+            rtol=1e-05,
+            err_msg=f'predictor_pre:\n {predictor_pre}\n, st_pre: \n{st_pre}.',
+        )
 
     @test_default_and_pir
     def test_resnet(self):
diff --git a/test/dygraph_to_static/test_mobile_net.py b/test/dygraph_to_static/test_mobile_net.py
@@ -664,8 +664,12 @@ def predict_dygraph_jit(args, data):
 
 
 def predict_analysis_inference(args, data):
+    if use_pir_api():
+        model_filename = args.pir_model_filename
+    else:
+        model_filename = args.model_filename
     output = PredictorTools(
-        args.model_save_dir, args.model_filename, args.params_filename, [data]
+        args.model_save_dir, model_filename, args.params_filename, [data]
     )
     (out,) = output()
     return out
@@ -734,15 +738,16 @@ def assert_same_predict(self, model_name):
             rtol=1e-05,
             err_msg=f'dy_jit_pre:\n {dy_jit_pre}\n, st_pre: \n{st_pre}.',
         )
-        if not use_pir_api():
-            predictor_pre = predict_analysis_inference(self.args, image)
-            np.testing.assert_allclose(
-                predictor_pre,
-                st_pre,
-                rtol=1e-05,
-                atol=1e-05,
-                err_msg=f'inference_pred_res:\n {predictor_pre}\n, st_pre: \n{st_pre}.',
-            )
+        if os.name == "nt" and use_pir_api():
+            return
+        predictor_pre = predict_analysis_inference(self.args, image)
+        np.testing.assert_allclose(
+            predictor_pre,
+            st_pre,
+            rtol=1e-05,
+            atol=1e-05,
+            err_msg=f'inference_pred_res:\n {predictor_pre}\n, st_pre: \n{st_pre}.',
+        )
 
     @test_legacy_and_pir
     def test_mobile_net_v1(self):
diff --git a/test/dygraph_to_static/test_resnet.py b/test/dygraph_to_static/test_resnet.py
@@ -407,9 +407,13 @@ def predict_dygraph_jit(self, data):
         return ret
 
     def predict_analysis_inference(self, data):
+        if use_pir_api():
+            model_filename = self.pir_model_filename
+        else:
+            model_filename = self.model_filename
         output = PredictorTools(
             self.model_save_dir,
-            self.model_filename,
+            model_filename,
             self.params_filename,
             [data],
         )
@@ -430,6 +434,7 @@ def verify_predict(self):
         dy_pre = self.resnet_helper.predict_dygraph(image)
         st_pre = self.resnet_helper.predict_static(image)
         dy_jit_pre = self.resnet_helper.predict_dygraph_jit(image)
+        predictor_pre = self.resnet_helper.predict_analysis_inference(image)
         np.testing.assert_allclose(
             dy_pre,
             st_pre,
@@ -442,14 +447,12 @@ def verify_predict(self):
             rtol=1e-05,
             err_msg=f'dy_jit_pre:\n {dy_jit_pre}\n, st_pre: \n{st_pre}.',
         )
-        if not use_pir_api():
-            predictor_pre = self.resnet_helper.predict_analysis_inference(image)
-            np.testing.assert_allclose(
-                predictor_pre,
-                st_pre,
-                rtol=1e-05,
-                err_msg=f'predictor_pre:\n {predictor_pre}\n, st_pre: \n{st_pre}.',
-            )
+        np.testing.assert_allclose(
+            predictor_pre,
+            st_pre,
+            rtol=1e-05,
+            err_msg=f'predictor_pre:\n {predictor_pre}\n, st_pre: \n{st_pre}.',
+        )
 
     @test_default_and_pir
     def test_resnet(self):
diff --git a/test/dygraph_to_static/test_se_resnet.py b/test/dygraph_to_static/test_se_resnet.py
@@ -539,13 +539,17 @@ def predict_dygraph_jit(self, data):
             return pred_res.numpy()
 
     def predict_analysis_inference(self, data):
+        if use_pir_api():
+            model_filename = self.pir_model_filename
+        else:
+            model_filename = self.model_filename
         output = PredictorTools(
             self.model_save_dir,
-            self.model_filename,
+            model_filename,
             self.params_filename,
             [data],
         )
-        out = output()
+        (out,) = output()
         return out
 
     def verify_predict(self):
@@ -567,18 +571,17 @@ def verify_predict(self):
             err_msg=f'dy_jit_pre:\n {dy_jit_pre}\n, st_pre: \n{st_pre}.',
         )
 
-        if not use_pir_api():
-            predictor_pre = self.predict_analysis_inference(image)
-            flat_st_pre = st_pre.flatten()
-            flat_predictor_pre = np.array(predictor_pre).flatten()
-            for i in range(len(flat_predictor_pre)):
-                # modify precision to 1e-6, avoid unittest failed
-                self.assertAlmostEqual(
-                    flat_predictor_pre[i],
-                    flat_st_pre[i],
-                    delta=1e-6,
-                    msg=f"predictor_pre:\n {flat_predictor_pre[i]}\n, st_pre: \n{flat_st_pre[i]}.",
-                )
+        predictor_pre = self.predict_analysis_inference(image)
+        flat_st_pre = st_pre.flatten()
+        flat_predictor_pre = np.array(predictor_pre).flatten()
+        for i in range(len(flat_predictor_pre)):
+            # modify precision to 1e-6, avoid unittest failed
+            self.assertAlmostEqual(
+                flat_predictor_pre[i],
+                flat_st_pre[i],
+                delta=1e-5,
+                msg=f"predictor_pre:\n {flat_predictor_pre[i]}\n, st_pre: \n{flat_st_pre[i]}.",
+            )
 
     @test_default_and_pir
     def test_check_result(self):
