test_helper.h 9.8 KB
Newer Older
1
/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
2 3 4 5 6 7 8 9 10 11 12 13

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

    http://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. */
14 15 16 17 18 19
#pragma once

#include <map>
#include <random>
#include <string>
#include <vector>
20

X
Xin Pan 已提交
21
#include "paddle/fluid/framework/ir/graph_to_program_pass.h"
Y
Yi Wang 已提交
22 23
#include "paddle/fluid/framework/lod_tensor.h"
#include "paddle/fluid/inference/io.h"
24
#include "paddle/fluid/platform/profiler.h"
25

26 27
DECLARE_bool(use_mkldnn);

28
template <typename T>
29
void SetupTensor(paddle::framework::LoDTensor* input,
30
                 paddle::framework::DDim dims, T lower, T upper) {
31 32
  static unsigned int seed = 100;
  std::mt19937 rng(seed++);
33 34 35 36 37
  std::uniform_real_distribution<double> uniform_dist(0, 1);

  T* input_ptr = input->mutable_data<T>(dims, paddle::platform::CPUPlace());
  for (int i = 0; i < input->numel(); ++i) {
    input_ptr[i] = static_cast<T>(uniform_dist(rng) * (upper - lower) + lower);
38 39 40
  }
}

41
template <typename T>
42 43
void SetupTensor(paddle::framework::LoDTensor* input,
                 paddle::framework::DDim dims, const std::vector<T>& data) {
44
  CHECK_EQ(paddle::framework::product(dims), static_cast<int64_t>(data.size()));
45 46
  T* input_ptr = input->mutable_data<T>(dims, paddle::platform::CPUPlace());
  memcpy(input_ptr, data.data(), input->numel() * sizeof(T));
47 48
}

49
template <typename T>
50 51 52
void SetupLoDTensor(paddle::framework::LoDTensor* input,
                    const paddle::framework::LoD& lod, T lower, T upper) {
  input->set_lod(lod);
53
  int dim = lod[0][lod[0].size() - 1];
54 55 56 57
  SetupTensor<T>(input, {dim, 1}, lower, upper);
}

template <typename T>
58
void SetupLoDTensor(paddle::framework::LoDTensor* input,
59
                    paddle::framework::DDim dims,
60 61
                    const paddle::framework::LoD lod,
                    const std::vector<T>& data) {
62
  const size_t level = lod.size() - 1;
63
  CHECK_EQ(dims[0], static_cast<int64_t>((lod[level]).back()));
64
  input->set_lod(lod);
65
  SetupTensor<T>(input, dims, data);
66 67 68
}

template <typename T>
69 70
void CheckError(const paddle::framework::LoDTensor& output1,
                const paddle::framework::LoDTensor& output2) {
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
  // Check lod information
  EXPECT_EQ(output1.lod(), output2.lod());

  EXPECT_EQ(output1.dims(), output2.dims());
  EXPECT_EQ(output1.numel(), output2.numel());

  T err = static_cast<T>(0);
  if (typeid(T) == typeid(float)) {
    err = 1E-3;
  } else if (typeid(T) == typeid(double)) {
    err = 1E-6;
  } else {
    err = 0;
  }

  size_t count = 0;
  for (int64_t i = 0; i < output1.numel(); ++i) {
    if (fabs(output1.data<T>()[i] - output2.data<T>()[i]) > err) {
      count++;
    }
  }
92
  EXPECT_EQ(count, 0U) << "There are " << count << " different elements.";
93 94
}

95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
std::unique_ptr<paddle::framework::ProgramDesc> InitProgram(
    paddle::framework::Executor* executor, paddle::framework::Scope* scope,
    const std::string& dirname, const bool is_combined = false) {
  std::unique_ptr<paddle::framework::ProgramDesc> inference_program;
  if (is_combined) {
    // All parameters are saved in a single file.
    // Hard-coding the file names of program and parameters in unittest.
    // The file names should be consistent with that used in Python API
    //  `fluid.io.save_inference_model`.
    std::string prog_filename = "__model_combined__";
    std::string param_filename = "__params_combined__";
    inference_program =
        paddle::inference::Load(executor, scope, dirname + "/" + prog_filename,
                                dirname + "/" + param_filename);
  } else {
    // Parameters are saved in separate files sited in the specified
    // `dirname`.
    inference_program = paddle::inference::Load(executor, scope, dirname);
  }
  return inference_program;
}

std::vector<std::vector<int64_t>> GetFeedTargetShapes(
    const std::string& dirname, const bool is_combined = false) {
  auto place = paddle::platform::CPUPlace();
  auto executor = paddle::framework::Executor(place);
  auto* scope = new paddle::framework::Scope();

  auto inference_program = InitProgram(&executor, scope, dirname, is_combined);
  auto& global_block = inference_program->Block(0);

  const std::vector<std::string>& feed_target_names =
      inference_program->GetFeedTargetNames();
  std::vector<std::vector<int64_t>> feed_target_shapes;
  for (size_t i = 0; i < feed_target_names.size(); ++i) {
    auto* var = global_block.FindVar(feed_target_names[i]);
    std::vector<int64_t> var_shape = var->GetShape();
    feed_target_shapes.push_back(var_shape);
  }

  delete scope;
  return feed_target_shapes;
}

X
Xin Pan 已提交
139 140 141 142 143 144 145 146 147
void Compile(paddle::framework::ProgramDesc* program) {
  std::unique_ptr<paddle::framework::ir::Graph> g(
      new paddle::framework::ir::Graph(*program));
  auto pass = paddle::framework::ir::PassRegistry::Instance().Get(
      "graph_to_program_pass");
  pass->SetNotOwned<paddle::framework::ProgramDesc>("program", program);
  pass->Apply(std::move(g));
}

148
template <typename Place, bool CreateVars = true, bool PrepareContext = false>
149 150
void TestInference(const std::string& dirname,
                   const std::vector<paddle::framework::LoDTensor*>& cpu_feeds,
151
                   const std::vector<paddle::framework::LoDTensor*>& cpu_fetchs,
152
                   const int repeat = 1, const bool is_combined = false) {
153
  // 1. Define place, executor, scope
154 155 156 157
  auto place = Place();
  auto executor = paddle::framework::Executor(place);
  auto* scope = new paddle::framework::Scope();

158 159 160 161 162 163
  // Profile the performance
  paddle::platform::ProfilerState state;
  if (paddle::platform::is_cpu_place(place)) {
    state = paddle::platform::ProfilerState::kCPU;
  } else {
#ifdef PADDLE_WITH_CUDA
164
    state = paddle::platform::ProfilerState::kAll;
165 166 167 168
    // The default device_id of paddle::platform::CUDAPlace is 0.
    // Users can get the device_id using:
    //   int device_id = place.GetDeviceId();
    paddle::platform::SetDeviceId(0);
Q
QI JUN 已提交
169 170
#else
    PADDLE_THROW("'CUDAPlace' is not supported in CPU only device.");
171 172 173
#endif
  }

174 175
  // 2. Initialize the inference_program and load parameters
  std::unique_ptr<paddle::framework::ProgramDesc> inference_program;
176 177 178

  // Enable the profiler
  paddle::platform::EnableProfiler(state);
179 180 181 182
  {
    paddle::platform::RecordEvent record_event(
        "init_program",
        paddle::platform::DeviceContextPool::Instance().Get(place));
183
    inference_program = InitProgram(&executor, scope, dirname, is_combined);
184
  }
X
Xin Pan 已提交
185 186
  Compile(inference_program.get());

187 188
  // Disable the profiler and print the timing information
  paddle::platform::DisableProfiler(paddle::platform::EventSortingKey::kDefault,
189
                                    "load_program_profiler");
190
  paddle::platform::ResetProfiler();
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210

  // 3. Get the feed_target_names and fetch_target_names
  const std::vector<std::string>& feed_target_names =
      inference_program->GetFeedTargetNames();
  const std::vector<std::string>& fetch_target_names =
      inference_program->GetFetchTargetNames();

  // 4. Prepare inputs: set up maps for feed targets
  std::map<std::string, const paddle::framework::LoDTensor*> feed_targets;
  for (size_t i = 0; i < feed_target_names.size(); ++i) {
    // Please make sure that cpu_feeds[i] is right for feed_target_names[i]
    feed_targets[feed_target_names[i]] = cpu_feeds[i];
  }

  // 5. Define Tensor to get the outputs: set up maps for fetch targets
  std::map<std::string, paddle::framework::LoDTensor*> fetch_targets;
  for (size_t i = 0; i < fetch_target_names.size(); ++i) {
    fetch_targets[fetch_target_names[i]] = cpu_fetchs[i];
  }

211 212 213 214
  // 6. If export Flags_use_mkldnn=True, use mkldnn related ops.
  if (FLAGS_use_mkldnn) executor.EnableMKLDNN(*inference_program);

  // 7. Run the inference program
215
  {
216 217 218 219
    if (!CreateVars) {
      // If users don't want to create and destroy variables every time they
      // run, they need to set `create_vars` to false and manually call
      // `CreateVariables` before running.
L
Liu Yiqun 已提交
220
      executor.CreateVariables(*inference_program, scope, 0);
221 222
    }

223
    // Ignore the profiling results of the first run
224
    std::unique_ptr<paddle::framework::ExecutorPrepareContext> ctx;
225
    bool CreateLocalScope = CreateVars;
226 227
    if (PrepareContext) {
      ctx = executor.Prepare(*inference_program, 0);
228
      executor.RunPreparedContext(ctx.get(), scope, &feed_targets,
229
                                  &fetch_targets, CreateLocalScope, CreateVars);
230
    } else {
231
      executor.Run(*inference_program, scope, &feed_targets, &fetch_targets,
232
                   CreateLocalScope, CreateVars);
233
    }
234 235 236 237

    // Enable the profiler
    paddle::platform::EnableProfiler(state);

238 239 240 241 242 243
    // Run repeat times to profile the performance
    for (int i = 0; i < repeat; ++i) {
      paddle::platform::RecordEvent record_event(
          "run_inference",
          paddle::platform::DeviceContextPool::Instance().Get(place));

244
      if (PrepareContext) {
L
Liu Yiqun 已提交
245
        // Note: if you change the inference_program, you need to call
246
        // executor.Prepare() again to get a new ExecutorPrepareContext.
247
        executor.RunPreparedContext(ctx.get(), scope, &feed_targets,
248 249
                                    &fetch_targets, CreateLocalScope,
                                    CreateVars);
250
      } else {
251
        executor.Run(*inference_program, scope, &feed_targets, &fetch_targets,
252
                     CreateLocalScope, CreateVars);
253
      }
254 255
    }

256 257
    // Disable the profiler and print the timing information
    paddle::platform::DisableProfiler(
D
daminglu 已提交
258
        paddle::platform::EventSortingKey::kDefault, "run_inference_profiler");
259 260
    paddle::platform::ResetProfiler();
  }
261 262 263

  delete scope;
}
X
Xin Pan 已提交
264 265

USE_PASS(graph_to_program_pass);
反馈
建议
客服 返回
顶部