315 lines
13 KiB
C++
315 lines
13 KiB
C++
// Copyright (C) 2018-2019 Intel Corporation
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
|
|
#include <fstream>
|
|
#include <vector>
|
|
#include <chrono>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <limits>
|
|
|
|
#include <inference_engine.hpp>
|
|
#include <ext_list.hpp>
|
|
#include <format_reader_ptr.h>
|
|
|
|
#include <samples/common.hpp>
|
|
#include <samples/slog.hpp>
|
|
#include <samples/args_helper.hpp>
|
|
#include <samples/classification_results.h>
|
|
|
|
#include "classification_sample.h"
|
|
|
|
using namespace InferenceEngine;
|
|
|
|
ConsoleErrorListener error_listener;
|
|
|
|
bool ParseAndCheckCommandLine(int argc, char *argv[]) {
|
|
// ---------------------------Parsing and validation of input args--------------------------------------
|
|
gflags::ParseCommandLineNonHelpFlags(&argc, &argv, true);
|
|
if (FLAGS_h) {
|
|
showUsage();
|
|
return false;
|
|
}
|
|
slog::info << "Parsing input parameters" << slog::endl;
|
|
|
|
if (FLAGS_ni < 1) {
|
|
throw std::logic_error("Parameter -ni should be greater than zero (default 1)");
|
|
}
|
|
|
|
if (FLAGS_i.empty()) {
|
|
throw std::logic_error("Parameter -i is not set");
|
|
}
|
|
|
|
if (FLAGS_m.empty()) {
|
|
throw std::logic_error("Parameter -m is not set");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief The entry point the Inference Engine sample application
|
|
* @file classification_sample/main.cpp
|
|
* @example classification_sample/main.cpp
|
|
*/
|
|
int main(int argc, char *argv[]) {
|
|
try {
|
|
slog::info << "InferenceEngine: " << GetInferenceEngineVersion() << slog::endl;
|
|
|
|
// ------------------------------ Parsing and validation of input args ---------------------------------
|
|
if (!ParseAndCheckCommandLine(argc, argv)) {
|
|
return 0;
|
|
}
|
|
|
|
/** This vector stores paths to the processed images **/
|
|
std::vector<std::string> imageNames;
|
|
parseInputFilesArguments(imageNames);
|
|
if (imageNames.empty()) throw std::logic_error("No suitable images were found");
|
|
// -----------------------------------------------------------------------------------------------------
|
|
|
|
// --------------------------- 1. Load Plugin for inference engine -------------------------------------
|
|
slog::info << "Loading plugin" << slog::endl;
|
|
InferencePlugin plugin = PluginDispatcher({ FLAGS_pp }).getPluginByDevice(FLAGS_d);
|
|
if (FLAGS_p_msg) {
|
|
static_cast<InferenceEngine::InferenceEnginePluginPtr>(plugin)->SetLogCallback(error_listener);
|
|
}
|
|
|
|
/** Loading default extensions **/
|
|
if (FLAGS_d.find("CPU") != std::string::npos) {
|
|
/**
|
|
* cpu_extensions library is compiled from "extension" folder containing
|
|
* custom MKLDNNPlugin layer implementations. These layers are not supported
|
|
* by mkldnn, but they can be useful for inferring custom topologies.
|
|
**/
|
|
plugin.AddExtension(std::make_shared<Extensions::Cpu::CpuExtensions>());
|
|
}
|
|
|
|
if (!FLAGS_l.empty()) {
|
|
// CPU(MKLDNN) extensions are loaded as a shared library and passed as a pointer to base extension
|
|
auto extension_ptr = make_so_pointer<IExtension>(FLAGS_l);
|
|
plugin.AddExtension(extension_ptr);
|
|
slog::info << "CPU Extension loaded: " << FLAGS_l << slog::endl;
|
|
}
|
|
if (!FLAGS_c.empty()) {
|
|
// clDNN Extensions are loaded from an .xml description and OpenCL kernel files
|
|
plugin.SetConfig({{PluginConfigParams::KEY_CONFIG_FILE, FLAGS_c}});
|
|
slog::info << "GPU Extension loaded: " << FLAGS_c << slog::endl;
|
|
}
|
|
|
|
/** Setting plugin parameter for collecting per layer metrics **/
|
|
if (FLAGS_pc) {
|
|
plugin.SetConfig({ { PluginConfigParams::KEY_PERF_COUNT, PluginConfigParams::YES } });
|
|
}
|
|
|
|
/** Printing plugin version **/
|
|
printPluginVersion(plugin, std::cout);
|
|
// -----------------------------------------------------------------------------------------------------
|
|
|
|
// --------------------------- 2. Read IR Generated by ModelOptimizer (.xml and .bin files) ------------
|
|
std::string binFileName = fileNameNoExt(FLAGS_m) + ".bin";
|
|
slog::info << "Loading network files:"
|
|
"\n\t" << FLAGS_m <<
|
|
"\n\t" << binFileName <<
|
|
slog::endl;
|
|
|
|
CNNNetReader networkReader;
|
|
/** Reading network model **/
|
|
networkReader.ReadNetwork(FLAGS_m);
|
|
|
|
/** Extracting model name and loading weights **/
|
|
networkReader.ReadWeights(binFileName);
|
|
CNNNetwork network = networkReader.getNetwork();
|
|
// -----------------------------------------------------------------------------------------------------
|
|
|
|
// --------------------------- 3. Configure input & output ---------------------------------------------
|
|
|
|
// --------------------------- Prepare input blobs -----------------------------------------------------
|
|
slog::info << "Preparing input blobs" << slog::endl;
|
|
|
|
/** Taking information about all topology inputs **/
|
|
InputsDataMap inputInfo = network.getInputsInfo();
|
|
if (inputInfo.size() != 1) throw std::logic_error("Sample supports topologies only with 1 input");
|
|
|
|
auto inputInfoItem = *inputInfo.begin();
|
|
|
|
/** Specifying the precision and layout of input data provided by the user.
|
|
* This should be called before load of the network to the plugin **/
|
|
inputInfoItem.second->setPrecision(Precision::U8);
|
|
inputInfoItem.second->setLayout(Layout::NCHW);
|
|
|
|
std::vector<std::shared_ptr<unsigned char>> imagesData;
|
|
for (auto & i : imageNames) {
|
|
FormatReader::ReaderPtr reader(i.c_str());
|
|
if (reader.get() == nullptr) {
|
|
slog::warn << "Image " + i + " cannot be read!" << slog::endl;
|
|
continue;
|
|
}
|
|
/** Store image data **/
|
|
std::shared_ptr<unsigned char> data(
|
|
reader->getData(inputInfoItem.second->getTensorDesc().getDims()[3],
|
|
inputInfoItem.second->getTensorDesc().getDims()[2]));
|
|
if (data.get() != nullptr) {
|
|
imagesData.push_back(data);
|
|
}
|
|
}
|
|
if (imagesData.empty()) throw std::logic_error("Valid input images were not found!");
|
|
|
|
/** Setting batch size using image count **/
|
|
network.setBatchSize(imagesData.size());
|
|
size_t batchSize = network.getBatchSize();
|
|
slog::info << "Batch size is " << std::to_string(batchSize) << slog::endl;
|
|
|
|
// ------------------------------ Prepare output blobs -------------------------------------------------
|
|
slog::info << "Preparing output blobs" << slog::endl;
|
|
|
|
OutputsDataMap outputInfo(network.getOutputsInfo());
|
|
// BlobMap outputBlobs;
|
|
std::string firstOutputName;
|
|
|
|
for (auto & item : outputInfo) {
|
|
if (firstOutputName.empty()) {
|
|
firstOutputName = item.first;
|
|
}
|
|
DataPtr outputData = item.second;
|
|
if (!outputData) {
|
|
throw std::logic_error("output data pointer is not valid");
|
|
}
|
|
|
|
item.second->setPrecision(Precision::FP32);
|
|
}
|
|
|
|
const SizeVector outputDims = outputInfo.begin()->second->getDims();
|
|
|
|
bool outputCorrect = false;
|
|
if (outputDims.size() == 2 /* NC */) {
|
|
outputCorrect = true;
|
|
} else if (outputDims.size() == 4 /* NCHW */) {
|
|
/* H = W = 1 */
|
|
if (outputDims[2] == 1 && outputDims[3] == 1) outputCorrect = true;
|
|
}
|
|
|
|
if (!outputCorrect) {
|
|
throw std::logic_error("Incorrect output dimensions for classification model");
|
|
}
|
|
// -----------------------------------------------------------------------------------------------------
|
|
|
|
// --------------------------- 4. Loading model to the plugin ------------------------------------------
|
|
slog::info << "Loading model to the plugin" << slog::endl;
|
|
|
|
ExecutableNetwork executable_network = plugin.LoadNetwork(network, {});
|
|
inputInfoItem.second = {};
|
|
outputInfo = {};
|
|
network = {};
|
|
networkReader = {};
|
|
// -----------------------------------------------------------------------------------------------------
|
|
|
|
// --------------------------- 5. Create infer request -------------------------------------------------
|
|
InferRequest infer_request = executable_network.CreateInferRequest();
|
|
// -----------------------------------------------------------------------------------------------------
|
|
|
|
// --------------------------- 6. Prepare input --------------------------------------------------------
|
|
/** Iterate over all the input blobs **/
|
|
for (const auto & item : inputInfo) {
|
|
/** Creating input blob **/
|
|
Blob::Ptr input = infer_request.GetBlob(item.first);
|
|
|
|
/** Filling input tensor with images. First b channel, then g and r channels **/
|
|
size_t num_channels = input->getTensorDesc().getDims()[1];
|
|
size_t image_size = input->getTensorDesc().getDims()[2] * input->getTensorDesc().getDims()[3];
|
|
|
|
auto data = input->buffer().as<PrecisionTrait<Precision::U8>::value_type*>();
|
|
|
|
/** Iterate over all input images **/
|
|
for (size_t image_id = 0; image_id < imagesData.size(); ++image_id) {
|
|
/** Iterate over all pixel in image (b,g,r) **/
|
|
for (size_t pid = 0; pid < image_size; pid++) {
|
|
/** Iterate over all channels **/
|
|
for (size_t ch = 0; ch < num_channels; ++ch) {
|
|
/** [images stride + channels stride + pixel id ] all in bytes **/
|
|
data[image_id * image_size * num_channels + ch * image_size + pid ] = imagesData.at(image_id).get()[pid*num_channels + ch];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
inputInfo = {};
|
|
// -----------------------------------------------------------------------------------------------------
|
|
|
|
// --------------------------- 7. Do inference ---------------------------------------------------------
|
|
slog::info << "Starting inference (" << FLAGS_ni << " iterations)" << slog::endl;
|
|
|
|
typedef std::chrono::high_resolution_clock Time;
|
|
typedef std::chrono::duration<double, std::ratio<1, 1000>> ms;
|
|
typedef std::chrono::duration<float> fsec;
|
|
|
|
double total = 0.0;
|
|
/** Start inference & calc performance **/
|
|
for (size_t iter = 0; iter < FLAGS_ni; ++iter) {
|
|
auto t0 = Time::now();
|
|
infer_request.Infer();
|
|
auto t1 = Time::now();
|
|
fsec fs = t1 - t0;
|
|
ms d = std::chrono::duration_cast<ms>(fs);
|
|
total += d.count();
|
|
}
|
|
// -----------------------------------------------------------------------------------------------------
|
|
|
|
// --------------------------- 8. Process output -------------------------------------------------------
|
|
slog::info << "Processing output blobs" << slog::endl;
|
|
|
|
const Blob::Ptr output_blob = infer_request.GetBlob(firstOutputName);
|
|
|
|
/** Validating -nt value **/
|
|
const size_t resultsCnt = output_blob->size() / batchSize;
|
|
if (FLAGS_nt > resultsCnt || FLAGS_nt < 1) {
|
|
slog::warn << "-nt " << FLAGS_nt << " is not available for this network (-nt should be less than " \
|
|
<< resultsCnt+1 << " and more than 0)\n will be used maximal value : " << resultsCnt;
|
|
FLAGS_nt = resultsCnt;
|
|
}
|
|
|
|
/** Read labels from file (e.x. AlexNet.labels) **/
|
|
std::string labelFileName = fileNameNoExt(FLAGS_m) + ".labels";
|
|
std::vector<std::string> labels;
|
|
|
|
std::ifstream inputFile;
|
|
inputFile.open(labelFileName, std::ios::in);
|
|
if (inputFile.is_open()) {
|
|
std::string strLine;
|
|
while (std::getline(inputFile, strLine)) {
|
|
trim(strLine);
|
|
labels.push_back(strLine);
|
|
}
|
|
}
|
|
|
|
ClassificationResult classificationResult(output_blob, imageNames,
|
|
batchSize, FLAGS_nt,
|
|
labels);
|
|
classificationResult.print();
|
|
|
|
// -----------------------------------------------------------------------------------------------------
|
|
if (std::fabs(total) < std::numeric_limits<double>::epsilon()) {
|
|
throw std::logic_error("total can't be equal to zero");
|
|
}
|
|
std::cout << std::endl << "total inference time: " << total << std::endl;
|
|
std::cout << "Average running time of one iteration: " << total / static_cast<double>(FLAGS_ni) << " ms" << std::endl;
|
|
std::cout << std::endl << "Throughput: " << 1000 * static_cast<double>(FLAGS_ni) * batchSize / total << " FPS" << std::endl;
|
|
std::cout << std::endl;
|
|
|
|
/** Show performance results **/
|
|
if (FLAGS_pc) {
|
|
printPerformanceCounts(infer_request, std::cout);
|
|
}
|
|
}
|
|
catch (const std::exception& error) {
|
|
slog::err << "" << error.what() << slog::endl;
|
|
return 1;
|
|
}
|
|
catch (...) {
|
|
slog::err << "Unknown/internal exception happened." << slog::endl;
|
|
return 1;
|
|
}
|
|
|
|
slog::info << "Execution successful" << slog::endl;
|
|
return 0;
|
|
}
|