1 // Copyright (C) 2018-2019 Intel Corporation
2 // SPDX-License-Identifier: Apache-2.0
6 * @brief A header file that provides a set of convenience utility functions and the main include file for all other .h files.
7 * @file inference_engine.hpp
18 #include <ie_error.hpp>
19 #include <ie_layers.h>
20 #include <ie_device.hpp>
21 #include <ie_plugin_dispatcher.hpp>
22 #include <ie_plugin_config.hpp>
23 #include <ie_icnn_network.hpp>
24 #include <ie_icnn_network_stats.hpp>
25 #include <cpp/ie_cnn_net_reader.h>
26 #include <cpp/ie_plugin_cpp.hpp>
27 #include <cpp/ie_executable_network.hpp>
28 #include <ie_version.hpp>
30 namespace InferenceEngine {
32 * @brief Gets the top n results from a tblob
33 * @param n Top n count
34 * @param input 1D tblob that contains probabilities
35 * @param output Vector of indexes for the top n places
38 inline void TopResults(unsigned int n, TBlob<T> &input, std::vector<unsigned> &output) {
39 size_t input_rank = input.dims().size();
40 if (!input_rank || !input.dims().at(input_rank - 1))
41 THROW_IE_EXCEPTION << "Input blob has incorrect dimensions!";
42 size_t batchSize = input.dims().at(input_rank - 1);
43 std::vector<unsigned> indexes(input.size() / batchSize);
45 n = static_cast<unsigned>(std::min<size_t>((size_t) n, input.size()));
47 output.resize(n * batchSize);
49 for (size_t i = 0; i < batchSize; i++) {
50 size_t offset = i * (input.size() / batchSize);
51 T *batchData = input.data();
54 std::iota(std::begin(indexes), std::end(indexes), 0);
55 std::partial_sort(std::begin(indexes), std::begin(indexes) + n, std::end(indexes),
56 [&batchData](unsigned l, unsigned r) {
57 return batchData[l] > batchData[r];
59 for (unsigned j = 0; j < n; j++) {
60 output.at(i * n + j) = indexes.at(j);
65 #define TBLOB_TOP_RESULT(precision)\
66 case InferenceEngine::Precision::precision : {\
67 using myBlobType = InferenceEngine::PrecisionTrait<Precision::precision>::value_type;\
68 TBlob<myBlobType> &tblob = dynamic_cast<TBlob<myBlobType> &>(input);\
69 TopResults(n, tblob, output);\
74 * @brief Gets the top n results from a blob
75 * @param n Top n count
76 * @param input 1D blob that contains probabilities
77 * @param output Vector of indexes for the top n places
79 inline void TopResults(unsigned int n, Blob &input, std::vector<unsigned> &output) {
80 switch (input.precision()) {
81 TBLOB_TOP_RESULT(FP32);
82 TBLOB_TOP_RESULT(FP16);
83 TBLOB_TOP_RESULT(Q78);
84 TBLOB_TOP_RESULT(I16);
87 TBLOB_TOP_RESULT(U16);
88 TBLOB_TOP_RESULT(I32);
90 THROW_IE_EXCEPTION << "cannot locate blob for precision: " << input.precision();
94 #undef TBLOB_TOP_RESULT
97 * @brief Copies a 8-bit RGB image to the blob.
98 * Throws an exception in case of dimensions or input size mismatch
99 * @tparam data_t Type of the target blob
100 * @param RGB8 8-bit RGB image
101 * @param RGB8_size Size of the image
102 * @param blob Target blob to write image to
104 template<typename data_t>
105 void copyFromRGB8(uint8_t *RGB8, size_t RGB8_size, InferenceEngine::TBlob<data_t> *blob) {
106 if (4 != blob->dims().size())
107 THROW_IE_EXCEPTION << "Cannot write data to input blob! Blob has incorrect dimensions size "
108 << blob->dims().size();
109 size_t num_channels = blob->dims()[2]; // because RGB
110 size_t num_images = blob->dims()[3];
111 size_t w = blob->dims()[0];
112 size_t h = blob->dims()[1];
113 size_t nPixels = w * h;
115 if (RGB8_size != w * h * num_channels * num_images)
116 THROW_IE_EXCEPTION << "input pixels mismatch, expecting " << w * h * num_channels * num_images
117 << " bytes, got: " << RGB8_size;
119 std::vector<data_t *> dataArray;
120 for (unsigned int n = 0; n < num_images; n++) {
121 for (unsigned int i = 0; i < num_channels; i++) {
122 if (!n && !i && dataArray.empty()) {
123 dataArray.push_back(blob->data());
125 dataArray.push_back(dataArray.at(n * num_channels + i - 1) + nPixels);
129 for (size_t n = 0; n < num_images; n++) {
130 size_t n_num_channels = n * num_channels;
131 size_t n_num_channels_nPixels = n_num_channels * nPixels;
132 for (size_t i = 0; i < nPixels; i++) {
133 size_t i_num_channels = i * num_channels + n_num_channels_nPixels;
134 for (size_t j = 0; j < num_channels; j++) {
135 dataArray.at(n_num_channels + j)[i] = RGB8[i_num_channels + j];
142 * @brief Splits the RGB channels to either I16 Blob or float blob.
143 * The image buffer is assumed to be packed with no support for strides.
144 * @param imgBufRGB8 Packed 24bit RGB image (3 bytes per pixel: R-G-B)
145 * @param lengthbytesSize Size in bytes of the RGB image. It is equal to amount of pixels times 3 (number of channels)
146 * @param input Blob to contain the split image (to 3 channels)
148 inline void ConvertImageToInput(unsigned char *imgBufRGB8, size_t lengthbytesSize, Blob &input) {
149 TBlob<float> *float_input = dynamic_cast<TBlob<float> *>(&input);
150 if (float_input != nullptr) copyFromRGB8(imgBufRGB8, lengthbytesSize, float_input);
152 TBlob<short> *short_input = dynamic_cast<TBlob<short> *>(&input);
153 if (short_input != nullptr) copyFromRGB8(imgBufRGB8, lengthbytesSize, short_input);
155 TBlob<uint8_t> *byte_input = dynamic_cast<TBlob<uint8_t> *>(&input);
156 if (byte_input != nullptr) copyFromRGB8(imgBufRGB8, lengthbytesSize, byte_input);
160 * @brief Copies data from a certain precision to float
161 * @param dst Pointer to an output float buffer, must be allocated before the call
162 * @param src Source blob to take data from
165 void copyToFloat(float *dst, const InferenceEngine::Blob *src) {
169 const InferenceEngine::TBlob<T> *t_blob = dynamic_cast<const InferenceEngine::TBlob<T> *>(src);
170 if (t_blob == nullptr) {
171 THROW_IE_EXCEPTION << "input type is " << src->precision() << " but input is not " << typeid(T).name();
174 const T *srcPtr = t_blob->readOnly();
175 if (srcPtr == nullptr) {
176 THROW_IE_EXCEPTION << "Input data was not allocated.";
178 for (size_t i = 0; i < t_blob->size(); i++) dst[i] = srcPtr[i];
181 } // namespace InferenceEngine