api_impl_tester.cc 10.2 KB
Newer Older
X
Xin Pan 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/* Copyright (c) 2018 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

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. */

#include <glog/logging.h>
#include <gtest/gtest.h>

L
Luo Tao 已提交
18
#include <thread>  // NOLINT
T
tensor-tang 已提交
19

X
Xin Pan 已提交
20
#include "gflags/gflags.h"
L
Luo Tao 已提交
21
#include "paddle/fluid/inference/api/api_impl.h"
X
Xin Pan 已提交
22 23 24 25 26 27 28 29 30 31
#include "paddle/fluid/inference/tests/test_helper.h"

DEFINE_string(dirname, "", "Directory of the inference model.");

namespace paddle {

PaddleTensor LodTensorToPaddleTensor(framework::LoDTensor* t) {
  PaddleTensor pt;

  if (t->type() == typeid(int64_t)) {
32
    pt.data.Reset(t->data<void>(), t->numel() * sizeof(int64_t));
X
Xin Pan 已提交
33 34
    pt.dtype = PaddleDType::INT64;
  } else if (t->type() == typeid(float)) {
35
    pt.data.Reset(t->data<void>(), t->numel() * sizeof(float));
X
Xin Pan 已提交
36 37 38 39 40 41 42 43
    pt.dtype = PaddleDType::FLOAT32;
  } else {
    LOG(FATAL) << "unsupported type.";
  }
  pt.shape = framework::vectorize2int(t->dims());
  return pt;
}

Y
Yan Chunwei 已提交
44 45
NativeConfig GetConfig() {
  NativeConfig config;
46
  config.model_dir = FLAGS_dirname + "/word2vec.inference.model";
X
Xin Pan 已提交
47
  LOG(INFO) << "dirname  " << config.model_dir;
X
Xin Pan 已提交
48
  config.fraction_of_gpu_memory = 0.15;
T
tensor-tang 已提交
49
#ifdef PADDLE_WITH_CUDA
Y
Yan Chunwei 已提交
50
  config.use_gpu = true;
T
tensor-tang 已提交
51 52 53
#else
  config.use_gpu = false;
#endif
X
Xin Pan 已提交
54
  config.device = 0;
55 56
  return config;
}
X
Xin Pan 已提交
57

T
tensor-tang 已提交
58
void MainWord2Vec(bool use_gpu) {
Y
Yan Chunwei 已提交
59 60
  NativeConfig config = GetConfig();
  auto predictor = CreatePaddlePredictor<NativeConfig>(config);
T
tensor-tang 已提交
61
  config.use_gpu = use_gpu;
X
Xin Pan 已提交
62 63 64 65 66 67 68 69 70 71

  framework::LoDTensor first_word, second_word, third_word, fourth_word;
  framework::LoD lod{{0, 1}};
  int64_t dict_size = 2073;  // The size of dictionary

  SetupLoDTensor(&first_word, lod, static_cast<int64_t>(0), dict_size - 1);
  SetupLoDTensor(&second_word, lod, static_cast<int64_t>(0), dict_size - 1);
  SetupLoDTensor(&third_word, lod, static_cast<int64_t>(0), dict_size - 1);
  SetupLoDTensor(&fourth_word, lod, static_cast<int64_t>(0), dict_size - 1);

72 73 74 75 76 77 78 79 80
  std::vector<PaddleTensor> paddle_tensor_feeds;
  paddle_tensor_feeds.push_back(LodTensorToPaddleTensor(&first_word));
  paddle_tensor_feeds.push_back(LodTensorToPaddleTensor(&second_word));
  paddle_tensor_feeds.push_back(LodTensorToPaddleTensor(&third_word));
  paddle_tensor_feeds.push_back(LodTensorToPaddleTensor(&fourth_word));

  std::vector<PaddleTensor> outputs;
  ASSERT_TRUE(predictor->Run(paddle_tensor_feeds, &outputs));
  ASSERT_EQ(outputs.size(), 1UL);
81 82
  size_t len = outputs[0].data.length();
  float* data = static_cast<float*>(outputs[0].data.data());
83
  for (size_t j = 0; j < len / sizeof(float); ++j) {
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
    ASSERT_LT(data[j], 1.0);
    ASSERT_GT(data[j], -1.0);
  }

  std::vector<paddle::framework::LoDTensor*> cpu_feeds;
  cpu_feeds.push_back(&first_word);
  cpu_feeds.push_back(&second_word);
  cpu_feeds.push_back(&third_word);
  cpu_feeds.push_back(&fourth_word);

  framework::LoDTensor output1;
  std::vector<paddle::framework::LoDTensor*> cpu_fetchs1;
  cpu_fetchs1.push_back(&output1);

  TestInference<platform::CPUPlace>(config.model_dir, cpu_feeds, cpu_fetchs1);

  float* lod_data = output1.data<float>();
101
  for (int i = 0; i < output1.numel(); ++i) {
102 103 104 105 106
    EXPECT_LT(lod_data[i] - data[i], 1e-3);
    EXPECT_GT(lod_data[i] - data[i], -1e-3);
  }
}

T
tensor-tang 已提交
107
void MainImageClassification(bool use_gpu) {
108 109
  int batch_size = 2;
  bool repeat = false;
Y
Yan Chunwei 已提交
110
  NativeConfig config = GetConfig();
T
tensor-tang 已提交
111
  config.use_gpu = use_gpu;
112
  config.model_dir =
113
      FLAGS_dirname + "/image_classification_resnet.inference.model";
114 115 116 117 118 119 120 121 122 123

  const bool is_combined = false;
  std::vector<std::vector<int64_t>> feed_target_shapes =
      GetFeedTargetShapes(config.model_dir, is_combined);

  framework::LoDTensor input;
  // Use normilized image pixels as input data,
  // which should be in the range [0.0, 1.0].
  feed_target_shapes[0][0] = batch_size;
  framework::DDim input_dims = framework::make_ddim(feed_target_shapes[0]);
124 125
  SetupTensor<float>(&input, input_dims, static_cast<float>(0),
                     static_cast<float>(1));
126 127 128 129 130 131 132
  std::vector<framework::LoDTensor*> cpu_feeds;
  cpu_feeds.push_back(&input);

  framework::LoDTensor output1;
  std::vector<framework::LoDTensor*> cpu_fetchs1;
  cpu_fetchs1.push_back(&output1);

L
Luo Tao 已提交
133 134
  TestInference<platform::CPUPlace, false, true>(
      config.model_dir, cpu_feeds, cpu_fetchs1, repeat, is_combined);
135

Y
Yan Chunwei 已提交
136
  auto predictor = CreatePaddlePredictor(config);
137 138
  std::vector<PaddleTensor> paddle_tensor_feeds;
  paddle_tensor_feeds.push_back(LodTensorToPaddleTensor(&input));
X
Xin Pan 已提交
139 140

  std::vector<PaddleTensor> outputs;
141
  ASSERT_TRUE(predictor->Run(paddle_tensor_feeds, &outputs));
142
  ASSERT_EQ(outputs.size(), 1UL);
143 144
  size_t len = outputs[0].data.length();
  float* data = static_cast<float*>(outputs[0].data.data());
145 146
  float* lod_data = output1.data<float>();
  for (size_t j = 0; j < len / sizeof(float); ++j) {
X
clean  
Xin Pan 已提交
147
    EXPECT_NEAR(lod_data[j], data[j], 1e-3);
X
Xin Pan 已提交
148 149 150
  }
}

T
tensor-tang 已提交
151
void MainThreadsWord2Vec(bool use_gpu) {
T
tensor-tang 已提交
152
  NativeConfig config = GetConfig();
T
tensor-tang 已提交
153
  config.use_gpu = use_gpu;
T
tensor-tang 已提交
154 155
  auto main_predictor = CreatePaddlePredictor<NativeConfig>(config);

156
  // prepare inputs data and reference results
T
tensor-tang 已提交
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
  constexpr int num_jobs = 3;
  std::vector<std::vector<framework::LoDTensor>> jobs(num_jobs);
  std::vector<std::vector<PaddleTensor>> paddle_tensor_feeds(num_jobs);
  std::vector<framework::LoDTensor> refs(num_jobs);
  for (size_t i = 0; i < jobs.size(); ++i) {
    // each job has 4 words
    jobs[i].resize(4);
    for (size_t j = 0; j < 4; ++j) {
      framework::LoD lod{{0, 1}};
      int64_t dict_size = 2073;  // The size of dictionary
      SetupLoDTensor(&jobs[i][j], lod, static_cast<int64_t>(0), dict_size - 1);
      paddle_tensor_feeds[i].push_back(LodTensorToPaddleTensor(&jobs[i][j]));
    }

    // get reference result of each job
    std::vector<paddle::framework::LoDTensor*> ref_feeds;
    std::vector<paddle::framework::LoDTensor*> ref_fetches(1, &refs[i]);
    for (auto& word : jobs[i]) {
      ref_feeds.push_back(&word);
    }
    TestInference<platform::CPUPlace>(config.model_dir, ref_feeds, ref_fetches);
  }

  // create threads and each thread run 1 job
  std::vector<std::thread> threads;
  for (int tid = 0; tid < num_jobs; ++tid) {
    threads.emplace_back([&, tid]() {
      auto predictor = main_predictor->Clone();
      auto& local_inputs = paddle_tensor_feeds[tid];
      std::vector<PaddleTensor> local_outputs;
      ASSERT_TRUE(predictor->Run(local_inputs, &local_outputs));

      // check outputs range
      ASSERT_EQ(local_outputs.size(), 1UL);
191 192
      const size_t len = local_outputs[0].data.length();
      float* data = static_cast<float*>(local_outputs[0].data.data());
T
tensor-tang 已提交
193 194 195 196 197 198 199
      for (size_t j = 0; j < len / sizeof(float); ++j) {
        ASSERT_LT(data[j], 1.0);
        ASSERT_GT(data[j], -1.0);
      }

      // check outputs correctness
      float* ref_data = refs[tid].data<float>();
200
      EXPECT_EQ(refs[tid].numel(), static_cast<int64_t>(len / sizeof(float)));
T
tensor-tang 已提交
201
      for (int i = 0; i < refs[tid].numel(); ++i) {
202
        EXPECT_NEAR(ref_data[i], data[i], 1e-3);
T
tensor-tang 已提交
203
      }
204 205 206 207 208 209 210
    });
  }
  for (int i = 0; i < num_jobs; ++i) {
    threads[i].join();
  }
}

T
tensor-tang 已提交
211
void MainThreadsImageClassification(bool use_gpu) {
212 213 214
  constexpr int num_jobs = 4;  // each job run 1 batch
  constexpr int batch_size = 1;
  NativeConfig config = GetConfig();
T
tensor-tang 已提交
215
  config.use_gpu = use_gpu;
216
  config.model_dir =
217
      FLAGS_dirname + "/image_classification_resnet.inference.model";
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236

  auto main_predictor = CreatePaddlePredictor<NativeConfig>(config);
  std::vector<framework::LoDTensor> jobs(num_jobs);
  std::vector<std::vector<PaddleTensor>> paddle_tensor_feeds(num_jobs);
  std::vector<framework::LoDTensor> refs(num_jobs);
  for (size_t i = 0; i < jobs.size(); ++i) {
    // prepare inputs
    std::vector<std::vector<int64_t>> feed_target_shapes =
        GetFeedTargetShapes(config.model_dir, /*is_combined*/ false);
    feed_target_shapes[0][0] = batch_size;
    framework::DDim input_dims = framework::make_ddim(feed_target_shapes[0]);
    SetupTensor<float>(&jobs[i], input_dims, 0.f, 1.f);
    paddle_tensor_feeds[i].push_back(LodTensorToPaddleTensor(&jobs[i]));

    // get reference result of each job
    std::vector<framework::LoDTensor*> ref_feeds(1, &jobs[i]);
    std::vector<framework::LoDTensor*> ref_fetches(1, &refs[i]);
    TestInference<platform::CPUPlace>(config.model_dir, ref_feeds, ref_fetches);
  }
T
tensor-tang 已提交
237

238 239 240 241 242 243 244 245 246 247 248
  // create threads and each thread run 1 job
  std::vector<std::thread> threads;
  for (int tid = 0; tid < num_jobs; ++tid) {
    threads.emplace_back([&, tid]() {
      auto predictor = main_predictor->Clone();
      auto& local_inputs = paddle_tensor_feeds[tid];
      std::vector<PaddleTensor> local_outputs;
      ASSERT_TRUE(predictor->Run(local_inputs, &local_outputs));

      // check outputs correctness
      ASSERT_EQ(local_outputs.size(), 1UL);
249 250
      const size_t len = local_outputs[0].data.length();
      float* data = static_cast<float*>(local_outputs[0].data.data());
251
      float* ref_data = refs[tid].data<float>();
252
      EXPECT_EQ((size_t)refs[tid].numel(), len / sizeof(float));
253 254 255
      for (int i = 0; i < refs[tid].numel(); ++i) {
        EXPECT_NEAR(ref_data[i], data[i], 1e-3);
      }
T
tensor-tang 已提交
256 257 258 259 260 261 262
    });
  }
  for (int i = 0; i < num_jobs; ++i) {
    threads[i].join();
  }
}

T
tensor-tang 已提交
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
TEST(inference_api_native, word2vec_cpu) { MainWord2Vec(false /*use_gpu*/); }
TEST(inference_api_native, word2vec_cpu_threads) {
  MainThreadsWord2Vec(false /*use_gpu*/);
}
TEST(inference_api_native, image_classification_cpu) {
  MainThreadsImageClassification(false /*use_gpu*/);
}
TEST(inference_api_native, image_classification_cpu_threads) {
  MainThreadsImageClassification(false /*use_gpu*/);
}

#ifdef PADDLE_WITH_CUDA
TEST(inference_api_native, word2vec_gpu) { MainWord2Vec(true /*use_gpu*/); }
TEST(inference_api_native, word2vec_gpu_threads) {
  MainThreadsWord2Vec(true /*use_gpu*/);
}
TEST(inference_api_native, image_classification_gpu) {
  MainThreadsImageClassification(true /*use_gpu*/);
}
TEST(inference_api_native, image_classification_gpu_threads) {
  MainThreadsImageClassification(true /*use_gpu*/);
}

#endif

X
Xin Pan 已提交
288
}  // namespace paddle