フロントエンド拡張#

OpExtension を使用した単一操作マッピング#

このセクションでは、フレームワーク表現の単一操作が OpenVINO 表現の単一操作にマップされる場合について説明します。これは 1 対 1 マッピングと呼ばれます。次の条件をすべて満たす場合に正常に動作する OpExtension クラスがあります:

1. フレームワーク表現での操作への入力数は、OpenVINO 表現の場合と同じです。

2. 出力数も両方の表現は同じです。

3. 入力にはインデックスを付けることができ、それに応じて順番にマッピングされます。フレームワーク表現のインデックス 0 を持つ入力は、OpenVINO 表現のインデックス 0 を持つ入力にマップされます。

4. 出力も同様です。

5. OpenVINO 操作の各属性は、元の操作の属性の 1 つから、または事前定義された定数値によって初期化できます。コピーされた属性の値に式を含めることはできません。値はそのまま受け入れられるため、値のタイプには互換性がある必要があります。

次の例では、Identity のタイプを使用した ONNX 操作を OpenVINO テンプレート拡張 Identity クラスにマップします。

#include <openvino/frontend/extension.hpp>

auto extension1 = ov::frontend::OpExtension<TemplateExtension::Identity>("Identity"); 

// または、元の FW タイプと OV タイプの操作が一致する場合はさらに単純になります。これが "Identity" です 
auto extension2 = ov::frontend::OpExtension<TemplateExtension::Identity>();

Identity 操作には属性がないため、マッピングに属性が含まれません。

構築された拡張機能などの拡張オブジェクトは、カスタム操作を含むモデルを読み込む直前に OpenVINO ランタイムに追加するのに使用できます。

ov::Core core; 
// read_model メソッドを呼び出す前に任意の数の拡張機能を追加 
core.add_extension(ov::frontend::OpExtension<TemplateExtension::Identity>()); 
core.read_model("/path/to/model.onnx");

ただし、拡張機能は、別途コンパイルされた共有ライブラリー内に構築することもできます。これは、Python アプリケーションや benchmark_app などのツールでカスタム操作を使用してモデルをロードするのに適しています。このようなライブラリーをビルドしてロードする方法の詳細については、ガイドを確認してください。

操作に複数の入力および/または出力がある場合、それらは順番にマップされます。入出力テンソルの要素のタイプは、周囲の操作で期待されるタイプと一致する必要があります。例えば、カスタム操作が f32 データタイプを生成する場合、この出力を使用する操作も f32 をサポートする必要があります。それ以外は、自動タイプ変換は実行されないため、モデル変換はエラーで失敗します。

from openvino.frontend import OpExtension 
core.add_extension(OpExtension("Relu", "MyRelu"))

core.add_extension(ov::frontend::OpExtension<>("Relu", "MyRelu"));

class CustomOperation : public ov::op::Op { 

    std::string attr1; 
    int attr2; 

public: 
    OPENVINO_OP("CustomOperation"); 

    bool visit_attributes(ov::AttributeVisitor& visitor) override { 
        visitor.on_attribute("attr1", attr1); 
        visitor.on_attribute("attr2", attr2); 
        return true; 
} 

// ... その他の必要なメソッドを実装

core.add_extension(ov::frontend::OpExtension<CustomOperation>());

core.add_extension(ov::frontend::OpExtension<CustomOperation>( 
    std::map<std::string, std::string>{ {"attr1", "fw_attr1"}, {"attr2", "fw_attr2"} }, 
    {} 
));

core.add_extension(ov::frontend::OpExtension<CustomOperation>( 
    std::map<std::string, std::string>{ {"attr1", "fw_attr1"} }, 
    { {"attr2", 5} } 
));

core.add_extension(ov::frontend::OpExtension<CustomOperation>({"A", "B", "C"}, {"X", "Y"}));

core.add_extension(ov::frontend::OpExtension<CustomOperation>( 
    {"A", "B", "C"}, 
    {"X", "Y"}, 
    std::map<std::string, std::string>{ {"attr1", "fw_attr1"}, {"attr2", "fw_attr2"} }, 
    {} 
));

core.add_extension(ov::frontend::OpExtension<CustomOperation>( 
    {"A", "B", "C"}, 
    {"X", "Y"}, 
    std::map<std::string, std::string>{ {"attr1", "fw_attr1"} }, 
    { {"attr2", 5} } 
));

class CustomElu : public ov::op::Op { 
private: 
    float m_alpha; 
    float m_beta; 

public:     OPENVINO_OP("CustomElu"); 

    CustomElu() = default; 

    CustomElu(const ov::Output<ov::Node>& input, float alpha, float beta) : Op({input}), m_alpha(alpha), m_beta(beta) { 
        constructor_validate_and_infer_types(); 
    } 

    void validate_and_infer_types() override { 
        set_output_size(1); 
        set_output_type(0, get_input_element_type(0), get_input_partial_shape(0)); 
    } 

    bool visit_attributes(ov::AttributeVisitor& visitor) override { 
        visitor.on_attribute("alpha", m_alpha); 
        visitor.on_attribute("beta", m_beta); 
        return true; 
    } 

    std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector& inputs) const override { 
        return std::make_shared<CustomElu>(inputs[0], m_alpha, m_beta); 
    } 
};

auto extension = std::make_shared<ov::frontend::OpExtension<CustomElu>>("aten::elu", 
    std::map<std::string, size_t>{{"alpha", 1}}, 
    std::map<std::string, ov::Any>{{"beta", 1.0f}});

OPENVINO_FRAMEWORK_MAP マクロを使用したカスタム操作のフロントエンドへのマッピング#

OPENVINO_FRAMEWORK_MAP は、OpenVINO 操作のクラス定義内で使用するマクロで、この操作とフロントエンド操作の間のマッピングを指定できます。

次の例について考えてみます。CustomOp 操作 (mode 属性あり) を持つ ONNX モデル、CustomOpV3 操作 (axis 属性あり) を持つ TensorFlow モデル、そして “X” という名前の入力を持つ CustomOp (mode 属性あり) を持つ PaddlePaddle モデルがあると想定します。出力は “Out” という名前で、それらはすべて次のような単一の OpenVINO 操作 CustomOp で実装できます:

#include <openvino/frontend/extension/op.hpp> 
#include <openvino/frontend/onnx/extension/op.hpp> 
#include <openvino/frontend/tensorflow/extension/op.hpp> 
#include <openvino/frontend/paddle/extension/op.hpp>

class CustomOp : public ov::op::Op { 
    std::string m_mode; 
    int m_axis; 

public: 
    OPENVINO_OP("CustomOp"); 
    OPENVINO_FRAMEWORK_MAP(onnx, "CustomOp", { {"mode", "mode"} }, { {"axis", -1} }); 
    OPENVINO_FRAMEWORK_MAP(tensorflow, "CustomOpV3", { {"axis", "axis"} }, { {"mode", "linear"} }); 
    OPENVINO_FRAMEWORK_MAP(paddle, {"X"}, {"Out"}, "CustomOp", { {"mode", "mode"} }, { {"axis", -1} }); 

    bool visit_attributes(ov::AttributeVisitor& visitor) override { 
        visitor.on_attribute("mode", m_mode); 
        visitor.on_attribute("axis", m_axis); 
        return true; 
    } 

    // ... その他の必要なメソッドを実装

このマクロが受け取るパラメーターを詳しく見てみます (2 つの種類があることに注意してください。2 つ目は、入力名と出力名を指定する必要がある PaddlePaddle 操作にマップするものです)。

OPENVINO_FRAMEWORK_MAP(framework, name, attributes_map, attributes_values) 
OPENVINO_FRAMEWORK_MAP(framework, input_names, output_names, name, attributes_map, attributes_values)

• framework - フレームワーク名。

• name - フレームワークの操作名。OpenVINO カスタム操作名 (OPENVINO_OP マクロの最初のパラメーターとして渡される名前) がフレームワーク操作名と同じで、attributes_map と attributes_values の両方が指定されていない場合、これはオプションです。

• input_names - 入力の名前を指定する文字列のベクトル (PaddlePaddle を OpenVINO 操作にマップするために必要)、

• output_names - 出力の名前を指定する文字列のベクトル (PaddlePaddle を OpenVINO 操作にマップするために必要)、

• attributes_map - OpenVINO 操作属性とフレームワーク操作属性の間のマッピングを提供するために使用されます。キーと値のペアが含まれます。キーは OpenVINO 操作属性名、値は対応するフレームワーク操作属性名です。OpenVINO 操作属性の数とその名前がフレームワーク操作属性と 1 対 1 で一致する場合、このパラメーターはオプションです。

• attributes_values - attributes_map で指定されていない OpenVINO 操作属性のデフォルト値を提供するために使用されます。キーと値のペアが含まれ、キーは OpenVINO 操作属性名、値はこの属性値です。このパラメーターは、attributes_map にすべての OpenVINO 操作属性が含まれている場合、または attributes_map が提供されていない場合には指定できません。

上の例では、OPENVINO_FRAMEWORK_MAP が 3 回使用されています。まず、OpenVINO CustomOp は ONNX CustomOp 操作にマップされ、m_mode 属性は mode 属性にマップされ、m_axis 属性はデフォルト値 -1 を取得します。次に、OpenVINO CustomOp は TensorFlow CustomOpV3 操作にマッピングされ、m_axis 属性は axis 属性にマッピングされ、m_mode 属性はデフォルト値の線形を取得します。最後に、OpenVINO CustomOp は PaddlePaddle CustomOp 操作にマップされ、m_mode 属性は mode 属性にマップされ、m_axis 属性はデフォルト値 -1 を取得します。このマッピングでは、入力名 “X” と出力名 “Out” も指定します。

最後のステップは、次のようにカスタム操作を登録することです:

ov::Core core; 
core.add_extension(ov::OpExtension<CustomOp>());

target_link_libraries(${TARGET_NAME} PRIVATE openvino::frontend::onnx)

ConversionExtension を使用した複数の操作へのマッピング#

前のセクションでは、名前と属性値をオプションで調整して、単一のオペレーションを単一のオペレーションにマップする場合について説明しました。既存の C++ カーネル実装を使用した独自のカスタム操作にはこれで十分です。この場合、操作のフレームワーク表現と OpenVINO 表現は制御下にあり、入力/出力/属性を調整して OpExtension を使用できるようになります。

1 対 1 のマッピングが不可能な場合、複数の操作への分解を考慮する必要があります。これは、冗長であまり自動化されていない ConversionExtension クラスを使用することで実現できます。これにより、任意のコードを記述して、単一のフレームワーク操作を、任意の複雑性を持つ依存関係グラフを構築する OpenVINO 操作に置き換えることができます。

ConversionExtension は、OpenVINO 操作クラスからグラフを構築する関数に単一の操作をマップします。OpenVINO ランタイムでモデルをビルドに従って、OpenVINO 操作クラスを使用して置換用のモデルを構築する方法を学習します。

以下は、次の式に従って、ConversionExtension を使用して ONNX から “ThresholdedRelu” を変換する方法を示しています: ThresholdedRelu(x, alpha) -> Multiply(x, Convert(Greater(x, alpha), type=float))。

import openvino.runtime.opset12 as ops 
from openvino.frontend import ConversionExtension

#include <openvino/opsets/opset11.hpp>

def conversion(node): 
    input_node = node.get_input(0) 
    input_type = input_node.get_element_type() 
    greater = ops.greater(input_node, ops.constant([node.get_attribute("alpha")], input_type)) 
    casted = ops.convert(greater, input_type.get_type_name()) 
    return ops.multiply(input_node, casted).outputs() 

core.add_extension(ConversionExtension("ThresholdedRelu", conversion))

core.add_extension(ov::frontend::ConversionExtension( 
    "ThresholdedRelu", 
    [](const ov::frontend::NodeContext& node) { 
        auto greater = std::make_shared<ov::opset11::Greater>( 
            node.get_input(0), 
            ov::opset11::Constant::create(ov::element::f32, {}, {node.get_attribute<float>("alpha")})); 
        auto casted = std::make_shared<ov::opset11::Convert>(greater, ov::element::f32); 
        return ov::OutputVector{ std::make_shared<ov::opset11::Multiply>(node.get_input(0), casted) 
        }; 
    }));

次の例は、ConversionExtension を使用して PyTorch aten::hardtanh を変換する方法を示し、get_values_from_const_input 関数を使用して入力から属性値をフェッチする方法を示します。

import torch 
from openvino.frontend import ConversionExtension, NodeContext 
from openvino.tools.mo import convert_model 

class HardTanh(torch.nn.Module): 
    def __init__(self, min_val, max_val): 
        super(HardTanh, self).__init__() 
        self.min_val = min_val 
        self.max_val = max_val 

    def forward(self, inp): 
        return torch.nn.functional.hardtanh(inp, self.min_val, self.max_val) 

def convert_hardtanh(node: NodeContext): 
    inp = node.get_input(0) 
    min_value = node.get_values_from_const_input(1) 
    max_value = node.get_values_from_const_input(2) 
    return ops.clamp(inp, min_value, max_value).outputs() 

model = HardTanh(min_val=0.1, max_val=2.0) 
hardtanh_ext = ConversionExtension("aten::hardtanh", convert_hardtanh) 
ov_model = convert_model(input_model=model, extensions=[hardtanh_ext])

元のフレームワーク操作属性値にアクセスし、入力に接続するには、NodeContext タイプの node オブジェクトが使用されます。3 つのメインメソッドがあります:

• NodeContext::get_input は、指定されたインデックスを持つ入力を取得し、

• NodeContext::get_attribute は、指定された名前の属性値を取得し、

• NodeContext::get_values_from_const_input は、指定された入力インデックスを持つ属性を取得します。

変換関数は、元のフレームワーク操作の対応する出力に同じ順序でマップされるノード出力のベクトルを返す必要があります。

一部のフレームワークでは、変換中に操作の出力名を指定する必要があります。PaddlePaddle 操作の場合、通常、NamedOutputs コンテナを使用してすべての出力に名前を指定します。通常、これらの名前は、PaddlePaddle コードの個々の操作のソースコードにあります。次の例は、top_k_v2 操作のこのような変換を示しています。

core.add_extension(ov::frontend::ConversionExtension("top_k_v2", [](const ov::frontend::NodeContext& node) { 
    auto x = node.get_input("X"); 
    const auto k_expected = node.get_attribute<int>("k", 1); 
    auto k_expected_node = ov::opset11::Constant::create(ov::element::i32, {}, {k_expected}); 

    auto axis = node.get_attribute<int32_t>("axis", -1); 
    bool sorted = node.get_attribute<bool>("sorted", true); 
    bool largest = node.get_attribute<bool>("largest", true); 

    std::string sort_type = sorted ? "value" : "none"; 
    std::string mode = largest ? "max" : "min"; 

    auto node_topk = std::make_shared<ov::opset11::TopK>(x, k_expected_node, axis, mode, sort_type); 

    ov::frontend::paddle::NamedOutputs named_outputs; 
    named_outputs["Out"] = ov::OutputVector{node_topk->output(0)}; 
    named_outputs["Indices"] = ov::OutputVector{node_topk->output(1)}; 

    return named_outputs; 
}));

TensorFlow フレームワークの場合、操作に複数の出力がある場合、インデックス付き出力アクセスと名前付き出力アクセスの両方を許可する NamedOutputVector 構造体を使用して、出力に名前を割り当てることを推奨します。出力の名前を含む TensorFlow 操作の説明については、tf.raw_ops を参照してください。次の例は、TopKV2 操作の変換を示しています。

core.add_extension(ov::frontend::ConversionExtension("TopKV2", [](const ov::frontend::NodeContext& node) { 
    auto input = node.get_input(0); 
    auto k_input = node.get_input(1); 
    bool sorted = node.get_attribute<bool>("sorted", true); 
    auto mode = ov::opset11::TopK::Mode::MAX; 
    auto sort_type = sorted ? ov::opset11::TopK::SortType::SORT_VALUES : ov::opset11::TopK::SortType::SORT_INDICES; 
    auto top_k = std::make_shared<ov::opset11::TopK>(input, k_input, -1, mode, sort_type, ov::element::i32, true); 
    return ov::frontend::NamedOutputVector{{"values", top_k->output(0)}, {"indices", top_k->output(1)}}; 
}));