refine and reuse code

paddle/fluid/inference/tests/api/CMakeLists.txt

@@ -68,6 +68,6 @@ if (NOT EXISTS ${OCR_INSTALL_DIR} AND WITH_INFERENCE)
     message(STATUS "finish downloading ${filename}")
 endif()
 inference_analysis_test(test_analyzer_ocr SRCS analyzer_vis_tester.cc
-    EXTRA_DEPS paddle_inference_api paddle_fluid_api ir_pass_manager analysis_predictor
+    EXTRA_DEPS ${INFERENCE_EXTRA_DEPS}
     ARGS --infer_model=${OCR_INSTALL_DIR}/model
         --infer_data=${OCR_INSTALL_DIR}/data.txt)

paddle/fluid/inference/tests/api/analyzer_vis_tester.cc

@@ -12,22 +12,9 @@ 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. */
 
-#include "paddle/fluid/inference/analysis/analyzer.h"
-#include <gflags/gflags.h>
-#include <glog/logging.h>
-#include <gtest/gtest.h>
 #include <fstream>
 #include <iostream>
-#include "paddle/fluid/framework/ir/fuse_pass_base.h"
+#include "paddle/fluid/inference/tests/api/tester_helper.h"
-#include "paddle/fluid/inference/analysis/ut_helper.h"
-#include "paddle/fluid/inference/api/analysis_predictor.h"
-#include "paddle/fluid/inference/api/helper.h"
-#include "paddle/fluid/inference/api/paddle_inference_pass.h"
-
-DEFINE_string(infer_model, "", "model path for LAC");
-DEFINE_string(infer_data, "", "data file for LAC");
-DEFINE_int32(batch_size, 1, "batch size.");
-DEFINE_int32(repeat, 1, "Running the inference program repeat times.");
 
 namespace paddle {
 namespace inference {
@@ -105,69 +92,36 @@ void TestVisualPrediction(bool use_mkldnn) {
   VLOG(3) << "output.size " << outputs_slots.size();
 
   // run native as reference
-  NativeConfig config;
-  config.param_file = FLAGS_infer_model + "/__params__";
-  config.prog_file = FLAGS_infer_model + "/__model__";
-  config.use_gpu = false;
-  config.device = 0;
-  // config.specify_input_name = true;
   auto ref_predictor =
-      CreatePaddlePredictor<NativeConfig, PaddleEngineKind::kNative>(config);
+      CreatePaddlePredictor<NativeConfig, PaddleEngineKind::kNative>(cfg);
   std::vector<PaddleTensor> ref_outputs_slots;
   ref_predictor->Run({input}, &ref_outputs_slots);
-  EXPECT_EQ(ref_outputs_slots.size(), outputs_slots.size());
+  CompareResult(outputs_slots, ref_outputs_slots);
-  for (size_t i = 0; i < outputs_slots.size(); ++i) {
+  // print what are fused
-    auto &ref_out = ref_outputs_slots[i];
+  AnalysisPredictor *analysis_predictor =
-    auto &out = outputs_slots[i];
+      dynamic_cast<AnalysisPredictor *>(predictor.get());
-    size_t ref_size =
+  auto &fuse_statis = analysis_predictor->analysis_argument()
-        std::accumulate(ref_out.shape.begin(), ref_out.shape.end(), 1,
+                          .Get<std::unordered_map<std::string, int>>(
-                        [](int a, int b) { return a * b; });
+                              framework::ir::kFuseStatisAttr);
-    size_t size = std::accumulate(out.shape.begin(), out.shape.end(), 1,
+  for (auto &item : fuse_statis) {
-                                  [](int a, int b) { return a * b; });
+    LOG(INFO) << "fused " << item.first << " " << item.second;
-    EXPECT_EQ(size, ref_size);
+  }
-    EXPECT_EQ(out.dtype, ref_out.dtype);
+  int num_ops = 0;
-    switch (out.dtype) {
+  for (auto &node :
-      case PaddleDType::INT64: {
+       analysis_predictor->analysis_argument().main_dfg->nodes.nodes()) {
-        int64_t *pdata = static_cast<int64_t *>(out.data.data());
+    if (node->IsFunction()) {
-        int64_t *pdata_ref = static_cast<int64_t *>(ref_out.data.data());
+      ++num_ops;
-        for (size_t j = 0; j < size; ++j) {
-          EXPECT_EQ(pdata_ref[j], pdata[j]);
-        }
-        break;
-      }
-      case PaddleDType::FLOAT32: {
-        float *pdata = static_cast<float *>(out.data.data());
-        float *pdata_ref = static_cast<float *>(ref_out.data.data());
-        for (size_t j = 0; j < size; ++j) {
-          EXPECT_NEAR(pdata_ref[j], pdata[j], 1e-3);
-        }
-        break;
-      }
-    }
-    // print what are fused
-    AnalysisPredictor *analysis_predictor =
-        dynamic_cast<AnalysisPredictor *>(predictor.get());
-    auto &fuse_statis = analysis_predictor->analysis_argument()
-                            .Get<std::unordered_map<std::string, int>>(
-                                framework::ir::kFuseStatisAttr);
-    for (auto &item : fuse_statis) {
-      LOG(INFO) << "fused " << item.first << " " << item.second;
-    }
-    int num_ops = 0;
-    for (auto &node :
-         analysis_predictor->analysis_argument().main_dfg->nodes.nodes()) {
-      if (node->IsFunction()) {
-        ++num_ops;
-      }
     }
-    LOG(INFO) << "has num ops: " << num_ops;
   }
+  LOG(INFO) << "has num ops: " << num_ops;
 }
 
 TEST(Analyzer_vis, analysis) { TestVisualPrediction(/*use_mkldnn*/ false); }
+#ifdef PADDLE_WITH_MKLDNN
 TEST(Analyzer_vis, analysis_mkldnn) {
   TestVisualPrediction(/*use_mkldnn*/ true);
 }
+#endif
 
 }  // namespace analysis
 }  // namespace inference

paddle/fluid/inference/tests/api/tester_helper.h

@@ -37,22 +37,37 @@ namespace paddle {
 namespace inference {
 
 void CompareResult(const std::vector<PaddleTensor> &outputs,
-                   const std::vector<PaddleTensor> &base_outputs) {
+                   const std::vector<PaddleTensor> &ref_outputs) {
-  PADDLE_ENFORCE_GT(outputs.size(), 0);
+  EXPECT_GT(outputs.size(), 0);
-  PADDLE_ENFORCE_EQ(outputs.size(), base_outputs.size());
+  EXPECT_EQ(outputs.size(), ref_outputs.size());
   for (size_t i = 0; i < outputs.size(); i++) {
     auto &out = outputs[i];
-    auto &base_out = base_outputs[i];
+    auto &ref_out = ref_outputs[i];
     size_t size = std::accumulate(out.shape.begin(), out.shape.end(), 1,
                                   [](int a, int b) { return a * b; });
-    size_t size1 = std::accumulate(base_out.shape.begin(), base_out.shape.end(),
+    size_t ref_size =
-                                   1, [](int a, int b) { return a * b; });
+        std::accumulate(ref_out.shape.begin(), ref_out.shape.end(), 1,
-    PADDLE_ENFORCE_EQ(size, size1);
+                        [](int a, int b) { return a * b; });
-    PADDLE_ENFORCE_GT(size, 0);
+    EXPECT_GT(size, 0);
-    float *data = static_cast<float *>(out.data.data());
+    EXPECT_EQ(size, ref_size);
-    float *base_data = static_cast<float *>(base_out.data.data());
+    EXPECT_EQ(out.dtype, ref_out.dtype);
-    for (size_t i = 0; i < size; i++) {
+    switch (out.dtype) {
-      EXPECT_NEAR(data[i], base_data[i], 1e-3);
+      case PaddleDType::INT64: {
+        int64_t *pdata = static_cast<int64_t *>(out.data.data());
+        int64_t *pdata_ref = static_cast<int64_t *>(ref_out.data.data());
+        for (size_t j = 0; j < size; ++j) {
+          EXPECT_EQ(pdata_ref[j], pdata[j]);
+        }
+        break;
+      }
+      case PaddleDType::FLOAT32: {
+        float *pdata = static_cast<float *>(out.data.data());
+        float *pdata_ref = static_cast<float *>(ref_out.data.data());
+        for (size_t j = 0; j < size; ++j) {
+          EXPECT_NEAR(pdata_ref[j], pdata[j], 1e-3);
+        }
+        break;
+      }
     }
   }
 }