トランスフォーメーション API 概要#

// ノードが ov::op::v0::Convolution タイプであると仮定します。// 既知のとおり、ov::op::v0::Convolution には 2 つの入力ポート (データ、重み) と 1 つの出力ポートがあります。 
ov::Input<ov::Node> data = node->input(0); 
ov::Input<ov::Node> weights = node->input(1); 
ov::Output<ov::Node> output = node->output(0); 

// 形状とタイプを取得 
auto pshape = data.get_partial_shape(); 
auto el_type = data.get_element_type(); 

// 入力ポートの親、つまり入力によってマップされた出力を取得 
ov::Output<ov::Node> parent_output; 
parent_output = data.get_source_output(); 

// 出力ポートの親を取得する別の簡単な方法 
parent_output = node->input_value(0); 

// 出力ポートのすべての消費を取得 
auto consumers = output.get_target_inputs();

bool ov_replace_node(std::shared_ptr<ov::Node> node) { 
    // ステップ 1. ノードが ov::op::v0::Negative タイプであることを確認 
    auto neg = std::dynamic_pointer_cast<ov::op::v0::Negative>(node); 
    if (!neg) { 
        return false; 
    } 

    // ステップ 2. 最初の入力を負の値の出力とし、2 番目を -1 の値を持つ定数として ov::op::v1::Multiply 演算を作成 
    auto mul = std::make_shared<ov::op::v1::Multiply>(neg->input_value(0), ov::op::v0::Constant::create(neg->get_element_type(), ov::Shape{1}, {-1})); 

    mul->set_friendly_name(neg->get_friendly_name()); 
    ov::copy_runtime_info(neg, mul); 

    // ステップ 3. 負の演算を乗算演算に置き換える 
    ov::replace_node(neg, mul); 
    return true; 

    // ステップ 4. すべての消費者が乗算演算に移動されたため、負の演算は自動的に削除されます 
}

// すべての neg->output(0) 消費者は mul->output(0) ポートに移動されます 
neg->output(0).replace(mul->output(0));

// ステップ 1. 出力ポートが 1 つあるノードがあり、その後に追加の操作である新しいノードを挿入 
void insert_example(std::shared_ptr<ov::Node> node) { 
    // ノードのすべての消費者を取得 
    auto consumers = node->output(0).get_target_inputs(); 

    // ステップ 2. 新しいノード ov::op::v0::Relu を作成 
    auto new_node = std::make_shared<ov::op::v0::Relu>(node); 

    // ステップ 3. すべての消費者を new_node に再接続 
    for (auto input : consumers) { 
        input.replace_source_output(new_node); 
    } 
}

void insert_example_with_copy(std::shared_ptr<ov::Node> node) { 
    // ノードをコピー 
    auto node_copy = node->clone_with_new_inputs(node->input_values()); 
    // 新しいノードを作成 
    auto new_node = std::make_shared<ov::op::v0::Relu>(node_copy); 
    ov::replace_node(node, new_node); 
}

// 削除したいノードがあるとします 
bool success = ov::replace_output_update_name(node->output(0), node->input_value(0));

// Div 操作を Power および Multiply サブグラフに置き換え、元のフレンドリー名を Multiply 操作に設定します。
 
auto pow = std::make_shared<ov::op::v1::Power>(div->input(1).get_source_output(), 
ov::op::v0::Constant::create(div->get_input_element_type(1), ov::Shape{1}, {-1})); 

auto mul = std::make_shared<ov::op::v1::Multiply>(div->input(0).get_source_output(), pow); 
mul->set_friendly_name(div->get_friendly_name()); 
ov::replace_node(div, mul);

// 転置を変形操作に置き換える (1:1) 
ov::copy_runtime_info(transpose, reshape); 

// Div 操作を Power と Multiply サブグラフに置き換える (1:N) 
ov::copy_runtime_info(div, {pow, mul}); 

// 加算操作による畳み込みの融合 (N:1) 
ov::copy_runtime_info({conv, bias}, {conv_fused}); 

// 1 つのサブグラフを別のサブグラフに置き換えるその他の変換 (N:M) 
ov::copy_runtime_info({a, b, c}, {e, f});

// ConstantFolding パスの後、Power は Constant に置き換えられます 
auto input = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{1}); 

auto pow = std::make_shared<ov::op::v1::Power>(ov::op::v0::Constant::create(ov::element::f32, ov::Shape{1}, {2}), ov::op::v0::Constant::create(ov::element::f32, ov::Shape{1}, {3})); 

auto mul = std::make_shared<ov::op::v1::Multiply>(input /* not constant input */, pow);

template <class T> 
ov::Output<ov::Node> eltwise_fold(const ov::Output<ov::Node>& input0, const ov::Output<ov::Node>& input1) { 
     auto eltwise = std::make_shared<T>(input0, input1); 
    ov::OutputVector output(eltwise->get_output_size()); 
    // 定数畳み込みが成功しなかった場合は、eltwise 出力を返す 
    if (!eltwise->constant_fold(output, {input0, input1})) { 
        return eltwise->output(0); 
    } 
    return output[0]; 
}