update ascend310 infer of ssd

model_zoo/official/cv/ssd/ascend310_infer/src/CMakeLists.txt → model_zoo/official/cv/ssd/ascend310_infer/CMakeLists.txt

@@ -6,9 +6,9 @@ set(PROJECT_SRC_ROOT ${CMAKE_CURRENT_LIST_DIR}/)
 option(MINDSPORE_PATH "mindspore install path" "")
 include_directories(${MINDSPORE_PATH})
 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)
 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)

model_zoo/official/cv/ssd/ascend310_infer/src/build.sh → model_zoo/official/cv/ssd/ascend310_infer/build.sh

@@ -13,6 +13,16 @@
 # See the License for the specific language governing permissions and
 # 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`"
-make
+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

model_zoo/official/cv/ssd/ascend310_infer/src/main.cc

@@ -27,10 +27,10 @@
 #include "include/api/context.h"
 #include "include/api/types.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 "../inc/utils.h"
+#include "inc/utils.h"
 
 using mindspore::GlobalContext;
 using mindspore::Serialization;
@@ -42,7 +42,7 @@ using mindspore::GraphCell;
 using mindspore::kSuccess;
 using mindspore::MSTensor;
 using mindspore::dataset::Execute;
-using mindspore::dataset::vision::DvppDecodeResizeCropJpeg;
+using mindspore::dataset::vision::DvppDecodeResizeJpeg;
 
 
 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");
 
 int main(int argc, char **argv) {
-    gflags::ParseCommandLineFlags(&argc, &argv, true);
-    if (RealPath(FLAGS_mindir_path).empty()) {
-        std::cout << "Invalid mindir" << std::endl;
-        return 1;
-    }
-    if (RealPath(FLAGS_aipp_path).empty()) {
-        std::cout << "Invalid aipp path" << std::endl;
-        return 1;
-    }
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  if (RealPath(FLAGS_mindir_path).empty()) {
+    std::cout << "Invalid mindir" << std::endl;
+    return 1;
+  }
+  if (RealPath(FLAGS_aipp_path).empty()) {
+    std::cout << "Invalid aipp path" << std::endl;
+    return 1;
+  }
 
-    GlobalContext::SetGlobalDeviceTarget(mindspore::kDeviceTypeAscend310);
-    GlobalContext::SetGlobalDeviceID(FLAGS_device_id);
-    auto graph = Serialization::LoadModel(FLAGS_mindir_path, ModelType::kMindIR);
-    auto model_context = std::make_shared<mindspore::ModelContext>();
-    if (!FLAGS_aipp_path.empty()) {
-      ModelContext::SetInsertOpConfigPath(model_context, FLAGS_aipp_path);
-    }
+  GlobalContext::SetGlobalDeviceTarget(mindspore::kDeviceTypeAscend310);
+  GlobalContext::SetGlobalDeviceID(FLAGS_device_id);
+  auto graph = Serialization::LoadModel(FLAGS_mindir_path, ModelType::kMindIR);
+  auto model_context = std::make_shared<mindspore::ModelContext>();
+  if (!FLAGS_aipp_path.empty()) {
+    ModelContext::SetInsertOpConfigPath(model_context, FLAGS_aipp_path);
+  }
 
-    Model model(GraphCell(graph), model_context);
-    Status ret = model.Build();
-    if (ret != kSuccess) {
-        std::cout << "ERROR: Build failed." << std::endl;
-        return 1;
-    }
+  Model model(GraphCell(graph), model_context);
+  Status ret = model.Build();
+  if (ret != kSuccess) {
+    std::cout << "ERROR: Build failed." << std::endl;
+    return 1;
+  }
 
-    auto all_files = GetAllFiles(FLAGS_dataset_path);
-    if (all_files.empty()) {
+  auto all_files = GetAllFiles(FLAGS_dataset_path);
+  if (all_files.empty()) {
     std::cout << "ERROR: no input data." << std::endl;
     return 1;
-    }
+  }
 
-    std::map<double, double> costTime_map;
-    size_t size = all_files.size();
-    Execute resize_op(DvppDecodeResizeCropJpeg({640, 640}, {640, 640}));
-    for (size_t i = 0; i < size; ++i) {
-        struct timeval start = {0};
-        struct timeval end = {0};
-        double startTimeMs;
-        double endTimeMs;
-        std::vector<MSTensor> inputs;
-        std::vector<MSTensor> outputs;
-        std::cout << "Start predict input files:" << all_files[i] << std::endl;
-        auto imgDvpp = std::make_shared<MSTensor>();
-        resize_op(ReadFileToTensor(all_files[i]), imgDvpp.get());
+  std::map<double, double> costTime_map;
+  size_t size = all_files.size();
+  Execute resize_op(std::shared_ptr<DvppDecodeResizeJpeg>(new DvppDecodeResizeJpeg({640, 640})));
+  for (size_t i = 0; i < size; ++i) {
+    struct timeval start = {0};
+    struct timeval end = {0};
+    double startTimeMs;
+    double endTimeMs;
+    std::vector<MSTensor> inputs;
+    std::vector<MSTensor> outputs;
+    std::cout << "Start predict input files:" << all_files[i] << std::endl;
+    auto imgDvpp = std::make_shared<MSTensor>();
+    resize_op(ReadFileToTensor(all_files[i]), imgDvpp.get());
 
-        inputs.emplace_back(imgDvpp->Name(), imgDvpp->DataType(), imgDvpp->Shape(),
-                            imgDvpp->Data().get(), imgDvpp->DataSize());
-        gettimeofday(&start, nullptr);
-        ret = model.Predict(inputs, &outputs);
-        gettimeofday(&end, nullptr);
-        if (ret != kSuccess) {
-            std::cout << "Predict " << all_files[i] << " failed." << std::endl;
-            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++;
+    inputs.emplace_back(imgDvpp->Name(), imgDvpp->DataType(), imgDvpp->Shape(),
+                        imgDvpp->Data().get(), imgDvpp->DataSize());
+    gettimeofday(&start, nullptr);
+    ret = model.Predict(inputs, &outputs);
+    gettimeofday(&end, nullptr);
+    if (ret != kSuccess) {
+      std::cout << "Predict " << all_files[i] << " failed." << std::endl;
+      return 1;
     }
-    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;
+    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;
+  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;
 }

model_zoo/official/cv/ssd/ascend310_infer/src/utils.cc

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

model_zoo/official/cv/ssd/scripts/run_infer_310.sh

@@ -55,7 +55,7 @@ fi
 
 function compile_app()
 {
-    cd ../ascend310_infer/src
+    cd ../ascend310_infer
     if [ -f "Makefile" ]; then
         make clean
     fi
@@ -73,7 +73,7 @@ function infer()
     fi
     mkdir result_Files
     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()