非同期画像分類のサンプル#

// Copyright (C) 2018-2024 Intel Corporation 
// SPDX-License-Identifier: Apache-2.0 
// 

/** 
* @brief The entry point the OpenVINO Runtime sample application 
* @file classification_sample_async/main.cpp 
* @example classification_sample_async/main.cpp 
*/ 

#include <sys/stat.h> 

#include <condition_variable> 
#include <fstream> 
#include <map> 
#include <memory> 
#include <mutex> 
#include <string> 
#include <vector> 

// clang-format off 
#include "openvino/openvino.hpp" 

#include "samples/args_helper.hpp" 
#include "samples/common.hpp" 
#include "samples/classification_results.h" 
#include "samples/slog.hpp" 
#include "format_reader_ptr.h" 

#include "classification_sample_async.h" 
// clang-format on 

using namespace ov::preprocess; 

namespace { 
bool parse_and_check_command_line(int argc, char* argv[]) { 
    gflags::ParseCommandLineNonHelpFlags(&argc, &argv, true); 
    if (FLAGS_h) { 
        show_usage(); 
        showAvailableDevices(); 
        return false; 
    } 
    slog::info << "Parsing input parameters" << slog::endl; 

    if (FLAGS_m.empty()) { 
        show_usage(); 
        throw std::logic_error("Model is required but not set.Please set -m option."); } 

    if (FLAGS_i.empty()) { 
        show_usage(); 
        throw std::logic_error("Input is required but not set.Please set -i option."); 
    } 

    return true;
} 
} // namespace

int main(int argc, char* argv[]) { 
    try { 
        // -------- OpenVINO ランタイムのバージョンを取得 -------- 
        slog::info << ov::get_openvino_version() << slog::endl; 

        // -------- 入力引数の解析と検証 -------- 
        if (!parse_and_check_command_line(argc, argv)) { 
            return EXIT_SUCCESS; 
        } 

        // -------- 入力の読み込み -------- 
        // このベクトルには、処理された画像へのパスが格納されます。 
        std::vector<std::string> image_names; 
        parseInputFilesArguments(image_names); 
        if (image_names.empty()) 
            throw std::logic_error("No suitable images were found"); 

        // -------- ステップ 1. OpenVINO ランタイムコアの初期化 -------- 
        ov::Core core; 

        // -------- ステップ 2. モデルの読み取り -------- 
        slog::info << "Loading model files: << slog::endl << FLAGS_m << slog::endl; 
        std::shared_ptr<ov::Model> model = core.read_model(FLAGS_m); 
    printInputAndOutputsInfo(*model); 

        OPENVINO_ASSERT(model->inputs().size() == 1, "Sample supports models with 1 input only"); 
        OPENVINO_ASSERT(model->outputs().size() == 1, "Sample supports models with 1 output only"); 

        // -------- ステップ 3. 前処理の構成 -------- 
        const ov::Layout tensor_layout{"NHWC"}; 

        ov::preprocess::PrePostProcessor ppp(model); 
        // 1) 引数のない input() はモデルに単一の入力があると想定します 
        ov::preprocess::InputInfo& input_info = ppp.input(); 
        // 2) 入力テンソル情報を設定: 
        // - テンソルの精度は 'u8’ と仮定します 
        // - データのレイアウトは 'NHWC’ です 
        input_info.tensor().set_element_type(ov::element::u8).set_layout(tensor_layout); 
        // 3) モデルに入力用の 'NCHW’ レイアウトがあると仮定 
        input_info.model().set_layout("NCHW"); 
        // 4) 引数なしの output() はモデルが単一の結果を持つと仮定 
        // - 引数なしの output() はモデルが単一の結果を持つと仮定 
        // - テンソルの精度は 'f32' と仮定 
        ppp.output().tensor().set_element_type(ov::element::f32); 

        // 5) build() メソッドが呼び出されると、レイアウトと精度の変換のため 
        // 前 (後) 処理ステップが自動的に挿入されます。 
        model = ppp.build(); 

        // -------- ステップ 4. 入力画像をリード -------- 
        slog::info << "Read input images" << slog::endl; 

        ov::Shape input_shape = model->input().get_shape(); 
        const size_t width = input_shape[ov::layout::width_idx(tensor_layout)]; 
        const size_t height = input_shape[ov::layout::height_idx(tensor_layout)]; 

        std::vector<std::shared_ptr<unsigned char>> images_data; 
        std::vector<std::string> valid_image_names; 
        for (const auto& i : image_names) { 
            FormatReader::ReaderPtr reader(i.c_str()); 
            if (reader.get() == nullptr) { 
                slog::warn << "Image " + i + " cannot be read!" << slog::endl; 
                continue; 
            } 
            // 画像データを収集 
            std::shared_ptr<unsigned char> data(reader->getData(width, height)); 
            if (data != nullptr) { 
                images_data.push_back(data); 
                valid_image_names.push_back(i); 
            } 
        } 
        if (images_data.empty() || valid_image_names.empty()) 
            throw std::logic_error("Valid input images were not found!"); 

        // -------- ステップ 5. 画像数を使用したバッチサイズの設定 -------- 
        const size_t batchSize = images_data.size(); 
        slog::info << "Set batch size " << std::to_string(batchSize) << slog::endl; 
        ov::set_batch(model, batchSize); 
        printInputAndOutputsInfo(*model); 

        // -------- ステップ 6. モデルをデバイスにロード -------- 
        slog::info << "Loading model to the device " << FLAGS_d << slog::endl; 
        ov::CompiledModel compiled_model = core.compile_model(model, FLAGS_d); 

        // -------- ステップ 7. 推論要求の作成 -------- 
        slog::info << "Create infer request" << slog::endl; 
        ov::InferRequest infer_request = compiled_model.create_infer_request(); 

        // -------- ステップ 8. 複数の入力画像を一括で結合 -------- 
        ov::Tensor input_tensor = infer_request.get_input_tensor(); 

        for (size_t image_id = 0; image_id < images_data.size(); ++image_id) { 
            const size_t image_size = shape_size(model->input().get_shape()) / batchSize; 
            std::memcpy(input_tensor.data<std::uint8_t>() + image_id * image_size, images_data[image_id].get(), image_size); 
        } 

        // -------- ステップ 9. 非同期推論を行う -------- 
        size_t num_iterations = 10; 
        size_t cur_iteration = 0; 
        std::condition_variable condVar; 
        std::mutex mutex; std::exception_ptr exception_var; 
        // -------- ステップ 10. 非同期推論を行います -------- 
        infer_request.set_callback([&](
            std::exception_ptr ex) { std::lock_guard<std::mutex> l(mutex); 
            if (ex) { 
                exception_var = ex; 
                condVar.notify_all(); 
                return; 
            } 

            cur_iteration++; 
            slog::info << "Completed " << cur_iteration << " async request execution" << slog::endl; 
            if (cur_iteration < num_iterations) { 
                // ここでユーザーは推論結果を含む出力を読み取り、新しい入力で 
                //非同期リクエストを再度繰り返すことができます。 
                infer_request.start_async(); 
            } else { 
                // 最後の非同期推論要求の実行後にサンプル実行を 
                // 続行する 
                condVar.notify_one(); 
            } 
        }); 

        // 最初の非同期リクエストを開始 
        slog::info << "Start inference (asynchronous executions)" << slog::endl; 
        infer_request.start_async(); 

        // 非同期リクエストのすべての反復を待機 
        std::unique_lock<std::mutex> lock(mutex); 
        condVar.wait(lock, [&] { 
            if (exception_var) { 
                std::rethrow_exception(exception_var); 
            } 

            return cur_iteration == num_iterations; 
         }); 

        slog::info << "Completed async requests execution" << slog::endl; 

        // -------- ステップ 11. 出力を処理 -------- 
        ov::Tensor output = infer_request.get_output_tensor(); 

        // ファイルからラベルを読み取る (例 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); 
            } 
        } 

        // フォーマットされた分類結果をプリント 
        constexpr size_t N_TOP_RESULTS = 10; 
        ClassificationResult classificationResult(output, valid_image_names, batchSize, N_TOP_RESULTS, labels); 
        classificationResult.show(); 
    } catch (const std::exception& ex) { 
        slog::err << ex.what() << slog::endl; 
        return EXIT_FAILURE; 
    } catch (...) { 
            slog::err << "Unknown/internal exception happened." << slog::endl; 
            return EXIT_FAILURE; 
        } 

        return EXIT_SUCCESS; 
}