【TensorRT】Solve the problem of absolute path environment dependency of trt_engine (#72278)

PolaKuma · web-flow · commit 72b5f9d1744e · 2025-04-29T13:28:39.000+08:00
* fix

* fix codestyle

* Update tensorrt_engine_instruction.cc

* fix codestyle

* fix codestyle

* Update tensorrt_engine_instruction.cc

* fix codestyle

* Update tensorrt_engine_instruction.cc

* update

* fix codestyle

* fix

* fix codestyle

* Update CMakeLists.txt

* fix codestyle

* delete test refit

* modify the name of flag

* fix codestyle
diff --git a/paddle/common/flags.cc b/paddle/common/flags.cc
@@ -790,6 +790,18 @@ PHI_DEFINE_EXPORTED_string(tracer_onednn_ops_off,
                            "",
                            "List of OneDNN operation types to be turned off");
 
+/**
+ * Performance related FLAG
+ * Name: engine_serialized_path
+ * Since Version: 2.0.0
+ * Value Range: string, default=./
+ * Example:
+ * Note: Path to directory where engine serialized files are stored.
+ */
+PHI_DEFINE_EXPORTED_string(trt_engine_serialized_path,
+                           "./",
+                           "Path to directory of engine serialized files");
+
 /**
  * Debug related FLAG
  * Name: check_kernel_launch
diff --git a/paddle/fluid/framework/new_executor/instruction/tensorrt_engine_instruction.cc b/paddle/fluid/framework/new_executor/instruction/tensorrt_engine_instruction.cc
@@ -12,8 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/fluid/framework/new_executor/instruction/tensorrt_engine_instruction.h"
+#include <filesystem>
+
 #include "paddle/fluid/framework/new_executor/instruction/instruction_util.h"
+#include "paddle/fluid/framework/new_executor/instruction/tensorrt_engine_instruction.h"
 #include "paddle/fluid/inference/analysis/helper.h"
 #include "paddle/fluid/pir/serialize_deserialize/include/interface.h"
 #include "paddle/fluid/platform/profiler/supplement_tracing.h"
@@ -23,6 +25,8 @@
 #include "paddle/phi/core/platform/profiler/event_tracing.h"
 #include "paddle/phi/kernels/funcs/data_type_transform.h"
 
+COMMON_DECLARE_string(trt_engine_serialized_path);
+
 namespace paddle {
 namespace framework {
 
@@ -202,7 +206,15 @@ TensorRTEngineInstruction::TensorRTEngineInstruction(
              "===============";
   trt_engine_ = std::make_unique<paddle::platform::TensorRTEngine>(
       params, paddle::platform::NaiveLogger::Global());
-  auto engine_data = ReadBinaryFileToString(engine_serialized_path);
+  std::string engine_data;
+  try {
+    engine_data = ReadBinaryFileToString(engine_serialized_path);
+  } catch (const std::exception &e) {
+    std::filesystem::path path(engine_serialized_path);
+    std::string filename = path.filename().string();
+    std::string file_root = FLAGS_trt_engine_serialized_path;
+    engine_data = ReadBinaryFileToString(file_root + '/' + filename);
+  }
   trt_engine_->Deserialize(engine_data);
 
   size_t len = refit_param_names_.size();
@@ -850,19 +862,18 @@ std::string TensorRTEngineInstruction::ReadBinaryFileToString(
     const std::string &filePath) {
   std::ifstream inputFile(filePath, std::ios::binary);
 
-  if (!inputFile) {
-    throw std::runtime_error("Failed to open file: " + filePath);
-  }
+  PADDLE_ENFORCE(inputFile.is_open(),
+                 common::errors::NotFound("Failed to open file: %s", filePath));
 
   inputFile.seekg(0, std::ios::end);
   std::streamsize fileSize = inputFile.tellg();
   inputFile.seekg(0, std::ios::beg);
 
   std::string fileContent(static_cast<size_t>(fileSize), '\0');
 
-  if (!inputFile.read(&fileContent[0], fileSize)) {
-    throw std::runtime_error("Failed to read file: " + filePath);
-  }
+  PADDLE_ENFORCE(inputFile.read(&fileContent[0], fileSize).good(),
+                 common::errors::InvalidArgument(
+                     "Failed to read content from file: %s", filePath));
 
   return fileContent;
 }
diff --git a/paddle/fluid/inference/api/analysis_predictor.cc b/paddle/fluid/inference/api/analysis_predictor.cc
@@ -2392,6 +2392,14 @@ CreatePaddlePredictor<AnalysisConfig, PaddleEngineKind::kAnalysis>(
         if (std::getenv("FLAGS_cache_inference_while_scope") == nullptr) {
           SetGflag("cache_inference_while_scope", "1");
         }
+        std::string model_path = config.prog_file();
+        if (!model_path.empty()) {
+          std::string model_dir = model_path.substr(0, model_path.rfind('.'));
+          SetGflag("trt_engine_serialized_path", model_dir.c_str());
+        } else if (!config.model_dir().empty()) {
+          std::string model_dir = config.model_dir();
+          SetGflag("trt_engine_serialized_path", model_dir.c_str());
+        }
       });
 
       if (config.thread_local_stream_enabled() &&
diff --git a/test/tensorrt/CMakeLists.txt b/test/tensorrt/CMakeLists.txt
@@ -11,6 +11,8 @@ if(NOT WIN32 AND TENSORRT_FOUND)
   set_tests_properties(test_converter_model_bert PROPERTIES TIMEOUT "500")
   set_tests_properties(test_converter_model_dummy PROPERTIES TIMEOUT "500")
   set_tests_properties(test_converter_model_resnet50 PROPERTIES TIMEOUT "500")
+  set_tests_properties(test_converter_model_resnet50_move PROPERTIES TIMEOUT
+                                                                     "500")
   set_tests_properties(test_converter_conv PROPERTIES TIMEOUT "300")
   set_tests_properties(test_export PROPERTIES TIMEOUT "500")
   set_tests_properties(test_converter_norm PROPERTIES TIMEOUT "300")
diff --git a/test/tensorrt/test_converter_model_resnet50_move.py b/test/tensorrt/test_converter_model_resnet50_move.py
@@ -0,0 +1,161 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import tempfile
+import unittest
+
+import numpy as np
+from get_program import (
+    get_r50_program,
+    get_r50_refit_program,
+)
+
+import paddle
+import paddle.inference as paddle_infer
+from paddle.tensorrt.export import (
+    Input,
+    TensorRTConfig,
+    convert_to_trt,
+)
+from paddle.tensorrt.util import (
+    predict_program,
+)
+
+
+def standardize(array):
+    mean_val = np.mean(array)
+    std_val = np.std(array)
+    standardized_array = (array - mean_val) / std_val
+    return standardized_array
+
+
+class TestConverterResNet50Move(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.path = os.path.join(self.temp_dir.name, 'pir-trt')
+
+    def test_paddle_to_tensorrt_conversion_r50(self):
+        # Step1: get program and init fake inputs
+        program, scope, param_dict = get_r50_program()
+
+        # Set input
+        input_config = Input(
+            min_input_shape=(1, 3, 224, 224),
+            optim_input_shape=(1, 3, 224, 224),
+            max_input_shape=(4, 3, 224, 224),
+            input_data_type='float32',
+            name='input',
+        )
+        _, input_optim_data, _ = input_config.generate_input_data()
+
+        # Create a TensorRTConfig with inputs as a required field.
+        trt_config = TensorRTConfig(inputs=[input_config])
+        trt_config.disable_passes = ['dead_code_elimination_pass']
+
+        output_var = program.list_vars()[-1]
+
+        # get original results(for tests only)
+
+        output_expected = predict_program(
+            program, {"input": input_optim_data}, [output_var]
+        )
+
+        program_with_trt = convert_to_trt(program, trt_config, scope)
+        output_var = program_with_trt.list_vars()[-1]
+
+        # Step6: run inference(converted_program)
+        output_converted = predict_program(
+            program_with_trt, {"input": input_optim_data}, [output_var]
+        )
+
+        output_expected = standardize(output_expected[0])
+        output_trt = standardize(output_converted[0])
+
+        # Check that the results are close to each other within a tolerance of 1e-3
+        np.testing.assert_allclose(
+            output_expected,
+            output_trt,
+            rtol=1e-3,
+            atol=1e-3,
+            err_msg="Outputs are not within the 1e-3 tolerance",
+        )
+
+    def test_engine_serialized_path_move(self):
+        paddle.enable_static()
+        save_path = os.path.join(self.temp_dir.name, 'resnet50')
+        program, scope, param_dict = get_r50_refit_program(save_path)
+
+        input_config = Input(
+            min_input_shape=(1, 3, 224, 224),
+            optim_input_shape=(1, 3, 224, 224),
+            max_input_shape=(4, 3, 224, 224),
+            input_data_type='float32',
+        )
+        _, input_optim_data, _ = input_config.generate_input_data()
+        trt_config = TensorRTConfig(inputs=[input_config])
+        output_var = program.list_vars()[-1]
+        output_expected = predict_program(
+            program, {"input": input_optim_data}, [output_var]
+        )
+
+        trt_save_path = os.path.join(self.temp_dir.name, 'resnet50trt')
+        trt_config.save_model_dir = trt_save_path
+        cache_path = trt_config.save_model_dir
+        model_dir = save_path
+
+        program_with_trt = paddle.tensorrt.convert(model_dir, trt_config)
+        config_json = cache_path + '.json'
+        params_file = cache_path + '.pdiparams'
+
+        import shutil
+
+        cache_path_new = '/root/.pp_trt_cache_test'
+        config_json_new = cache_path_new + '.json'
+        params_file_new = cache_path_new + '.pdiparams'
+
+        if os.path.exists(cache_path_new):
+            shutil.rmtree(cache_path_new)
+        shutil.copytree(cache_path, cache_path_new)
+        shutil.copy2(config_json, config_json_new)
+        shutil.rmtree(cache_path)
+
+        config = paddle_infer.Config(config_json_new, params_file_new)
+        config.switch_ir_debug(True)
+        if paddle.is_compiled_with_cuda():
+            config.enable_use_gpu(100, 0)
+        else:
+            config.disable_gpu()
+        predictor = paddle_infer.create_predictor(config)
+
+        paddle.disable_static()
+        for i, input_instrance in enumerate(trt_config.inputs):
+            min_data, _, max_data = input_instrance.generate_input_data()
+            model_inputs = paddle.to_tensor(min_data)
+            output_converted = predictor.run([model_inputs])
+
+        output_expected = standardize(output_expected[0])
+        output_trt = standardize(output_converted[0].numpy())
+
+        np.testing.assert_allclose(
+            output_expected,
+            output_trt,
+            rtol=1e-1,
+            atol=1e-1,
+            err_msg="Outputs are not within the 1e-1 tolerance",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
