Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
PaddlePaddle
PaddleDetection
提交
726c0fb9
P
PaddleDetection
项目概览
PaddlePaddle
/
PaddleDetection
大约 1 年 前同步成功
通知
694
Star
11112
Fork
2696
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
184
列表
看板
标记
里程碑
合并请求
40
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
P
PaddleDetection
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
184
Issue
184
列表
看板
标记
里程碑
合并请求
40
合并请求
40
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
726c0fb9
编写于
6月 04, 2018
作者:
W
weixing02
浏览文件
操作
浏览文件
下载
差异文件
Merge branch 'develop' of
https://github.com/PaddlePaddle/Paddle
into new_api
上级
05a2a1a9
07c48dbf
变更
2
隐藏空白更改
内联
并排
Showing
2 changed file
with
244 addition
and
0 deletion
+244
-0
paddle/fluid/inference/tests/book/CMakeLists.txt
paddle/fluid/inference/tests/book/CMakeLists.txt
+8
-0
paddle/fluid/inference/tests/book/test_inference_nlp.cc
paddle/fluid/inference/tests/book/test_inference_nlp.cc
+236
-0
未找到文件。
paddle/fluid/inference/tests/book/CMakeLists.txt
浏览文件 @
726c0fb9
...
...
@@ -38,3 +38,11 @@ inference_test(recommender_system)
#inference_test(rnn_encoder_decoder)
#inference_test(understand_sentiment ARGS conv)
inference_test
(
word2vec
)
# This is an unly work around to make this test run
# TODO(TJ): clean me up
cc_test
(
test_inference_nlp
SRCS test_inference_nlp.cc
DEPS paddle_fluid
ARGS
--model_path=
${
PADDLE_BINARY_DIR
}
/python/paddle/fluid/tests/book/recognize_digits_mlp.inference.model
)
paddle/fluid/inference/tests/book/test_inference_nlp.cc
0 → 100644
浏览文件 @
726c0fb9
/* 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 <sys/time.h>
#include <time.h>
#include <fstream>
#include <thread> // NOLINT
#include "gflags/gflags.h"
#include "gtest/gtest.h"
#include "paddle/fluid/inference/tests/test_helper.h"
#ifdef PADDLE_WITH_MKLML
#include <mkl_service.h>
#include <omp.h>
#endif
DEFINE_string
(
model_path
,
""
,
"Directory of the inference model."
);
DEFINE_string
(
data_file
,
""
,
"File of input index data."
);
DEFINE_int32
(
repeat
,
100
,
"Running the inference program repeat times"
);
DEFINE_bool
(
use_mkldnn
,
false
,
"Use MKLDNN to run inference"
);
DEFINE_bool
(
prepare_vars
,
true
,
"Prepare variables before executor"
);
DEFINE_int32
(
num_threads
,
1
,
"Number of threads should be used"
);
inline
double
GetCurrentMs
()
{
struct
timeval
time
;
gettimeofday
(
&
time
,
NULL
);
return
1e+3
*
time
.
tv_sec
+
1e-3
*
time
.
tv_usec
;
}
// This function just give dummy data for recognize_digits model.
size_t
DummyData
(
std
::
vector
<
paddle
::
framework
::
LoDTensor
>*
out
)
{
paddle
::
framework
::
LoDTensor
input
;
SetupTensor
<
float
>
(
&
input
,
{
1
,
1
,
28
,
28
},
-
1.
f
,
1.
f
);
out
->
emplace_back
(
input
);
return
1
;
}
// Load the input word index data from file and save into LodTensor.
// Return the size of words.
size_t
LoadData
(
std
::
vector
<
paddle
::
framework
::
LoDTensor
>*
out
,
const
std
::
string
&
filename
)
{
if
(
filename
.
empty
())
{
return
DummyData
(
out
);
}
size_t
sz
=
0
;
std
::
fstream
fin
(
filename
);
std
::
string
line
;
out
->
clear
();
while
(
getline
(
fin
,
line
))
{
std
::
istringstream
iss
(
line
);
std
::
vector
<
int64_t
>
ids
;
std
::
string
field
;
while
(
getline
(
iss
,
field
,
' '
))
{
ids
.
push_back
(
stoi
(
field
));
}
if
(
ids
.
size
()
>=
1024
)
{
// Synced with NLP guys, they will ignore input larger then 1024
continue
;
}
paddle
::
framework
::
LoDTensor
words
;
paddle
::
framework
::
LoD
lod
{{
0
,
ids
.
size
()}};
words
.
set_lod
(
lod
);
int64_t
*
pdata
=
words
.
mutable_data
<
int64_t
>
(
{
static_cast
<
int64_t
>
(
ids
.
size
()),
1
},
paddle
::
platform
::
CPUPlace
());
memcpy
(
pdata
,
ids
.
data
(),
words
.
numel
()
*
sizeof
(
int64_t
));
out
->
emplace_back
(
words
);
sz
+=
ids
.
size
();
}
return
sz
;
}
// Split input data samples into small pieces jobs as balanced as possible,
// according to the number of threads.
void
SplitData
(
const
std
::
vector
<
paddle
::
framework
::
LoDTensor
>&
datasets
,
std
::
vector
<
std
::
vector
<
const
paddle
::
framework
::
LoDTensor
*>>*
jobs
,
const
int
num_threads
)
{
size_t
s
=
0
;
jobs
->
resize
(
num_threads
);
while
(
s
<
datasets
.
size
())
{
for
(
auto
it
=
jobs
->
begin
();
it
!=
jobs
->
end
();
it
++
)
{
it
->
emplace_back
(
&
datasets
[
s
]);
s
++
;
if
(
s
>=
datasets
.
size
())
{
break
;
}
}
}
}
void
ThreadRunInfer
(
const
int
tid
,
paddle
::
framework
::
Executor
*
executor
,
paddle
::
framework
::
Scope
*
scope
,
const
std
::
unique_ptr
<
paddle
::
framework
::
ProgramDesc
>&
inference_program
,
const
std
::
vector
<
std
::
vector
<
const
paddle
::
framework
::
LoDTensor
*>>&
jobs
)
{
auto
copy_program
=
std
::
unique_ptr
<
paddle
::
framework
::
ProgramDesc
>
(
new
paddle
::
framework
::
ProgramDesc
(
*
inference_program
));
auto
&
sub_scope
=
scope
->
NewScope
();
std
::
string
feed_holder_name
=
"feed_"
+
paddle
::
string
::
to_string
(
tid
);
std
::
string
fetch_holder_name
=
"fetch_"
+
paddle
::
string
::
to_string
(
tid
);
copy_program
->
SetFeedHolderName
(
feed_holder_name
);
copy_program
->
SetFetchHolderName
(
fetch_holder_name
);
const
std
::
vector
<
std
::
string
>&
feed_target_names
=
copy_program
->
GetFeedTargetNames
();
const
std
::
vector
<
std
::
string
>&
fetch_target_names
=
copy_program
->
GetFetchTargetNames
();
PADDLE_ENFORCE_EQ
(
fetch_target_names
.
size
(),
1UL
);
std
::
map
<
std
::
string
,
paddle
::
framework
::
LoDTensor
*>
fetch_targets
;
paddle
::
framework
::
LoDTensor
outtensor
;
fetch_targets
[
fetch_target_names
[
0
]]
=
&
outtensor
;
std
::
map
<
std
::
string
,
const
paddle
::
framework
::
LoDTensor
*>
feed_targets
;
PADDLE_ENFORCE_EQ
(
feed_target_names
.
size
(),
1UL
);
auto
&
inputs
=
jobs
[
tid
];
auto
start_ms
=
GetCurrentMs
();
for
(
size_t
i
=
0
;
i
<
inputs
.
size
();
++
i
)
{
feed_targets
[
feed_target_names
[
0
]]
=
inputs
[
i
];
executor
->
Run
(
*
copy_program
,
&
sub_scope
,
&
feed_targets
,
&
fetch_targets
,
true
/*create_local_scope*/
,
true
/*create_vars*/
,
feed_holder_name
,
fetch_holder_name
);
}
auto
stop_ms
=
GetCurrentMs
();
scope
->
DeleteScope
(
&
sub_scope
);
LOG
(
INFO
)
<<
"Tid: "
<<
tid
<<
", process "
<<
inputs
.
size
()
<<
" samples, avg time per sample: "
<<
(
stop_ms
-
start_ms
)
/
inputs
.
size
()
<<
" ms"
;
}
TEST
(
inference
,
nlp
)
{
if
(
FLAGS_model_path
.
empty
())
{
LOG
(
FATAL
)
<<
"Usage: ./example --model_path=path/to/your/model"
;
}
if
(
FLAGS_data_file
.
empty
())
{
LOG
(
WARNING
)
<<
"No data file provided, will use dummy data!"
<<
"Note: if you use nlp model, please provide data file."
;
}
LOG
(
INFO
)
<<
"Model Path: "
<<
FLAGS_model_path
;
LOG
(
INFO
)
<<
"Data File: "
<<
FLAGS_data_file
;
std
::
vector
<
paddle
::
framework
::
LoDTensor
>
datasets
;
size_t
num_total_words
=
LoadData
(
&
datasets
,
FLAGS_data_file
);
LOG
(
INFO
)
<<
"Number of samples (seq_len<1024): "
<<
datasets
.
size
();
LOG
(
INFO
)
<<
"Total number of words: "
<<
num_total_words
;
const
bool
model_combined
=
false
;
// 0. Call `paddle::framework::InitDevices()` initialize all the devices
// 1. Define place, executor, scope
auto
place
=
paddle
::
platform
::
CPUPlace
();
auto
executor
=
paddle
::
framework
::
Executor
(
place
);
std
::
unique_ptr
<
paddle
::
framework
::
Scope
>
scope
(
new
paddle
::
framework
::
Scope
());
// 2. Initialize the inference_program and load parameters
std
::
unique_ptr
<
paddle
::
framework
::
ProgramDesc
>
inference_program
;
inference_program
=
InitProgram
(
&
executor
,
scope
.
get
(),
FLAGS_model_path
,
model_combined
);
if
(
FLAGS_use_mkldnn
)
{
EnableMKLDNN
(
inference_program
);
}
#ifdef PADDLE_WITH_MKLML
// only use 1 thread number per std::thread
omp_set_dynamic
(
0
);
omp_set_num_threads
(
1
);
mkl_set_num_threads
(
1
);
#endif
double
start_ms
=
0
,
stop_ms
=
0
;
if
(
FLAGS_num_threads
>
1
)
{
std
::
vector
<
std
::
vector
<
const
paddle
::
framework
::
LoDTensor
*>>
jobs
;
SplitData
(
datasets
,
&
jobs
,
FLAGS_num_threads
);
std
::
vector
<
std
::
unique_ptr
<
std
::
thread
>>
threads
;
start_ms
=
GetCurrentMs
();
for
(
int
i
=
0
;
i
<
FLAGS_num_threads
;
++
i
)
{
threads
.
emplace_back
(
new
std
::
thread
(
ThreadRunInfer
,
i
,
&
executor
,
scope
.
get
(),
std
::
ref
(
inference_program
),
std
::
ref
(
jobs
)));
}
for
(
int
i
=
0
;
i
<
FLAGS_num_threads
;
++
i
)
{
threads
[
i
]
->
join
();
}
stop_ms
=
GetCurrentMs
();
}
else
{
if
(
FLAGS_prepare_vars
)
{
executor
.
CreateVariables
(
*
inference_program
,
scope
.
get
(),
0
);
}
// always prepare context
std
::
unique_ptr
<
paddle
::
framework
::
ExecutorPrepareContext
>
ctx
;
ctx
=
executor
.
Prepare
(
*
inference_program
,
0
);
// preapre fetch
const
std
::
vector
<
std
::
string
>&
fetch_target_names
=
inference_program
->
GetFetchTargetNames
();
PADDLE_ENFORCE_EQ
(
fetch_target_names
.
size
(),
1UL
);
std
::
map
<
std
::
string
,
paddle
::
framework
::
LoDTensor
*>
fetch_targets
;
paddle
::
framework
::
LoDTensor
outtensor
;
fetch_targets
[
fetch_target_names
[
0
]]
=
&
outtensor
;
// prepare feed
const
std
::
vector
<
std
::
string
>&
feed_target_names
=
inference_program
->
GetFeedTargetNames
();
PADDLE_ENFORCE_EQ
(
feed_target_names
.
size
(),
1UL
);
std
::
map
<
std
::
string
,
const
paddle
::
framework
::
LoDTensor
*>
feed_targets
;
// feed data and run
start_ms
=
GetCurrentMs
();
for
(
size_t
i
=
0
;
i
<
datasets
.
size
();
++
i
)
{
feed_targets
[
feed_target_names
[
0
]]
=
&
(
datasets
[
i
]);
executor
.
RunPreparedContext
(
ctx
.
get
(),
scope
.
get
(),
&
feed_targets
,
&
fetch_targets
,
!
FLAGS_prepare_vars
);
}
stop_ms
=
GetCurrentMs
();
LOG
(
INFO
)
<<
"Tid: 0, process "
<<
datasets
.
size
()
<<
" samples, avg time per sample: "
<<
(
stop_ms
-
start_ms
)
/
datasets
.
size
()
<<
" ms"
;
}
LOG
(
INFO
)
<<
"Total inference time with "
<<
FLAGS_num_threads
<<
" threads : "
<<
(
stop_ms
-
start_ms
)
/
1000.0
<<
" sec, QPS: "
<<
datasets
.
size
()
/
((
stop_ms
-
start_ms
)
/
1000
);
}
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录