!17285 alexnet add 310 infer

From: @zeyangao
Reviewed-by: @oacjiewen,@c_34
Signed-off-by: @c_34

model_zoo/official/cv/alexnet/README.md

@@ -191,6 +191,40 @@ Before running the command below, please check the checkpoint path used for eval
   'Accuracy': 0.88512
   ```
 
+## Inference Process
+
+### [Export MindIR](#contents)
+
+```shell
+python export.py --ckpt_file [CKPT_PATH] --file_name [FILE_NAME] --file_format [FILE_FORMAT]
+```
+
+The ckpt_file parameter is required,
+`EXPORT_FORMAT` should be in ["AIR", "MINDIR"]
+
+### Infer on Ascend310
+
+Before performing inference, the mindir file must be exported by `export.py` script. We only provide an example of inference using MINDIR model.
+Current batch_Size for imagenet2012 dataset can only be set to 1.
+
+```shell
+# Ascend310 inference
+bash run_infer_310.sh [MINDIR_PATH] [DATASET_PATH] [NEED_PREPROCESS] [DEVICE_ID]
+```
+
+- `MINDIR_PATH` specifies path of used "MINDIR" OR "AIR" model.
+- `DATASET_PATH` specifies path of cifar10 datasets
+- `NEED_PREPROCESS` means weather need preprocess or not, it's value is 'y' or 'n', if you choose y, the cifar10 dataset will be processed in bin format, the imagenet2012 dataset will generate label json file.  
+- `DEVICE_ID` is optional, default value is 0.
+
+### result
+
+Inference result is saved in current path, you can find result like this in acc.log file.
+
+```bash
+'acc': 0.88772
+```
+
 ## [Model Description](#contents)
 
 ### [Performance](#contents)

model_zoo/official/cv/alexnet/README_CN.md

@@ -195,6 +195,40 @@ train.py和config.py中主要参数如下：
   'Accuracy': 0.88512
   ```
 
+## 推理过程
+
+### [导出MindIR](#contents)
+
+```shell
+python export.py --ckpt_file [CKPT_PATH] --file_name [FILE_NAME] --file_format [FILE_FORMAT]
+```
+
+参数ckpt_file为必填项，
+`EXPORT_FORMAT` 必须在 ["AIR", "MINDIR"]中选择。
+
+### 在Ascend310执行推理
+
+在执行推理前，mindir文件必须通过`export.py`脚本导出。以下展示了使用minir模型执行推理的示例。
+目前imagenet2012数据集仅支持batch_Size为1的推理。
+
+```shell
+# Ascend310 inference
+bash run_infer_310.sh [MINDIR_PATH] [DATASET_PATH] [NEED_PREPROCESS] [DEVICE_ID]
+```
+
+- `MINDIR_PATH` mindir文件路径
+- `DATASET_PATH` 推理数据集路径
+- `NEED_PREPROCESS` 表示数据集是否需要预处理，可在`y`或者`n`中选择，如果选择`y`，cifar10数据集将被处理为bin格式。
+- `DEVICE_ID` 可选，默认值为0。
+
+### 结果
+
+推理结果保存在脚本执行的当前路径，你可以在acc.log中看到以下精度计算结果。
+
+```bash
+'acc': 0.88772
+```
+
 ## 模型描述
 
 ### 性能

model_zoo/official/cv/alexnet/ascend310_infer/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.14.1)
+project(Ascend310Infer)
+add_compile_definitions(_GLIBCXX_USE_CXX11_ABI=0)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -std=c++17 -Werror -Wall -fPIE -Wl,--allow-shlib-undefined")
+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})
+find_library(MS_LIB libmindspore.so ${MINDSPORE_PATH}/lib)
+file(GLOB_RECURSE MD_LIB ${MINDSPORE_PATH}/_c_dataengine*)
+
+add_executable(main src/main.cc src/utils.cc)
+target_link_libraries(main ${MS_LIB} ${MD_LIB} gflags)

model_zoo/official/cv/alexnet/ascend310_infer/build.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# 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.
+# ============================================================================
+if [ -d out ]; then
+    rm -rf out
+fi
+
+mkdir out
+cd out || exit
+
+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/alexnet/ascend310_infer/inc/utils.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2021 Huawei Technologies Co., Ltd
+ * 
+ * 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.
+ */
+
+#ifndef MINDSPORE_INFERENCE_UTILS_H_
+#define MINDSPORE_INFERENCE_UTILS_H_
+
+#include <sys/stat.h>
+#include <dirent.h>
+#include <vector>
+#include <string>
+#include <memory>
+#include "include/api/types.h"
+
+std::vector<std::string> GetAllFiles(std::string_view dirName);
+DIR *OpenDir(std::string_view dirName);
+std::string RealPath(std::string_view path);
+mindspore::MSTensor ReadFileToTensor(const std::string &file);
+int WriteResult(const std::string& imageFile, const std::vector<mindspore::MSTensor> &outputs);
+std::vector<std::string> GetAllFiles(std::string dir_name);
+std::vector<std::vector<std::string>> GetAllInputData(std::string dir_name);
+
+#endif

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

@@ -0,0 +1,181 @@
+/**
+ * Copyright 2021 Huawei Technologies Co., Ltd
+ * 
+ * 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 <gflags/gflags.h>
+#include <dirent.h>
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <iosfwd>
+#include <vector>
+#include <fstream>
+#include <sstream>
+
+#include "include/api/model.h"
+#include "include/api/context.h"
+#include "include/api/types.h"
+#include "include/api/serialization.h"
+#include "include/dataset/vision_ascend.h"
+#include "include/dataset/execute.h"
+#include "include/dataset/transforms.h"
+#include "include/dataset/vision.h"
+#include "inc/utils.h"
+
+using mindspore::Context;
+using mindspore::Serialization;
+using mindspore::Model;
+using mindspore::Status;
+using mindspore::ModelType;
+using mindspore::GraphCell;
+using mindspore::kSuccess;
+using mindspore::MSTensor;
+using mindspore::dataset::Execute;
+using mindspore::dataset::vision::Decode;
+using mindspore::dataset::vision::Resize;
+using mindspore::dataset::vision::CenterCrop;
+using mindspore::dataset::vision::Normalize;
+using mindspore::dataset::vision::HWC2CHW;
+
+
+DEFINE_string(mindir_path, "", "mindir path");
+DEFINE_string(dataset_name, "cifar10", "['cifar10', 'imagenet2012']");
+DEFINE_string(input0_path, ".", "input0 path");
+DEFINE_int32(device_id, 0, "device id");
+
+int load_model(Model *model, std::vector<MSTensor> *model_inputs, std::string mindir_path, int device_id) {
+  if (RealPath(mindir_path).empty()) {
+    std::cout << "Invalid mindir" << std::endl;
+    return 1;
+  }
+
+  auto context = std::make_shared<Context>();
+  auto ascend310 = std::make_shared<mindspore::Ascend310DeviceInfo>();
+  ascend310->SetDeviceID(device_id);
+  context->MutableDeviceInfo().push_back(ascend310);
+  mindspore::Graph graph;
+  Serialization::Load(mindir_path, ModelType::kMindIR, &graph);
+
+  Status ret = model->Build(GraphCell(graph), context);
+  if (ret != kSuccess) {
+    std::cout << "ERROR: Build failed." << std::endl;
+    return 1;
+  }
+
+  *model_inputs = model->GetInputs();
+  if (model_inputs->empty()) {
+    std::cout << "Invalid model, inputs is empty." << std::endl;
+    return 1;
+  }
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+  Model model;
+  std::vector<MSTensor> model_inputs;
+  load_model(&model, &model_inputs, FLAGS_mindir_path, FLAGS_device_id);
+
+  std::map<double, double> costTime_map;
+  struct timeval start = {0};
+  struct timeval end = {0};
+  double startTimeMs;
+  double endTimeMs;
+
+  if (FLAGS_dataset_name == "cifar10") {
+    auto input0_files = GetAllFiles(FLAGS_input0_path);
+    if (input0_files.empty()) {
+      std::cout << "ERROR: no input data." << std::endl;
+      return 1;
+    }
+    size_t size = input0_files.size();
+    for (size_t i = 0; i < size; ++i) {
+      std::vector<MSTensor> inputs;
+      std::vector<MSTensor> outputs;
+      std::cout << "Start predict input files:" << input0_files[i] <<std::endl;
+      auto input0 = ReadFileToTensor(input0_files[i]);
+      inputs.emplace_back(model_inputs[0].Name(), model_inputs[0].DataType(), model_inputs[0].Shape(),
+                          input0.Data().get(), input0.DataSize());
+
+      gettimeofday(&start, nullptr);
+      Status ret = model.Predict(inputs, &outputs);
+      gettimeofday(&end, nullptr);
+      if (ret != kSuccess) {
+        std::cout << "Predict " << input0_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(input0_files[i], outputs);
+    }
+  } else {
+    auto input0_files = GetAllInputData(FLAGS_input0_path);
+    if (input0_files.empty()) {
+      std::cout << "ERROR: no input data." << std::endl;
+      return 1;
+    }
+    size_t size = input0_files.size();
+    for (size_t i = 0; i < size; ++i) {
+      for (size_t j = 0; j < input0_files[i].size(); ++j) {
+        std::vector<MSTensor> inputs;
+        std::vector<MSTensor> outputs;
+        std::cout << "Start predict input files:" << input0_files[i][j] <<std::endl;
+        auto decode = Decode();
+        auto resize = Resize({256, 256});
+        auto centercrop = CenterCrop({224, 224});
+        auto normalize = Normalize({123.675, 116.28, 103.53}, {58.395, 57.12, 57.375});
+        auto hwc2chw = HWC2CHW();
+
+        Execute SingleOp({decode, resize, centercrop, normalize, hwc2chw});
+        auto imgDvpp = std::make_shared<MSTensor>();
+        SingleOp(ReadFileToTensor(input0_files[i][j]), imgDvpp.get());
+        inputs.emplace_back(model_inputs[0].Name(), model_inputs[0].DataType(), model_inputs[0].Shape(),
+                            imgDvpp->Data().get(), imgDvpp->DataSize());
+      gettimeofday(&start, nullptr);
+      Status ret = model.Predict(inputs, &outputs);
+      gettimeofday(&end, nullptr);
+      if (ret != kSuccess) {
+        std::cout << "Predict " << input0_files[i][j] << " 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(input0_files[i][j], outputs);
+      }
+    }
+  }
+  double average = 0.0;
+  int inferCount = 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;
+  std::stringstream timeCost;
+  timeCost << "NN inference cost average time: "<< average << " ms of infer_count " << inferCount << std::endl;
+  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 << timeCost.str();
+  fileStream.close();
+  costTime_map.clear();
+  return 0;
+}

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

@@ -0,0 +1,185 @@
+/**
+ * Copyright 2021 Huawei Technologies Co., Ltd
+ * 
+ * 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 <fstream>
+#include <algorithm>
+#include <iostream>
+#include "inc/utils.h"
+
+using mindspore::MSTensor;
+using mindspore::DataType;
+
+
+std::vector<std::vector<std::string>> GetAllInputData(std::string dir_name) {
+  std::vector<std::vector<std::string>> ret;
+
+  DIR *dir = OpenDir(dir_name);
+  if (dir == nullptr) {
+    return {};
+  }
+  struct dirent *filename;
+  /* read all the files in the dir ~ */
+  std::vector<std::string> sub_dirs;
+  while ((filename = readdir(dir)) != nullptr) {
+    std::string d_name = std::string(filename->d_name);
+    // get rid of "." and ".."
+    if (d_name == "." || d_name == ".." || d_name.empty()) {
+      continue;
+    }
+    std::string dir_path = RealPath(std::string(dir_name) + "/" + filename->d_name);
+    struct stat s;
+    lstat(dir_path.c_str(), &s);
+    if (!S_ISDIR(s.st_mode)) {
+      continue;
+    }
+
+    sub_dirs.emplace_back(dir_path);
+  }
+  std::sort(sub_dirs.begin(), sub_dirs.end());
+
+  (void)std::transform(sub_dirs.begin(), sub_dirs.end(), std::back_inserter(ret),
+                       [](const std::string &d) { return GetAllFiles(d); });
+
+  return ret;
+}
+
+
+std::vector<std::string> GetAllFiles(std::string dir_name) {
+  struct dirent *filename;
+  DIR *dir = OpenDir(dir_name);
+  if (dir == nullptr) {
+    return {};
+  }
+
+  std::vector<std::string> res;
+  while ((filename = readdir(dir)) != nullptr) {
+    std::string d_name = std::string(filename->d_name);
+    if (d_name == "." || d_name == ".." || d_name.size() <= 3) {
+      continue;
+    }
+    res.emplace_back(std::string(dir_name) + "/" + filename->d_name);
+  }
+  std::sort(res.begin(), res.end());
+
+  return res;
+}
+
+
+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;
+  }
+  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;
+}
+
+mindspore::MSTensor ReadFileToTensor(const std::string &file) {
+  if (file.empty()) {
+    std::cout << "Pointer file is nullptr" << std::endl;
+    return mindspore::MSTensor();
+  }
+
+  std::ifstream ifs(file);
+  if (!ifs.good()) {
+    std::cout << "File: " << file << " is not exist" << std::endl;
+    return mindspore::MSTensor();
+  }
+
+  if (!ifs.is_open()) {
+    std::cout << "File: " << file << "open failed" << std::endl;
+    return mindspore::MSTensor();
+  }
+
+  ifs.seekg(0, std::ios::end);
+  size_t size = ifs.tellg();
+  mindspore::MSTensor buffer(file, mindspore::DataType::kNumberTypeUInt8, {static_cast<int64_t>(size)}, nullptr, size);
+
+  ifs.seekg(0, std::ios::beg);
+  ifs.read(reinterpret_cast<char *>(buffer.MutableData()), size);
+  ifs.close();
+
+  return buffer;
+}
+
+
+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;
+}
+
+std::string RealPath(std::string_view path) {
+  char realPathMem[PATH_MAX] = {0};
+  char *realPathRet = nullptr;
+  realPathRet = realpath(path.data(), realPathMem);
+  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;
+}

model_zoo/official/cv/alexnet/postprocess.py

@@ -0,0 +1,55 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# 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
+#
+# less 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.
+# ============================================================================
+"""postprocess for 310 inference"""
+import os
+import json
+import argparse
+import numpy as np
+from mindspore.nn import Top1CategoricalAccuracy, Top5CategoricalAccuracy
+
+
+batch_size = 1
+parser = argparse.ArgumentParser(description="postprocess")
+parser.add_argument("--result_dir", type=str, required=True, help="result files path.")
+parser.add_argument("--label_dir", type=str, required=True, help="image file path.")
+parser.add_argument('--dataset_name', type=str, choices=["cifar10", "imagenet2012"], default="cifar10")
+args = parser.parse_args()
+
+if __name__ == '__main__':
+    top1_acc = Top1CategoricalAccuracy()
+    rst_path = args.result_dir
+    if args.dataset_name == "cifar10":
+        from src.config import alexnet_cifar10_cfg as cfg
+        labels = np.load(args.label_dir, allow_pickle=True)
+        for idx, label in enumerate(labels):
+            f_name = os.path.join(rst_path, "alexnet_data_bs" + str(cfg.batch_size) + "_" + str(idx) + "_0.bin")
+            pred = np.fromfile(f_name, np.float32)
+            pred = pred.reshape(cfg.batch_size, int(pred.shape[0] / cfg.batch_size))
+            top1_acc.update(pred, labels[idx])
+        print("acc: ", top1_acc.eval())
+    else:
+        from src.config import alexnet_imagenet_cfg as cfg
+        top5_acc = Top5CategoricalAccuracy()
+        file_list = os.listdir(rst_path)
+        with open(args.label_dir, "r") as label:
+            labels = json.load(label)
+        for f in file_list:
+            label = f.split("_0.bin")[0] + ".JPEG"
+            pred = np.fromfile(os.path.join(rst_path, f), np.float32)
+            pred = pred.reshape(cfg.batch_size, int(pred.shape[0] / cfg.batch_size))
+            top1_acc.update(pred, [labels[label],])
+            top5_acc.update(pred, [labels[label],])
+        print("Top1 acc: ", top1_acc.eval())
+        print("Top5 acc: ", top5_acc.eval())

model_zoo/official/cv/alexnet/preprocess.py

@@ -0,0 +1,73 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# 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.
+# ============================================================================
+"""preprocess"""
+import os
+import argparse
+import json
+import numpy as np
+from src.dataset import create_dataset_cifar10
+
+def create_label(result_path, dir_path):
+    print("[WARNING] Create imagenet label. Currently only use for Imagenet2012!")
+    dirs = os.listdir(dir_path)
+    file_list = []
+    for file in dirs:
+        file_list.append(file)
+    file_list = sorted(file_list)
+
+    total = 0
+    img_label = {}
+    for i, file_dir in enumerate(file_list):
+        files = os.listdir(os.path.join(dir_path, file_dir))
+        for f in files:
+            img_label[f] = i
+        total += len(files)
+
+    json_file = os.path.join(result_path, "imagenet_label.json")
+    with open(json_file, "w+") as label:
+        json.dump(img_label, label)
+
+    print("[INFO] Completed! Total {} data.".format(total))
+
+parser = argparse.ArgumentParser('preprocess')
+parser.add_argument('--dataset', type=str, choices=["cifar10", "imagenet2012"], default="cifar10")
+parser.add_argument('--data_path', type=str, default='', help='eval data dir')
+parser.add_argument('--result_path', type=str, default='./preprocess_Result/', help='result path')
+args = parser.parse_args()
+
+if args.dataset == "cifar10":
+    from src.config import alexnet_cifar10_cfg as cfg
+else:
+    from src.config import alexnet_imagenet_cfg as cfg
+
+args.per_batch_size = cfg.batch_size
+#args.image_size = cfg.image_size
+
+
+if __name__ == "__main__":
+    if args.dataset == "cifar10":
+        dataset = create_dataset_cifar10(args.data_path, args.per_batch_size, training=False)
+        img_path = os.path.join(args.result_path, "00_data")
+        os.makedirs(img_path)
+        label_list = []
+        for idx, data in enumerate(dataset.create_dict_iterator(output_numpy=True)):
+            file_name = "alexnet_data_bs" + str(args.per_batch_size) + "_" + str(idx) + ".bin"
+            file_path = os.path.join(img_path, file_name)
+            data["image"].tofile(file_path)
+            label_list.append(data["label"])
+        np.save(os.path.join(args.result_path, "cifar10_label_ids.npy"), label_list)
+        print("=" * 20, "export bin files finished", "=" * 20)
+    else:
+        create_label(args.result_path, args.data_path)

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

@@ -0,0 +1,152 @@
+#!/bin/bash
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# 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.
+# ============================================================================
+
+if [[ $# -lt 3 || $# -gt 4 ]]; then
+    echo "Usage: bash run_infer_310.sh [MINDIR_PATH] [DATASET_PATH] [NEED_PREPROCESS] [DEVICE_ID]
+    NEED_PREPROCESS means weather need preprocess or not, it's value is 'y' or 'n'.
+    DEVICE_ID is optional, it can be set by environment variable device_id, otherwise the value is zero"
+exit 1
+fi
+
+get_real_path(){
+    if [ "${1:0:1}" == "/" ]; then
+        echo "$1"
+    else
+        echo "$(realpath -m $PWD/$1)"
+    fi
+}
+model=$(get_real_path $1)
+dataset_name='cifar10'
+
+
+dataset_path=$(get_real_path $2)
+
+if [ "$3" == "y" ] || [ "$3" == "n" ];then
+    need_preprocess=$3
+else
+  echo "weather need preprocess or not, it's value must be in [y, n]"
+  exit 1
+fi
+
+device_id=0
+if [ $# == 4 ]; then
+    device_id=$4
+fi
+
+echo "mindir name: "$model
+echo "dataset name: "$dataset_name
+echo "dataset path: "$dataset_path
+echo "need preprocess: "$need_preprocess
+echo "device id: "$device_id
+
+export ASCEND_HOME=/usr/local/Ascend/
+if [ -d ${ASCEND_HOME}/ascend-toolkit ]; then
+    export PATH=$ASCEND_HOME/ascend-toolkit/latest/fwkacllib/ccec_compiler/bin:$ASCEND_HOME/ascend-toolkit/latest/atc/bin:$PATH
+    export LD_LIBRARY_PATH=/usr/local/lib:$ASCEND_HOME/ascend-toolkit/latest/atc/lib64:$ASCEND_HOME/ascend-toolkit/latest/fwkacllib/lib64:$ASCEND_HOME/driver/lib64:$ASCEND_HOME/add-ons:$LD_LIBRARY_PATH
+    export TBE_IMPL_PATH=$ASCEND_HOME/ascend-toolkit/latest/opp/op_impl/built-in/ai_core/tbe
+    export PYTHONPATH=${TBE_IMPL_PATH}:$ASCEND_HOME/ascend-toolkit/latest/fwkacllib/python/site-packages:$PYTHONPATH
+    export ASCEND_OPP_PATH=$ASCEND_HOME/ascend-toolkit/latest/opp
+else
+    export PATH=$ASCEND_HOME/atc/ccec_compiler/bin:$ASCEND_HOME/atc/bin:$PATH
+    export LD_LIBRARY_PATH=/usr/local/lib:$ASCEND_HOME/atc/lib64:$ASCEND_HOME/acllib/lib64:$ASCEND_HOME/driver/lib64:$ASCEND_HOME/add-ons:$LD_LIBRARY_PATH
+    export PYTHONPATH=$ASCEND_HOME/atc/python/site-packages:$PYTHONPATH
+    export ASCEND_OPP_PATH=$ASCEND_HOME/opp
+fi
+export SLOG_PRINT_to_STDOUT=0
+export GLOG_v=2
+export DUMP_GE_GRAPH=2
+
+
+export ASCEND_HOME=/usr/local/Ascend
+
+export PATH=$ASCEND_HOME/fwkacllib/ccec_compiler/bin:$ASCEND_HOME/fwkacllib/bin:$ASCEND_HOME/toolkit/bin:$PATH
+
+export LD_LIBRARY_PATH=/usr/local/lib/:/usr/local/fwkacllib/lib64:$ASCEND_HOME/driver/lib64:$ASCEND_HOME/add-ons:/usr/local/Ascend/toolkit/lib64:$LD_LIBRARY_PATH
+
+export PYTHONPATH=$ASCEND_HOME/fwkacllib/python/site-packages
+
+export PATH=/usr/local/python375/bin:$PATH
+export NPU_HOST_LIB=/usr/local/Ascend/acllib/lib64/stub
+export ASCEND_OPP_PATH=/usr/local/Ascend/opp
+export ASCEND_AICPU_PATH=/usr/local/Ascend
+export LD_LIBRARY_PATH=/usr/local/lib64/:$LD_LIBRARY_PATH
+
+
+function preprocess_data()
+{
+    if [ -d preprocess_Result ]; then
+        rm -rf ./preprocess_Result
+    fi
+    mkdir preprocess_Result
+    python3.7 ../preprocess.py --dataset=$dataset_name --data_path=$dataset_path --result_path=./preprocess_Result/
+}
+
+function compile_app()
+{
+    cd ../ascend310_infer/ || exit
+    bash build.sh &> build.log
+}
+
+function infer()
+{
+    cd - || exit
+    if [ -d result_Files ]; then
+        rm -rf ./result_Files
+    fi
+    if [ -d time_Result ]; then
+        rm -rf ./time_Result
+    fi
+    mkdir result_Files
+    mkdir time_Result
+
+    if [ "$dataset_name" == "cifar10" ]; then
+        ../ascend310_infer/out/main --mindir_path=$model --dataset_name=$dataset_name --input0_path=./preprocess_Result/00_data --device_id=$device_id  &> infer.log
+    else
+        ../ascend310_infer/out/main --mindir_path=$model --dataset_name=$dataset_name --input0_path=$dataset_path --device_id=$device_id  &> infer.log
+    fi
+}
+
+function cal_acc()
+{
+    if [ "$dataset_name" == "cifar10" ]; then
+        python3.7 ../postprocess.py --result_dir=./result_Files --label_dir=./preprocess_Result/cifar10_label_ids.npy --dataset_name=$dataset_name  &> acc.log
+    else
+        python3.7 ../postprocess.py --result_dir=./result_Files --label_dir=./preprocess_Result/imagenet_label.json --dataset_name=$dataset_name  &> acc.log
+    fi
+}
+
+if [ $need_preprocess == "y" ]; then
+    preprocess_data
+    if [ $? -ne 0 ]; then
+        echo "preprocess dataset failed"
+        exit 1
+    fi
+fi
+compile_app
+if [ $? -ne 0 ]; then
+    echo "compile app code failed"
+    exit 1
+fi
+infer
+if [ $? -ne 0 ]; then
+    echo " execute inference failed"
+    exit 1
+fi
+cal_acc
+if [ $? -ne 0 ]; then
+    echo "calculate accuracy failed"
+    exit 1
+fi

model_zoo/official/cv/alexnet/src/config.py

@@ -0,0 +1,54 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# 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.
+# ============================================================================
+
+"""
+network config setting, will be used in train.py
+"""
+from easydict import EasyDict as edict
+
+alexnet_cifar10_cfg = edict({
+    'num_classes': 10,
+    'learning_rate': 0.002,
+    'momentum': 0.9,
+    'epoch_size': 30,
+    'batch_size': 32,
+    'buffer_size': 1000,
+    'image_height': 227,
+    'image_width': 227,
+    'save_checkpoint_steps': 1562,
+    'keep_checkpoint_max': 10,
+    'air_name': "alexnet.air",
+})
+
+alexnet_imagenet_cfg = edict({
+    'num_classes': 1000,
+    'learning_rate': 0.13,
+    'momentum': 0.9,
+    'epoch_size': 150,
+    'batch_size': 256,
+    'buffer_size': None, # invalid parameter
+    'image_height': 224,
+    'image_width': 224,
+    'save_checkpoint_steps': 625,
+    'keep_checkpoint_max': 10,
+    'air_name': "alexnet.air",
+
+    # opt
+    'weight_decay': 0.0001,
+    'loss_scale': 1024,
+
+    # lr
+    'is_dynamic_loss_scale': 0,
+})

model_zoo/official/cv/alexnet/src/dataset.py

@@ -22,9 +22,10 @@ import mindspore.dataset.transforms.c_transforms as C
 import mindspore.dataset.vision.c_transforms as CV
 from mindspore.common import dtype as mstype
 from mindspore.communication.management import get_rank, get_group_size
+from .config import alexnet_cifar10_cfg, alexnet_imagenet_cfg
 
 
-def create_dataset_cifar10(cfg, data_path, batch_size=32, repeat_size=1, status="train", target="Ascend"):
+def create_dataset_cifar10(data_path, cfg, batch_size=32, repeat_size=1, training=True, target="Ascend"):
     """
     create dataset for train or test
     """
@@ -39,18 +40,18 @@ def create_dataset_cifar10(cfg, data_path, batch_size=32, repeat_size=1, status=
                                      num_shards=device_num, shard_id=rank_id)
     rescale = 1.0 / 255.0
     shift = 0.0
-    # cfg = alexnet_cifar10_cfg
+    cfg = alexnet_cifar10_cfg
 
     resize_op = CV.Resize((cfg.image_height, cfg.image_width))
     rescale_op = CV.Rescale(rescale, shift)
     normalize_op = CV.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
-    if status == "train":
+    if training:
         random_crop_op = CV.RandomCrop([32, 32], [4, 4, 4, 4])
         random_horizontal_op = CV.RandomHorizontalFlip()
     channel_swap_op = CV.HWC2CHW()
     typecast_op = C.TypeCast(mstype.int32)
     cifar_ds = cifar_ds.map(input_columns="label", operations=typecast_op, num_parallel_workers=8)
-    if status == "train":
+    if training:
         cifar_ds = cifar_ds.map(input_columns="image", operations=random_crop_op, num_parallel_workers=8)
         cifar_ds = cifar_ds.map(input_columns="image", operations=random_horizontal_op, num_parallel_workers=8)
     cifar_ds = cifar_ds.map(input_columns="image", operations=resize_op, num_parallel_workers=8)
@@ -64,7 +65,7 @@ def create_dataset_cifar10(cfg, data_path, batch_size=32, repeat_size=1, status=
     return cifar_ds
 
 
-def create_dataset_imagenet(cfg, dataset_path, batch_size=32, repeat_num=1, training=True,
+def create_dataset_imagenet(dataset_path, cfg, batch_size=32, repeat_num=1, training=True,
                             num_parallel_workers=None, shuffle=None, sampler=None, class_indexing=None):
     """
     create a train or eval imagenet2012 dataset for resnet50
@@ -81,7 +82,7 @@ def create_dataset_imagenet(cfg, dataset_path, batch_size=32, repeat_num=1, trai
     """
 
     device_num, rank_id = _get_rank_info()
-    # cfg = alexnet_imagenet_cfg
+    cfg = alexnet_imagenet_cfg
 
     num_parallel_workers = 16
     if device_num == 1: