Skip to content

P
PaddleDetection

PaddlePaddle / PaddleDetection
大约 1 年 前同步成功

通知 695
Star 11112
Fork 2696
P
PaddleDetection
提交 962061f0 编写于 作者: D dzhwinter
浏览文件
操作

windows fix

上级 85f8dd1c
显示空白变更内容
内联 并排
Showing with 324 addition and 191 deletion
cmake/generic.cmake
浏览文件 @ 962061f0
......@@ -243,7 +243,7 @@ function(cc_library TARGET_NAME)
# add libxxx.lib prefix in windows
set(${TARGET_NAME}_LIB_NAME "${CMAKE_STATIC_LIBRARY_PREFIX}${TARGET_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}" CACHE STRING "output library name for target ${TARGET_NAME}")
endif(WIN32)
message("flags" ${CMAKE_CXX_FLAGS})
if(cc_library_SRCS)
if(cc_library_SHARED OR cc_library_shared) # build *.so
add_library(${TARGET_NAME} SHARED ${cc_library_SRCS})
......
paddle/fluid/framework/executor.cc
浏览文件 @ 962061f0
......@@ -293,26 +293,41 @@ void Executor::Run(const ProgramDesc& program, Scope* scope,
std::unique_ptr<ExecutorPrepareContext> Executor::Prepare(
const ProgramDesc& program, int block_id) {
VLOG(3) << "before create prepare" << block_id << " " << program.Size();
std::unique_ptr<ExecutorPrepareContext> ctx(
new ExecutorPrepareContext(program, block_id));
PADDLE_ENFORCE_LT(static_cast<size_t>(block_id), program.Size());
VLOG(3) << "after create prepare";
// PADDLE_ENFORCE_LT(static_cast<size_t>(block_id), program.Size());
VLOG(3) << "before create op_desc";
auto& block = program.Block(block_id);
VLOG(3) << "create before" << ctx->ops_.size() << " " << block.AllOps().size();
int counter = 0;
for (auto& op_desc : block.AllOps()) {
ctx->ops_.push_back(OpRegistry::CreateOp(*op_desc));
VLOG(3) << "create op " << "index " << ++counter << " type " << op_desc->Type();
}
VLOG(3) << "create finished" << ctx->ops_.size() << " " << block.AllOps().size();
return ctx;
}
std::vector<std::shared_ptr<ExecutorPrepareContext>> Executor::Prepare(
const ProgramDesc& program, const std::vector<int>& block_ids) {
VLOG(3) << "inside prepare";
std::vector<std::shared_ptr<ExecutorPrepareContext>> result;
VLOG(3) << "before go through block_ids";
for (auto& bid : block_ids) {
VLOG(3) << "block id" << bid;
auto* ctx = new ExecutorPrepareContext(program, bid);
PADDLE_ENFORCE_LT(static_cast<size_t>(bid), program.Size());
//PADDLE_ENFORCE_LT(static_cast<size_t>(bid), program.Size());
auto& block = program.Block(bid);
int counter = 0;
VLOG(3) << "create before" << ctx->ops_.size() << " " << block.AllOps().size();
for (auto& op_desc : block.AllOps()) {
ctx->ops_.push_back(OpRegistry::CreateOp(*op_desc));
VLOG(3) << "create op " << "index " << ++counter << " type " << op_desc->Type();
}
VLOG(3) << "create finished" << ctx->ops_.size() << " " << block.AllOps().size();
result.push_back(std::shared_ptr<ExecutorPrepareContext>(ctx));
}
return result;
......
paddle/fluid/inference/api/api_impl.cc
浏览文件 @ 962061f0
......@@ -88,12 +88,16 @@ bool NativePaddlePredictor::Init(
VLOG(3) << config_.model_dir;
inference_program_ = paddle::inference::Load(executor_.get(), scope_.get(),
config_.model_dir);
VLOG(3) << "load model Finish";
VLOG(3) << "load model finish";
} else if (!config_.prog_file.empty() && !config_.param_file.empty()) {
// All parameters are saved in a single file.
// The file names should be consistent with that used
// in Python API `fluid.io.save_inference_model`.
VLOG(3) << "load program";
VLOG(3) << "load program before";
auto exe = executor_.get();
VLOG(3) << "executor_";
auto sc = scope_.get();
VLOG(3) << "scope_";
inference_program_ = paddle::inference::Load(
executor_.get(), scope_.get(), config_.prog_file, config_.param_file);
VLOG(3) << "load program finish";
......@@ -101,13 +105,18 @@ bool NativePaddlePredictor::Init(
LOG(ERROR) << "fail to load inference model.";
return false;
}
VLOG(3) << "prepare";
VLOG(3) << "pointer" << inference_program_.get();
VLOG(3) << "prepare before";
ctx_ = executor_->Prepare(*inference_program_, 0);
VLOG(3) << "prepare finished";
executor_->CreateVariables(*inference_program_,
sub_scope_ ? sub_scope_ : scope_.get(), 0);
VLOG(3) << "create variables";
// Get the feed_target_names and fetch_target_names
PrepareFeedFetch();
VLOG(3) << "feed fetch";
return true;
}
......
paddle/fluid/inference/api/demo_ci/inference_icnet.cc
浏览文件 @ 962061f0
......@@ -29,17 +29,18 @@ limitations under the License. */
#include "paddle/fluid/inference/paddle_inference_api.h"
std::string MODELDIR = ""; /* "Directory of the inference model." */ // NOLINT
std::string REFER = ""; /*"path to reference result for comparison."*/ //NOTLINT
std::string REFER = "";
/*"path to reference result for comparison."*/ //NOTLINT
/*path of data; each line is a record, format:
<space splitted floats as data>\t<space splitted ints as shape>
Please check the demo data of data.txt for details.
*/
std::string DATA = "";
bool USE_GPU = false; /*"Whether use gpu."*/
bool USE_GPU = true; /*"Whether use gpu."*/
auto message_err = []() {
auto message_err = []()
{
std::cout << "Copyright (c) 2018 PaddlePaddle Authors." << std::endl;
std::cout << "Demo Case for windows inference. "
<< "\n"
......@@ -49,53 +50,61 @@ auto message_err = []() {
std::cout << std::endl;
};
namespace paddle {
namespace demo {
void split(const std::string& str, char sep,
std::vector<std::string>* pieces) {
namespace paddle
{
namespace demo
{
void split(const std::string& str, char sep,
std::vector<std::string>* pieces)
{
pieces->clear();
if (str.empty()) {
if (str.empty())
{
return;
}
size_t pos = 0;
size_t next = str.find(sep, pos);
while (next != std::string::npos) {
while (next != std::string::npos)
{
pieces->push_back(str.substr(pos, next - pos));
pos = next + 1;
next = str.find(sep, pos);
}
if (!str.substr(pos).empty()) {
if (!str.substr(pos).empty())
{
pieces->push_back(str.substr(pos));
}
}
}
/*
/*
* Get a summary of a PaddleTensor content.
*/
std::string SummaryTensor(const PaddleTensor& tensor) {
std::string SummaryTensor(const PaddleTensor& tensor)
{
std::stringstream ss;
int num_elems = tensor.data.length() / PaddleDtypeSize(tensor.dtype);
ss << "data[:10]\t";
switch (tensor.dtype) {
case PaddleDType::INT64: {
for (int i = 0; i < std::min(num_elems, 10); i++) {
switch (tensor.dtype)
{
case PaddleDType::INT64:
for (int i = 0; i < std::min(num_elems, 10); i++)
{
ss << static_cast<int64_t*>(tensor.data.data())[i] << " ";
}
break;
}
case PaddleDType::FLOAT32:
for (int i = 0; i < std::min(num_elems, 10); i++) {
for (int i = 0; i < std::min(num_elems, 10); i++)
{
ss << static_cast<float*>(tensor.data.data())[i] << " ";
}
break;
}
return ss.str();
}
}
std::string ToString(const NativeConfig& config) {
std::string ToString(const NativeConfig& config)
{
std::stringstream ss;
ss << "Use GPU : " << (config.use_gpu ? "True" : "False") << "\n"
<< "Device : " << config.device << "\n"
......@@ -105,39 +114,43 @@ std::string ToString(const NativeConfig& config) {
<< "Program File : " << config.prog_file << "\n"
<< "Param File : " << config.param_file;
return ss.str();
}
}
struct Record {
struct Record
{
std::vector<float> data;
std::vector<int32_t> shape;
};
};
Record ProcessALine(const std::string& line) {
std::cout << "process a line" << std::endl;;
Record ProcessALine(const std::string& line)
{
std::cout << "process a line" << std::endl;
std::vector<std::string> columns;
split(line, '\t', &columns);
assert(columns.size() == 2UL,
"data format error, should be <data>\t<shape>");
assert(columns.size() == 2UL, "data format error, should be <data>\t<shape>");
Record record;
std::vector<std::string> data_strs;
split(columns[0], ' ', &data_strs);
for (auto& d : data_strs) {
//将数据字符串转换为整型数据并放到record.data中
for (auto& d : data_strs)
{
record.data.push_back(std::stof(d));
}
std::vector<std::string> shape_strs;
split(columns[1], ' ', &shape_strs);
for (auto& s : shape_strs) {
for (auto& s : shape_strs)
{
record.shape.push_back(std::stoi(s));
}
std::cout << "data size " << record.data.size() << std::endl;
std::cout << "data shape size " << record.shape.size() << std::endl;
return record;
}
}
void CheckOutput(const std::string& referfile, const PaddleTensor& output) {
void CheckOutput(const std::string& referfile, const PaddleTensor& output)
{
std::string line;
std::ifstream file(referfile);
std::getline(file, line);
......@@ -148,47 +161,49 @@ void CheckOutput(const std::string& referfile, const PaddleTensor& output) {
std::cout << "predictor output numel " << numel << std::endl;
std::cout << "reference output numel " << refer.data.size() << std::endl;
assert(numel == refer.data.size());
switch (output.dtype) {
case PaddleDType::INT64: {
for (size_t i = 0; i < numel; ++i) {
assert(static_cast<int64_t*>(output.data.data())[i] ==
refer.data[i]);
switch (output.dtype)
{
case PaddleDType::INT64:
for (size_t i = 0; i < numel; ++i)
{
assert(static_cast<int64_t*>(output.data.data())[i] == refer.data[i]);
}
break;
}
case PaddleDType::FLOAT32:
for (size_t i = 0; i < numel; ++i) {
assert(
fabs(static_cast<float*>(output.data.data())[i] - refer.data[i]) <=
1e-5);
for (size_t i = 0; i < numel; ++i)
{
assert(fabs(static_cast<float*>(output.data.data())[i] - refer.data[i]) <= 1e-5);
}
break;
}
}
}
/*
/*
* Use the native fluid engine to inference the demo.
*/
void Main(bool use_gpu) {
void Main(bool use_gpu)
{
NativeConfig config;
config.param_file = MODELDIR + "/__params__";
config.prog_file = MODELDIR + "/__model__";
config.model_dir = MODELDIR;
//config.param_file = MODELDIR + "/__params__";
//config.prog_file = MODELDIR + "/__model__";
config.use_gpu = USE_GPU;
config.device = 0;
if (USE_GPU) {
if (USE_GPU)
{
config.fraction_of_gpu_memory = 0.1f; // set by yourself
}
std::cout << ToString(config) << std::endl;
std::cout << "init predictor" << std::endl;
auto predictor =
CreatePaddlePredictor<NativeConfig, PaddleEngineKind::kNative>(config);
auto predictor = CreatePaddlePredictor<NativeConfig, PaddleEngineKind::kNative>(config);
std::cout << "begin to process data" << std::endl;
// Just a single batch of data.
std::string line;
std::cout << "data : " << std::endl;
std::ifstream file(DATA);
if(!file.is_open()) {
if (!file.is_open())
{
std::cout << "failed open data" << DATA << std::endl;
exit(0);
}
......@@ -205,7 +220,7 @@ void Main(bool use_gpu) {
std::cout << "run executor" << std::endl;
std::vector<PaddleTensor> output;
predictor->Run({input}, &output);
predictor->Run({ input }, &output);
std::cout << "output.size " << output.size() << std::endl;
auto& tensor = output.front();
......@@ -214,22 +229,18 @@ void Main(bool use_gpu) {
// compare with reference result
std::cout << "refer result : " << REFER << std::endl;
CheckOutput(REFER, tensor);
}
}
}
int main(int argc, char** argv)
{
MODELDIR = "./LB_icnet_model";
//DATA = "./icnet_image.txt";
DATA = "./1.png.txt";
REFER = "./icnet_label.txt";
paddle::demo::Main(USE_GPU);
} // namespace demo
} // namespace paddle
int main(int argc, char** argv) {
// ParseArgs();
MODELDIR = "./mobilenet/model";
DATA = "./mobilenet/data.txt";
REFER = "./mobilenet/result.txt";
USE_GPU = true;
paddle::demo::Main(false /* USE_GPU*/);
if (USE_GPU) {
paddle::demo::Main(true /*USE_GPU*/);
}
system("pause");
return 0;
}
paddle/fluid/inference/api/demo_ci/naive_model_test.cc 0 → 100644
浏览文件 @ 962061f0
// 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 <chrono>
#include <iostream>
#include <fstream>
#include "paddle/fluid/inference/api/paddle_inference_api.h"
namespace paddle {
std::string DIRNAME = "./LB_icnet_model";
//std::string DIRNAME = "./infer_models";
NativeConfig GetConfig() {
NativeConfig config;
config.prog_file=DIRNAME + "/__model__";
config.param_file=DIRNAME + "/__params__";
config.fraction_of_gpu_memory = 0.8;
config.use_gpu = true;
config.device = 0;
return config;
}
using Time = decltype(std::chrono::high_resolution_clock::now());
Time time() { return std::chrono::high_resolution_clock::now(); };
double time_diff(Time t1, Time t2) {
typedef std::chrono::microseconds ms;
auto diff = t2 - t1;
ms counter = std::chrono::duration_cast<ms>(diff);
return counter.count() / 1000.0;
}
void test_naive(int batch_size){
NativeConfig config = GetConfig();
// config.model_dir = model_path;
auto predictor = CreatePaddlePredictor<NativeConfig>(config);
int height = 449;
int width = 581;
//int height = 3;
//int width = 3;
int num_sum = height * width * 3 * batch_size;
std::vector<float> data;
for(int i = 0; i < num_sum; i++) {
data.push_back(0.0);
}
PaddleTensor tensor;
tensor.shape = std::vector<int>({batch_size, 3, height, width});
tensor.data.Resize(sizeof(float) * batch_size * 3 * height * width);
std::copy(data.begin(), data.end(), static_cast<float*>(tensor.data.data()));
tensor.dtype = PaddleDType::FLOAT32;
std::vector<PaddleTensor> paddle_tensor_feeds(1, tensor);
PaddleTensor tensor_out;
std::vector<PaddleTensor> outputs(1, tensor_out);
predictor->Run(paddle_tensor_feeds, &outputs, batch_size);
std::cout << "start predict123:" << std::endl;
auto time1 = time();
for(size_t i = 0; i < 2; i++) {
predictor->Run(paddle_tensor_feeds, &outputs, batch_size);
std::cout << "pass " << i;
}
auto time2 = time();
std::ofstream ofresult("naive_test_result.txt", std::ios::app);
std::cout <<"batch: " << batch_size << " predict cost: " << time_diff(time1, time2) / 100.0 << "ms" << std::endl;
std::cout << outputs.size() << std::endl;
/*
int64_t * data_o = static_cast<int64_t*>(outputs[0].data.data());
for (size_t j = 0; j < outputs[0].data.length() / sizeof(int64_t); ++j) {
ofresult << std::to_string(data_o[j]) << " ";
}
ofresult << std::endl;
ofresult.close();
*/
}
} // namespace paddle
int main(int argc, char** argv) {
paddle::test_naive(1 << 0);
return 0;
}
\ No newline at end of file
paddle/fluid/inference/api/demo_ci/simple_on_word2vec.cc
浏览文件 @ 962061f0
......@@ -133,6 +133,7 @@ void MainThreads(int num_threads, bool use_gpu) {
} // namespace paddle
int main(int argc, char** argv) {
FLAGS_dirname = "./word2vec.inference.model";
google::ParseCommandLineFlags(&argc, &argv, true);
paddle::demo::Main(false /* use_gpu*/);
paddle::demo::MainThreads(1, false /* use_gpu*/);
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或