m53297601
/
mindspore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

update ascend310 infer of ssd

Browse Source
pull/12742/head
chenhaozhe 4 years ago
parent b16fcc8037
commit 1bd802aa32
5 changed files with 152 additions and 142 deletions
Show Stats Download Patch File Download Diff File

4
model_zoo/official/cv/ssd/ascend310_infer/src/CMakeLists.txt → model_zoo/official/cv/ssd/ascend310_infer/CMakeLists.txt
Unescape View File

@ -6,9 +6,9 @@ set(PROJECT_SRC_ROOT ${CMAKE_CURRENT_LIST_DIR}/)
option(MINDSPORE_PATH "mindspore install path" "") option(MINDSPORE_PATH "mindspore install path" "")
include_directories(${MINDSPORE_PATH}) include_directories(${MINDSPORE_PATH})
include_directories(${MINDSPORE_PATH}/include) include_directories(${MINDSPORE_PATH}/include)
include_directories(${PROJECT_SRC_ROOT}/../inc) include_directories(${PROJECT_SRC_ROOT})
find_library(MS_LIB libmindspore.so ${MINDSPORE_PATH}/lib) find_library(MS_LIB libmindspore.so ${MINDSPORE_PATH}/lib)
file(GLOB_RECURSE MD_LIB ${MINDSPORE_PATH}/_c_dataengine*) file(GLOB_RECURSE MD_LIB ${MINDSPORE_PATH}/_c_dataengine*)
add_executable(main main.cc utils.cc) add_executable(main src/main.cc src/utils.cc)
target_link_libraries(main ${MS_LIB} ${MD_LIB} gflags) target_link_libraries(main ${MS_LIB} ${MD_LIB} gflags)

12
model_zoo/official/cv/ssd/ascend310_infer/src/build.sh → model_zoo/official/cv/ssd/ascend310_infer/build.sh
Unescape View File

@ -13,6 +13,16 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
# ============================================================================ # ============================================================================
if [ ! -d out ]; then
mkdir out
fi
cmake . -DMINDSPORE_PATH="`pip3.7 show mindspore-ascend | grep Location | awk '{print $2"/mindspore"}' | xargs realpath`" cd out
if [ -f "Makefile" ]; then
make clean
fi
cmake .. \
-DMINDSPORE_PATH="`pip3.7 show mindspore-ascend | grep Location | awk '{print $2"/mindspore"}' | xargs realpath`"
make make

146
model_zoo/official/cv/ssd/ascend310_infer/src/main.cc
Unescape View File

@ -27,10 +27,10 @@
#include "include/api/context.h" #include "include/api/context.h"
#include "include/api/types.h" #include "include/api/types.h"
#include "include/api/serialization.h" #include "include/api/serialization.h"
#include "include/minddata/dataset/include/vision.h" #include "include/minddata/dataset/include/vision_ascend.h"
#include "include/minddata/dataset/include/execute.h" #include "include/minddata/dataset/include/execute.h"
#include "../inc/utils.h" #include "inc/utils.h"
using mindspore::GlobalContext; using mindspore::GlobalContext;
using mindspore::Serialization; using mindspore::Serialization;
@ -42,7 +42,7 @@ using mindspore::GraphCell;
using mindspore::kSuccess; using mindspore::kSuccess;
using mindspore::MSTensor; using mindspore::MSTensor;
using mindspore::dataset::Execute; using mindspore::dataset::Execute;
using mindspore::dataset::vision::DvppDecodeResizeCropJpeg; using mindspore::dataset::vision::DvppDecodeResizeJpeg;
DEFINE_string(mindir_path, "", "mindir path"); DEFINE_string(mindir_path, "", "mindir path");
@ -51,82 +51,82 @@ DEFINE_int32(device_id, 0, "device id");
DEFINE_string(aipp_path, "./aipp.cfg", "aipp path"); DEFINE_string(aipp_path, "./aipp.cfg", "aipp path");
int main(int argc, char **argv) { int main(int argc, char **argv) {
gflags::ParseCommandLineFlags(&argc, &argv, true); gflags::ParseCommandLineFlags(&argc, &argv, true);
if (RealPath(FLAGS_mindir_path).empty()) { if (RealPath(FLAGS_mindir_path).empty()) {
std::cout << "Invalid mindir" << std::endl; std::cout << "Invalid mindir" << std::endl;
return 1; return 1;
} }
if (RealPath(FLAGS_aipp_path).empty()) { if (RealPath(FLAGS_aipp_path).empty()) {
std::cout << "Invalid aipp path" << std::endl; std::cout << "Invalid aipp path" << std::endl;
return 1; return 1;
} }
GlobalContext::SetGlobalDeviceTarget(mindspore::kDeviceTypeAscend310); GlobalContext::SetGlobalDeviceTarget(mindspore::kDeviceTypeAscend310);
GlobalContext::SetGlobalDeviceID(FLAGS_device_id); GlobalContext::SetGlobalDeviceID(FLAGS_device_id);
auto graph = Serialization::LoadModel(FLAGS_mindir_path, ModelType::kMindIR); auto graph = Serialization::LoadModel(FLAGS_mindir_path, ModelType::kMindIR);
auto model_context = std::make_shared<mindspore::ModelContext>(); auto model_context = std::make_shared<mindspore::ModelContext>();
if (!FLAGS_aipp_path.empty()) { if (!FLAGS_aipp_path.empty()) {
ModelContext::SetInsertOpConfigPath(model_context, FLAGS_aipp_path); ModelContext::SetInsertOpConfigPath(model_context, FLAGS_aipp_path);
} }
Model model(GraphCell(graph), model_context); Model model(GraphCell(graph), model_context);
Status ret = model.Build(); Status ret = model.Build();
if (ret != kSuccess) { if (ret != kSuccess) {
std::cout << "ERROR: Build failed." << std::endl; std::cout << "ERROR: Build failed." << std::endl;
return 1; return 1;
} }
auto all_files = GetAllFiles(FLAGS_dataset_path); auto all_files = GetAllFiles(FLAGS_dataset_path);
if (all_files.empty()) { if (all_files.empty()) {
std::cout << "ERROR: no input data." << std::endl; std::cout << "ERROR: no input data." << std::endl;
return 1; return 1;
} }
std::map<double, double> costTime_map; std::map<double, double> costTime_map;
size_t size = all_files.size(); size_t size = all_files.size();
Execute resize_op(DvppDecodeResizeCropJpeg({640, 640}, {640, 640})); Execute resize_op(std::shared_ptr<DvppDecodeResizeJpeg>(new DvppDecodeResizeJpeg({640, 640})));
for (size_t i = 0; i < size; ++i) { for (size_t i = 0; i < size; ++i) {
struct timeval start = {0}; struct timeval start = {0};
struct timeval end = {0}; struct timeval end = {0};
double startTimeMs; double startTimeMs;
double endTimeMs; double endTimeMs;
std::vector<MSTensor> inputs; std::vector<MSTensor> inputs;
std::vector<MSTensor> outputs; std::vector<MSTensor> outputs;
std::cout << "Start predict input files:" << all_files[i] << std::endl; std::cout << "Start predict input files:" << all_files[i] << std::endl;
auto imgDvpp = std::make_shared<MSTensor>(); auto imgDvpp = std::make_shared<MSTensor>();
resize_op(ReadFileToTensor(all_files[i]), imgDvpp.get()); resize_op(ReadFileToTensor(all_files[i]), imgDvpp.get());
inputs.emplace_back(imgDvpp->Name(), imgDvpp->DataType(), imgDvpp->Shape(), inputs.emplace_back(imgDvpp->Name(), imgDvpp->DataType(), imgDvpp->Shape(),
imgDvpp->Data().get(), imgDvpp->DataSize()); imgDvpp->Data().get(), imgDvpp->DataSize());
gettimeofday(&start, nullptr); gettimeofday(&start, nullptr);
ret = model.Predict(inputs, &outputs); ret = model.Predict(inputs, &outputs);
gettimeofday(&end, nullptr); gettimeofday(&end, nullptr);
if (ret != kSuccess) { if (ret != kSuccess) {
std::cout << "Predict " << all_files[i] << " failed." << std::endl; std::cout << "Predict " << all_files[i] << " failed." << std::endl;
return 1; return 1;
}
startTimeMs = (1.0 * start.tv_sec * 1000000 + start.tv_usec) / 1000;
endTimeMs = (1.0 * end.tv_sec * 1000000 + end.tv_usec) / 1000;
costTime_map.insert(std::pair<double, double>(startTimeMs, endTimeMs));
WriteResult(all_files[i], outputs);
}
double average = 0.0;
int inferCount = 0;
char tmpCh[256] = {0};
for (auto iter = costTime_map.begin(); iter != costTime_map.end(); iter++) {
double diff = 0.0;
diff = iter->second - iter->first;
average += diff;
inferCount++;
} }
average = average / inferCount; startTimeMs = (1.0 * start.tv_sec * 1000000 + start.tv_usec) / 1000;
snprintf(tmpCh, sizeof(tmpCh), \ endTimeMs = (1.0 * end.tv_sec * 1000000 + end.tv_usec) / 1000;
"NN inference cost average time: %4.3f ms of infer_count %d \n", average, inferCount); costTime_map.insert(std::pair<double, double>(startTimeMs, endTimeMs));
std::cout << "NN inference cost average time: "<< average << "ms of infer_count " << inferCount << std::endl; WriteResult(all_files[i], outputs);
std::string fileName = "./time_Result" + std::string("/test_perform_static.txt"); }
std::ofstream fileStream(fileName.c_str(), std::ios::trunc); double average = 0.0;
fileStream << tmpCh; int inferCount = 0;
fileStream.close(); char tmpCh[256] = {0};
costTime_map.clear(); for (auto iter = costTime_map.begin(); iter != costTime_map.end(); iter++) {
return 0; double diff = 0.0;
diff = iter->second - iter->first;
average += diff;
inferCount++;
}
average = average / inferCount;
snprintf(tmpCh, sizeof(tmpCh), \
"NN inference cost average time: %4.3f ms of infer_count %d \n", average, inferCount);
std::cout << "NN inference cost average time: "<< average << "ms of infer_count " << inferCount << std::endl;
std::string fileName = "./time_Result" + std::string("/test_perform_static.txt");
std::ofstream fileStream(fileName.c_str(), std::ios::trunc);
fileStream << tmpCh;
fileStream.close();
costTime_map.clear();
return 0;
} }

126
model_zoo/official/cv/ssd/ascend310_infer/src/utils.cc
Unescape View File

@ -17,49 +17,49 @@
#include <fstream> #include <fstream>
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
#include "../inc/utils.h" #include "inc/utils.h"
using mindspore::MSTensor; using mindspore::MSTensor;
using mindspore::DataType; using mindspore::DataType;
std::vector<std::string> GetAllFiles(std::string_view dirName) { std::vector<std::string> GetAllFiles(std::string_view dirName) {
struct dirent *filename; struct dirent *filename;
DIR *dir = OpenDir(dirName); DIR *dir = OpenDir(dirName);
if (dir == nullptr) { if (dir == nullptr) {
return {}; return {};
} }
std::vector<std::string> res; std::vector<std::string> res;
while ((filename = readdir(dir)) != nullptr) { while ((filename = readdir(dir)) != nullptr) {
std::string dName = std::string(filename->d_name); std::string dName = std::string(filename->d_name);
if (dName == "." || dName == ".." || filename->d_type != DT_REG) { if (dName == "." || dName == ".." || filename->d_type != DT_REG) {
continue; continue;
}
res.emplace_back(std::string(dirName) + "/" + filename->d_name);
}
std::sort(res.begin(), res.end());
for (auto &f : res) {
std::cout << "image file: " << f << std::endl;
} }
return res; res.emplace_back(std::string(dirName) + "/" + filename->d_name);
}
std::sort(res.begin(), res.end());
for (auto &f : res) {
std::cout << "image file: " << f << std::endl;
}
return res;
} }
int WriteResult(const std::string& imageFile, const std::vector<MSTensor> &outputs) { int WriteResult(const std::string& imageFile, const std::vector<MSTensor> &outputs) {
std::string homePath = "./result_Files"; std::string homePath = "./result_Files";
for (size_t i = 0; i < outputs.size(); ++i) { for (size_t i = 0; i < outputs.size(); ++i) {
size_t outputSize; size_t outputSize;
std::shared_ptr<const void> netOutput; std::shared_ptr<const void> netOutput;
netOutput = outputs[i].Data(); netOutput = outputs[i].Data();
outputSize = outputs[i].DataSize(); outputSize = outputs[i].DataSize();
int pos = imageFile.rfind('/'); int pos = imageFile.rfind('/');
std::string fileName(imageFile, pos + 1); std::string fileName(imageFile, pos + 1);
fileName.replace(fileName.find('.'), fileName.size() - fileName.find('.'), '_' + std::to_string(i) + ".bin"); fileName.replace(fileName.find('.'), fileName.size() - fileName.find('.'), '_' + std::to_string(i) + ".bin");
std::string outFileName = homePath + "/" + fileName; std::string outFileName = homePath + "/" + fileName;
FILE * outputFile = fopen(outFileName.c_str(), "wb"); FILE * outputFile = fopen(outFileName.c_str(), "wb");
fwrite(netOutput.get(), outputSize, sizeof(char), outputFile); fwrite(netOutput.get(), outputSize, sizeof(char), outputFile);
fclose(outputFile); fclose(outputFile);
outputFile = nullptr; outputFile = nullptr;
} }
return 0; return 0;
} }
mindspore::MSTensor ReadFileToTensor(const std::string &file) { mindspore::MSTensor ReadFileToTensor(const std::string &file) {
@ -92,38 +92,38 @@ mindspore::MSTensor ReadFileToTensor(const std::string &file) {
DIR *OpenDir(std::string_view dirName) { DIR *OpenDir(std::string_view dirName) {
if (dirName.empty()) { if (dirName.empty()) {
std::cout << " dirName is null ! " << std::endl; std::cout << " dirName is null ! " << std::endl;
return nullptr; return nullptr;
} }
std::string realPath = RealPath(dirName); std::string realPath = RealPath(dirName);
struct stat s; struct stat s;
lstat(realPath.c_str(), &s); lstat(realPath.c_str(), &s);
if (!S_ISDIR(s.st_mode)) { if (!S_ISDIR(s.st_mode)) {
std::cout << "dirName is not a valid directory !" << std::endl; std::cout << "dirName is not a valid directory !" << std::endl;
return nullptr; return nullptr;
} }
DIR *dir; DIR *dir;
dir = opendir(realPath.c_str()); dir = opendir(realPath.c_str());
if (dir == nullptr) { if (dir == nullptr) {
std::cout << "Can not open dir " << dirName << std::endl; std::cout << "Can not open dir " << dirName << std::endl;
return nullptr; return nullptr;
} }
std::cout << "Successfully opened the dir " << dirName << std::endl; std::cout << "Successfully opened the dir " << dirName << std::endl;
return dir; return dir;
} }
std::string RealPath(std::string_view path) { std::string RealPath(std::string_view path) {
char realPathMem[PATH_MAX] = {0}; char realPathMem[PATH_MAX] = {0};
char *realPathRet = nullptr; char *realPathRet = nullptr;
realPathRet = realpath(path.data(), realPathMem); realPathRet = realpath(path.data(), realPathMem);
if (realPathRet == nullptr) { if (realPathRet == nullptr) {
std::cout << "File: " << path << " is not exist."; std::cout << "File: " << path << " is not exist.";
return ""; return "";
} }
std::string realPath(realPathMem); std::string realPath(realPathMem);
std::cout << path << " realpath is: " << realPath << std::endl; std::cout << path << " realpath is: " << realPath << std::endl;
return realPath; return realPath;
} }

4
model_zoo/official/cv/ssd/scripts/run_infer_310.sh
Unescape View File

@ -55,7 +55,7 @@ fi
function compile_app() function compile_app()
{ {
cd ../ascend310_infer/src cd ../ascend310_infer
if [ -f "Makefile" ]; then if [ -f "Makefile" ]; then
make clean make clean
fi fi
@ -73,7 +73,7 @@ function infer()
fi fi
mkdir result_Files mkdir result_Files
mkdir time_Result mkdir time_Result
../ascend310_infer/src/main --mindir_path=$model --dataset_path=$data_path --device_id=$device_id --aipp_path ../src/aipp.cfg &> infer.log ../ascend310_infer/out/main --mindir_path=$model --dataset_path=$data_path --device_id=$device_id --aipp_path ../src/aipp.cfg &> infer.log
} }
function cal_acc() function cal_acc()

Write Preview
Loading…
Cancel
Save