同期推論要求#

InferRequest クラスの機能:

バックエンド依存のネットワーク推論に必要な入力テンソルと出力テンソルを割り当てます。
推論プロセスのステージ (前処理、アップロード、推論、ダウンロード、後処理など) の関数を定義します。これらの関数は、後で非同期推論リクエストの実装に実行パイプラインを定義するのに使用できます。
推論ステージを 1 つずつ同期的に呼び出します。

InferRequest クラス#

OpenVINO プラグイン API は、同期推論要求実装の基本クラスとして使用するインターフェイス ov::ISyncInferRequest を提供します。これに基づいて、同期要求クラスの宣言は次のようになります。

class InferRequest : public ov::ISyncInferRequest { 
public: 
    explicit InferRequest(const std::shared_ptr<const ov::template_plugin::CompiledModel>& compiled_model); 
    ~InferRequest(); 

    void infer() override; 
    std::vector<ov::SoPtr<ov::IVariableState>> query_state() const override; 
    std::vector<ov::ProfilingInfo> get_profiling_info() const override; 

    // パイプライン・メソッド - 非同期推論リクエストの実装で使用され、特定のエグゼキューターに割り当てられるステージ 
    void infer_preprocess(); 
    void start_pipeline(); 
    void wait_pipeline(); 
    void infer_postprocess(); 
    void cancel(); 

    void set_tensors_impl(const ov::Output<const ov::Node> port, 
                          const std::vector<ov::SoPtr<ov::ITensor>>& tensors) override; 

private: 
    std::shared_ptr<const CompiledModel> get_template_model() const; 

    enum { Preprocess, Postprocess, StartPipeline, WaitPipeline, numOfStages }; 

    std::array<openvino::itt::handle_t, numOfStages> m_profiling_task; 
    // パフォーマンス・カウンター用 
    std::array<std::chrono::duration<float, std::micro>, numOfStages> m_durations; 

    std::vector<ov::Tensor> m_backend_input_tensors; 
    std::vector<ov::Tensor> m_backend_output_tensors; 
    std::shared_ptr<ov::runtime::Executable> m_executable; 
    ov::EvaluationContext m_eval_context; 
    std::vector<ov::SoPtr<ov::IVariableState>> m_variable_states; 
};

クラスフィールド#

サンプルクラスにはいくつかのフィールドがあります:

m_profiling_task - std::array<openvino::itt::handle_t, numOfStages> タイプの配列。パイプライン・ステージの名前を定義します。インテル® インストルメントとトレース・テクノロジー (ITT) を使用して推論パイプラインの実行をプロファイルするのに使用されます。
m_durations - 各パイプライン・ステージ期間の配列。
バックエンド固有のフィールド:
- m_backend_input_tensors - 入力バックエンド・テンソル。
- m_backend_output_tensors - 出力バックエンド・テンソル。
- m_executable - 実行可能オブジェクト/バックエンド計算グラフ。
- m_eval_context - 推論後にバックエンドの状態を保存する評価コンテキスト。
- m_variable_states - 変数状態のベクトル。

InferRequest コンストラクター#

コンストラクターはヘルパーフィールドを初期化し、テンソルを割り当てるメソッドを呼び出します:

ov::template_plugin::InferRequest::InferRequest(const std::shared_ptr<const ov::template_plugin::CompiledModel>& model) : ov::ISyncInferRequest(model) { 
    // TODO: 必要に応じて推論要求デバイスとホストバッファーを割り当て、プロファイリル・タスクの実際のリストを埋める 
    auto requestID = std::to_string(get_template_model()->m_request_id.fetch_add(1)); 

    std::string name = get_template_model()->m_model->get_friendly_name() + "_Req" + requestID; 
    m_profiling_task = { 
        openvino::itt::handle("Template" + std::to_string(get_template_model()->m_cfg.device_id) + "_" + name + "_Preprocess"), 
        openvino::itt::handle("Template" + std::to_string(get_template_model()->m_cfg.device_id) + "_" + name + "_Postprocess"), 
        openvino::itt::handle("Template" + std::to_string(get_template_model()->m_cfg.device_id) + "_" + name + "_StartPipeline"), 
        openvino::itt::handle("Template" + std::to_string(get_template_model()->m_cfg.device_id) + "_" + name + "_WaitPipline"), 
    }; 
    m_durations = {}; 
    m_executable = get_template_model()->get_template_plugin()->m_backend->compile(get_template_model()->m_model); 

    // プラグインのバックエンド固有のメモリーハンドルを割り当てる 
    m_backend_input_tensors.resize(get_inputs().size()); 
    m_backend_output_tensors.resize(get_outputs().size()); 

    // 入力/出力テンソルを割り当てる 
    for (const auto& input : get_inputs()) { 
        allocate_tensor(input, [input](ov::SoPtr<ov::ITensor>& tensor) { 
            // 共有テンソルの場合に重複作業を避けるためのチェックを追加できる 
            allocate_tensor_impl(tensor, 
                                  input.get_element_type(), 
                                  input.get_partial_shape().is_dynamic() ? ov::Shape{0} : input.get_shape()); 
        }); 
    } 
    for (const auto& output : get_outputs()) { 
        allocate_tensor(output, [output](ov::SoPtr<ov::ITensor>& tensor) { 
            // 共有テンソルの場合に重複作業を避けるためのチェックを追加できる 
            allocate_tensor_impl(tensor, 
                                  output.get_element_type(), 
                                  output.get_partial_shape().is_dynamic() ? ov::Shape{0} : output.get_shape()); 
        }); 
    } 

    // 変数の状態を保存 
    ov::op::util::VariableContext variable_context; 
    const auto& ov_model = m_executable->get_model(); 
    collect_variables(ov_model, variable_context, m_variable_states); 
    m_eval_context.emplace("VariableContext", variable_context); 
}

注

コンパイルされたモデルの入出力情報を使用して、テンソルの形状と要素タイプを理解します。これらは、ov::InferRequest::set_tensor で設定し、ov::InferRequest::get_tensor で取得できます。プラグインは、必要に応じてこれらのヒントを使用して、入力および出力テンソルの内部レイアウトと要素タイプを決定します。

~InferRequest デストラクター#

デストラクターには、推論要求を終了して破棄するプラグイン固有のロジックを含めることができます。

ov::template_plugin::InferRequest::~InferRequest() = default;

set_tensors_impl()#

このメソッドでは、プラグインがサポートしている場合にバッチ化されたテンソルを設定できます。

void ov::template_plugin::InferRequest::set_tensors_impl(const ov::Output<const ov::Node> port, 
const std::vector<ov::SoPtr<ov::ITensor>>& tensors) { 
    for (const auto& input : get_inputs()) { 
        if (input == port) { 
            m_batched_tensors[input.get_tensor_ptr()] = tensors; 
            return; 
        } 
    } 
    OPENVINO_THROW("Cannot find input tensors for port ", port); 
}

query_state()#

このメソッドはモデルの変数状態を返します。

std::vector<ov::SoPtr<ov::IVariableState>> 
ov::template_plugin::InferRequest::query_state() const { 
    return m_variable_states; 
}

infer()#

このメソッドは、パイプライン・ステージを同期的に呼び出します。メソッドのプラグイン内では、入力/出力テンソルをチェックし、外部テンソルをバックエンドに移動してから推論を実行する必要があります。

void ov::template_plugin::InferRequest::infer() { 
    // TODO: 同期推論要求に対して同期的に実行されるパイプライン・ステージの実際のリストを入力 
    infer_preprocess(); 
    start_pipeline(); 
    wait_pipeline(); // 現在の実装では何も行われません 
    infer_postprocess(); 
}

1. infer_preprocess()#

以下は infer_preprocess() メソッドのコードです。このメソッドはユーザーの入力/出力テンソルをチェックし、ユーザーテンソルからバックエンド固有の表現へ変換を示します:

void ov::template_plugin::InferRequest::infer_preprocess() { 
    OV_ITT_SCOPED_TASK(itt::domains::TemplatePlugin, m_profiling_task[Preprocess]); 
    auto start = Time::now(); 
    convert_batched_tensors(); 
    check_tensors(); 

    // バックエンド・テンソルを割り当て 
    OPENVINO_ASSERT(get_inputs().size() == m_backend_input_tensors.size()); 
    for (size_t i = 0; i < get_inputs().size(); i++) { 
        auto tensor = get_tensor(get_inputs()[i]); 
        if (std::dynamic_pointer_cast<ov::IRemoteTensor>(tensor._ptr)) { 
            auto vector_tensor = 
std::dynamic_pointer_cast<ov::template_plugin::VectorImpl>(tensor._ptr); 
            OPENVINO_ASSERT(vector_tensor, "Template plugin supports only VectorTensor with remote context."); 
            auto element_type = vector_tensor->get_element_type(); 
            void* data = vector_tensor->get_data(); 
            OPENVINO_ASSERT(data != nullptr); 
            // バックエンド・テンソルの作成 
            m_backend_input_tensors[i] = 
                get_template_model()->get_template_plugin()->m_backend->create_tensor(element_type, vector_tensor->get_shape(), data); 
        } else if (tensor->is_continuous()) { 
            // ROI 抽出は不要 
            m_backend_input_tensors[i] = 
                get_template_model()->get_template_plugin()->m_backend->create_tensor(tensor->get_element_type(), tensor->get_shape(), tensor->data()); 
        } else { 
            OPENVINO_ASSERT(tensor->get_element_type().bitwidth() % 8 == 0, 
                    "Template plugin: Unsupported ROI tensor with element type having ", 
                    std::to_string(tensor->get_element_type().bitwidth()), 
                    " bits size"); 
            ov::Shape shape = tensor->get_shape(); 
            // ROI テンソルの手動抽出を実行 
            // 基本的な実装では軸の順序は考慮されません `desc.getBlockingDesc().getOrder()` 
            // 手動抽出のパフォーマンスは最適ではありませんが、テンプレート実装には問題ありません。 
            m_backend_input_tensors[i] = 
                get_template_model()->get_template_plugin()->m_backend->create_tensor(tensor->get_element_type(), tensor->get_shape()); tensor->copy_to(ov::get_tensor_impl(m_backend_input_tensors[i])._ptr); 
        } 
    } 
    // テンソルは動的になる可能性があるため、この場合は適切な形状のテンソルを割り当てる必要があります。 
    OPENVINO_ASSERT(get_outputs().size() == m_backend_output_tensors.size()); 
    for (size_t i = 0; i < get_outputs().size(); i++) { 
        const auto& result = get_template_model()->m_model->get_results()[i]; 
        if (result->get_output_partial_shape(0).is_dynamic()) { 
            m_backend_output_tensors[i] = get_template_model()->get_template_plugin()->m_backend->create_tensor(); 
            continue; 
        } 
        auto tensor = make_tensor(get_tensor(get_outputs()[i])); 
        if (tensor.is_continuous() && !tensor.is<ov::RemoteTensor>()) 
            m_backend_output_tensors[i] = 
                get_template_model()->get_template_plugin()->m_backend->create_tensor(tensor.get_element_type(), tensor.get_shape(), tensor.data()); 
        else 
            m_backend_output_tensors[i] = 
                get_template_model()->get_template_plugin()->m_backend->create_tensor(tensor.get_element_type(), tensor.get_shape()); 
        } 
        m_durations[Preprocess] = Time::now() - start; 
}

2. start_pipeline()#

m_executable オブジェクトを使用してパイプラインを同期的に実行します:

void ov::template_plugin::InferRequest::start_pipeline() { 
    OV_ITT_SCOPED_TASK(itt::domains::TemplatePlugin, m_profiling_task[StartPipeline]) 
    auto start = Time::now(); 
    m_executable->call(m_backend_output_tensors, 
                       m_backend_input_tensors, 
                       m_eval_context, 
                       get_template_model()->m_cfg.perf_count); 
    m_durations[StartPipeline] = Time::now() - start; 
}

3. wait_pipeline()#

プラグインの非同期実行ではパイプラインを待機します:

void ov::template_plugin::InferRequest::wait_pipeline() { 
    OV_ITT_SCOPED_TASK(itt::domains::TemplatePlugin, m_profiling_task[WaitPipeline]) 
    auto start = Time::now(); 
    // TODO: ドライバー API またはその他の同期方法を使用してパイプラインを待機 
    // 注: 現在の実装では、`start Pipeline` はパイプラインを同期的に実行するのに使用されません 
    m_durations[WaitPipeline] = Time::now() - start; 
}

4. infer_postprocess()#

バックエンド固有のテンソルをユーザーテンソルに変換します:

void ov::template_plugin::InferRequest::infer_postprocess() { 
    OV_ITT_SCOPED_TASK(itt::domains::TemplatePlugin, m_profiling_task[Postprocess]); 
    auto start = Time::now(); 
    OPENVINO_ASSERT(get_outputs().size() == m_backend_output_tensors.size()); 
    for (size_t i = 0; i < get_outputs().size(); i++) { 
        const auto& result = get_template_model()->m_model->get_results()[i]; 
        const auto& host_tensor = m_backend_output_tensors[i]; 
        auto tensor = get_tensor(get_outputs()[i]); 
        if (result->get_output_partial_shape(0).is_dynamic()) { 
            ov::Output<const ov::Node> output{result->output(0).get_node(), result->output(0).get_index()}; 
            allocate_tensor(output, [&host_tensor](ov::SoPtr<ov::ITensor>& tensor) { 
                allocate_tensor_impl(tensor, host_tensor.get_element_type(), host_tensor.get_shape()); 
                host_tensor.copy_to(ov::make_tensor(tensor)); 
            }); 
        } else if (!tensor->is_continuous()) { 
            host_tensor.copy_to(ov::make_tensor(tensor)); 
        } else if (std::dynamic_pointer_cast<ov::IRemoteTensor>(tensor._ptr)) { 
            auto vector_tensor = std::dynamic_pointer_cast<ov::template_plugin::VectorImpl>(tensor._ptr); 
            OPENVINO_ASSERT(vector_tensor, "Template plugin supports only VectorTensor with remote context."); 
            void* data = vector_tensor->get_data(); 
            // ベクトルへコピー 
            std::memcpy(data, host_tensor.data(), tensor->get_byte_size()); 
        } 
    } 
    m_durations[Postprocess] = Time::now() - start; 
}

get_profiling_info()#

このメソッドは、パイプライン・ステージの実行中に測定されたプロファイル情報を返します:

std::vector<ov::ProfilingInfo> ov::template_plugin::InferRequest::get_profiling_info() 
const { 
    std::vector<ov::ProfilingInfo> info; 
    const auto fill_profiling_info = [](
                                   const std::string& name, const std::chrono::duration<float, std::micro>& time) -> ov::ProfilingInfo { 
        ov::ProfilingInfo p_info; 
        p_info.status = ov::ProfilingInfo::Status::EXECUTED; 
        p_info.node_name = name; 
        p_info.cpu_time = p_info.real_time = std::chrono::duration_cast<std::chrono::milliseconds>(time); 
        return p_info; 
    }; 

    info.emplace_back(fill_profiling_info("input preprocessing", m_durations[Preprocess])); 
    info.emplace_back(fill_profiling_info("execution time", m_durations[StartPipeline])); 
    auto template_model = get_template_model(); 
    for (const auto& op : template_model->get_runtime_model()->get_ops()) { 
        auto rt_info = op->get_rt_info(); 
        const auto& it = rt_info.find(ov::runtime::interpreter::PERF_COUNTER_NAME); 
        OPENVINO_ASSERT(it != rt_info.end(), "Operation ", op, " doesn't contain performance counter"); 
        auto counter = it->second.as<std::shared_ptr<ov::runtime::interpreter::PerfCounter>>(); 
        info.emplace_back(fill_profiling_info(op->get_friendly_name(), counter->duration())); 
    } 
    info.emplace_back(fill_profiling_info("output postprocessing", m_durations[Postprocess])); 
    return info; 
}

cancel()#

プラグイン固有のメソッドを使用すると、AsyncInferRequest による同期実行を中断できます:

void ov::template_plugin::InferRequest::cancel() { 
    m_executable->cancel(); 
}

プラグイン・ライブラリー実装の次のステップは、非同期推論要求クラスです。