From fcaf17828343a595e1978c763612f358211c4b2e Mon Sep 17 00:00:00 2001 From: Evgeny Kotov Date: Fri, 5 Dec 2025 10:55:23 +0100 Subject: [PATCH 1/3] Remove using namespace ov::op and using namespace ov::pass::pattern directives to fix UNITY build conflicts --- .../activations_scaling.cpp | 45 +- .../adaptive_pool_to_reduce.cpp | 23 +- .../add_fake_quantize_fusion.cpp | 14 +- .../align_eltwise_input_ranks.cpp | 8 +- .../augru_cell_fusion.cpp | 38 +- .../batch_to_space_fusion.cpp | 34 +- .../common_optimizations/binarize_weights.cpp | 32 +- .../broadcast_elementwise_fusion.cpp | 8 +- .../broadcast_transition.cpp | 10 +- .../common_optimizations/clamp_fusion.cpp | 8 +- .../compress_float_constants.cpp | 30 +- .../common_optimizations/concat_fusion.cpp | 17 +- .../concat_reduce_fusion.cpp | 14 +- .../concat_to_broadcast.cpp | 6 +- .../common_optimizations/conv_mul_fusion.cpp | 70 +- .../conv_to_binary_conv.cpp | 10 +- .../convert_nms_gather_path_to_unsigned.cpp | 18 +- .../convert_pagedattn_inputs.cpp | 54 +- .../convert_quantize_dequantize.cpp | 40 +- ...onvert_u4_weights_zero_point_to_scalar.cpp | 20 +- .../convolution_to_group_convolution.cpp | 6 +- .../depth_to_space_fusion.cpp | 14 +- .../dilated_convolution_converter.cpp | 28 +- ...isable_random_uniform_constant_folding.cpp | 4 +- .../disable_shapeof_constant_folding.cpp | 4 +- .../common_optimizations/divide_fusion.cpp | 10 +- .../dropout_with_random_uniform_replacer.cpp | 8 +- .../eliminate_duplicate_ti_inputs.cpp | 6 +- .../eliminate_loop_inputs_outputs.cpp | 23 +- .../eliminate_unsqueeze_gather.cpp | 45 +- .../enable_shapeof_constant_folding.cpp | 6 +- .../fold_subgraph_empty_inputs.cpp | 6 +- .../common_optimizations/fq_mul_fusion.cpp | 14 +- .../fq_reshape_fusion.cpp | 16 +- .../common_optimizations/fuse_moe_experts.cpp | 70 +- .../fuse_rotary_positional_embeddings.cpp | 490 ++++---- .../common_optimizations/gelu_fusion.cpp | 76 +- .../common_optimizations/glu_fusion.cpp | 17 +- .../group_normalization_fusion.cpp | 41 +- .../common_optimizations/gru_cell_fusion.cpp | 44 +- .../common_optimizations/hsigmoid_fusion.cpp | 10 +- .../common_optimizations/hswish_fusion.cpp | 12 +- .../leaky_relu_fusion.cpp | 8 +- .../lin_op_sequence_fusion.cpp | 12 +- .../lora_subgraph_fusion.cpp | 37 +- .../common_optimizations/lstm_cell_fusion.cpp | 92 +- ..._rope_input_to_keep_in_mixed_precision.cpp | 7 +- .../matmul_const_transposes_extraction.cpp | 10 +- .../matmul_experts_fusion.cpp | 96 +- .../matmul_multiply_fusion.cpp | 14 +- .../common_optimizations/mish_fusion.cpp | 2 +- .../moe_transpose_weights.cpp | 56 +- .../move_eltwise_up_data_movement.cpp | 2 +- .../common_optimizations/mul_conv_fusion.cpp | 32 +- .../mul_fake_quantize_fusion.cpp | 14 +- .../common_optimizations/mvn_fusion.cpp | 92 +- .../nearest_neighbor_upsampling_fusion.cpp | 14 +- .../nonzero_horizontal_fusion.cpp | 4 +- .../common_optimizations/nop_elimination.cpp | 195 ++-- .../normalize_l2_fusion.cpp | 8 +- .../optimize_strided_slice.cpp | 21 +- .../common_optimizations/pad_fusion.cpp | 98 +- .../common_optimizations/prelu_fusion.cpp | 50 +- .../pull_through_reduce.cpp | 28 +- .../pull_transpose_through_fq.cpp | 20 +- .../random_uniform_fusion.cpp | 10 +- .../common_optimizations/reduce_merge.cpp | 14 +- .../reduce_reshape_fusion.cpp | 14 +- .../relu_fake_quantize_fusion.cpp | 12 +- .../remove_concat_zero_dim_input.cpp | 6 +- .../remove_filtering_boxes_by_size.cpp | 10 +- .../common_optimizations/reshape_prelu.cpp | 8 +- .../reshape_sequence_fusion.cpp | 12 +- .../common_optimizations/ric_fusion.cpp | 128 +-- .../common_optimizations/rms_fusion.cpp | 56 +- .../common_optimizations/sdpa_fusion.cpp | 173 ++- .../sdpa_scale_fusion.cpp | 28 +- .../select_with_one_value_condition.cpp | 10 +- .../common_optimizations/sequence_fusion.cpp | 6 +- .../shared_ops_optimization.cpp | 10 +- .../shuffle_channels_fusion.cpp | 8 +- .../simplify_shape_of_sub_graph.cpp | 123 +- ...ip_gather_before_transpose_and_reshape.cpp | 4 +- .../common_optimizations/softmax_fusion.cpp | 6 +- .../common_optimizations/softplus_fusion.cpp | 4 +- .../softplus_to_mish_fusion.cpp | 6 +- .../space_to_batch_fusion.cpp | 36 +- .../strides_optimization.cpp | 22 +- .../common_optimizations/subtract_fusion.cpp | 14 +- .../common_optimizations/swish_fusion.cpp | 12 +- ...anspose_reshape_elimination_for_matmul.cpp | 6 +- .../transpose_sinking.cpp | 46 +- .../transpose_to_reshape.cpp | 4 +- .../weights_dequantize_to_fake_quantize.cpp | 8 +- .../wrap_interpolate_into_transposes.cpp | 4 +- .../flush_fp32_subnormals_to_zero.cpp | 6 +- ...decompression_convert_constant_folding.cpp | 32 +- .../mark_floatpoint_range.cpp | 7 +- ...k_subgraphs_to_keep_in_mixed_precision.cpp | 60 +- .../mark_dequantization_subgraph.cpp | 103 +- .../batch_norm_decomposition.cpp | 20 +- .../bidirectional_sequences_decomposition.cpp | 6 +- .../convert_avgpool_downgrade.cpp | 6 +- .../op_conversions/convert_batch_to_space.cpp | 12 +- .../convert_bitwise_to_logical_bool.cpp | 30 +- .../op_conversions/convert_broadcast3.cpp | 6 +- .../convert_broadcast_to_tiles.cpp | 2 +- .../op_conversions/convert_convertlike.cpp | 6 +- .../convert_convertpromotetypes.cpp | 8 +- .../convert_deformable_conv_v8_to_v1.cpp | 6 +- .../op_conversions/convert_depth_to_space.cpp | 4 +- .../op_conversions/convert_divide.cpp | 6 +- ...vert_embedding_bag_offsets15_downgrade.cpp | 6 +- ...nvert_embedding_bag_packed15_downgrade.cpp | 6 +- .../convert_fc_to_compressed.cpp | 14 +- .../convert_fc_to_quantized_legacy.cpp | 16 +- .../op_conversions/convert_gather_0d.cpp | 2 +- .../convert_gather_downgrade.cpp | 12 +- .../convert_gather_to_compressed.cpp | 32 +- .../op_conversions/convert_gather_upgrade.cpp | 12 +- .../op_conversions/convert_gelu.cpp | 4 +- .../convert_interpolate11_downgrade.cpp | 6 +- .../convert_interpolate1_to_interpolate4.cpp | 4 +- .../convert_matrix_nms_to_matrix_nms_ie.cpp | 2 +- .../convert_maxpool_downgrade.cpp | 12 +- .../convert_maxpool_upgrade.cpp | 4 +- .../op_conversions/convert_mod.cpp | 2 +- ...rt_multiclass_nms_to_multiclass_nms_ie.cpp | 6 +- .../convert_multiclass_nms_upgrade.cpp | 6 +- .../op_conversions/convert_mvn1_to_mvn6.cpp | 6 +- .../op_conversions/convert_negative.cpp | 2 +- .../convert_nms9_to_nms_ie_internal.cpp | 2 +- ...convert_nms_rotated_to_nms_ie_internal.cpp | 2 +- .../convert_nms_to_nms_ie_internal.cpp | 2 +- .../convert_one_hot_v16_to_v1.cpp | 6 +- .../convert_pad12_downgrade.cpp | 6 +- .../convert_pad_to_group_conv.cpp | 4 +- .../convert_previous_nms_to_nms_5.cpp | 20 +- .../convert_previous_nms_to_nms_9.cpp | 26 +- .../convert_prior_box_v8_to_v0.cpp | 6 +- .../convert_reduce_to_pooling.cpp | 24 +- .../convert_reduce_to_reshape.cpp | 56 +- .../convert_roi_align_v3_to_v9.cpp | 6 +- .../convert_roi_align_v9_to_v3.cpp | 6 +- .../convert_scatter_elements_to_scatter.cpp | 12 +- ...rt_scatter_elements_update12_downgrade.cpp | 6 +- .../convert_scatter_nd_update15_downgrade.cpp | 6 +- .../convert_sequences_to_tensor_iterator.cpp | 38 +- .../op_conversions/convert_shapeof3.cpp | 4 +- .../convert_shuffle_channels3.cpp | 4 +- .../convert_slice_to_strided_slice.cpp | 6 +- .../op_conversions/convert_slicescatter.cpp | 6 +- .../convert_softmax_downgrade.cpp | 8 +- .../convert_softmax_upgrade.cpp | 6 +- .../op_conversions/convert_space_to_batch.cpp | 12 +- .../op_conversions/convert_space_to_depth.cpp | 4 +- .../convert_squeeze15_downgrade.cpp | 6 +- .../op_conversions/convert_subtract.cpp | 12 +- .../convert_ti_to_sequences.cpp | 332 +++--- .../convert_topk11_downgrade.cpp | 6 +- .../op_conversions/convert_topk3.cpp | 4 +- .../convert_xor_to_logical_xor.cpp | 6 +- .../detection_output_downgrade.cpp | 6 +- .../detection_output_upgrade.cpp | 6 +- .../op_conversions/eye_decomposition.cpp | 22 +- .../op_conversions/fq_decomposition.cpp | 2 +- .../group_normalization_decomposition.cpp | 6 +- .../group_query_attention_decomposition.cpp | 171 ++- .../lstm_cell_decomposition.cpp | 2 +- ...ed_dot_product_attention_decomposition.cpp | 123 +- .../simplify_ctc_greedy_decoder_seq_len.cpp | 2 +- .../op_conversions/softmax_decomposition.cpp | 2 +- .../op_conversions/softplus_decomposition.cpp | 2 +- .../op_conversions/softsign_decomposition.cpp | 2 +- .../op_conversions/unique_decomposition.cpp | 6 +- .../compressed_weights_block.cpp | 32 +- .../position_ids_replacer.cpp | 102 +- .../prev_sequence_length_pattern.cpp | 25 +- .../state_management_pattern.cpp | 362 +++--- .../total_sequence_length_pattern.cpp | 78 +- .../broadcast_const_range_replacement.cpp | 8 +- .../smart_reshape/matmul_sr.cpp | 18 +- .../proposal_scales_stridedslice.cpp | 10 +- .../smart_reshape/reshape_sinking.cpp | 16 +- .../smart_reshape/reshape_to_1D.cpp | 4 +- .../smart_reshape/shape_of_const_folding.cpp | 8 +- .../smart_reshape/strided_slice_squeeze.cpp | 12 +- .../chained_maximum.cpp | 14 +- .../dereshape_matmul.cpp | 69 +- .../nop_broadcast.cpp | 15 +- .../reshape_optimizations.cpp | 13 +- .../symbolic_optimizations.cpp | 18 +- .../transpose_sinking/ts_base.cpp | 5 +- .../transpose_sinking/ts_binary.cpp | 15 +- .../transpose_sinking/ts_concat.cpp | 15 +- .../transpose_sinking/ts_cumsum.cpp | 15 +- .../transpose_sinking/ts_data_movement.cpp | 15 +- .../transpose_sinking/ts_fuse.cpp | 8 +- .../transpose_sinking/ts_gather.cpp | 11 +- .../transpose_sinking/ts_interpolate.cpp | 15 +- .../transpose_sinking/ts_reduction.cpp | 13 +- .../ts_reset_no_sinking_attribute.cpp | 7 +- .../transpose_sinking/ts_slice.cpp | 15 +- .../transpose_sinking/ts_split.cpp | 10 +- .../transpose_sinking/ts_squeeze.cpp | 15 +- .../transpose_sinking/ts_tile.cpp | 15 +- .../transpose_sinking/ts_unary.cpp | 19 +- .../transpose_sinking/ts_unsqueeze.cpp | 11 +- .../src/transformations/utils/utils.cpp | 30 +- .../convert_pagedattn_inputs.cpp | 85 +- .../eliminate_loop_inputs_outputs_test.cpp | 158 ++- .../eliminate_unsqueeze_gather.cpp | 162 ++- ...bgraph_to_keep_in_mixed_precision_test.cpp | 14 +- .../moc_transformations.cpp | 51 +- .../common_optimizations/sdpa_fusion_test.cpp | 77 +- .../shared_ops_optimization.cpp | 424 ++++--- .../sdpa_to_paged_attention_test.cpp | 1011 ++++++++--------- .../chained_maximum.cpp | 91 +- .../dereshape_fullyconnected.cpp | 55 +- .../dereshape_matmul.cpp | 85 +- .../nop_broadcast.cpp | 49 +- .../reshape_optimizations.cpp | 77 +- .../symbol_optimization.cpp | 145 ++- 223 files changed, 4004 insertions(+), 4149 deletions(-) diff --git a/src/common/transformations/src/transformations/common_optimizations/activations_scaling.cpp b/src/common/transformations/src/transformations/common_optimizations/activations_scaling.cpp index 90bf71ec5ce3c6..96bd6d1a43a70e 100644 --- a/src/common/transformations/src/transformations/common_optimizations/activations_scaling.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/activations_scaling.cpp @@ -46,20 +46,19 @@ const auto is_non_const_node = [](const ov::Output& output) -> bool { } // namespace using namespace ov::pass::activations_scaling; -using namespace ov::pass::pattern; using ov::pass::pattern::op::Or; ov::pass::activations_scaling::ScaleDownSingleLayer::ScaleDownSingleLayer(float scale_factor, ov::element::Type scaled_prec) { MATCHER_SCOPE(ScaleDownSingleLayer); - auto activation_m = any_input(); - auto weights_m = any_input(); - auto convolution_m = wrap_type({activation_m, weights_m}); - auto matmul_m = wrap_type({activation_m, weights_m}); + auto activation_m = ov::pass::pattern::any_input(); + auto weights_m = ov::pass::pattern::any_input(); + auto convolution_m = ov::pass::pattern::wrap_type({activation_m, weights_m}); + auto matmul_m = ov::pass::pattern::wrap_type({activation_m, weights_m}); auto scaled_op_m = std::make_shared(OutputVector{convolution_m, matmul_m}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); OPENVINO_ASSERT(pattern_map.count(convolution_m) || pattern_map.count(matmul_m), @@ -180,17 +179,17 @@ ov::pass::activations_scaling::ScaleDownSingleLayer::ScaleDownSingleLayer(float ov::pass::activations_scaling::EliminateScalarMul::EliminateScalarMul() { MATCHER_SCOPE(EliminateScalarMul); - auto activation_m = any_input(is_non_const_node); + auto activation_m = ov::pass::pattern::any_input(is_non_const_node); auto convert_m = ov::pass::pattern::optional(activation_m); auto scale_const_m = ov::pass::pattern::wrap_type(is_scalar_node); - auto mul_m = wrap_type({convert_m, scale_const_m}); - auto mvn_m = wrap_type({mul_m, any_input()}); - auto rms_m = wrap_type({mul_m, any_input()}); - auto group_norm_m = wrap_type({mul_m, any_input(), any_input()}); - auto shape_of_m = wrap_type({mul_m}); + auto mul_m = ov::pass::pattern::wrap_type({convert_m, scale_const_m}); + auto mvn_m = ov::pass::pattern::wrap_type({mul_m, ov::pass::pattern::any_input()}); + auto rms_m = ov::pass::pattern::wrap_type({mul_m, ov::pass::pattern::any_input()}); + auto group_norm_m = ov::pass::pattern::wrap_type({mul_m, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto shape_of_m = ov::pass::pattern::wrap_type({mul_m}); auto norm_m = std::make_shared(OutputVector{mvn_m, rms_m, group_norm_m, shape_of_m}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); if (transformation_callback(m.get_match_root())) { @@ -240,13 +239,13 @@ ov::pass::activations_scaling::EliminateScalarMul::EliminateScalarMul() { ov::pass::activations_scaling::MulShareTransformation::MulShareTransformation() { MATCHER_SCOPE(MulShareTransformation); - auto mvn_m = wrap_type({any_input(), any_input()}); - auto rms_m = wrap_type({any_input(), any_input()}); - auto group_norm_m = wrap_type({any_input(), any_input(), any_input()}); - auto shape_of_m = wrap_type({any_input()}); + auto mvn_m = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto rms_m = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto group_norm_m = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto shape_of_m = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); auto norm_m = std::make_shared(OutputVector{mvn_m, rms_m, group_norm_m, shape_of_m}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); if (transformation_callback(m.get_match_root())) { @@ -314,13 +313,13 @@ ov::pass::activations_scaling::MulShareTransformation::MulShareTransformation() ov::pass::activations_scaling::MoveDownScalarMul::MoveDownScalarMul() { MATCHER_SCOPE(MoveDownScalarMul); - auto activation_b_m = any_input(is_non_const_node); + auto activation_b_m = ov::pass::pattern::any_input(is_non_const_node); auto mul_const_m = ov::pass::pattern::wrap_type(is_scalar_node); - auto mul_b_m = wrap_type({activation_b_m, mul_const_m}); - auto activation_a_m = any_input(is_non_const_node); - auto mul_a_m = wrap_type({activation_a_m, mul_b_m}); + auto mul_b_m = ov::pass::pattern::wrap_type({activation_b_m, mul_const_m}); + auto activation_a_m = ov::pass::pattern::any_input(is_non_const_node); + auto mul_a_m = ov::pass::pattern::wrap_type({activation_a_m, mul_b_m}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); if (transformation_callback(m.get_match_root())) { diff --git a/src/common/transformations/src/transformations/common_optimizations/adaptive_pool_to_reduce.cpp b/src/common/transformations/src/transformations/common_optimizations/adaptive_pool_to_reduce.cpp index 750aa78e8e6c0f..4e9bd93b13275f 100644 --- a/src/common/transformations/src/transformations/common_optimizations/adaptive_pool_to_reduce.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/adaptive_pool_to_reduce.cpp @@ -16,19 +16,16 @@ #include "openvino/op/reduce_mean.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" #include "transformations/utils/utils.hpp" - -using namespace ov::op; - ov::pass::AdaptivePoolToReduce::AdaptivePoolToReduce() { MATCHER_SCOPE(AdaptivePoolToReduce); - auto data_pattern = pattern::any_input(); - auto out_spatial_shape = pattern::wrap_type(); - auto a_pool = pattern::wrap_type({data_pattern, out_spatial_shape}); + auto data_pattern = ov::pass::pattern::any_input(); + auto out_spatial_shape = ov::pass::pattern::wrap_type(); + auto a_pool = ov::pass::pattern::wrap_type({data_pattern, out_spatial_shape}); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); - const auto& spatial_shape_c = ov::as_type_ptr(pattern_map.at(out_spatial_shape)); + const auto& spatial_shape_c = ov::as_type_ptr(pattern_map.at(out_spatial_shape)); auto spatial_shape = spatial_shape_c->cast_vector(); // Verify that all dimensions in adaptive pool shape are 1 for (auto& s : spatial_shape) { @@ -38,17 +35,17 @@ ov::pass::AdaptivePoolToReduce::AdaptivePoolToReduce() { auto axes = std::vector(spatial_shape.size(), 0); std::iota(axes.begin(), axes.end(), 2); - auto axes_const = v0::Constant::create(element::i64, {spatial_shape.size()}, axes); + auto axes_const = ov::op::v0::Constant::create(element::i64, {spatial_shape.size()}, axes); const auto adaptive_pool = pattern_map.at(a_pool); std::shared_ptr res_node; - if (ov::as_type_ptr(adaptive_pool)) { - res_node = std::make_shared(adaptive_pool->input_value(0), axes_const, true); - } else if (ov::as_type_ptr(adaptive_pool)) { + if (ov::as_type_ptr(adaptive_pool)) { + res_node = std::make_shared(adaptive_pool->input_value(0), axes_const, true); + } else if (ov::as_type_ptr(adaptive_pool)) { if (adaptive_pool->outputs().size() > 1 && adaptive_pool->output(1).get_target_inputs().size() != 0) { // If indexes are used we can't replace it return false; } - res_node = std::make_shared(adaptive_pool->input_value(0), axes_const, true); + res_node = std::make_shared(adaptive_pool->input_value(0), axes_const, true); } else { return false; } diff --git a/src/common/transformations/src/transformations/common_optimizations/add_fake_quantize_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/add_fake_quantize_fusion.cpp index ed4ac5bdb7e919..90043d7a5d27d1 100644 --- a/src/common/transformations/src/transformations/common_optimizations/add_fake_quantize_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/add_fake_quantize_fusion.cpp @@ -25,16 +25,16 @@ ov::pass::AddFakeQuantizeFusion::AddFakeQuantizeFusion() { MATCHER_SCOPE(AddFakeQuantizeFusion); - auto input_pattern = pass::pattern::any_input(); + auto input_pattern = ov::pass::pattern::any_input(); auto const_pattern = ov::pass::pattern::wrap_type(); auto add_pattern = - ov::pass::pattern::wrap_type({input_pattern, const_pattern}, pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({input_pattern, const_pattern}, ov::pass::pattern::consumers_count(1)); auto fq_pattern = ov::pass::pattern::wrap_type({add_pattern, - pass::pattern::any_input(), - pass::pattern::any_input(), - pass::pattern::any_input(), - pass::pattern::any_input()}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_value_map = m.get_pattern_value_map(); const auto& input = pattern_value_map.at(input_pattern); const auto& type = input.get_element_type(); diff --git a/src/common/transformations/src/transformations/common_optimizations/align_eltwise_input_ranks.cpp b/src/common/transformations/src/transformations/common_optimizations/align_eltwise_input_ranks.cpp index 20a37cafbc06ea..c0445f8079d6ef 100644 --- a/src/common/transformations/src/transformations/common_optimizations/align_eltwise_input_ranks.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/align_eltwise_input_ranks.cpp @@ -15,13 +15,13 @@ #include "openvino/pass/pattern/op/wrap_type.hpp" ov::pass::AlignEltwiseInputRanks::AlignEltwiseInputRanks() { - auto eltwise_pattern = pattern::wrap_type(pattern::has_static_rank()); + ov::op::v0::FakeQuantize>(ov::pass::pattern::has_static_rank()); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); auto fq = as_type(node.get()); @@ -65,6 +65,6 @@ ov::pass::AlignEltwiseInputRanks::AlignEltwiseInputRanks() { return false; }; - auto m = std::make_shared(eltwise_pattern, "AlignEltwiseInputRanks"); + auto m = std::make_shared(eltwise_pattern, "AlignEltwiseInputRanks"); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/augru_cell_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/augru_cell_fusion.cpp index a89a8a43a4ed4f..4aa2e593ee2fc2 100644 --- a/src/common/transformations/src/transformations/common_optimizations/augru_cell_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/augru_cell_fusion.cpp @@ -27,8 +27,6 @@ using namespace std; using namespace ov::element; -using namespace ov::pass::pattern; - // The 1st input to the Add op is automatically broadcasted // from 1d to 2d tensor, but to be compatible with what // the transformation code expectes we have to broadcast the @@ -75,29 +73,29 @@ ov::pass::AUGRUCellFusion::AUGRUCellFusion() { return !(p_shape.rank().is_dynamic() || p_shape[1].is_dynamic()); }; - auto concat_1 = wrap_type({any_input(is_first_dim_static), any_input(is_first_dim_static)}); - auto matmul_1 = wrap_type({concat_1, any_input(is_first_dim_static)}); - auto add_1 = wrap_type({matmul_1, any_input()}); + auto concat_1 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(is_first_dim_static), ov::pass::pattern::any_input(is_first_dim_static)}); + auto matmul_1 = ov::pass::pattern::wrap_type({concat_1, ov::pass::pattern::any_input(is_first_dim_static)}); + auto add_1 = ov::pass::pattern::wrap_type({matmul_1, ov::pass::pattern::any_input()}); // only Sigmoid is supported in the current version of AUGRUCell - auto sigmoid = wrap_type({add_1}); - auto split = wrap_type({sigmoid, any_input()}); - auto multiply = wrap_type({split, any_input()}); + auto sigmoid = ov::pass::pattern::wrap_type({add_1}); + auto split = ov::pass::pattern::wrap_type({sigmoid, ov::pass::pattern::any_input()}); + auto multiply = ov::pass::pattern::wrap_type({split, ov::pass::pattern::any_input()}); - auto concat_2 = wrap_type({any_input(), multiply}); - auto matmul_2 = wrap_type({concat_2, any_input(is_first_dim_static)}); - auto add_2 = wrap_type({matmul_2, any_input()}); + auto concat_2 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), multiply}); + auto matmul_2 = ov::pass::pattern::wrap_type({concat_2, ov::pass::pattern::any_input(is_first_dim_static)}); + auto add_2 = ov::pass::pattern::wrap_type({matmul_2, ov::pass::pattern::any_input()}); // only Tanh is supported in the current version of AUGRUCell - auto tanh = wrap_type({add_2}); + auto tanh = ov::pass::pattern::wrap_type({add_2}); - auto subtract_1 = wrap_type({any_input(), any_input()}); - auto multiply_2 = wrap_type({subtract_1, split}); - auto subtract_2 = wrap_type({any_input(), multiply_2}); - auto multiply_3 = wrap_type({subtract_2, tanh}); + auto subtract_1 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto multiply_2 = ov::pass::pattern::wrap_type({subtract_1, split}); + auto subtract_2 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), multiply_2}); + auto multiply_3 = ov::pass::pattern::wrap_type({subtract_2, tanh}); - auto multiply_4 = wrap_type({multiply_2, any_input()}); - auto add_3 = wrap_type({multiply_4, multiply_3}); + auto multiply_4 = ov::pass::pattern::wrap_type({multiply_2, ov::pass::pattern::any_input()}); + auto add_3 = ov::pass::pattern::wrap_type({multiply_4, multiply_3}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { NodeRegistry rg; auto pattern_map = m.get_pattern_map(); auto concat = pattern_map.at(concat_1); @@ -148,6 +146,6 @@ ov::pass::AUGRUCellFusion::AUGRUCellFusion() { return true; }; - auto m = make_shared(add_3, matcher_name); + auto m = make_shared(add_3, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/batch_to_space_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/batch_to_space_fusion.cpp index edd51e76af0478..845229ba864bee 100644 --- a/src/common/transformations/src/transformations/common_optimizations/batch_to_space_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/batch_to_space_fusion.cpp @@ -22,30 +22,30 @@ ov::pass::BatchToSpaceFusion::BatchToSpaceFusion() { MATCHER_SCOPE(BatchToSpaceFusion); - auto data_pattern = pattern::any_input(pattern::has_static_shape()); + auto data_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); auto reshape_before_pattern = - pattern::wrap_type({data_pattern, pattern::wrap_type()}, - pattern::rank_equals(4)); + ov::pass::pattern::wrap_type({data_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto trans_before_pattern = - pattern::wrap_type({data_pattern, pattern::wrap_type()}, - pattern::rank_equals(4)); + ov::pass::pattern::wrap_type({data_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto reshape_or_transpose_before_pattern = - std::make_shared(OutputVector{reshape_before_pattern, trans_before_pattern}); - auto depth_to_space_pattern = pattern::wrap_type({reshape_or_transpose_before_pattern}); - auto starts_pattern = pattern::wrap_type(); - auto ends_pattern = pattern::wrap_type(); - auto slice_pattern = pattern::wrap_type( - {depth_to_space_pattern, starts_pattern, ends_pattern, pattern::wrap_type()}); + std::make_shared(OutputVector{reshape_before_pattern, trans_before_pattern}); + auto depth_to_space_pattern = ov::pass::pattern::wrap_type({reshape_or_transpose_before_pattern}); + auto starts_pattern = ov::pass::pattern::wrap_type(); + auto ends_pattern = ov::pass::pattern::wrap_type(); + auto slice_pattern = ov::pass::pattern::wrap_type( + {depth_to_space_pattern, starts_pattern, ends_pattern, ov::pass::pattern::wrap_type()}); auto reshape_after_pattern = - pattern::wrap_type({slice_pattern, pattern::wrap_type()}, - pattern::rank_equals(4)); + ov::pass::pattern::wrap_type({slice_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto trans_after_pattern = - pattern::wrap_type({slice_pattern, pattern::wrap_type()}, - pattern::rank_equals(4)); + ov::pass::pattern::wrap_type({slice_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto reshape_or_transpose_after_pattern = - std::make_shared(OutputVector{reshape_after_pattern, trans_after_pattern}); + std::make_shared(OutputVector{reshape_after_pattern, trans_after_pattern}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto get_reshape_or_transpose = [&pattern_map]( diff --git a/src/common/transformations/src/transformations/common_optimizations/binarize_weights.cpp b/src/common/transformations/src/transformations/common_optimizations/binarize_weights.cpp index b30dd77b87fcb5..a7eff727f1177f 100644 --- a/src/common/transformations/src/transformations/common_optimizations/binarize_weights.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/binarize_weights.cpp @@ -60,21 +60,21 @@ static std::vector quantize_weights(const Shape& weights_shape, pass::BinarizeWeights::BinarizeWeights() { MATCHER_SCOPE(BinarizeWeights); auto activations_fq_pattern = - pattern::wrap_type({pattern::any_input(), - pattern::wrap_type(), - pattern::wrap_type(), - pattern::wrap_type(), - pattern::wrap_type()}, - pattern::consumers_count(1)); - auto weights_fq_pattern = pattern::wrap_type({pattern::wrap_type(), - pattern::wrap_type(), - pattern::wrap_type(), - pattern::wrap_type(), - pattern::wrap_type()}, - pattern::consumers_count(1)); - auto conv_pattern = pattern::wrap_type({activations_fq_pattern, weights_fq_pattern}); - - matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); + auto weights_fq_pattern = ov::pass::pattern::wrap_type({ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); + auto conv_pattern = ov::pass::pattern::wrap_type({activations_fq_pattern, weights_fq_pattern}); + + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto conv = ov::as_type_ptr(m.get_match_root()); if (!conv) return false; @@ -208,6 +208,6 @@ pass::BinarizeWeights::BinarizeWeights() { return true; }; - auto m = std::make_shared(conv_pattern, matcher_name); + auto m = std::make_shared(conv_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/broadcast_elementwise_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/broadcast_elementwise_fusion.cpp index 6d27b3741c7f2e..480e1c98484b1b 100644 --- a/src/common/transformations/src/transformations/common_optimizations/broadcast_elementwise_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/broadcast_elementwise_fusion.cpp @@ -71,11 +71,11 @@ bool can_eliminate_broadcast(const ov::Output& eltwise, ov::pass::BroadcastElementwiseFusion::BroadcastElementwiseFusion() { MATCHER_SCOPE(BroadcastElementwiseFusion); - auto broadcast_input = pattern::any_input(); + auto broadcast_input = ov::pass::pattern::any_input(); auto broadcast = - pattern::wrap_type({broadcast_input, pattern::any_input()}, pattern::consumers_count(1)); - auto eltwise_input = pattern::any_input(); - auto eltwise = pattern::wrap_type({eltwise_input, broadcast}); + ov::pass::pattern::wrap_type({broadcast_input, ov::pass::pattern::any_input()}, ov::pass::pattern::consumers_count(1)); + auto eltwise_input = ov::pass::pattern::any_input(); + auto eltwise = ov::pass::pattern::wrap_type({eltwise_input, broadcast}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& pattern_value = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/broadcast_transition.cpp b/src/common/transformations/src/transformations/common_optimizations/broadcast_transition.cpp index d384519a5fc51c..ffab0e9aabd6d3 100644 --- a/src/common/transformations/src/transformations/common_optimizations/broadcast_transition.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/broadcast_transition.cpp @@ -22,11 +22,11 @@ ov::pass::BroadcastTransition::BroadcastTransition() { MATCHER_SCOPE(BroadcastTransition); auto bcast_m = - pass::pattern::wrap_type(pass::pattern::consumers_count(1)); - auto eltwise_input_m = pass::pattern::any_input(pass::pattern::has_static_rank()); - auto eltwise_1 = pass::pattern::wrap_type({eltwise_input_m, bcast_m}); - auto eltwise_2 = pass::pattern::wrap_type({bcast_m, eltwise_input_m}); - auto eltwise_m = std::make_shared(OutputVector{eltwise_1, eltwise_2}); + ov::pass::pattern::wrap_type(ov::pass::pattern::consumers_count(1)); + auto eltwise_input_m = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto eltwise_1 = ov::pass::pattern::wrap_type({eltwise_input_m, bcast_m}); + auto eltwise_2 = ov::pass::pattern::wrap_type({bcast_m, eltwise_input_m}); + auto eltwise_m = std::make_shared(OutputVector{eltwise_1, eltwise_2}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/clamp_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/clamp_fusion.cpp index 70a561d5aacacb..7c5cd43e96907a 100644 --- a/src/common/transformations/src/transformations/common_optimizations/clamp_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/clamp_fusion.cpp @@ -20,18 +20,18 @@ ov::pass::ClampFusion::ClampFusion() { MATCHER_SCOPE(ClampFusion); - auto data_pattern = pass::pattern::any_input(); + auto data_pattern = ov::pass::pattern::any_input(); auto min_const_pattern = ov::pass::pattern::wrap_type(); auto max_const_pattern = ov::pass::pattern::wrap_type(); auto max_pattern1 = ov::pass::pattern::wrap_type({data_pattern, min_const_pattern}, - pattern::consumers_count(1)); + ov::pass::pattern::consumers_count(1)); auto min_pattern1 = ov::pass::pattern::wrap_type({max_pattern1, max_const_pattern}); auto min_pattern2 = ov::pass::pattern::wrap_type({data_pattern, max_const_pattern}); auto max_pattern2 = ov::pass::pattern::wrap_type({min_pattern2, min_const_pattern}, - pattern::consumers_count(1)); + ov::pass::pattern::consumers_count(1)); auto root = std::make_shared(ov::OutputVector{min_pattern1, max_pattern2}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_value_map(); auto data = pattern_map.at(data_pattern); auto min_const = ov::as_type_ptr(pattern_map.at(min_const_pattern).get_node_shared_ptr()); diff --git a/src/common/transformations/src/transformations/common_optimizations/compress_float_constants.cpp b/src/common/transformations/src/transformations/common_optimizations/compress_float_constants.cpp index 09aacf6562db84..93aa23e472e410 100644 --- a/src/common/transformations/src/transformations/common_optimizations/compress_float_constants.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/compress_float_constants.cpp @@ -78,13 +78,13 @@ using namespace ov::pass; class DetectFakeQuantizeOrFakeConvert : public MatcherPass { public: DetectFakeQuantizeOrFakeConvert() { - auto root = pattern::wrap_type(); + auto root = ov::pass::pattern::wrap_type(); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { return true; }; - auto m = std::make_shared(root, "DetectFakeQuantizeOrFakeConvert"); + auto m = std::make_shared(root, "DetectFakeQuantizeOrFakeConvert"); register_matcher(m, callback); } }; @@ -92,26 +92,26 @@ class DetectFakeQuantizeOrFakeConvert : public MatcherPass { class DetectCompressedWeights : public MatcherPass { public: DetectCompressedWeights() { - auto weights = pattern::wrap_type(pattern::type_matches_any({ov::element::i4, + auto weights = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any({ov::element::i4, ov::element::u4, ov::element::i8, ov::element::u8, ov::element::nf4, ov::element::f8e4m3, ov::element::f8e5m2})); - auto convert = pattern::wrap_type({weights}); - auto zero_point_const = pattern::wrap_type(); - auto zero_point = pattern::optional(zero_point_const); - auto subtract = pattern::wrap_type({convert, zero_point}); - auto subtract_or_convert = std::make_shared(ov::OutputVector{convert, subtract}); + auto convert = ov::pass::pattern::wrap_type({weights}); + auto zero_point_const = ov::pass::pattern::wrap_type(); + auto zero_point = ov::pass::pattern::optional(zero_point_const); + auto subtract = ov::pass::pattern::wrap_type({convert, zero_point}); + auto subtract_or_convert = std::make_shared(ov::OutputVector{convert, subtract}); auto multiply = - pattern::wrap_type({subtract_or_convert, pattern::wrap_type()}); + ov::pass::pattern::wrap_type({subtract_or_convert, ov::pass::pattern::wrap_type()}); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { return true; }; - auto m = std::make_shared(multiply, "DetectCompressedWeights"); + auto m = std::make_shared(multiply, "DetectCompressedWeights"); register_matcher(m, callback); } }; @@ -136,9 +136,9 @@ void ov::pass::compress_model_to_f16(const std::shared_ptr& model, bool p ov::pass::CompressFloatConstantsImpl::CompressFloatConstantsImpl(bool postponed) { MATCHER_SCOPE(CompressFloatConstantsImpl); - auto const_pattern = pattern::wrap_type(); + auto const_pattern = ov::pass::pattern::wrap_type(); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& const_node_pattern = pattern_map.at(const_pattern); @@ -252,6 +252,6 @@ ov::pass::CompressFloatConstantsImpl::CompressFloatConstantsImpl(bool postponed) return true; }; - auto m = std::make_shared(const_pattern, matcher_name); + auto m = std::make_shared(const_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/concat_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/concat_fusion.cpp index 0d89447c6720e7..2f457daa6c7647 100644 --- a/src/common/transformations/src/transformations/common_optimizations/concat_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/concat_fusion.cpp @@ -13,34 +13,31 @@ #include "openvino/op/concat.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" #include "transformations/utils/utils.hpp" - -using namespace ov::op; - ov::pass::ConcatFusion::ConcatFusion() { MATCHER_SCOPE(ConcatFusion); auto has_same_axis_concat_input = [](const Output& output) { - const auto& concat = ov::as_type_ptr(output.get_node_shared_ptr()); + const auto& concat = ov::as_type_ptr(output.get_node_shared_ptr()); const auto axis = concat->get_axis(); auto is_aplicable = false; for (auto input : concat->input_values()) { - const auto inp_concat = ov::as_type_ptr(input.get_node_shared_ptr()); + const auto inp_concat = ov::as_type_ptr(input.get_node_shared_ptr()); if (inp_concat && inp_concat->get_axis() == axis && inp_concat->output(0).get_target_inputs().size() == 1) { is_aplicable = true; } } return is_aplicable; }; - auto concat_pattern = pattern::wrap_type(has_same_axis_concat_input); + auto concat_pattern = ov::pass::pattern::wrap_type(has_same_axis_concat_input); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); - const auto& concat = ov::as_type_ptr(pattern_map.at(concat_pattern)); + const auto& concat = ov::as_type_ptr(pattern_map.at(concat_pattern)); const auto axis = concat->get_axis(); OutputVector new_inputs; for (auto input : concat->input_values()) { - const auto inp_concat = ov::as_type_ptr(input.get_node_shared_ptr()); + const auto inp_concat = ov::as_type_ptr(input.get_node_shared_ptr()); if (inp_concat && inp_concat->get_axis() == axis && inp_concat->output(0).get_target_inputs().size() == 1) { const auto inp_concat_inps = inp_concat->input_values(); new_inputs.insert(new_inputs.end(), inp_concat_inps.begin(), inp_concat_inps.end()); @@ -49,7 +46,7 @@ ov::pass::ConcatFusion::ConcatFusion() { } } - auto new_concat = std::make_shared(new_inputs, axis); + auto new_concat = std::make_shared(new_inputs, axis); replace_node(concat, new_concat); new_concat->set_friendly_name(concat->get_friendly_name()); copy_runtime_info(concat, new_concat); diff --git a/src/common/transformations/src/transformations/common_optimizations/concat_reduce_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/concat_reduce_fusion.cpp index 213aefd39a2027..8c323886c7fbd7 100644 --- a/src/common/transformations/src/transformations/common_optimizations/concat_reduce_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/concat_reduce_fusion.cpp @@ -40,12 +40,12 @@ ReduceType get_reduce_type(const std::shared_ptr& reduce_node) { ov::pass::PullSqueezeThroughEltwise::PullSqueezeThroughEltwise() { MATCHER_SCOPE(PullSqueezeThroughEltwise); - auto eltwise_pattern = pattern::wrap_type(); + auto eltwise_pattern = ov::pass::pattern::wrap_type(); - auto squeeze_axes_pattern = pattern::wrap_type(); - auto squeeze_pattern = pattern::wrap_type({eltwise_pattern, squeeze_axes_pattern}); + auto squeeze_axes_pattern = ov::pass::pattern::wrap_type(); + auto squeeze_pattern = ov::pass::pattern::wrap_type({eltwise_pattern, squeeze_axes_pattern}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); const auto& eltwise = pattern_map.at(eltwise_pattern); const auto& squeeze = pattern_map.at(squeeze_pattern); @@ -79,7 +79,7 @@ ov::pass::PullSqueezeThroughEltwise::PullSqueezeThroughEltwise() { return true; }; - auto m = std::make_shared(squeeze_pattern, matcher_name); + auto m = std::make_shared(squeeze_pattern, matcher_name); this->register_matcher(m, callback); } @@ -87,12 +87,12 @@ ov::pass::ReplaceConcatReduceByMinOrMax::ReplaceConcatReduceByMinOrMax() { MATCHER_SCOPE(ReplaceConcatReduceByMinOrMax); auto concat_pattern = - ov::pass::pattern::wrap_type({pattern::any_input(), pattern::any_input()}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto reduce_axes_pattern = ov::pass::pattern::wrap_type(); auto reduce_pattern = ov::pass::pattern::wrap_type( {concat_pattern, reduce_axes_pattern}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto concat = as_type_ptr(pattern_map.at(concat_pattern).get_node_shared_ptr()); diff --git a/src/common/transformations/src/transformations/common_optimizations/concat_to_broadcast.cpp b/src/common/transformations/src/transformations/common_optimizations/concat_to_broadcast.cpp index 910a2d361cd9c1..aecbbae6720207 100644 --- a/src/common/transformations/src/transformations/common_optimizations/concat_to_broadcast.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/concat_to_broadcast.cpp @@ -24,7 +24,7 @@ static bool use_broadcast(const std::shared_ptr& concat) { ov::pass::ConcatToBroadcast::ConcatToBroadcast() { MATCHER_SCOPE(ConcatToBroadcast); - auto concat_label = pattern::wrap_type([](const Output& value) { + auto concat_label = ov::pass::pattern::wrap_type([](const Output& value) { auto node = value.get_node_shared_ptr(); if (node->output(0).get_partial_shape().rank().is_dynamic()) { return false; @@ -42,7 +42,7 @@ ov::pass::ConcatToBroadcast::ConcatToBroadcast() { }); }); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto root_node = pattern_map.at(concat_label).get_node_shared_ptr(); @@ -86,6 +86,6 @@ ov::pass::ConcatToBroadcast::ConcatToBroadcast() { return true; }; - auto m = std::make_shared(concat_label, matcher_name); + auto m = std::make_shared(concat_label, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/conv_mul_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/conv_mul_fusion.cpp index 9252d7148f3e28..7ccba179737a03 100644 --- a/src/common/transformations/src/transformations/common_optimizations/conv_mul_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/conv_mul_fusion.cpp @@ -18,13 +18,13 @@ ov::pass::ConvolutionMultiplyFusion::ConvolutionMultiplyFusion() { MATCHER_SCOPE(ConvolutionMultiplyFusion); - auto input = pattern::any_input(); - auto weights = pass::pattern::any_input(pattern::has_static_dim(0) /* has OIYX layout */); - auto conv = pattern::wrap_type({input, weights}, pattern::consumers_count(1)); - auto mul_const = pattern::wrap_type(pattern::has_static_shape()); - auto mul = pattern::wrap_type({conv, mul_const}); + auto input = ov::pass::pattern::any_input(); + auto weights = ov::pass::pattern::any_input(ov::pass::pattern::has_static_dim(0) /* has OIYX layout */); + auto conv = ov::pass::pattern::wrap_type({input, weights}, ov::pass::pattern::consumers_count(1)); + auto mul_const = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_shape()); + auto mul = ov::pass::pattern::wrap_type({conv, mul_const}); - matcher_pass_callback callback = [conv, input, weights, mul, mul_const](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [conv, input, weights, mul, mul_const](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); const auto& m_weights = pattern_to_output.at(weights); @@ -75,19 +75,19 @@ ov::pass::ConvolutionMultiplyFusion::ConvolutionMultiplyFusion() { return true; }; - auto m = std::make_shared(mul, matcher_name); + auto m = std::make_shared(mul, matcher_name); register_matcher(m, callback); } ov::pass::GroupConvolutionMultiplyFusion::GroupConvolutionMultiplyFusion() { MATCHER_SCOPE(GroupConvolutionMultiplyFusion); - auto input = pattern::any_input(); - auto weights = pass::pattern::any_input(pattern::has_static_dims({0, 1}) /* has GOIYX layout */); - auto conv = pattern::wrap_type({input, weights}, pattern::consumers_count(1)); - auto mul_const = pattern::wrap_type(); // pattern::has_static_shape()); - auto mul = pattern::wrap_type({conv, mul_const}); + auto input = ov::pass::pattern::any_input(); + auto weights = ov::pass::pattern::any_input(ov::pass::pattern::has_static_dims({0, 1}) /* has GOIYX layout */); + auto conv = ov::pass::pattern::wrap_type({input, weights}, ov::pass::pattern::consumers_count(1)); + auto mul_const = ov::pass::pattern::wrap_type(); // ov::pass::pattern::has_static_shape()); + auto mul = ov::pass::pattern::wrap_type({conv, mul_const}); - matcher_pass_callback callback = [conv, input, weights, mul, mul_const](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [conv, input, weights, mul, mul_const](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); auto m_weights = pattern_to_output.at(weights); @@ -161,23 +161,23 @@ ov::pass::GroupConvolutionMultiplyFusion::GroupConvolutionMultiplyFusion() { return true; }; - auto m = std::make_shared(mul, matcher_name); + auto m = std::make_shared(mul, matcher_name); register_matcher(m, callback); } ov::pass::ConvolutionBackpropDataMultiplyFusion::ConvolutionBackpropDataMultiplyFusion() { MATCHER_SCOPE(ConvolutionBackpropDataMultiplyFusion); - auto input = pattern::any_input(); - auto weights = pass::pattern::any_input(pattern::has_static_dim(1) /* has IOYX layout */); + auto input = ov::pass::pattern::any_input(); + auto weights = ov::pass::pattern::any_input(ov::pass::pattern::has_static_dim(1) /* has IOYX layout */); auto conv_2_inputs = - pattern::wrap_type({input, weights}, pattern::consumers_count(1)); - auto conv_3_inputs = pattern::wrap_type({input, weights, pattern::any_input()}, - pattern::consumers_count(1)); - auto conv = std::make_shared(OutputVector{conv_2_inputs, conv_3_inputs}); - auto mul_const = pattern::wrap_type(pattern::has_static_shape()); - auto mul = pattern::wrap_type({conv, mul_const}); - - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + ov::pass::pattern::wrap_type({input, weights}, ov::pass::pattern::consumers_count(1)); + auto conv_3_inputs = ov::pass::pattern::wrap_type({input, weights, ov::pass::pattern::any_input()}, + ov::pass::pattern::consumers_count(1)); + auto conv = std::make_shared(OutputVector{conv_2_inputs, conv_3_inputs}); + auto mul_const = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_shape()); + auto mul = ov::pass::pattern::wrap_type({conv, mul_const}); + + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); const auto& m_weights = pattern_to_output.at(weights); @@ -236,24 +236,24 @@ ov::pass::ConvolutionBackpropDataMultiplyFusion::ConvolutionBackpropDataMultiply return true; }; - auto m = std::make_shared(mul, matcher_name); + auto m = std::make_shared(mul, matcher_name); register_matcher(m, callback); } ov::pass::GroupConvolutionBackpropDataMultiplyFusion::GroupConvolutionBackpropDataMultiplyFusion() { MATCHER_SCOPE(GroupConvolutionBackpropDataMultiplyFusion); - auto input = pattern::any_input(); - auto weights = pass::pattern::any_input(pattern::has_static_dims({0, 2}) /* has GIOYX layout */); + auto input = ov::pass::pattern::any_input(); + auto weights = ov::pass::pattern::any_input(ov::pass::pattern::has_static_dims({0, 2}) /* has GIOYX layout */); auto conv_2_inputs = - pattern::wrap_type({input, weights}, pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({input, weights}, ov::pass::pattern::consumers_count(1)); auto conv_3_inputs = - pattern::wrap_type({input, weights, pattern::any_input()}, - pattern::consumers_count(1)); - auto conv = std::make_shared(OutputVector{conv_2_inputs, conv_3_inputs}); - auto mul_const = pattern::wrap_type(pattern::has_static_shape()); - auto mul = pattern::wrap_type({conv, mul_const}); + ov::pass::pattern::wrap_type({input, weights, ov::pass::pattern::any_input()}, + ov::pass::pattern::consumers_count(1)); + auto conv = std::make_shared(OutputVector{conv_2_inputs, conv_3_inputs}); + auto mul_const = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_shape()); + auto mul = ov::pass::pattern::wrap_type({conv, mul_const}); - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); const auto& m_weights = pattern_to_output.at(weights); @@ -314,6 +314,6 @@ ov::pass::GroupConvolutionBackpropDataMultiplyFusion::GroupConvolutionBackpropDa return true; }; - auto m = std::make_shared(mul, matcher_name); + auto m = std::make_shared(mul, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/conv_to_binary_conv.cpp b/src/common/transformations/src/transformations/common_optimizations/conv_to_binary_conv.cpp index 0bab29bc45fa27..b68972a831e634 100644 --- a/src/common/transformations/src/transformations/common_optimizations/conv_to_binary_conv.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/conv_to_binary_conv.cpp @@ -39,16 +39,16 @@ static std::vector binarize_weights(const std::vector& weights) ov::pass::ConvToBinaryConv::ConvToBinaryConv() { MATCHER_SCOPE(ConvToBinaryConv); auto fq_pattern = - ov::pass::pattern::wrap_type({pattern::any_input(), - pattern::any_input(), - pattern::any_input(), + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}, - pattern::consumers_count(1)); + ov::pass::pattern::consumers_count(1)); auto conv_pattern = ov::pass::pattern::wrap_type( {fq_pattern, ov::pass::pattern::wrap_type()}); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto conv = ov::as_type_ptr(m.get_match_root()); if (!conv) return false; diff --git a/src/common/transformations/src/transformations/common_optimizations/convert_nms_gather_path_to_unsigned.cpp b/src/common/transformations/src/transformations/common_optimizations/convert_nms_gather_path_to_unsigned.cpp index 09b86bbd904128..81220a7d42075c 100644 --- a/src/common/transformations/src/transformations/common_optimizations/convert_nms_gather_path_to_unsigned.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/convert_nms_gather_path_to_unsigned.cpp @@ -34,18 +34,18 @@ class InitNMSPath : public pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("InitNMSPath"); InitNMSPath() { MATCHER_SCOPE(InitNMSPath); - auto nms_pattern = pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& out_nodes = m.get_match_root()->output(0).get_target_inputs(); for (const auto& out_node : out_nodes) { ov::set_nms_selected_indices(out_node.get_node()); } return true; }; - auto m = make_shared(nms_pattern, matcher_name); + auto m = make_shared(nms_pattern, matcher_name); register_matcher(m, callback); } }; @@ -54,7 +54,7 @@ class PropagateNMSPath : public pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("PropagateNMSPath"); PropagateNMSPath() { MATCHER_SCOPE(PropagateNMSPath); - auto node_pattern = pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto propagate_path = [](const ov::OutputVector& input_nodes, ov::Node* target_node) { if (any_of(input_nodes.begin(), input_nodes.end(), [](const Output& output) { return ov::has_nms_selected_indices(output.get_node()); @@ -112,7 +112,7 @@ class PropagateNMSPath : public pass::MatcherPass { } return false; }; - auto m = make_shared(node_pattern, matcher_name); + auto m = make_shared(node_pattern, matcher_name); register_matcher(m, callback); } }; @@ -121,8 +121,8 @@ class UpdateConvertGather : public pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("UpdateConvertGather"); UpdateConvertGather() { MATCHER_SCOPE(UpdateConvertGather); - auto node_pattern = pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + auto node_pattern = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto gather = m.get_match_root(); auto indices = gather->input_value(1); if (!ov::has_nms_selected_indices(indices.get_node())) @@ -140,7 +140,7 @@ class UpdateConvertGather : public pass::MatcherPass { } return true; }; - auto m = make_shared(node_pattern, matcher_name); + auto m = make_shared(node_pattern, matcher_name); register_matcher(m, callback); } }; diff --git a/src/common/transformations/src/transformations/common_optimizations/convert_pagedattn_inputs.cpp b/src/common/transformations/src/transformations/common_optimizations/convert_pagedattn_inputs.cpp index a6cd648b14ef23..1e402a84679ce7 100644 --- a/src/common/transformations/src/transformations/common_optimizations/convert_pagedattn_inputs.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/convert_pagedattn_inputs.cpp @@ -17,36 +17,34 @@ #include "transformations/utils/utils.hpp" using namespace ov::pass; -using namespace ov::op; - ov::pass::ConvertPagedAttnInputs::ConvertPagedAttnInputs(const KVCacheConfig& config, UpdateShapeFunc func) : m_config(config), m_update_shape_func(std::move(func)) { MATCHER_SCOPE(ConvertPagedAttnInputs); - auto Q = pattern::any_input(pattern::has_static_rank()); - auto K = pattern::any_input(pattern::has_static_rank()); - auto V = pattern::any_input(pattern::has_static_rank()); - auto key_cache_0 = pattern::wrap_type({}); - auto value_cache_0 = pattern::wrap_type({}); - auto past_lens = pattern::any_input(pattern::has_static_rank()); - auto subsequence_begins = pattern::any_input(pattern::has_static_rank()); - auto block_indices = pattern::any_input(pattern::has_static_rank()); - auto block_indices_begins = pattern::any_input(pattern::has_static_rank()); - auto scale = pattern::any_input(pattern::has_static_rank()); - auto sliding_window = pattern::any_input(pattern::has_static_rank()); - auto alibi_slopes = pattern::any_input(pattern::has_static_rank()); - auto max_context_len = pattern::any_input(pattern::has_static_rank()); - auto score_aggregation_window = pattern::any_input(pattern::has_static_rank()); - auto rotated_block_indices = pattern::any_input(pattern::has_static_rank()); - auto rotation_deltas = pattern::any_input(pattern::has_static_rank()); - auto rotation_trig_lut = pattern::any_input(pattern::has_static_rank()); - auto xattention_threshold = pattern::any_input(pattern::has_static_rank()); - auto xattention_block_size = pattern::any_input(pattern::has_static_rank()); - auto xattention_stride = pattern::any_input(pattern::has_static_rank()); - auto sinks = pattern::any_input(pattern::has_static_rank()); + auto Q = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto K = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto V = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto key_cache_0 = ov::pass::pattern::wrap_type({}); + auto value_cache_0 = ov::pass::pattern::wrap_type({}); + auto past_lens = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto subsequence_begins = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto block_indices = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto block_indices_begins = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto scale = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto sliding_window = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto alibi_slopes = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto max_context_len = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto score_aggregation_window = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto rotated_block_indices = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto rotation_deltas = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto rotation_trig_lut = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto xattention_threshold = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto xattention_block_size = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto xattention_stride = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto sinks = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); - auto result = pattern::wrap_type({Q, + auto result = ov::pass::pattern::wrap_type({Q, K, V, key_cache_0, @@ -67,10 +65,10 @@ ov::pass::ConvertPagedAttnInputs::ConvertPagedAttnInputs(const KVCacheConfig& co xattention_block_size, xattention_stride, sinks}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto pa_op = m.get_match_root(); - auto key_cache = ov::as_type_ptr(pa_op->get_input_node_shared_ptr(3)); - auto value_cache = ov::as_type_ptr(pa_op->get_input_node_shared_ptr(4)); + auto key_cache = ov::as_type_ptr(pa_op->get_input_node_shared_ptr(3)); + auto value_cache = ov::as_type_ptr(pa_op->get_input_node_shared_ptr(4)); auto format_cache_precision = [](ov::element::Type cache_precision, ov::element::Type infer_precision) { return cache_precision == ov::element::f16 && infer_precision == ov::element::bf16 ? infer_precision : cache_precision; @@ -140,7 +138,7 @@ ov::pass::ConvertPagedAttnInputs::ConvertPagedAttnInputs(const KVCacheConfig& co return status; }; - auto m = std::make_shared(result, matcher_name); + auto m = std::make_shared(result, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/convert_quantize_dequantize.cpp b/src/common/transformations/src/transformations/common_optimizations/convert_quantize_dequantize.cpp index e6ea1e477a71b6..2286a10cf5d693 100644 --- a/src/common/transformations/src/transformations/common_optimizations/convert_quantize_dequantize.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/convert_quantize_dequantize.cpp @@ -68,34 +68,30 @@ ov::pass::ConvertQuantizeDequantize::ConvertQuantizeDequantize( const ov::element::TypeVector& supported_original_precisions, const bool ignore_consumers_count_check) { MATCHER_SCOPE(ConvertQuantizeDequantize); - - using namespace ov::pass::pattern; - using namespace ov::op; - - auto data_pattern = any_input(type_matches_any(supported_original_precisions)); - auto input_low_pattern = any_input(); - auto input_high_pattern = any_input(); - auto output_low_pattern = wrap_type(); - auto output_high_pattern = wrap_type(); - auto fq_pattern = wrap_type( +auto data_pattern = ov::pass::pattern::any_input(ov::pass::pattern::type_matches_any(supported_original_precisions)); + auto input_low_pattern = ov::pass::pattern::any_input(); + auto input_high_pattern = ov::pass::pattern::any_input(); + auto output_low_pattern = ov::pass::pattern::wrap_type(); + auto output_high_pattern = ov::pass::pattern::wrap_type(); + auto fq_pattern = ov::pass::pattern::wrap_type( {data_pattern, input_low_pattern, input_high_pattern, output_low_pattern, output_high_pattern}); ov::pass::pattern::op::Predicate convert1_predicate = - ignore_consumers_count_check ? type_matches_any(supported_low_precisions) - : type_matches_any(supported_low_precisions) && consumers_count(1); - auto convert1_pattern = wrap_type({fq_pattern}, convert1_predicate); + ignore_consumers_count_check ? ov::pass::pattern::type_matches_any(supported_low_precisions) + : ov::pass::pattern::type_matches_any(supported_low_precisions) && ov::pass::pattern::consumers_count(1); + auto convert1_pattern = ov::pass::pattern::wrap_type({fq_pattern}, convert1_predicate); ov::pass::pattern::op::Predicate convert2_predicate = - ignore_consumers_count_check ? type_matches_any(supported_original_precisions) - : type_matches_any(supported_original_precisions) && consumers_count(1); - auto convert2_pattern = wrap_type({convert1_pattern}, convert2_predicate); + ignore_consumers_count_check ? ov::pass::pattern::type_matches_any(supported_original_precisions) + : ov::pass::pattern::type_matches_any(supported_original_precisions) && ov::pass::pattern::consumers_count(1); + auto convert2_pattern = ov::pass::pattern::wrap_type({convert1_pattern}, convert2_predicate); - auto zero_point_pattern = any_input(); + auto zero_point_pattern = ov::pass::pattern::any_input(); ov::pass::pattern::op::Predicate sub_predicate = - ignore_consumers_count_check ? ov::pass::pattern::op::Predicate() : consumers_count(1); - auto sub_pattern = optional({convert2_pattern, zero_point_pattern}, sub_predicate); - auto scale_pattern = any_input(); - auto mul_pattern = wrap_type({sub_pattern, scale_pattern}); + ignore_consumers_count_check ? ov::pass::pattern::op::Predicate() : ov::pass::pattern::consumers_count(1); + auto sub_pattern = ov::pass::pattern::optional({convert2_pattern, zero_point_pattern}, sub_predicate); + auto scale_pattern = ov::pass::pattern::any_input(); + auto mul_pattern = ov::pass::pattern::wrap_type({sub_pattern, scale_pattern}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_value_map(); if (transformation_callback(m.get_match_root())) { diff --git a/src/common/transformations/src/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.cpp b/src/common/transformations/src/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.cpp index 7caba65d8031fa..d8de2271a7c08d 100644 --- a/src/common/transformations/src/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.cpp @@ -16,23 +16,23 @@ ov::pass::ConvertU4WeightsZeroPointToScalar::ConvertU4WeightsZeroPointToScalar() { MATCHER_SCOPE(ConvertU4WeightsZeroPointToScalar); - auto weights_m = pattern::wrap_type(pattern::type_matches(ov::element::u4)); - auto convert_m = pattern::wrap_type({weights_m}, pattern::consumers_count(1)); + auto weights_m = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(ov::element::u4)); + auto convert_m = ov::pass::pattern::wrap_type({weights_m}, ov::pass::pattern::consumers_count(1)); auto float_zp_predicate = [](ov::Output output) -> bool { - return pattern::type_matches_any({ov::element::f32, ov::element::f16})(output) && - pattern::consumers_count(1)(output); + return ov::pass::pattern::type_matches_any({ov::element::f32, ov::element::f16})(output) && + ov::pass::pattern::consumers_count(1)(output); }; - auto float_zero_point_m = pattern::wrap_type(float_zp_predicate); + auto float_zero_point_m = ov::pass::pattern::wrap_type(float_zp_predicate); auto u4_zp_predicate = [](ov::Output output) -> bool { - return pattern::type_matches(ov::element::u4)(output) && pattern::consumers_count(1)(output); + return ov::pass::pattern::type_matches(ov::element::u4)(output) && ov::pass::pattern::consumers_count(1)(output); }; - auto u4_zero_point_m = pattern::wrap_type(u4_zp_predicate); - auto zero_point_convert_m = pattern::wrap_type({u4_zero_point_m}, float_zp_predicate); + auto u4_zero_point_m = ov::pass::pattern::wrap_type(u4_zp_predicate); + auto zero_point_convert_m = ov::pass::pattern::wrap_type({u4_zero_point_m}, float_zp_predicate); - auto zero_point_m = std::make_shared(OutputVector{float_zero_point_m, zero_point_convert_m}); - auto subtract_m = pattern::wrap_type({convert_m, zero_point_m}); + auto zero_point_m = std::make_shared(OutputVector{float_zero_point_m, zero_point_convert_m}); + auto subtract_m = ov::pass::pattern::wrap_type({convert_m, zero_point_m}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/convolution_to_group_convolution.cpp b/src/common/transformations/src/transformations/common_optimizations/convolution_to_group_convolution.cpp index 4d1f8bab446f51..11bbca62f625c3 100644 --- a/src/common/transformations/src/transformations/common_optimizations/convolution_to_group_convolution.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/convolution_to_group_convolution.cpp @@ -105,9 +105,9 @@ ov::pass::ConvolutionToGroupConvolutionFusion::ConvolutionToGroupConvolutionFusi } return true; }; - auto concat_label = pattern::wrap_type(has_conv_inputs); + auto concat_label = ov::pass::pattern::wrap_type(has_conv_inputs); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_value_map = m.get_pattern_value_map(); const auto& concat = pattern_value_map.at(concat_label).get_node_shared_ptr(); @@ -171,6 +171,6 @@ ov::pass::ConvolutionToGroupConvolutionFusion::ConvolutionToGroupConvolutionFusi return true; }; - auto m = std::make_shared(concat_label, matcher_name); + auto m = std::make_shared(concat_label, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/depth_to_space_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/depth_to_space_fusion.cpp index ad555d36de03fd..4aa0e1b1b8acbc 100644 --- a/src/common/transformations/src/transformations/common_optimizations/depth_to_space_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/depth_to_space_fusion.cpp @@ -121,17 +121,17 @@ bool check_depth_first(const ov::PartialShape& shape_input, ov::pass::DepthToSpaceFusion::DepthToSpaceFusion() { MATCHER_SCOPE(DepthToSpaceFusion); - auto input0 = pass::pattern::any_input(pattern::rank_equals(4)); - auto input1 = pass::pattern::any_input(); - auto input2 = pass::pattern::any_input(); - auto input3 = pass::pattern::any_input(); + auto input0 = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto input1 = ov::pass::pattern::any_input(); + auto input2 = ov::pass::pattern::any_input(); + auto input3 = ov::pass::pattern::any_input(); auto reshape_before = - ov::pass::pattern::wrap_type({input0, input1}, pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({input0, input1}, ov::pass::pattern::consumers_count(1)); auto permute = - ov::pass::pattern::wrap_type({reshape_before, input2}, pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({reshape_before, input2}, ov::pass::pattern::consumers_count(1)); auto reshape_after = ov::pass::pattern::wrap_type({permute, input3}); - ov::matcher_pass_callback callback = [](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto reshape_after = ov::as_type_ptr(m.get_match_root()); if (!reshape_after) { return false; diff --git a/src/common/transformations/src/transformations/common_optimizations/dilated_convolution_converter.cpp b/src/common/transformations/src/transformations/common_optimizations/dilated_convolution_converter.cpp index 1c78b25abe1f72..2b91911746822f 100644 --- a/src/common/transformations/src/transformations/common_optimizations/dilated_convolution_converter.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/dilated_convolution_converter.cpp @@ -23,21 +23,21 @@ // Convolution(GroupConvolution) node ov::pass::DilatedConvolutionConverter::DilatedConvolutionConverter() { MATCHER_SCOPE(DilatedConvolutionConverter); - auto data_pattern = pattern::any_input(); - auto block_shape_pattern = pattern::wrap_type(); - auto pads_begin_pattern = pattern::wrap_type(); - auto pads_end_pattern = pattern::wrap_type(); - auto space_to_batch_pattern = pattern::wrap_type( + auto data_pattern = ov::pass::pattern::any_input(); + auto block_shape_pattern = ov::pass::pattern::wrap_type(); + auto pads_begin_pattern = ov::pass::pattern::wrap_type(); + auto pads_end_pattern = ov::pass::pattern::wrap_type(); + auto space_to_batch_pattern = ov::pass::pattern::wrap_type( {data_pattern, block_shape_pattern, pads_begin_pattern, pads_end_pattern}); - auto conv_p = pattern::wrap_type({space_to_batch_pattern, pattern::any_input()}); - auto gconv_p = pattern::wrap_type({space_to_batch_pattern, pattern::any_input()}); - auto conv_pattern = std::make_shared(OutputVector{conv_p, gconv_p}); - auto crops_begin_pattern = pattern::wrap_type(); - auto crops_end_pattern = pattern::wrap_type(); - auto batch_to_space_pattern = pattern::wrap_type( - {conv_pattern, pattern::any_input(), crops_begin_pattern, crops_end_pattern}); + auto conv_p = ov::pass::pattern::wrap_type({space_to_batch_pattern, ov::pass::pattern::any_input()}); + auto gconv_p = ov::pass::pattern::wrap_type({space_to_batch_pattern, ov::pass::pattern::any_input()}); + auto conv_pattern = std::make_shared(OutputVector{conv_p, gconv_p}); + auto crops_begin_pattern = ov::pass::pattern::wrap_type(); + auto crops_end_pattern = ov::pass::pattern::wrap_type(); + auto batch_to_space_pattern = ov::pass::pattern::wrap_type( + {conv_pattern, ov::pass::pattern::any_input(), crops_begin_pattern, crops_end_pattern}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto block_shape = ov::as_type_ptr(pattern_map.at(block_shape_pattern).get_node_shared_ptr()); @@ -135,6 +135,6 @@ ov::pass::DilatedConvolutionConverter::DilatedConvolutionConverter() { return true; }; - auto m = std::make_shared(batch_to_space_pattern, matcher_name); + auto m = std::make_shared(batch_to_space_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/disable_random_uniform_constant_folding.cpp b/src/common/transformations/src/transformations/common_optimizations/disable_random_uniform_constant_folding.cpp index 8be24c91d425d5..f8ade682d871bf 100644 --- a/src/common/transformations/src/transformations/common_optimizations/disable_random_uniform_constant_folding.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/disable_random_uniform_constant_folding.cpp @@ -11,9 +11,9 @@ #include "transformations/rt_info/disable_constant_folding.hpp" ov::pass::DisableRandomUniformConstantFolding::DisableRandomUniformConstantFolding() { - auto random_uniform = pattern::wrap_type(); + auto random_uniform = ov::pass::pattern::wrap_type(); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { disable_constant_folding(m.get_match_root()); return true; }; diff --git a/src/common/transformations/src/transformations/common_optimizations/disable_shapeof_constant_folding.cpp b/src/common/transformations/src/transformations/common_optimizations/disable_shapeof_constant_folding.cpp index 0e20a9d66ec88e..64ebeb26c87cf7 100644 --- a/src/common/transformations/src/transformations/common_optimizations/disable_shapeof_constant_folding.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/disable_shapeof_constant_folding.cpp @@ -11,14 +11,14 @@ #include "transformations/rt_info/disable_constant_folding.hpp" ov::pass::DisableShapeOfConstantFolding::DisableShapeOfConstantFolding(bool check_shape) { - auto shape_of = pattern::wrap_type([=](const Output& output) { + auto shape_of = ov::pass::pattern::wrap_type([=](const Output& output) { const auto& shape = output.get_partial_shape(); if (!check_shape) return true; return shape.is_dynamic() || shape_size(shape.get_shape()) != 1; }); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { disable_constant_folding(m.get_match_root()); return true; }; diff --git a/src/common/transformations/src/transformations/common_optimizations/divide_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/divide_fusion.cpp index 8b639f356fd91a..9f57a58ed1090c 100644 --- a/src/common/transformations/src/transformations/common_optimizations/divide_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/divide_fusion.cpp @@ -18,13 +18,13 @@ ov::pass::DivideFusion::DivideFusion() { MATCHER_SCOPE(DivideFusion); - auto p_pow_input = pattern::any_input(); - auto p_pow_const = pattern::wrap_type(); - auto p_pow = pattern::wrap_type({p_pow_input, p_pow_const}); - auto p_mul_input = pattern::any_input(); + auto p_pow_input = ov::pass::pattern::any_input(); + auto p_pow_const = ov::pass::pattern::wrap_type(); + auto p_pow = ov::pass::pattern::wrap_type({p_pow_input, p_pow_const}); + auto p_mul_input = ov::pass::pattern::any_input(); auto p_mul = ov::pass::pattern::wrap_type({p_mul_input, p_pow}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); const auto& minuend_input = pattern_to_output.at(p_mul_input); const auto& subtrahend_input = pattern_to_output.at(p_pow_input); diff --git a/src/common/transformations/src/transformations/common_optimizations/dropout_with_random_uniform_replacer.cpp b/src/common/transformations/src/transformations/common_optimizations/dropout_with_random_uniform_replacer.cpp index 3d9cdcf421630e..1a9b86477bedb2 100644 --- a/src/common/transformations/src/transformations/common_optimizations/dropout_with_random_uniform_replacer.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/dropout_with_random_uniform_replacer.cpp @@ -22,21 +22,21 @@ ov::pass::DropoutWithRandomUniformReplacer::DropoutWithRandomUniformReplacer() { MATCHER_SCOPE(DropoutWithRandomUniformReplacer); - const auto shape_pattern = pass::pattern::any_input(); + const auto shape_pattern = ov::pass::pattern::any_input(); const auto ru_min_const_pattern = ov::pass::pattern::wrap_type(); const auto ru_max_const_pattern = ov::pass::pattern::wrap_type(); const auto random_uniform_pattern = ov::pass::pattern::wrap_type( {shape_pattern, ru_min_const_pattern, ru_max_const_pattern}, - pattern::consumers_count(1)); + ov::pass::pattern::consumers_count(1)); - const auto optional_convert = pattern::optional(random_uniform_pattern); + const auto optional_convert = ov::pass::pattern::optional(random_uniform_pattern); const auto add_const_pattern = ov::pass::pattern::wrap_type(); const auto add_pattern = ov::pass::pattern::wrap_type({optional_convert, add_const_pattern}); const auto floor_pattern = ov::pass::pattern::wrap_type({add_pattern}); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto random_uniform = pattern_map.at(random_uniform_pattern); const auto shape_of = pattern_map.at(shape_pattern); diff --git a/src/common/transformations/src/transformations/common_optimizations/eliminate_duplicate_ti_inputs.cpp b/src/common/transformations/src/transformations/common_optimizations/eliminate_duplicate_ti_inputs.cpp index d2ae082ba363f6..31a6e90b310cf6 100644 --- a/src/common/transformations/src/transformations/common_optimizations/eliminate_duplicate_ti_inputs.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/eliminate_duplicate_ti_inputs.cpp @@ -17,8 +17,8 @@ using namespace ov::op::util; ov::pass::EliminateDuplicateTIInputs::EliminateDuplicateTIInputs() { MATCHER_SCOPE(EliminateDuplicateTIInputs); - auto ti = pattern::wrap_type(); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + auto ti = ov::pass::pattern::wrap_type(); + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto ti = ov::as_type_ptr(m.get_match_root()); if (ti == nullptr) { return false; @@ -114,6 +114,6 @@ ov::pass::EliminateDuplicateTIInputs::EliminateDuplicateTIInputs() { new_ti->set_friendly_name(ti->get_friendly_name()); return true; }; - auto m = std::make_shared(ti, matcher_name); + auto m = std::make_shared(ti, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/eliminate_loop_inputs_outputs.cpp b/src/common/transformations/src/transformations/common_optimizations/eliminate_loop_inputs_outputs.cpp index 81a1c63e65e078..413f4f5c7b6e1a 100644 --- a/src/common/transformations/src/transformations/common_optimizations/eliminate_loop_inputs_outputs.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/eliminate_loop_inputs_outputs.cpp @@ -17,25 +17,22 @@ using namespace std; using namespace ov; -using namespace ov::op; using namespace ov::op::util; using namespace ov::element; -using namespace ov::pass::pattern; - using InvariantD = MultiSubGraphOp::InvariantInputDescription; using SlicedD = MultiSubGraphOp::SliceInputDescription; using MergedD = MultiSubGraphOp::MergedInputDescription; using OutputD = MultiSubGraphOp::BodyOutputDescription; using ConcatD = MultiSubGraphOp::ConcatOutputDescription; -using ResultPtr = std::shared_ptr; +using ResultPtr = std::shared_ptr; using OutputDescPtr = MultiSubGraphOp::OutputDescription::Ptr; using OutputDescMap = std::unordered_map; using InputDescPtr = MultiSubGraphOp::InputDescription::Ptr; using BodyResultIdxMap = std::unordered_map; namespace { -std::unordered_set remove_results(const std::shared_ptr& param, +std::unordered_set remove_results(const std::shared_ptr& param, const InputDescPtr& input_desc, OutputDescMap& output_desc_map, const BodyResultIdxMap& result_map, @@ -57,7 +54,7 @@ std::unordered_set remove_results(const std::shared_ptr std::unordered_set removed_result_inds; for (const auto& target_input : param->get_output_target_inputs(0)) { const auto& consumer = target_input.get_node()->shared_from_this(); - const auto& result = ov::as_type_ptr(consumer); + const auto& result = ov::as_type_ptr(consumer); if (!result) { continue; } @@ -89,9 +86,9 @@ std::unordered_set remove_results(const std::shared_ptr ov::pass::EliminateLoopInputsOutputs::EliminateLoopInputsOutputs() { MATCHER_SCOPE(EliminateLoopInputsOutputs); - auto subgraph_label = wrap_type(); + auto subgraph_label = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { // delete useless Parameter and Result nodes in isolated graph (Parameter->Result) // after that, set indices of sliced and invariant inputs // and outputs in the resulted SubGraph operation @@ -112,11 +109,11 @@ ov::pass::EliminateLoopInputsOutputs::EliminateLoopInputsOutputs() { const auto& subgraph_in_values = subgraph->input_values(); int64_t body_condition_output_idx = -1; int64_t current_iteration_input_idx = -1; - if (auto loop = as_type_ptr(subgraph)) { + if (auto loop = as_type_ptr(subgraph)) { const auto& trip_count = subgraph_in_values[0]; const auto& exec_cond = subgraph_in_values[1]; - auto new_loop = make_shared(trip_count, exec_cond); + auto new_loop = make_shared(trip_count, exec_cond); new_loop->set_special_body_ports(loop->get_special_body_ports()); new_node = new_loop; // condition Result node index may be shifted due to removing @@ -125,7 +122,7 @@ ov::pass::EliminateLoopInputsOutputs::EliminateLoopInputsOutputs() { body_condition_output_idx = loop->get_special_body_ports().body_condition_output_idx; current_iteration_input_idx = loop->get_special_body_ports().current_iteration_input_idx; } else { - new_node = make_shared(); + new_node = make_shared(); } new_node->set_function(body_model); @@ -269,7 +266,7 @@ ov::pass::EliminateLoopInputsOutputs::EliminateLoopInputsOutputs() { } } - if (auto loop = as_type_ptr(new_node)) { + if (auto loop = as_type_ptr(new_node)) { // update of body condition index is required due to body graph clean-up auto special_body_ports = loop->get_special_body_ports(); if (special_body_ports.body_condition_output_idx >= 0) { @@ -298,6 +295,6 @@ ov::pass::EliminateLoopInputsOutputs::EliminateLoopInputsOutputs() { return true; }; - auto m = make_shared(subgraph_label, matcher_name); + auto m = make_shared(subgraph_label, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp b/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp index fdca715f35c948..c0bac13e7a9260 100644 --- a/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp @@ -20,26 +20,23 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::op; using namespace ov::op::util; -using namespace ov::pass::pattern; - ov::pass::EliminateUnsqueezeGather::EliminateUnsqueezeGather() { MATCHER_SCOPE(EliminateUnsqueezeGather); // Remove Unsqueeze + Gather pair, if Gather gathers data by `1` dimension that was previously added by Unsqueeze - const auto unsqueezeAxis = any_input(); - const auto unsqueezeInput = any_input(); - const auto unsqueeze = wrap_type({unsqueezeInput, unsqueezeAxis}, consumers_count(1)); - const auto gatherIndices = v0::Constant::create(element::i64, Shape{}, {0}); - const auto gatherAxis = any_input(); - const auto gather = wrap_type({unsqueeze, gatherIndices, gatherAxis}); - - ov::matcher_pass_callback callback = [=](Matcher& m) { + const auto unsqueezeAxis = ov::pass::pattern::any_input(); + const auto unsqueezeInput = ov::pass::pattern::any_input(); + const auto unsqueeze = ov::pass::pattern::wrap_type({unsqueezeInput, unsqueezeAxis}, ov::pass::pattern::consumers_count(1)); + const auto gatherIndices = ov::op::v0::Constant::create(element::i64, Shape{}, {0}); + const auto gatherAxis = ov::pass::pattern::any_input(); + const auto gather = ov::pass::pattern::wrap_type({unsqueeze, gatherIndices, gatherAxis}); + + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& patternValue = m.get_pattern_value_map(); const auto& m_unsqueezeAxis = patternValue.at(unsqueezeAxis); const auto& m_gatherAxis = patternValue.at(gatherAxis); - const auto& unsqueezeAxisNode = as_type_ptr(m_unsqueezeAxis.get_node_shared_ptr()); - const auto& gatherAxisNode = as_type_ptr(m_gatherAxis.get_node_shared_ptr()); + const auto& unsqueezeAxisNode = as_type_ptr(m_unsqueezeAxis.get_node_shared_ptr()); + const auto& gatherAxisNode = as_type_ptr(m_gatherAxis.get_node_shared_ptr()); if (!unsqueezeAxisNode || !gatherAxisNode) { return false; @@ -66,30 +63,30 @@ ov::pass::EliminateUnsqueezeGather::EliminateUnsqueezeGather() { return true; }; - auto m = std::make_shared(gather, matcher_name); + auto m = std::make_shared(gather, matcher_name); register_matcher(m, callback); } inline bool scalar_with_one_consumer(const Output& out) { - return rank_equals(0)(out) && consumers_count(1)(out); + return ov::pass::pattern::rank_equals(0)(out) && ov::pass::pattern::consumers_count(1)(out); } ov::pass::EliminateGatherUnsqueeze::EliminateGatherUnsqueeze() { MATCHER_SCOPE(EliminateGatherUnsqueeze); - const auto gather_label = wrap_type(scalar_with_one_consumer); - const auto be_label = wrap_type( - {gather_label, any_input()}, + const auto gather_label = ov::pass::pattern::wrap_type(scalar_with_one_consumer); + const auto be_label = ov::pass::pattern::wrap_type( + {gather_label, ov::pass::pattern::any_input()}, scalar_with_one_consumer); - const auto or_label = std::make_shared(OutputVector{gather_label, be_label}); - const auto unsqueeze_label = wrap_type({or_label, any_input()}, rank_equals(1)); + const auto or_label = std::make_shared(OutputVector{gather_label, be_label}); + const auto unsqueeze_label = ov::pass::pattern::wrap_type({or_label, ov::pass::pattern::any_input()}, ov::pass::pattern::rank_equals(1)); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto pattern_nodes = m.get_pattern_map(); auto& gather = pattern_nodes.at(gather_label); auto& unsqueeze = pattern_nodes.at(unsqueeze_label); - const auto& indices = ov::op::util::make_try_fold(gather->input_value(1), - v0::Constant::create(element::i32, {1}, {1}), + const auto& indices = ov::op::util::make_try_fold(gather->input_value(1), + ov::op::v0::Constant::create(element::i32, {1}, {1}), false); register_new_node(indices); gather->input(1).replace_source_output(indices->output(0)); @@ -103,6 +100,6 @@ ov::pass::EliminateGatherUnsqueeze::EliminateGatherUnsqueeze() { return true; }; - auto m = std::make_shared(unsqueeze_label, matcher_name); + auto m = std::make_shared(unsqueeze_label, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/enable_shapeof_constant_folding.cpp b/src/common/transformations/src/transformations/common_optimizations/enable_shapeof_constant_folding.cpp index 9204bcdf1141c9..d336b6b1690ed0 100644 --- a/src/common/transformations/src/transformations/common_optimizations/enable_shapeof_constant_folding.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/enable_shapeof_constant_folding.cpp @@ -9,18 +9,18 @@ #include "transformations/rt_info/disable_constant_folding.hpp" ov::pass::EnableShapeOfConstantFolding::EnableShapeOfConstantFolding(bool check_shape) { - auto shape_of = pattern::wrap_type([=](const Output& output) { + auto shape_of = ov::pass::pattern::wrap_type([=](const Output& output) { const auto& shape = output.get_partial_shape(); if (!check_shape) return true; return shape.is_dynamic() || shape_size(shape.get_shape()) != 1; }); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { enable_constant_folding(m.get_match_root()); return true; }; - auto m = std::make_shared(shape_of, "EnableShapeOfConstantFolding"); + auto m = std::make_shared(shape_of, "EnableShapeOfConstantFolding"); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/fold_subgraph_empty_inputs.cpp b/src/common/transformations/src/transformations/common_optimizations/fold_subgraph_empty_inputs.cpp index e69be6947c561c..62af0e901fb9f8 100644 --- a/src/common/transformations/src/transformations/common_optimizations/fold_subgraph_empty_inputs.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/fold_subgraph_empty_inputs.cpp @@ -17,8 +17,8 @@ ov::pass::FoldSubgraphEmptyInputs::FoldSubgraphEmptyInputs() { MATCHER_SCOPE(FoldSubgraphEmptyInputs); - auto multi_subgraph_op_pattern = pattern::wrap_type(); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + auto multi_subgraph_op_pattern = ov::pass::pattern::wrap_type(); + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto multi_subgraph_op = ov::as_type_ptr(m.get_match_root()); if (multi_subgraph_op == nullptr) { return false; @@ -63,7 +63,7 @@ ov::pass::FoldSubgraphEmptyInputs::FoldSubgraphEmptyInputs() { } return false; }; - auto m = std::make_shared(multi_subgraph_op_pattern, matcher_name); + auto m = std::make_shared(multi_subgraph_op_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/fq_mul_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/fq_mul_fusion.cpp index c34c2bf9aaf252..19c4fbde9c6d4b 100644 --- a/src/common/transformations/src/transformations/common_optimizations/fq_mul_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/fq_mul_fusion.cpp @@ -43,19 +43,19 @@ ov::pass::FakeQuantizeMulFusion::FakeQuantizeMulFusion() { MATCHER_SCOPE(FakeQuantizeMulFusion); - const auto data_p = pass::pattern::any_input(); - const auto fq_output_low_p = pass::pattern::any_input(); - const auto fq_output_high_p = pass::pattern::any_input(); + const auto data_p = ov::pass::pattern::any_input(); + const auto fq_output_low_p = ov::pass::pattern::any_input(); + const auto fq_output_high_p = ov::pass::pattern::any_input(); const auto fq_node_p = ov::pass::pattern::wrap_type( - {data_p, pass::pattern::any_input(), pass::pattern::any_input(), fq_output_low_p, fq_output_high_p}, - pattern::consumers_count(1)); + {data_p, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), fq_output_low_p, fq_output_high_p}, + ov::pass::pattern::consumers_count(1)); const auto mul_constant_p = ov::pass::pattern::wrap_type(); const auto mul_node_p = - ov::pass::pattern::wrap_type({fq_node_p, mul_constant_p}, pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({fq_node_p, mul_constant_p}, ov::pass::pattern::consumers_count(1)); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& data = pattern_map.at(data_p); diff --git a/src/common/transformations/src/transformations/common_optimizations/fq_reshape_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/fq_reshape_fusion.cpp index c6964f49e2854c..c6b9f615672bc0 100644 --- a/src/common/transformations/src/transformations/common_optimizations/fq_reshape_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/fq_reshape_fusion.cpp @@ -22,15 +22,15 @@ ov::pass::FakeQuantizeReshapeFusion::FakeQuantizeReshapeFusion() { MATCHER_SCOPE(FakeQuantizeReshapeFusion); // for weights only - const auto data_p = ov::pass::pattern::wrap_type(pattern::has_static_shape()); - const auto convert_p = ov::pass::pattern::optional(data_p, pattern::consumers_count(1)); + const auto data_p = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_shape()); + const auto convert_p = ov::pass::pattern::optional(data_p, ov::pass::pattern::consumers_count(1)); const auto fq_node_p = ov::pass::pattern::wrap_type({convert_p, - pattern::any_input(pattern::has_static_shape()), - pattern::any_input(pattern::has_static_shape()), - pattern::any_input(pattern::has_static_shape()), - pattern::any_input(pattern::has_static_shape())}, - pattern::consumers_count(1)); + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}, + ov::pass::pattern::consumers_count(1)); const auto reshape_node_p = ov::pass::pattern::wrap_type( {fq_node_p, ov::pass::pattern::wrap_type()}, [](const Output& output) { @@ -41,7 +41,7 @@ ov::pass::FakeQuantizeReshapeFusion::FakeQuantizeReshapeFusion() { }); }); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& fq_node = pattern_map.at(fq_node_p).get_node_shared_ptr(); const auto& reshape_node = pattern_map.at(reshape_node_p).get_node_shared_ptr(); diff --git a/src/common/transformations/src/transformations/common_optimizations/fuse_moe_experts.cpp b/src/common/transformations/src/transformations/common_optimizations/fuse_moe_experts.cpp index e141f0c7235973..9e70c0dbb54d58 100644 --- a/src/common/transformations/src/transformations/common_optimizations/fuse_moe_experts.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/fuse_moe_experts.cpp @@ -87,82 +87,82 @@ bool is_slice_to_end(const std::shared_ptr& node) { } // Pattern matching for individual expert computation block with SwiGLU activation -std::shared_ptr mlp3_no_bias_swiglu_block( +std::shared_ptr mlp3_no_bias_swiglu_block( const Output& permute_Transpose, // Transpose -> OneHot -> TopK -> Softmax -> MatMul -> Hidden States const Output& unsqueeze_Unsqueeze, // Unsqueeze -> Reshape -> Hidden States const Output& index_Split_out_1, // Split -> Unsqueeze -> Divide -> TopK -> Softmax -> MatMul -> Hidden States const Output& index_Reshape // Reshape -> Divide -> TopK -> Softmax -> MatMul -> Hidden States ) { - auto index_add__ScatterElementsUpdate_2 = pattern::any_input(); + auto index_add__ScatterElementsUpdate_2 = ov::pass::pattern::any_input(); auto shape_const = wrap_type(); auto expert_id = wrap_type(); auto slice_end_const = wrap_type(); auto select_Gather_1 = wrap_type( - {permute_Transpose, expert_id, wrap_type(pattern::value_matches("0"))}, + {permute_Transpose, expert_id, wrap_type(ov::pass::pattern::value_matches("0"))}, {{"batch_dims", 0}}); auto squeeze_Squeeze_1 = - wrap_type({select_Gather_1, wrap_type(pattern::value_matches("0"))}); + wrap_type({select_Gather_1, wrap_type(ov::pass::pattern::value_matches("0"))}); // NonZero output_type relaxed to accept both i32 and i64 auto ListUnpack_NonZero_1 = wrap_type({squeeze_Squeeze_1}); auto ListUnpack_Split_1 = wrap_type( - {ListUnpack_NonZero_1, wrap_type(pattern::value_matches("0"))}, + {ListUnpack_NonZero_1, wrap_type(ov::pass::pattern::value_matches("0"))}, {{"num_splits", 2}}); ListUnpack_Split_1->set_output_size(2); auto ListUnpack_Squeeze_0_1 = wrap_type( - {ListUnpack_Split_1->output(1), wrap_type(pattern::value_matches("0"))}); + {ListUnpack_Split_1->output(1), wrap_type(ov::pass::pattern::value_matches("0"))}); // Convert is optional - pattern matches both with and without type conversion auto index_add__Convert_1 = wrap_type({ListUnpack_Squeeze_0_1}) | ListUnpack_Squeeze_0_1; auto index_add__Reshape_1 = wrap_type( - {index_add__Convert_1, wrap_type(pattern::value_matches("-1, 1"))}, + {index_add__Convert_1, wrap_type(ov::pass::pattern::value_matches("-1, 1"))}, {{"special_zero", false}}); auto index_add__Slice_1 = wrap_type({index_add__ScatterElementsUpdate_2, - wrap_type(pattern::value_matches("0, 0")), + wrap_type(ov::pass::pattern::value_matches("0, 0")), slice_end_const, - wrap_type(pattern::value_matches("1, 1")), - wrap_type(pattern::value_matches("0, 1"))}); + wrap_type(ov::pass::pattern::value_matches("1, 1")), + wrap_type(ov::pass::pattern::value_matches("0, 1"))}); auto index_add__ShapeOf_14 = wrap_type({index_add__Slice_1}, {{"output_type", "i32"}}); auto index_add__Broadcast_16 = wrap_type({index_add__Reshape_1, index_add__ShapeOf_14}, {{"mode", "bidirectional"}}); auto unsqueeze_Unsqueeze_reshape = - wrap_type({unsqueeze_Unsqueeze, pattern::any_input()}, {{"special_zero", false}}); + wrap_type({unsqueeze_Unsqueeze, ov::pass::pattern::any_input()}, {{"special_zero", false}}); auto index_Gather_2 = wrap_type({unsqueeze_Unsqueeze_reshape, index_add__Convert_1, - wrap_type(pattern::value_matches("0"))}, + wrap_type(ov::pass::pattern::value_matches("0"))}, {{"batch_dims", 0}}); auto reshape_Reshape_1_0 = - wrap_type({index_Gather_2, pattern::any_input()}, {{"special_zero", true}}); + wrap_type({index_Gather_2, ov::pass::pattern::any_input()}, {{"special_zero", true}}); auto reshape_Reshape_1_1 = - wrap_type({reshape_Reshape_1_0, pattern::any_input()}, {{"special_zero", true}}); + wrap_type({reshape_Reshape_1_0, ov::pass::pattern::any_input()}, {{"special_zero", true}}); auto reshape_Reshape_1_2 = - wrap_type({reshape_Reshape_1_1, pattern::any_input()}, {{"special_zero", true}}); + wrap_type({reshape_Reshape_1_1, ov::pass::pattern::any_input()}, {{"special_zero", true}}); auto reshape_Reshape_1 = wrap_type({reshape_Reshape_1_2, shape_const}, {{"special_zero", true}}); - auto gate_proj_weight = pattern::any_input(pattern::rank_equals(2)); + auto gate_proj_weight = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2)); auto linear_MatMul_gate = wrap_type({reshape_Reshape_1, gate_proj_weight}, {{"transpose_a", false}, {"transpose_b", true}}); auto silu_Swish = wrap_type({linear_MatMul_gate}); - auto up_proj_weight = pattern::any_input(pattern::rank_equals(2)); + auto up_proj_weight = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2)); auto linear_MatMul_up = wrap_type({reshape_Reshape_1, up_proj_weight}, {{"transpose_a", false}, {"transpose_b", true}}); auto mul_Multiply = wrap_type({silu_Swish, linear_MatMul_up}, {{"auto_broadcast", "numpy"}}); - auto down_proj_weight = pattern::any_input(pattern::rank_equals(2)); + auto down_proj_weight = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2)); auto linear_MatMul_down = wrap_type({mul_Multiply, down_proj_weight}, {{"transpose_a", false}, {"transpose_b", true}}); auto ListUnpack_Squeeze_1 = wrap_type( - {ListUnpack_Split_1->output(0), wrap_type(pattern::value_matches("0"))}); + {ListUnpack_Split_1->output(0), wrap_type(ov::pass::pattern::value_matches("0"))}); // Convert is optional - pattern matches both with and without type conversion auto index_Convert_4 = wrap_type({ListUnpack_Squeeze_1}) | ListUnpack_Squeeze_1; auto index_Multiply_1 = wrap_type({index_add__Convert_1, index_Split_out_1}, {{"auto_broadcast", "numpy"}}); auto index_Add_1 = wrap_type({index_Convert_4, index_Multiply_1}, {{"auto_broadcast", "numpy"}}); auto index_Gather_3 = wrap_type( - {index_Reshape, index_Add_1, wrap_type(pattern::value_matches("0"))}, + {index_Reshape, index_Add_1, wrap_type(ov::pass::pattern::value_matches("0"))}, {{"batch_dims", 0}}); auto index_Reshape_8_1 = wrap_type( - {index_Gather_3, wrap_type(pattern::value_matches("0, 1"))}, + {index_Gather_3, wrap_type(ov::pass::pattern::value_matches("0, 1"))}, {{"special_zero", true}}); auto mul_Multiply_2 = wrap_type({linear_MatMul_down, index_Reshape_8_1}, {{"auto_broadcast", "numpy"}}); @@ -172,9 +172,9 @@ std::shared_ptr mlp3_no_bias_swiglu_block( wrap_type({index_add__ScatterElementsUpdate_2, index_add__Broadcast_16, index_add__Broadcast_17, - wrap_type(pattern::value_matches("0"))}, + wrap_type(ov::pass::pattern::value_matches("0"))}, {{"reduction", "sum"}, {"use_init_val", true}}); - auto block = std::make_shared( + auto block = std::make_shared( ov::OutputVector{permute_Transpose, unsqueeze_Unsqueeze, index_Split_out_1, index_Reshape}, ov::OutputVector{index_add__ScatterElementsUpdate_5}, "expert_block"); @@ -190,9 +190,9 @@ std::shared_ptr mlp3_no_bias_swiglu_block( // Helper function to create commonly used axis constants struct AxisPatterns { - std::shared_ptr axis0 = wrap_type(pattern::value_matches("0")); - std::shared_ptr axis1 = wrap_type(pattern::value_matches("1")); - std::shared_ptr axis2 = wrap_type(pattern::value_matches("2")); + std::shared_ptr axis0 = wrap_type(ov::pass::pattern::value_matches("0")); + std::shared_ptr axis1 = wrap_type(ov::pass::pattern::value_matches("1")); + std::shared_ptr axis2 = wrap_type(ov::pass::pattern::value_matches("2")); }; // Helper function to extract a dimension from a tensor shape @@ -209,12 +209,12 @@ std::shared_ptr extract_shape_dim(const Output& input, size_t axis_i // Helper function to create router pattern (Softmax -> TopK -> OneHot -> Transpose) // This pattern identifies the expert selection logic from router logits std::pair, std::shared_ptr> create_router_pattern() { - auto linear_MatMul = pattern::any_input(); + auto linear_MatMul = ov::pass::pattern::any_input(); auto expert_num = wrap_type(); auto num_topk = wrap_type(); - auto one_hot_on = wrap_type(pattern::value_matches("1")); - auto one_hot_off = wrap_type(pattern::value_matches("0")); - auto transpose_perm = wrap_type(pattern::value_matches("2, 1, 0")); + auto one_hot_on = wrap_type(ov::pass::pattern::value_matches("1")); + auto one_hot_off = wrap_type(ov::pass::pattern::value_matches("0")); + auto transpose_perm = wrap_type(ov::pass::pattern::value_matches("2, 1, 0")); auto softmax = wrap_type({linear_MatMul}, {{"axis", 1}}); auto topk = wrap_type( @@ -249,7 +249,7 @@ std::shared_ptr create_expert_indexing_pattern(const std::shared_ptr std::tuple, std::shared_ptr> create_routing_weights_pattern( const std::shared_ptr& topk, const AxisPatterns& axes) { - auto reduce_neg1 = wrap_type(pattern::value_matches("-1")); + auto reduce_neg1 = wrap_type(ov::pass::pattern::value_matches("-1")); auto sum_reduce = wrap_type({topk->output(0), reduce_neg1}, {{"keep_dims", true}}); auto normalized = wrap_type({topk->output(0), sum_reduce}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); @@ -257,7 +257,7 @@ std::tuple, std::shared_ptr> create_routing_weights_ auto shape_of = wrap_type({unsqueeze}, {{"output_type", "i32"}}); auto split = wrap_type({shape_of, axes.axis0}, {{"num_splits", 3}}); split->set_output_size(3); - auto reshape = wrap_type({unsqueeze, pattern::any_input()}, {{"special_zero", true}}); + auto reshape = wrap_type({unsqueeze, ov::pass::pattern::any_input()}, {{"special_zero", true}}); return {split, reshape}; } @@ -277,7 +277,7 @@ ov::pass::FuseMOEExperts::FuseMOEExperts() : MultiMatcher("FuseMOEExperts") { auto index_add__Convert = create_expert_indexing_pattern(permute_Transpose, axes); // Prepare additional patterns for expert computation - auto view_Reshape = pattern::any_input(); + auto view_Reshape = ov::pass::pattern::any_input(); auto slice_end = wrap_type(); // Used in callback for slice validation // Pattern for hidden states preparation @@ -293,9 +293,9 @@ ov::pass::FuseMOEExperts::FuseMOEExperts() : MultiMatcher("FuseMOEExperts") { mlp3_no_bias_swiglu_block(permute_Transpose, unsqueeze_Unsqueeze, index_Split->output(1), index_Reshape); // Match the final reshape and residual add after all expert computations - auto original_shape = pattern::any_input(); + auto original_shape = ov::pass::pattern::any_input(); auto last_reshape = wrap_type({expert_scatter, original_shape}, {{"special_zero", false}}); - auto residual_input = pattern::any_input(); + auto residual_input = ov::pass::pattern::any_input(); auto last_add = wrap_type({residual_input, last_reshape}, {{"auto_broadcast", "numpy"}}); auto callback = [=](const std::unordered_map, std::vector>& matches) { diff --git a/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp b/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp index 43ffd9853299ab..d0b6622d5944b0 100644 --- a/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp @@ -47,8 +47,6 @@ #include "transformations/utils/utils.hpp" using namespace ov::pass; -using namespace ov::op; - ov::pass::RoPEFusion::RoPEFusion(bool support_2d_rope) : m_support_2d_rope(support_2d_rope) {} bool ov::pass::RoPEFusion::run_on_model(const std::shared_ptr& model) { @@ -83,7 +81,7 @@ static std::shared_ptr gen_chatglm_const() { auto pred = value_matches("-1, head_cnt, 1, ndims/2, 1") || value_matches("1, -1, head_cnt, ndims/2, 1") || value_matches("0, 0, 0, ndims/2, 1") || value_matches("-1, batch, head_cnt, ndims/2, 1"); - return wrap_type(pred); + return wrap_type(pred); } ov::pass::RoPEFusionFlux::RoPEFusionFlux() { @@ -96,29 +94,29 @@ ov::pass::RoPEFusionFlux::RoPEFusionFlux() { // y1 = x * t_cos // y2 = x3 * t_sin // y = y1 + y2 - auto x = pattern::any_input(pattern::rank_equals(4) && pattern::shape_matches("[PRESERVED_DIMS..., head_size]")); - auto t_cos = pattern::any_input(pattern::rank_equals(4)); - auto t_sin = pattern::any_input(pattern::rank_equals(4)); + auto x = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4) && ov::pass::pattern::shape_matches("[PRESERVED_DIMS..., head_size]")); + auto t_cos = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto t_sin = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); - auto x1 = pattern::wrap_type({x, pattern::any_input()}, - pattern::shape_matches("[PRESERVED_DIMS..., ?, 2]")); - auto split = pattern::wrap_type({x1, -1}, {{"num_splits", 2}}); + auto x1 = ov::pass::pattern::wrap_type({x, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[PRESERVED_DIMS..., ?, 2]")); + auto split = ov::pass::pattern::wrap_type({x1, -1}, {{"num_splits", 2}}); split->set_output_size(2); // 3 versions of mulitply by -1 depending on transformations execution prior to this pass - auto opt_squeeze = pattern::optional({split->output(1), -1}); - auto x1_1_neg = pattern::wrap_type({opt_squeeze, -1}, {{"auto_broadcast", "numpy"}}); - auto opt_squeeze_1 = pattern::optional({x1_1_neg, -1}); - auto opt_unsqueeze = pattern::optional({opt_squeeze_1, -1}); + auto opt_squeeze = ov::pass::pattern::optional({split->output(1), -1}); + auto x1_1_neg = ov::pass::pattern::wrap_type({opt_squeeze, -1}, {{"auto_broadcast", "numpy"}}); + auto opt_squeeze_1 = ov::pass::pattern::optional({x1_1_neg, -1}); + auto opt_unsqueeze = ov::pass::pattern::optional({opt_squeeze_1, -1}); - auto x2 = pattern::wrap_type({opt_unsqueeze, split->output(0)}, {{"axis", -1}}); - auto x3 = pattern::wrap_type({x2, pattern::any_input()}, - pattern::shape_matches("[PRESERVED_DIMS..., head_size]")); + auto x2 = ov::pass::pattern::wrap_type({opt_unsqueeze, split->output(0)}, {{"axis", -1}}); + auto x3 = ov::pass::pattern::wrap_type({x2, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[PRESERVED_DIMS..., head_size]")); - auto y1 = pattern::wrap_type({x, t_cos}, {{"auto_broadcast", "numpy"}}); - auto y2 = pattern::wrap_type({x3, t_sin}, {{"auto_broadcast", "numpy"}}); + auto y1 = ov::pass::pattern::wrap_type({x, t_cos}, {{"auto_broadcast", "numpy"}}); + auto y2 = ov::pass::pattern::wrap_type({x3, t_sin}, {{"auto_broadcast", "numpy"}}); - auto result = pattern::wrap_type({y1, y2}, {{"auto_broadcast", "numpy"}}); + auto result = ov::pass::pattern::wrap_type({y1, y2}, {{"auto_broadcast", "numpy"}}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -179,25 +177,25 @@ ov::pass::RoPEFusionGPTNEOX::RoPEFusionGPTNEOX(int rank) { // branch. // so here we use a WA, only match the path of rotate_hal(x)*sin and check the x*cos path // in the callback - auto x = pattern::any_input(pattern::rank_equals(rank)); - auto x_or_cos1 = pattern::any_input(pattern::rank_equals(rank)); - auto x_or_cos2 = pattern::any_input(pattern::rank_equals(rank)); - auto t_sin = pattern::any_input(pattern::rank_equals(rank)); + auto x = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(rank)); + auto x_or_cos1 = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(rank)); + auto x_or_cos2 = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(rank)); + auto t_sin = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(rank)); - auto varsplit = pattern::wrap_type({x, rank - 1, {"half_ndims", "?"}}); + auto varsplit = ov::pass::pattern::wrap_type({x, rank - 1, {"half_ndims", "?"}}); varsplit->set_output_size(2); auto int32_max = std::numeric_limits::max(); auto x2 = NewGenSlice(x, "half_ndims", int32_max, 1, rank - 1); - auto x2neg = pattern::wrap_type({x2 | varsplit->output(1), -1.0f}, {{"auto_broadcast", "numpy"}}); + auto x2neg = ov::pass::pattern::wrap_type({x2 | varsplit->output(1), -1.0f}, {{"auto_broadcast", "numpy"}}); auto x1 = NewGenSlice(x, 0, "half_ndims", 1, rank - 1); - auto x_rotate_half = pattern::wrap_type({x2neg, x1 | varsplit->output(0)}, {{"axis", -1}}); + auto x_rotate_half = ov::pass::pattern::wrap_type({x2neg, x1 | varsplit->output(0)}, {{"axis", -1}}); - auto mul_cos = pattern::wrap_type({x_or_cos1, x_or_cos2}, {{"auto_broadcast", "numpy"}}); - auto mul_sin = pattern::wrap_type({x_rotate_half, t_sin}, {{"auto_broadcast", "numpy"}}); + auto mul_cos = ov::pass::pattern::wrap_type({x_or_cos1, x_or_cos2}, {{"auto_broadcast", "numpy"}}); + auto mul_sin = ov::pass::pattern::wrap_type({x_rotate_half, t_sin}, {{"auto_broadcast", "numpy"}}); - auto result = pattern::wrap_type({mul_cos, mul_sin}, {{"auto_broadcast", "numpy"}}); + auto result = ov::pass::pattern::wrap_type({mul_cos, mul_sin}, {{"auto_broadcast", "numpy"}}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -234,7 +232,7 @@ ov::pass::RoPEFusionGPTNEOX::RoPEFusionGPTNEOX(int rank) { new_args.push_back(v_cos); new_args.push_back(pattern_map.at(t_sin)); auto old_node = root; - auto new_node = std::make_shared(new_args, config); + auto new_node = std::make_shared(new_args, config); new_node->set_friendly_name(old_node->get_friendly_name()); ov::copy_runtime_info({pattern_map.at(x2neg).get_node_shared_ptr(), pattern_map.at(x_rotate_half).get_node_shared_ptr(), @@ -257,40 +255,40 @@ ov::pass::RoPEFusionCosSinPreprocess::RoPEFusionCosSinPreprocess() { using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionCosSinPreprocess); - auto cos_const = pattern::wrap_type(pattern::type_matches(element::f32)); - auto sin_const = pattern::wrap_type(pattern::type_matches(element::f32)); + auto cos_const = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::f32)); + auto sin_const = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::f32)); - auto node_batch_size = pattern::any_input(pattern::type_matches(element::i32) && pattern::shape_matches("[1]")); - auto tile_batch = pattern::any_input(pattern::type_matches(element::i32) && pattern::shape_matches("[1]")); - auto gather_positions = pattern::any_input(pattern::type_matches(element::i32) && pattern::rank_equals(4)); + auto node_batch_size = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::shape_matches("[1]")); + auto tile_batch = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::shape_matches("[1]")); + auto gather_positions = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::rank_equals(4)); auto prepare_cos_sin_gptneox = [&](std::shared_ptr const_tab) { - auto slice = pattern::wrap_type({const_tab, {0}, node_batch_size, {1}, {0}}); + auto slice = ov::pass::pattern::wrap_type({const_tab, {0}, node_batch_size, {1}, {0}}); auto strided_slice = NewGenStridedSlice(const_tab, {0}, node_batch_size, {1}, 0); - return pattern::wrap_type({strided_slice | slice, gather_positions}, {{"axis", 2}}); + return ov::pass::pattern::wrap_type({strided_slice | slice, gather_positions}, {{"axis", 2}}); }; - auto seq_len = pattern::any_input(pattern::type_matches(element::i32) && pattern::shape_matches("[1]")); - auto gather_positions_2d = pattern::any_input(pattern::type_matches(element::i32) && pattern::rank_equals(2)); + auto seq_len = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::shape_matches("[1]")); + auto gather_positions_2d = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::rank_equals(2)); auto prepare_cos_sin_llama = [&](std::shared_ptr const_tab) { - auto ScatterUpdate = pattern::wrap_type({{0, 0, 0}, 2, seq_len, 0}); - auto slice_Slice = pattern::wrap_type({const_tab, {0}, seq_len, {1}, {2}}); + auto ScatterUpdate = ov::pass::pattern::wrap_type({{0, 0, 0}, 2, seq_len, 0}); + auto slice_Slice = ov::pass::pattern::wrap_type({const_tab, {0}, seq_len, {1}, {2}}); auto slice_StridedSlice = NewGenStridedSlice(const_tab, {0, 0, 0}, ScatterUpdate, {1, 1, 1}, 2); - auto squeeze = pattern::wrap_type({slice_StridedSlice | slice_Slice, pattern::any_input()}, - pattern::shape_matches("[?, head_dims]")); - auto index_Gather = pattern::wrap_type({squeeze, gather_positions_2d, 0}, {{"batch_dims", 0}}); + auto squeeze = ov::pass::pattern::wrap_type({slice_StridedSlice | slice_Slice, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, head_dims]")); + auto index_Gather = ov::pass::pattern::wrap_type({squeeze, gather_positions_2d, 0}, {{"batch_dims", 0}}); // another simplified pattern for gathering at position_ids - auto slice_Slice2 = pattern::wrap_type({const_tab, {0}, seq_len, {1}, {0}}); + auto slice_Slice2 = ov::pass::pattern::wrap_type({const_tab, {0}, seq_len, {1}, {0}}); auto slice_StridedSlice2 = NewGenStridedSlice(const_tab, {0}, seq_len, {1}, 0); auto index_Gather2 = - pattern::wrap_type({slice_Slice2 | slice_StridedSlice2, gather_positions_2d, 0}, + ov::pass::pattern::wrap_type({slice_Slice2 | slice_StridedSlice2, gather_positions_2d, 0}, {{"batch_dims", 0}}); - auto unsqueeze = pattern::wrap_type({index_Gather | index_Gather2, pattern::any_input()}, - pattern::shape_matches("[1, 1, ?, head_dims]")); - auto unsqueeze2 = pattern::wrap_type({index_Gather2, 1}); + auto unsqueeze = ov::pass::pattern::wrap_type({index_Gather | index_Gather2, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[1, 1, ?, head_dims]")); + auto unsqueeze2 = ov::pass::pattern::wrap_type({index_Gather2, 1}); return unsqueeze2 | unsqueeze; }; @@ -298,8 +296,8 @@ ov::pass::RoPEFusionCosSinPreprocess::RoPEFusionCosSinPreprocess() { auto cos_tab = prepare_cos_sin_gptneox(cos_const) | prepare_cos_sin_llama(cos_const); auto sin_tab = prepare_cos_sin_gptneox(sin_const) | prepare_cos_sin_llama(sin_const); - auto x = pattern::any_input(pattern::rank_equals(4)); - auto rope = pattern::wrap_type({x, cos_tab, sin_tab}); + auto x = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto rope = ov::pass::pattern::wrap_type({x, cos_tab, sin_tab}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -339,17 +337,17 @@ ov::pass::RoPEFusionIOSlicing::RoPEFusionIOSlicing() { using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionIOSlicing); auto int32_max = std::numeric_limits::max(); - auto data = pattern::any_input(pattern::rank_equals(4)); - auto varsplit = pattern::wrap_type({data, 3, {"ndims", "?"}}); + auto data = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto varsplit = ov::pass::pattern::wrap_type({data, 3, {"ndims", "?"}}); varsplit->set_output_size(2); auto x = NewGenSlice(data, 0, "ndims", 1, 3); auto y = NewGenSlice(data, "ndims", int32_max, 1, 3); - auto x_emb = pattern::wrap_type( - {x | varsplit->output(0), pattern::any_input(), pattern::any_input()}) | - pattern::wrap_type( - {x | varsplit->output(0), pattern::any_input(), pattern::any_input(), pattern::any_input()}); - auto result = pattern::wrap_type({x_emb, y | varsplit->output(1)}, {{"axis", -1}}); + auto x_emb = ov::pass::pattern::wrap_type( + {x | varsplit->output(0), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}) | + ov::pass::pattern::wrap_type( + {x | varsplit->output(0), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto result = ov::pass::pattern::wrap_type({x_emb, y | varsplit->output(1)}, {{"axis", -1}}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -388,22 +386,22 @@ ov::pass::RoPEFusionPreprocess::RoPEFusionPreprocess() { MATCHER_SCOPE(RoPEFusionPreprocess); // Pattern for input to be sliced (for models with combined QKV projection) - auto input_to_slice = pattern::any_input(pattern::rank_equals(4)); + auto input_to_slice = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); // Pattern for input to be transposed (for models that transpose before RoPE) - auto input_to_trans = pattern::any_input(pattern::rank_equals(4)); + auto input_to_trans = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); // Slice input if needed: [B, L, H, S] -> [B, L', H, S] auto input_slice = NewGenSlice(input_to_slice, {"slice_start"}, {"slice_stop"}, 1, 3); // Transpose input if needed: [B, L, H, S] -> [B, H, L, S] - auto x = pattern::wrap_type({input_slice | input_to_trans, {0, 2, 1, 3}}); + auto x = ov::pass::pattern::wrap_type({input_slice | input_to_trans, {0, 2, 1, 3}}); // RoPE node: supports both 3 and 4 inputs - auto result = pattern::wrap_type({x, pattern::any_input(), pattern::any_input()}) | - pattern::wrap_type( - {x, pattern::any_input(), pattern::any_input(), pattern::any_input()}); + auto result = ov::pass::pattern::wrap_type({x, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}) | + ov::pass::pattern::wrap_type( + {x, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto root = m.get_match_root(); auto rope_node = as_type_ptr(root); @@ -431,11 +429,11 @@ ov::pass::RoPEFusionPreprocess::RoPEFusionPreprocess() { register_new_node(rope_node); return true; }; - auto m = std::make_shared(result, matcher_name); + auto m = std::make_shared(result, matcher_name); this->register_matcher(m, callback); } -auto const_idx_predicate = [](pattern::PatternSymbolMap&, const ov::Output& out) { +auto const_idx_predicate = [](ov::pass::pattern::PatternSymbolMap&, const ov::Output& out) { if (auto const_node = ov::as_type_ptr(out.get_node_shared_ptr())) { const auto& vec = const_node->get_vector(); int32_t v = 0; @@ -448,67 +446,67 @@ auto const_idx_predicate = [](pattern::PatternSymbolMap&, const ov::Output repeat_interleave_pattern(const ov::Output& var_split_output) { - auto unsqueeze = pattern::wrap_type({var_split_output, {"dim0", "dim1", "1", "32"}}) | - pattern::wrap_type({var_split_output, 2}); + auto unsqueeze = ov::pass::pattern::wrap_type({var_split_output, {"dim0", "dim1", "1", "32"}}) | + ov::pass::pattern::wrap_type({var_split_output, 2}); // repeate cos/sin table auto const_idx = - pattern::wrap_type(pattern::type_matches(ov::element::i32) && const_idx_predicate); - return pattern::wrap_type({unsqueeze, const_idx, 3}, {{"batch_dims", 0}}); + ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(ov::element::i32) && const_idx_predicate); + return ov::pass::pattern::wrap_type({unsqueeze, const_idx, 3}, {{"batch_dims", 0}}); } ov::pass::RoPEFusionGPTJ::RoPEFusionGPTJ() { using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionGPTJ); - auto gather_sin_cos = pattern::any_input(pattern::type_matches(ov::element::f32)); - auto varsplit = pattern::wrap_type({gather_sin_cos, -1, {"ndims/2", "-1"}}); + auto gather_sin_cos = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(ov::element::f32)); + auto varsplit = ov::pass::pattern::wrap_type({gather_sin_cos, -1, {"ndims/2", "-1"}}); varsplit->set_output_size(2); auto repeat_interleave_sin = repeat_interleave_pattern(varsplit->output(0)); auto repeat_interleave_cos = repeat_interleave_pattern(varsplit->output(1)); - auto view_Reshape = pattern::any_input(pattern::rank_equals(4)); + auto view_Reshape = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto slice_Slice_965 = NewGenSlice(view_Reshape, 0, "ndims", 1, 3); // view_Reshape : B,L,H,S - auto varsplit_view_Reshape = pattern::wrap_type({view_Reshape, 3, {"ndims", "end"}}); + auto varsplit_view_Reshape = ov::pass::pattern::wrap_type({view_Reshape, 3, {"ndims", "end"}}); varsplit_view_Reshape->set_output_size(2); // x interleave (-x[:,:,:, 1::2], x[:,:,:, 0::2]) auto slice_Slice_1174 = NewGenSlice(slice_Slice_965 | varsplit_view_Reshape->output(0), 1, INT_MAX, 2, 3); auto neg_Multiply_1177 = - pattern::wrap_type({slice_Slice_1174, -1.0f}, {{"auto_broadcast", "numpy"}}); - auto Unsqueeze_65524 = pattern::wrap_type({neg_Multiply_1177, -1}); - auto Unsqueeze_28998 = pattern::wrap_type({neg_Multiply_1177, {"-1", "1", "head_num", "32", "1"}}, + ov::pass::pattern::wrap_type({slice_Slice_1174, -1.0f}, {{"auto_broadcast", "numpy"}}); + auto Unsqueeze_65524 = ov::pass::pattern::wrap_type({neg_Multiply_1177, -1}); + auto Unsqueeze_28998 = ov::pass::pattern::wrap_type({neg_Multiply_1177, {"-1", "1", "head_num", "32", "1"}}, {{"special_zero", false}}); auto slice_Slice_1168 = NewGenSlice(slice_Slice_965 | varsplit_view_Reshape->output(0), 0, INT_MAX, 2, 3); - auto Unsqueeze_65525 = pattern::wrap_type({slice_Slice_1168, -1}); - auto Unsqueeze_28999 = pattern::wrap_type({slice_Slice_1168, {"-1", "1", "head_num", "32", "1"}}, + auto Unsqueeze_65525 = ov::pass::pattern::wrap_type({slice_Slice_1168, -1}); + auto Unsqueeze_28999 = ov::pass::pattern::wrap_type({slice_Slice_1168, {"-1", "1", "head_num", "32", "1"}}, {{"special_zero", false}}); auto stack_1182 = - pattern::wrap_type({Unsqueeze_65524 | Unsqueeze_28998, Unsqueeze_65525 | Unsqueeze_28999}, + ov::pass::pattern::wrap_type({Unsqueeze_65524 | Unsqueeze_28998, Unsqueeze_65525 | Unsqueeze_28999}, {{"axis", -1}}); - auto ShapeOf_169068 = pattern::wrap_type({stack_1182}); + auto ShapeOf_169068 = ov::pass::pattern::wrap_type({stack_1182}); auto flatten_Slice_1194 = NewGenSlice(ShapeOf_169068, 0, 3, 1, 0); - auto flatten_Concat_1197 = pattern::wrap_type({flatten_Slice_1194, {-1}}, {{"axis", 0}}); + auto flatten_Concat_1197 = ov::pass::pattern::wrap_type({flatten_Slice_1194, {-1}}, {{"axis", 0}}); // If with special zero, no need to use shapeof to get full shape - auto flatten_Reshape_1198 = pattern::wrap_type({stack_1182, flatten_Concat_1197}); + auto flatten_Reshape_1198 = ov::pass::pattern::wrap_type({stack_1182, flatten_Concat_1197}); auto flatten_Reshape_Zero = - pattern::wrap_type({stack_1182, ov::pass::pattern::any_input()}, {{"special_zero", true}}); + ov::pass::pattern::wrap_type({stack_1182, ov::pass::pattern::any_input()}, {{"special_zero", true}}); // x*cos [B,L,H,ndims] - auto mul_cos = pattern::wrap_type( + auto mul_cos = ov::pass::pattern::wrap_type( {slice_Slice_965 | varsplit_view_Reshape->output(0), repeat_interleave_cos}, {{"auto_broadcast", "numpy"}}); auto mul_sin = - pattern::wrap_type({flatten_Reshape_1198 | flatten_Reshape_Zero, repeat_interleave_sin}, + ov::pass::pattern::wrap_type({flatten_Reshape_1198 | flatten_Reshape_Zero, repeat_interleave_sin}, {{"auto_broadcast", "numpy"}}); // *cos + *sin - auto rotary_emb = pattern::wrap_type({mul_cos, mul_sin}, {{"auto_broadcast", "numpy"}}); + auto rotary_emb = ov::pass::pattern::wrap_type({mul_cos, mul_sin}, {{"auto_broadcast", "numpy"}}); auto slice_Slice_971 = NewGenSlice(view_Reshape, "ndims", INT_MAX, 1, 3); - auto result = pattern::wrap_type({rotary_emb, slice_Slice_971 | varsplit_view_Reshape->output(1)}, + auto result = ov::pass::pattern::wrap_type({rotary_emb, slice_Slice_971 | varsplit_view_Reshape->output(1)}, {{"axis", -1}}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { @@ -583,17 +581,17 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { // [seq_length, batch_size, input_size(will be cropped to match hidden state size)] // [batch_size, seq_length, input_size] support_2d_rope - auto qkv_linear = pattern::any_input(pattern::rank_equals(3)); - auto seq_length = pattern::any_input(pattern::type_matches(element::i32) && pattern::shape_matches("[1]")); + auto qkv_linear = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(3)); + auto seq_length = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::shape_matches("[1]")); // [max_pos_embeddings, batch_size, half_rotary_dims, 2] // [batch_size, max_pos_embeddings, half_rotary_dims, 2] support_2d_rope - auto cos_sin_cache = pattern::any_input(pattern::rank_equals(4)); + auto cos_sin_cache = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto qkv_proj = - pattern::wrap_type({qkv_linear, -1, {"total_size_q", "total_size_k", "total_size_v"}}); + ov::pass::pattern::wrap_type({qkv_linear, -1, {"total_size_q", "total_size_k", "total_size_v"}}); qkv_proj->set_output_size(3); - auto reshape_pattern_const = pattern::wrap_type(pattern::value_matches("0, 0, head_cnt, head_size")); - auto cur_key = pattern::wrap_type({qkv_proj, reshape_pattern_const}, {{"special_zero", true}}); + auto reshape_pattern_const = ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("0, 0, head_cnt, head_size")); + auto cur_key = ov::pass::pattern::wrap_type({qkv_proj, reshape_pattern_const}, {{"special_zero", true}}); std::shared_ptr input_key = nullptr; // Extended the RoPE to a two-dimensional form to accommodate the 2D positional encoding in GLM. // Calculate positional embedding independent of batch and each head @@ -602,113 +600,113 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { // For Models, where SDPA to PagedAttention transformation was applied, // all sequences have the size == 1, we move sequences to the batch, this is the PagedAttention specific, // so seq_length dim will be always 1, this means that Transpose is unnecessary and Reshape op can be used. - auto transposed_cur_key = pattern::wrap_type({qkv_proj, {"-1", "head_cnt", "1", "head_size"}}, + auto transposed_cur_key = ov::pass::pattern::wrap_type({qkv_proj, {"-1", "head_cnt", "1", "head_size"}}, {{"special_zero", false}}); // Transpose for SDPA version: - input_key = pattern::wrap_type({cur_key, {0, 2, 1, 3}}) | transposed_cur_key; + input_key = ov::pass::pattern::wrap_type({cur_key, {0, 2, 1, 3}}) | transposed_cur_key; } else { // Get key [seq_length, batch, head_cnt, head_size] input_key = std::move(cur_key); } auto slice0 = NewGenSlice(input_key, 0, "ndims", 1, 3); - auto var_split0 = pattern::wrap_type({input_key, 3, {"ndims", "end"}}); + auto var_split0 = ov::pass::pattern::wrap_type({input_key, 3, {"ndims", "end"}}); var_split0->set_output_size(2); // rotate half std::shared_ptr reshape0 = nullptr; if (support_2d_rope) { auto const_target_shape0 = - pattern::wrap_type(pattern::value_matches("0, head_cnt, 0, ndims/2, 2")); - reshape0 = pattern::wrap_type({slice0 | var_split0->output(0), const_target_shape0}, + ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("0, head_cnt, 0, ndims/2, 2")); + reshape0 = ov::pass::pattern::wrap_type({slice0 | var_split0->output(0), const_target_shape0}, {{"special_zero", true}}); } else { auto concat0 = - pattern::wrap_type({seq_length, {-1}, {"head_cnt"}, {"ndims/2"}, {2}}, {{"axis", 0}}); + ov::pass::pattern::wrap_type({seq_length, {-1}, {"head_cnt"}, {"ndims/2"}, {2}}, {{"axis", 0}}); auto const_target_shape1 = - pattern::wrap_type(pattern::value_matches("0, 0, head_cnt, ndims/2, 2")); + ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("0, 0, head_cnt, ndims/2, 2")); auto const_target_shape2 = - pattern::wrap_type(pattern::value_matches("seq_len, batch, head_cnt, ndims/2, 2")); - reshape0 = pattern::wrap_type( + ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("seq_len, batch, head_cnt, ndims/2, 2")); + reshape0 = ov::pass::pattern::wrap_type( {slice0 | var_split0->output(0), concat0 | const_target_shape1 | const_target_shape2}); } - auto x_even = pattern::wrap_type({reshape0, 0, -1}, {{"batch_dims", 0}}); - auto x_odd = pattern::wrap_type({reshape0, 1, -1}, {{"batch_dims", 0}}); + auto x_even = ov::pass::pattern::wrap_type({reshape0, 0, -1}, {{"batch_dims", 0}}); + auto x_odd = ov::pass::pattern::wrap_type({reshape0, 1, -1}, {{"batch_dims", 0}}); - auto var_split1 = pattern::wrap_type({cos_sin_cache, 0, {"0", "end"}}); + auto var_split1 = ov::pass::pattern::wrap_type({cos_sin_cache, 0, {"0", "end"}}); var_split1->set_output_size(2); std::shared_ptr reshape1 = nullptr; if (support_2d_rope) { // Slice cos_sin_cache to support 2-dimentional RoPE - auto scatter_update0 = pattern::wrap_type({{0, 0}, {1}, seq_length, {0}}, {}); - auto slice1 = pattern::wrap_type({cos_sin_cache, {0}, seq_length, {1}, {1}}); - auto slice2 = pattern::wrap_type({cos_sin_cache, {0, 0}, scatter_update0, {1, 1}, {0}}); - auto ss_stop = pattern::wrap_type(); + auto scatter_update0 = ov::pass::pattern::wrap_type({{0, 0}, {1}, seq_length, {0}}, {}); + auto slice1 = ov::pass::pattern::wrap_type({cos_sin_cache, {0}, seq_length, {1}, {1}}); + auto slice2 = ov::pass::pattern::wrap_type({cos_sin_cache, {0, 0}, scatter_update0, {1, 1}, {0}}); + auto ss_stop = ov::pass::pattern::wrap_type(); auto strided_slice0 = NewGenStridedSlice(cos_sin_cache, {0, 0}, ss_stop | scatter_update0, {1, 1}, 1); - auto concat1 = pattern::wrap_type({{-1}, {1}, seq_length, {"ndims/2"}, {2}}, {{"axis", 0}}); + auto concat1 = ov::pass::pattern::wrap_type({{-1}, {1}, seq_length, {"ndims/2"}, {2}}, {{"axis", 0}}); auto const_target_shape3 = - pattern::wrap_type(pattern::value_matches("batch, 1, seq_len, ndims/2, 2")); + ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("batch, 1, seq_len, ndims/2, 2")); // [batch, 1, seq_length, half_rotary_dims, 2] - reshape1 = pattern::wrap_type( + reshape1 = ov::pass::pattern::wrap_type( {strided_slice0 | slice1 | slice2 | var_split1->output(0), concat1 | const_target_shape3}); } else { - auto concat2 = pattern::wrap_type({seq_length, {-1}, {1}, {"ndims/2"}, {2}}, {{"axis", 0}}); - auto const_target_shape4 = pattern::wrap_type(pattern::value_matches("1, -1, 1, ndims/2, 2")); + auto concat2 = ov::pass::pattern::wrap_type({seq_length, {-1}, {1}, {"ndims/2"}, {2}}, {{"axis", 0}}); + auto const_target_shape4 = ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("1, -1, 1, ndims/2, 2")); auto const_target_shape5 = - pattern::wrap_type(pattern::value_matches("seq_len, batch, 1, ndims/2, 2")); + ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("seq_len, batch, 1, ndims/2, 2")); - auto slice3 = pattern::wrap_type({cos_sin_cache, {0}, seq_length, {1}, {0}}); + auto slice3 = ov::pass::pattern::wrap_type({cos_sin_cache, {0}, seq_length, {1}, {0}}); auto strided_slice1 = NewGenStridedSlice(cos_sin_cache, {0}, seq_length, {1}, 0); // [seq_length, 1, batch, half_rotary_dims, 2] - reshape1 = pattern::wrap_type( + reshape1 = ov::pass::pattern::wrap_type( {strided_slice1 | slice3 | var_split1->output(0), concat2 | const_target_shape4 | const_target_shape5}); } - auto cos_tab = pattern::wrap_type({reshape1, 0, -1}, {{"batch_dims", 0}}); - auto x_even_cos = pattern::wrap_type({x_even, cos_tab}, {{"auto_broadcast", "numpy"}}); + auto cos_tab = ov::pass::pattern::wrap_type({reshape1, 0, -1}, {{"batch_dims", 0}}); + auto x_even_cos = ov::pass::pattern::wrap_type({x_even, cos_tab}, {{"auto_broadcast", "numpy"}}); - auto sin_tab = pattern::wrap_type({reshape1, 1, -1}, {{"batch_dims", 0}}); - auto x_odd_sin = pattern::wrap_type({x_odd, sin_tab}, {{"auto_broadcast", "numpy"}}); - auto neg_x_odd_sin = pattern::wrap_type({x_odd_sin, -1.000000f}, {{"auto_broadcast", "numpy"}}); - auto add0 = pattern::wrap_type({x_even_cos, neg_x_odd_sin}, {{"auto_broadcast", "numpy"}}); - auto y_even = pattern::wrap_type({add0, -1}) | - pattern::wrap_type({add0, gen_chatglm_const()}, {{"special_zero", false}}); - auto x_odd_cos = pattern::wrap_type({x_odd, cos_tab}, {{"auto_broadcast", "numpy"}}); - auto x_even_sin = pattern::wrap_type({x_even, sin_tab}, {{"auto_broadcast", "numpy"}}); - auto add1 = pattern::wrap_type({x_odd_cos, x_even_sin}, {{"auto_broadcast", "numpy"}}); - auto y_odd = pattern::wrap_type({add1, -1}) | - pattern::wrap_type({add1, gen_chatglm_const()}, {{"special_zero", false}}); + auto sin_tab = ov::pass::pattern::wrap_type({reshape1, 1, -1}, {{"batch_dims", 0}}); + auto x_odd_sin = ov::pass::pattern::wrap_type({x_odd, sin_tab}, {{"auto_broadcast", "numpy"}}); + auto neg_x_odd_sin = ov::pass::pattern::wrap_type({x_odd_sin, -1.000000f}, {{"auto_broadcast", "numpy"}}); + auto add0 = ov::pass::pattern::wrap_type({x_even_cos, neg_x_odd_sin}, {{"auto_broadcast", "numpy"}}); + auto y_even = ov::pass::pattern::wrap_type({add0, -1}) | + ov::pass::pattern::wrap_type({add0, gen_chatglm_const()}, {{"special_zero", false}}); + auto x_odd_cos = ov::pass::pattern::wrap_type({x_odd, cos_tab}, {{"auto_broadcast", "numpy"}}); + auto x_even_sin = ov::pass::pattern::wrap_type({x_even, sin_tab}, {{"auto_broadcast", "numpy"}}); + auto add1 = ov::pass::pattern::wrap_type({x_odd_cos, x_even_sin}, {{"auto_broadcast", "numpy"}}); + auto y_odd = ov::pass::pattern::wrap_type({add1, -1}) | + ov::pass::pattern::wrap_type({add1, gen_chatglm_const()}, {{"special_zero", false}}); - auto concat2 = pattern::wrap_type({y_even, y_odd}, {{"axis", -1}}); + auto concat2 = ov::pass::pattern::wrap_type({y_even, y_odd}, {{"axis", -1}}); - auto shape_of0 = pattern::wrap_type({concat2}); + auto shape_of0 = ov::pass::pattern::wrap_type({concat2}); auto slice4 = NewGenSlice(shape_of0, 0, 3, 1, 0); - auto concat3 = pattern::wrap_type({slice4, {-1}}, {{"axis", 0}}); + auto concat3 = ov::pass::pattern::wrap_type({slice4, {-1}}, {{"axis", 0}}); std::shared_ptr const_target_shape6 = nullptr; std::shared_ptr reshape2 = nullptr; if (support_2d_rope) { // [batch, head_cnt, length, half_rotary_dims, 2] const_target_shape6 = - pattern::wrap_type(pattern::value_matches("batch, head_cnt, seq_len, ndims") || - pattern::value_matches("0, head_cnt, 0, ndims")); - reshape2 = pattern::wrap_type({concat2, concat3 | const_target_shape6}, {{"special_zero", true}}); + ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("batch, head_cnt, seq_len, ndims") || + ov::pass::pattern::value_matches("0, head_cnt, 0, ndims")); + reshape2 = ov::pass::pattern::wrap_type({concat2, concat3 | const_target_shape6}, {{"special_zero", true}}); } else { // [length, batch, head_cnt, half_rotary_dims, 2] - auto const_target_shape7 = pattern::wrap_type(pattern::value_matches("0, 0, head_cnt, ndims")); + auto const_target_shape7 = ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("0, 0, head_cnt, ndims")); const_target_shape6 = - pattern::wrap_type(pattern::value_matches("seq_len, batch, head_cnt, ndims")); - reshape2 = pattern::wrap_type({concat2, concat3 | const_target_shape6 | const_target_shape7}, + ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("seq_len, batch, head_cnt, ndims")); + reshape2 = ov::pass::pattern::wrap_type({concat2, concat3 | const_target_shape6 | const_target_shape7}, {{"special_zero", true}}); } auto slice5 = NewGenSlice(input_key, "ndims", INT_MAX, 1, 3); - auto concat4 = pattern::wrap_type({reshape2, slice5 | var_split0->output(1)}, {{"axis", -1}}); + auto concat4 = ov::pass::pattern::wrap_type({reshape2, slice5 | var_split0->output(1)}, {{"axis", -1}}); auto result = concat4 | reshape2; matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { @@ -777,46 +775,46 @@ ov::pass::RoPEFusionChatGLMHF::RoPEFusionChatGLMHF() { using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionChatGLMHF); - auto qk_linear = pattern::any_input(pattern::shape_matches("[?, 1, ?]")); - auto cos = pattern::any_input(pattern::shape_matches("[?, 1, 1, ?]")); - auto sin = pattern::any_input(pattern::shape_matches("[?, 1, 1, ?]")); + auto qk_linear = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, 1, ?]")); + auto cos = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, 1, 1, ?]")); + auto sin = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, 1, 1, ?]")); - auto reshape = pattern::wrap_type({qk_linear, pattern::any_input()}, - pattern::shape_matches("[?, head_cnt, 1, head_size]"), + auto reshape = ov::pass::pattern::wrap_type({qk_linear, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, head_cnt, 1, head_size]"), {{"special_zero", false}}); - auto vsplit_out0 = pattern::wrap_type( - {reshape, 3, pattern::any_input()}, - pattern::output_index_matches(0) && pattern::shape_matches("[?, head_cnt, 1, ndims]")); - auto vsplit_out1 = pattern::wrap_type( - {reshape, 3, pattern::any_input()}, - pattern::output_index_matches(1) && pattern::shape_matches("[?, head_cnt, 1, ndims]")); + auto vsplit_out0 = ov::pass::pattern::wrap_type( + {reshape, 3, ov::pass::pattern::any_input()}, + ov::pass::pattern::output_index_matches(0) && ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims]")); + auto vsplit_out1 = ov::pass::pattern::wrap_type( + {reshape, 3, ov::pass::pattern::any_input()}, + ov::pass::pattern::output_index_matches(1) && ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims]")); auto slice_1 = NewGenSlice(reshape, 0, "ndims", 1, 3) | vsplit_out0; auto const_idx = - pattern::wrap_type(pattern::type_matches(ov::element::i32) && const_idx_predicate); - auto repeat_interleave_cos = pattern::wrap_type({cos, const_idx, -1}, {{"batch_dims", 0}}); - auto repeat_interleave_sin = pattern::wrap_type({sin, const_idx, -1}, {{"batch_dims", 0}}); + ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(ov::element::i32) && const_idx_predicate); + auto repeat_interleave_cos = ov::pass::pattern::wrap_type({cos, const_idx, -1}, {{"batch_dims", 0}}); + auto repeat_interleave_sin = ov::pass::pattern::wrap_type({sin, const_idx, -1}, {{"batch_dims", 0}}); - auto multiply = pattern::wrap_type({slice_1, repeat_interleave_cos}, {{"auto_broadcast", "numpy"}}); + auto multiply = ov::pass::pattern::wrap_type({slice_1, repeat_interleave_cos}, {{"auto_broadcast", "numpy"}}); auto slice_2 = NewGenSlice(slice_1, 1, INT_MAX, 2, 3); - auto neg = pattern::wrap_type({slice_2, -1}, {{"auto_broadcast", "numpy"}}); - auto unsqueeze_1 = pattern::wrap_type({neg, pattern::any_input()}, - pattern::shape_matches("[?, head_cnt, 1, ndims/2, 1]"), + auto neg = ov::pass::pattern::wrap_type({slice_2, -1}, {{"auto_broadcast", "numpy"}}); + auto unsqueeze_1 = ov::pass::pattern::wrap_type({neg, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims/2, 1]"), {{"special_zero", false}}); auto slice_3 = NewGenSlice(slice_1, 0, INT_MAX, 2, 3); - auto unsqueeze_2 = pattern::wrap_type({slice_3, pattern::any_input()}, - pattern::shape_matches("[?, head_cnt, 1, ndims/2, 1]"), + auto unsqueeze_2 = ov::pass::pattern::wrap_type({slice_3, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims/2, 1]"), {{"special_zero", false}}); - auto stack = pattern::wrap_type({unsqueeze_1, unsqueeze_2}, {{"axis", -1}}); - auto flatten = pattern::wrap_type({stack, pattern::any_input()}, - pattern::shape_matches("[?, head_cnt, 1, ndims]"), + auto stack = ov::pass::pattern::wrap_type({unsqueeze_1, unsqueeze_2}, {{"axis", -1}}); + auto flatten = ov::pass::pattern::wrap_type({stack, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims]"), {{"special_zero", true}}); - auto multiply_1 = pattern::wrap_type({flatten, repeat_interleave_sin}, {{"auto_broadcast", "numpy"}}); - auto add = pattern::wrap_type({multiply, multiply_1}, {{"auto_broadcast", "numpy"}}); + auto multiply_1 = ov::pass::pattern::wrap_type({flatten, repeat_interleave_sin}, {{"auto_broadcast", "numpy"}}); + auto add = ov::pass::pattern::wrap_type({multiply, multiply_1}, {{"auto_broadcast", "numpy"}}); auto slice_5 = NewGenSlice(reshape, "ndims", INT_MAX, 1, 3) | vsplit_out1; - auto result = pattern::wrap_type({add, slice_5}, {{"axis", -1}}); + auto result = ov::pass::pattern::wrap_type({add, slice_5}, {{"axis", -1}}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -845,7 +843,7 @@ ov::pass::RoPEFusionChatGLMHF::RoPEFusionChatGLMHF() { new_args.push_back(pattern_map.at(sin)); auto old_node = root; - auto new_node = std::make_shared(new_args, config); + auto new_node = std::make_shared(new_args, config); new_node->set_friendly_name(old_node->get_friendly_name()); ov::copy_runtime_info({root->get_input_node_shared_ptr(0), root}, new_node); ov::replace_node(old_node, new_node); @@ -861,93 +859,93 @@ ov::pass::RoPEFusionQwen::RoPEFusionQwen() { MATCHER_SCOPE(RoPEFusionQwen); // rotary_emb_cos & rotary_emb_sin are sliced by present kv-length (past-kv-length + cur_len) - auto rotary_emb_cos = pattern::any_input(pattern::shape_matches("[1, ?, 1, ?]")); // [1,..4096,1,128] - auto rotary_emb_sin = pattern::any_input(pattern::shape_matches("[1, ?, 1, ?]")); // [1,..4096,1,128] - auto qkv_proj = pattern::any_input(pattern::shape_matches("[?, ?, ?]")); // [?,?,12288] - auto position_ids = pattern::any_input(); + auto rotary_emb_cos = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[1, ?, 1, ?]")); // [1,..4096,1,128] + auto rotary_emb_sin = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[1, ?, 1, ?]")); // [1,..4096,1,128] + auto qkv_proj = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, ?, ?]")); // [?,?,12288] + auto position_ids = ov::pass::pattern::any_input(); auto ListUnpack_410_VariadicSplit = - pattern::wrap_type({qkv_proj, 2, {"head_cnt*head_size", "head_cnt*head_size", "?"}}); + ov::pass::pattern::wrap_type({qkv_proj, 2, {"head_cnt*head_size", "head_cnt*head_size", "?"}}); ListUnpack_410_VariadicSplit->set_output_size(3); // B,L,H,S - auto view_Reshape_424 = pattern::wrap_type({ListUnpack_410_VariadicSplit, pattern::any_input()}, - pattern::shape_matches("[?, ?, head_cnt, head_size]"), + auto view_Reshape_424 = ov::pass::pattern::wrap_type({ListUnpack_410_VariadicSplit, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, ?, head_cnt, head_size]"), {{"special_zero", true}}); auto slice_Slice_543 = NewGenSlice(view_Reshape_424, 0, "head_size", 1, 3); - auto ShapeOf_485735 = pattern::wrap_type({pattern::any_input()}, {}); - auto Multiply_567524 = pattern::wrap_type({ShapeOf_485735, -1}, {{"auto_broadcast", "numpy"}}); - auto Gather_377635 = pattern::wrap_type({Multiply_567524, 1, 0}, {{"batch_dims", 0}}); + auto ShapeOf_485735 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}, {}); + auto Multiply_567524 = ov::pass::pattern::wrap_type({ShapeOf_485735, -1}, {{"auto_broadcast", "numpy"}}); + auto Gather_377635 = ov::pass::pattern::wrap_type({Multiply_567524, 1, 0}, {{"batch_dims", 0}}); - auto ShapeOf_409241 = pattern::wrap_type({pattern::any_input()}, {}); - auto Gather_311651 = pattern::wrap_type({ShapeOf_409241, 1, 0}, {{"batch_dims", 0}}); - auto neg_Multiply = pattern::wrap_type({Gather_311651, -1}, {{"auto_broadcast", "numpy"}}); + auto ShapeOf_409241 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}, {}); + auto Gather_311651 = ov::pass::pattern::wrap_type({ShapeOf_409241, 1, 0}, {{"batch_dims", 0}}); + auto neg_Multiply = ov::pass::pattern::wrap_type({Gather_311651, -1}, {{"auto_broadcast", "numpy"}}); - auto ScatterUpdate_463814 = pattern::wrap_type({{0, 0}, 1, Gather_377635 | neg_Multiply, 0}); - auto slice_Slice_446 = pattern::wrap_type({rotary_emb_cos, Gather_377635 | neg_Multiply, INT_MAX, 1, 1}); + auto ScatterUpdate_463814 = ov::pass::pattern::wrap_type({{0, 0}, 1, Gather_377635 | neg_Multiply, 0}); + auto slice_Slice_446 = ov::pass::pattern::wrap_type({rotary_emb_cos, Gather_377635 | neg_Multiply, INT_MAX, 1, 1}); - auto gather_cos_by_pos_ids = pattern::wrap_type({rotary_emb_cos, position_ids, 1}, {{"batch_dims", 0}}); - auto reshape_cos_to_expected_layout = pattern::wrap_type({gather_cos_by_pos_ids, pattern::any_input()}, - pattern::shape_matches("[?, 1, 1, 128]"), + auto gather_cos_by_pos_ids = ov::pass::pattern::wrap_type({rotary_emb_cos, position_ids, 1}, {{"batch_dims", 0}}); + auto reshape_cos_to_expected_layout = ov::pass::pattern::wrap_type({gather_cos_by_pos_ids, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, 1, 1, 128]"), {{"special_zero", false}}); auto slice_StridedSlice_446 = NewGenStridedSlice(rotary_emb_cos, ScatterUpdate_463814, {0, INT_MAX}, {1, 1}, 1); - auto mul_Multiply_552 = pattern::wrap_type( + auto mul_Multiply_552 = ov::pass::pattern::wrap_type( {slice_Slice_543, slice_StridedSlice_446 | slice_Slice_446 | reshape_cos_to_expected_layout}, {{"auto_broadcast", "numpy"}}); auto reshape_opt1 = [&](std::shared_ptr input_BLHS) { - auto ShapeOf_485814 = pattern::wrap_type({input_BLHS}, {}); - auto Gather_377647 = pattern::wrap_type({ShapeOf_485814, 1, 0}, {{"batch_dims", 0}}); + auto ShapeOf_485814 = ov::pass::pattern::wrap_type({input_BLHS}, {}); + auto Gather_377647 = ov::pass::pattern::wrap_type({ShapeOf_485814, 1, 0}, {{"batch_dims", 0}}); // batch-size, we don't care auto Gather_377641 = - pattern::any_input(pattern::type_matches(ov::element::i32) && pattern::shape_matches("[1]")); + ov::pass::pattern::any_input(ov::pass::pattern::type_matches(ov::element::i32) && ov::pass::pattern::shape_matches("[1]")); auto ListConstruct_581_Concat = - pattern::wrap_type({Gather_377641, Gather_377647, "head_cnt", 2, "head_size/2"}, {{"axis", 0}}); - auto Gather_391791 = pattern::wrap_type({ShapeOf_485814, {0, 1}, 0}, {{"batch_dims", 0}}); - auto ListConstruct_522_Concat = pattern::wrap_type({Gather_391791, 32, 2, 64}, {{"axis", 0}}); + ov::pass::pattern::wrap_type({Gather_377641, Gather_377647, "head_cnt", 2, "head_size/2"}, {{"axis", 0}}); + auto Gather_391791 = ov::pass::pattern::wrap_type({ShapeOf_485814, {0, 1}, 0}, {{"batch_dims", 0}}); + auto ListConstruct_522_Concat = ov::pass::pattern::wrap_type({Gather_391791, 32, 2, 64}, {{"axis", 0}}); - auto reshape_Reshape_577 = pattern::wrap_type({input_BLHS, pattern::any_input()}, - pattern::shape_matches("[?, 2, head_size/2]"), + auto reshape_Reshape_577 = ov::pass::pattern::wrap_type({input_BLHS, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, 2, head_size/2]"), {{"special_zero", true}}); - return pattern::wrap_type( + return ov::pass::pattern::wrap_type( {reshape_Reshape_577, ListConstruct_581_Concat | ListConstruct_522_Concat}, {{"special_zero", false}}); }; - auto reshape_special = pattern::wrap_type( - {slice_Slice_543, pattern::any_input()}, - pattern::shape_matches("[..., 0, 2, head_size/2]") || pattern::shape_matches("[..., head_cnt, 2, head_size/2]"), + auto reshape_special = ov::pass::pattern::wrap_type( + {slice_Slice_543, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[..., 0, 2, head_size/2]") || ov::pass::pattern::shape_matches("[..., head_cnt, 2, head_size/2]"), {{"special_zero", true}}); auto ListUnpack_586_Split = - pattern::wrap_type({reshape_opt1(slice_Slice_543) | reshape_special, -2}, {{"num_splits", 2}}); + ov::pass::pattern::wrap_type({reshape_opt1(slice_Slice_543) | reshape_special, -2}, {{"num_splits", 2}}); ListUnpack_586_Split->set_output_size(2); auto Multiply_567527 = - pattern::wrap_type({ListUnpack_586_Split->output(1), -1.0f}, {{"auto_broadcast", "numpy"}}); - auto ListUnpack_586_Squeeze_0 = pattern::wrap_type({Multiply_567527, -2}); - auto ListUnpack_586_Squeeze = pattern::wrap_type({ListUnpack_586_Split->output(0), -2}); + ov::pass::pattern::wrap_type({ListUnpack_586_Split->output(1), -1.0f}, {{"auto_broadcast", "numpy"}}); + auto ListUnpack_586_Squeeze_0 = ov::pass::pattern::wrap_type({Multiply_567527, -2}); + auto ListUnpack_586_Squeeze = ov::pass::pattern::wrap_type({ListUnpack_586_Split->output(0), -2}); - auto ListUnpack_Squeeze_0_1 = pattern::wrap_type({Multiply_567527, pattern::any_input()}, - pattern::shape_matches("[?, 1, 32, 64]"), + auto ListUnpack_Squeeze_0_1 = ov::pass::pattern::wrap_type({Multiply_567527, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, 1, 32, 64]"), {{"special_zero", false}}); - auto ListUnpack_Squeeze_1 = pattern::wrap_type({ListUnpack_586_Split->output(0), pattern::any_input()}, - pattern::shape_matches("[?, 1, 32, 64]"), + auto ListUnpack_Squeeze_1 = ov::pass::pattern::wrap_type({ListUnpack_586_Split->output(0), ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, 1, 32, 64]"), {{"special_zero", false}}); - auto cat_Concat_593 = pattern::wrap_type( + auto cat_Concat_593 = ov::pass::pattern::wrap_type( {ListUnpack_586_Squeeze_0 | ListUnpack_Squeeze_0_1, ListUnpack_586_Squeeze | ListUnpack_Squeeze_1}, {{"axis", -1}}); auto slice_StridedSlice_470 = NewGenStridedSlice(rotary_emb_sin, ScatterUpdate_463814, {0, INT_MAX}, {1, 1}, 1); - auto slice_Slice_470 = pattern::wrap_type({rotary_emb_sin, Gather_377635 | neg_Multiply, INT_MAX, 1, 1}); - auto gather_sin_by_pos_ids = pattern::wrap_type({rotary_emb_sin, position_ids, 1}, {{"batch_dims", 0}}); - auto reshape_sin_to_expected_layout = pattern::wrap_type({gather_sin_by_pos_ids, pattern::any_input()}, - pattern::shape_matches("[?, 1, 1, 128]"), + auto slice_Slice_470 = ov::pass::pattern::wrap_type({rotary_emb_sin, Gather_377635 | neg_Multiply, INT_MAX, 1, 1}); + auto gather_sin_by_pos_ids = ov::pass::pattern::wrap_type({rotary_emb_sin, position_ids, 1}, {{"batch_dims", 0}}); + auto reshape_sin_to_expected_layout = ov::pass::pattern::wrap_type({gather_sin_by_pos_ids, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, 1, 1, 128]"), {{"special_zero", false}}); - auto mul_Multiply_594 = pattern::wrap_type( + auto mul_Multiply_594 = ov::pass::pattern::wrap_type( {cat_Concat_593, slice_StridedSlice_470 | slice_Slice_470 | reshape_sin_to_expected_layout}, {{"auto_broadcast", "numpy"}}); - auto result = pattern::wrap_type({mul_Multiply_552, mul_Multiply_594}, {{"auto_broadcast", "numpy"}}); + auto result = ov::pass::pattern::wrap_type({mul_Multiply_552, mul_Multiply_594}, {{"auto_broadcast", "numpy"}}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -1005,7 +1003,7 @@ ov::pass::RoPEFusionQwen::RoPEFusionQwen() { rt_from.push_back(pattern_map.at(ListUnpack_586_Squeeze).get_node_shared_ptr()); } auto old_node = root; - auto new_node = std::make_shared(new_args, config); + auto new_node = std::make_shared(new_args, config); new_node->set_friendly_name(old_node->get_friendly_name()); ov::copy_runtime_info(rt_from, new_node); ov::replace_node(old_node, new_node); @@ -1023,37 +1021,37 @@ ov::pass::RoPEFusionQwen::RoPEFusionQwen() { ov::pass::RoPEShareCosSin::RoPEShareCosSin() { MATCHER_SCOPE(RoPEShareCosSin); - std::vector> inputs = {pattern::any_input(), pattern::any_input()}; + std::vector> inputs = {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}; // Broadcast pattern auto const_broadcast_axes = - pattern::wrap_type(pattern::type_matches(element::u8) && pattern::value_matches("{0}")); - auto broadcast = pattern::wrap_type({"{1.000000f}", inputs[0], const_broadcast_axes}, + ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::u8) && ov::pass::pattern::value_matches("{0}")); + auto broadcast = ov::pass::pattern::wrap_type({"{1.000000f}", inputs[0], const_broadcast_axes}, {{"mode", "numpy"}}); // Multiply pattern (expand broadcast) - auto const_inv_freq = pattern::wrap_type(); // Pattern for the constant inverse frequency + auto const_inv_freq = ov::pass::pattern::wrap_type(); // Pattern for the constant inverse frequency auto multiply = - pattern::wrap_type({const_inv_freq, broadcast}, {{"auto_broadcast", "numpy"}}); + ov::pass::pattern::wrap_type({const_inv_freq, broadcast}, {{"auto_broadcast", "numpy"}}); // MatMul pattern auto matmul = - pattern::wrap_type({multiply, inputs[1]}, {{"transpose_a", false}, {"transpose_b", false}}); + ov::pass::pattern::wrap_type({multiply, inputs[1]}, {{"transpose_a", false}, {"transpose_b", false}}); // Transpose pattern - auto transpose = pattern::wrap_type({matmul, {0, 2, 1}}); + auto transpose = ov::pass::pattern::wrap_type({matmul, {0, 2, 1}}); // Concat pattern - auto concat = pattern::wrap_type({transpose, transpose}, {{"axis", -1}}); + auto concat = ov::pass::pattern::wrap_type({transpose, transpose}, {{"axis", -1}}); // Cosine and Sine patterns - auto cos = pattern::wrap_type({concat}); - auto sin = pattern::wrap_type({concat}); + auto cos = ov::pass::pattern::wrap_type({concat}); + auto sin = ov::pass::pattern::wrap_type({concat}); // Unsqueeze result pattern (cos or sin) - auto result = pattern::wrap_type({cos | sin, {1}}); + auto result = ov::pass::pattern::wrap_type({cos | sin, {1}}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pass::pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto root = m.get_match_root(); @@ -1117,7 +1115,7 @@ ov::pass::RoPEShareCosSin::RoPEShareCosSin() { return true; }; - auto m = std::make_shared(result, matcher_name); + auto m = std::make_shared(result, matcher_name); this->register_matcher(m, callback); } @@ -1130,26 +1128,26 @@ ov::pass::RoPEFusionGPTOSS::RoPEFusionGPTOSS() { // first_ = first_half * cos - second_half * sin // second_ = second_half * cos + first_half * sin // return torch.cat((first_, second_), dim=-1) - auto x = pattern::any_input(pattern::rank_equals(4)); - auto t_cos = pattern::any_input(pattern::shape_matches("[?, 1, ?, half_ndims]")); - auto t_sin = pattern::any_input(pattern::shape_matches("[?, 1, ?, half_ndims]")); + auto x = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto t_cos = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, 1, ?, half_ndims]")); + auto t_sin = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, 1, ?, half_ndims]")); - auto vsplit_out0 = pattern::wrap_type( + auto vsplit_out0 = ov::pass::pattern::wrap_type( {x, -1, {"half_ndims", "?"}}, - pattern::output_index_matches(0) && pattern::shape_matches("[?, ?, ?, half_ndims]")); - auto vsplit_out1 = pattern::wrap_type( + ov::pass::pattern::output_index_matches(0) && ov::pass::pattern::shape_matches("[?, ?, ?, half_ndims]")); + auto vsplit_out1 = ov::pass::pattern::wrap_type( {x, -1, {"half_ndims", "?"}}, - pattern::output_index_matches(1) && pattern::shape_matches("[?, ?, ?, half_ndims]")); - auto first_half_mul_cos = pattern::wrap_type({vsplit_out0, t_cos}, {{"auto_broadcast", "numpy"}}); - auto second_half_mul_sin = pattern::wrap_type({vsplit_out1, t_sin}, {{"auto_broadcast", "numpy"}}); - auto neg = pattern::wrap_type({second_half_mul_sin, -1.0f}, {{"auto_broadcast", "numpy"}}); - auto sub_Subtract = pattern::wrap_type({first_half_mul_cos, neg}, {{"auto_broadcast", "numpy"}}); - - auto second_half_mul_cos = pattern::wrap_type({vsplit_out1, t_cos}, {{"auto_broadcast", "numpy"}}); - auto first_half_mul_sin = pattern::wrap_type({vsplit_out0, t_sin}, {{"auto_broadcast", "numpy"}}); + ov::pass::pattern::output_index_matches(1) && ov::pass::pattern::shape_matches("[?, ?, ?, half_ndims]")); + auto first_half_mul_cos = ov::pass::pattern::wrap_type({vsplit_out0, t_cos}, {{"auto_broadcast", "numpy"}}); + auto second_half_mul_sin = ov::pass::pattern::wrap_type({vsplit_out1, t_sin}, {{"auto_broadcast", "numpy"}}); + auto neg = ov::pass::pattern::wrap_type({second_half_mul_sin, -1.0f}, {{"auto_broadcast", "numpy"}}); + auto sub_Subtract = ov::pass::pattern::wrap_type({first_half_mul_cos, neg}, {{"auto_broadcast", "numpy"}}); + + auto second_half_mul_cos = ov::pass::pattern::wrap_type({vsplit_out1, t_cos}, {{"auto_broadcast", "numpy"}}); + auto first_half_mul_sin = ov::pass::pattern::wrap_type({vsplit_out0, t_sin}, {{"auto_broadcast", "numpy"}}); auto add_Add = - pattern::wrap_type({second_half_mul_cos, first_half_mul_sin}, {{"auto_broadcast", "numpy"}}); - auto concat_result = pattern::wrap_type({sub_Subtract, add_Add}, {{"axis", -1}}); + ov::pass::pattern::wrap_type({second_half_mul_cos, first_half_mul_sin}, {{"auto_broadcast", "numpy"}}); + auto concat_result = ov::pass::pattern::wrap_type({sub_Subtract, add_Add}, {{"axis", -1}}); auto result = concat_result; @@ -1173,7 +1171,7 @@ ov::pass::RoPEFusionGPTOSS::RoPEFusionGPTOSS() { new_args.push_back(x_val); new_args.push_back(v_cos); new_args.push_back(pattern_map.at(t_sin)); - auto new_node = std::make_shared(new_args, config); + auto new_node = std::make_shared(new_args, config); new_node->set_friendly_name(root->get_friendly_name()); ov::copy_runtime_info({pattern_map.at(neg).get_node_shared_ptr(), pattern_map.at(sub_Subtract).get_node_shared_ptr(), diff --git a/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp index 249b0f4e89610b..37b9bf1eb8849f 100644 --- a/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp @@ -29,16 +29,14 @@ using namespace ov; using namespace ov::op::util; -using namespace ov::pass::pattern::op; - constexpr auto SQRT2 = static_cast(M_SQRT2); constexpr auto SQRT1_2 = static_cast(M_SQRT1_2); constexpr auto SQRT_2_PI = 0.79788456080286535588f; // std::sqrt(M_2_PI) namespace { -Predicate check_value(float ref, float eps = std::numeric_limits::epsilon()) { - return Predicate( +ov::pass::pattern::op::Predicate check_value(float ref, float eps = std::numeric_limits::epsilon()) { + return ov::pass::pattern::op::Predicate( [=](const Output& output) -> bool { return ov::op::util::has_constant_value(output.get_node_shared_ptr(), ref, eps); }, @@ -66,14 +64,14 @@ ov::pass::GeluFusionWithErfOne::GeluFusionWithErfOne() { MATCHER_SCOPE(GeluFusionWithErfOne); // Replaces a sub-graph with a Gelu op // Shared by every pattern: (1 + erf(x / sqrt(2))) - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto div_constant = ov::pass::pattern::wrap_type(check_value(SQRT2, 0.001f)); auto div = ov::pass::pattern::wrap_type({input, div_constant}); // In case of ConvertDivideWithConstant is applied and Div is converted to Mul auto mul_as_div_constant = ov::pass::pattern::wrap_type(check_value(SQRT1_2, 0.001f)); auto mul_as_div = ov::pass::pattern::wrap_type({input, mul_as_div_constant}); - auto erf_input = std::make_shared(ov::OutputVector{div, mul_as_div}); + auto erf_input = std::make_shared(ov::OutputVector{div, mul_as_div}); auto erf = ov::pass::pattern::wrap_type({erf_input}); @@ -97,14 +95,14 @@ ov::pass::GeluFusionWithErfTwo::GeluFusionWithErfTwo() { MATCHER_SCOPE(GeluFusionWithErfTwo); // Replaces a sub-graph with a Gelu op // Shared by every pattern: (1 + erf(x / sqrt(2))) - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto div_constant = ov::pass::pattern::wrap_type(check_value(SQRT2, 0.001f)); auto div = ov::pass::pattern::wrap_type({input, div_constant}); // In case of ConvertDivideWithConstant is applied and Div is converted to Mul auto mul_as_div_constant = ov::pass::pattern::wrap_type(check_value(SQRT1_2, 0.001f)); auto mul_as_div = ov::pass::pattern::wrap_type({input, mul_as_div_constant}); - auto erf_input = std::make_shared(ov::OutputVector{div, mul_as_div}); + auto erf_input = std::make_shared(ov::OutputVector{div, mul_as_div}); auto erf = ov::pass::pattern::wrap_type({erf_input}); auto add_constant = ov::pass::pattern::wrap_type(check_value(1.0f)); @@ -127,14 +125,14 @@ ov::pass::GeluFusionWithErfThree::GeluFusionWithErfThree() { MATCHER_SCOPE(GeluFusionWithErfThree); // Replaces a sub-graph with a Gelu op // Shared by every pattern: (1 + erf(x / sqrt(2))) - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto div_constant = ov::pass::pattern::wrap_type(check_value(SQRT2, 0.001f)); auto div = ov::pass::pattern::wrap_type({input, div_constant}); // In case of ConvertDivideWithConstant is applied and Div is converted to Mul auto mul_as_div_constant = ov::pass::pattern::wrap_type(check_value(SQRT1_2, 0.001f)); auto mul_as_div = ov::pass::pattern::wrap_type({input, mul_as_div_constant}); - auto erf_input = std::make_shared(ov::OutputVector{div, mul_as_div}); + auto erf_input = std::make_shared(ov::OutputVector{div, mul_as_div}); auto erf = ov::pass::pattern::wrap_type({erf_input}); auto add_constant = ov::pass::pattern::wrap_type(check_value(1.0f)); @@ -156,25 +154,23 @@ ov::pass::GeluFusionWithErfThree::GeluFusionWithErfThree() { ov::pass::GeluFusionWithErfFour::GeluFusionWithErfFour() { MATCHER_SCOPE(GeluFusionWithErfFour); using namespace ov; - using namespace ov::pass::pattern; - - auto input = any_input(); - auto mul1_constant = wrap_type(check_value(SQRT1_2, 0.001f)); - auto mul1 = wrap_type({input, mul1_constant}); - auto erf = wrap_type({mul1}); - auto mul2_constant = wrap_type(check_value(0.5f)); - auto mul2 = wrap_type({erf, mul2_constant}); - auto add_constant = wrap_type(check_value(0.5f)); - auto add = wrap_type({add_constant, mul2}); +auto input = ov::pass::pattern::any_input(); + auto mul1_constant = ov::pass::pattern::wrap_type(check_value(SQRT1_2, 0.001f)); + auto mul1 = ov::pass::pattern::wrap_type({input, mul1_constant}); + auto erf = ov::pass::pattern::wrap_type({mul1}); + auto mul2_constant = ov::pass::pattern::wrap_type(check_value(0.5f)); + auto mul2 = ov::pass::pattern::wrap_type({erf, mul2_constant}); + auto add_constant = ov::pass::pattern::wrap_type(check_value(0.5f)); + auto add = ov::pass::pattern::wrap_type({add_constant, mul2}); // x * (0.5 + 0.5 * erf(x * (1 / sqrt(2)))) - auto mul3 = wrap_type({input, add}); + auto mul3 = ov::pass::pattern::wrap_type({input, add}); - matcher_pass_callback callback = [=](Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { return gelu_replacer(m, input); }; - auto m = std::make_shared(mul3, matcher_name); + auto m = std::make_shared(mul3, matcher_name); register_matcher(m, callback); } @@ -183,7 +179,7 @@ ov::pass::GeluFusionWithTanh::GeluFusionWithTanh() { // Replaces a sub-graph with a Gelu (ov::op::v0::Tanh) op // Gaussian Error Linear Unit, TanH based approximation: // x * (0.5 * (1 + tanh([sqrt(2 / pi)] * [x + 0.044715^3])) - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto pow_constant = ov::pass::pattern::wrap_type(check_value(3.0f)); auto pow = ov::pass::pattern::wrap_type({input, pow_constant}); @@ -224,30 +220,30 @@ ov::pass::GeluFusionWithTanhNoPower::GeluFusionWithTanhNoPower() { // Replaces a sub-graph with a Gelu (ov::op::v0::Tanh) op // x * 0.5 * (1 + tanh((x * 0.044715 * x + 1) * x * sqrt(2 / pi))) MATCHER_SCOPE(GeluFusionWithTanhNoPower); - auto input = pattern::any_input(); + auto input = ov::pass::pattern::any_input(); - auto const1 = pattern::wrap_type(check_value(0.044715f, 0.001f)); - auto mul1 = pattern::wrap_type({input, const1}); + auto const1 = ov::pass::pattern::wrap_type(check_value(0.044715f, 0.001f)); + auto mul1 = ov::pass::pattern::wrap_type({input, const1}); - auto mul2 = pattern::wrap_type({mul1, input}); + auto mul2 = ov::pass::pattern::wrap_type({mul1, input}); - auto const2 = pattern::wrap_type(check_value(1.0f)); - auto add1 = pattern::wrap_type({const2, mul2}); + auto const2 = ov::pass::pattern::wrap_type(check_value(1.0f)); + auto add1 = ov::pass::pattern::wrap_type({const2, mul2}); - auto const3 = pattern::wrap_type(check_value(SQRT_2_PI, 0.01f)); - auto mul3 = pattern::wrap_type({input, const3}); + auto const3 = ov::pass::pattern::wrap_type(check_value(SQRT_2_PI, 0.01f)); + auto mul3 = ov::pass::pattern::wrap_type({input, const3}); - auto mul4 = pattern::wrap_type({add1, mul3}); + auto mul4 = ov::pass::pattern::wrap_type({add1, mul3}); - auto tanh = pattern::wrap_type({mul4}); + auto tanh = ov::pass::pattern::wrap_type({mul4}); - auto const4 = pattern::wrap_type(check_value(1.0f)); - auto add2 = pattern::wrap_type({tanh, const4}); + auto const4 = ov::pass::pattern::wrap_type(check_value(1.0f)); + auto add2 = ov::pass::pattern::wrap_type({tanh, const4}); - auto const5 = pattern::wrap_type(check_value(0.5f)); - auto mul5 = pattern::wrap_type({input, const5}); + auto const5 = ov::pass::pattern::wrap_type(check_value(0.5f)); + auto mul5 = ov::pass::pattern::wrap_type({input, const5}); - auto mul6 = pattern::wrap_type({add2, mul5}); + auto mul6 = ov::pass::pattern::wrap_type({add2, mul5}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { return gelu_replacer(m, input, ov::op::GeluApproximationMode::TANH); @@ -261,7 +257,7 @@ ov::pass::GeluFusionWithTanhNoPower2::GeluFusionWithTanhNoPower2() { MATCHER_SCOPE(GeluFusionWithTanhNoPower2); // Replaces a sub-graph with a Gelu (ov::op::v0::Tanh) op // x * (0.5 * (1 + tanh([sqrt(2 / pi)] * [x + 0.044715 * x * x * x]))) - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto mul_0 = ov::pass::pattern::wrap_type({input, input}); auto mul_1 = ov::pass::pattern::wrap_type({input, mul_0}); diff --git a/src/common/transformations/src/transformations/common_optimizations/glu_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/glu_fusion.cpp index 52d9f5f2378c7a..95147e9d77a937 100644 --- a/src/common/transformations/src/transformations/common_optimizations/glu_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/glu_fusion.cpp @@ -21,8 +21,7 @@ namespace ov { namespace pass { GLUFusion::GLUFusion() { - using namespace ov::pass::pattern; - using ov::pass::pattern::op::Or; +using ov::pass::pattern::op::Or; auto last_dim_static = [](const ov::Output& output) { auto out_ps = output.get_node()->get_output_partial_shape(0); @@ -31,21 +30,21 @@ GLUFusion::GLUFusion() { // Detect GLU decomposition pattern // GLU(Xw, Xv, beta) = (Xw * (1.0 + exp(-beta * Xw))) * Xv - auto data_m = any_input(last_dim_static); + auto data_m = ov::pass::pattern::any_input(last_dim_static); // VariadicSplit(X, axis, split_lengths) = Xw, Xv - auto axis_const_m = wrap_type(); - auto split_lengths_const_m = wrap_type(); - auto variadic_split_m = wrap_type({data_m, axis_const_m, split_lengths_const_m}); + auto axis_const_m = ov::pass::pattern::wrap_type(); + auto split_lengths_const_m = ov::pass::pattern::wrap_type(); + auto variadic_split_m = ov::pass::pattern::wrap_type({data_m, axis_const_m, split_lengths_const_m}); variadic_split_m->set_output_size(2); // Swish(Xw) = Xw * (1.0 + exp(-beta * Xw)) - auto swish_m = wrap_type({variadic_split_m->output(0)}); - auto gelu_m = wrap_type({variadic_split_m->output(0)}); + auto swish_m = ov::pass::pattern::wrap_type({variadic_split_m->output(0)}); + auto gelu_m = ov::pass::pattern::wrap_type({variadic_split_m->output(0)}); // Mul(Xw, Xv) = Swish(Xw) * Xv auto glu_m = std::make_shared(OutputVector{swish_m, gelu_m}); - auto mul_m = wrap_type({glu_m, variadic_split_m->output(1)}); + auto mul_m = ov::pass::pattern::wrap_type({glu_m, variadic_split_m->output(1)}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/group_normalization_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/group_normalization_fusion.cpp index e8c7f342022e3f..960bc3f5dd81cc 100644 --- a/src/common/transformations/src/transformations/common_optimizations/group_normalization_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/group_normalization_fusion.cpp @@ -18,9 +18,6 @@ #include "openvino/pass/pattern/op/optional.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" #include "transformations/utils/utils.hpp" - -using namespace ov::pass::pattern; - ov::pass::GroupNormalizationFusion::GroupNormalizationFusion() { MATCHER_SCOPE(GroupNormalizationFusion); @@ -34,36 +31,36 @@ ov::pass::GroupNormalizationFusion::GroupNormalizationFusion() { return (output_ps.rank().is_static()) && (output_ps.rank().get_length() >= 2); }; - auto input_m = any_input(all_of({has_real_not_quantized_type, has_at_least_2d_shape, has_static_dim(1)})); + auto input_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({has_real_not_quantized_type, has_at_least_2d_shape, ov::pass::pattern::has_static_dim(1)})); - auto pre_mvn_shape_const_m = wrap_type(all_of({rank_equals(1), has_static_dim(0)})); + auto pre_mvn_shape_const_m = ov::pass::pattern::wrap_type(ov::pass::pattern::all_of({ov::pass::pattern::rank_equals(1), ov::pass::pattern::has_static_dim(0)})); auto pre_mvn_reshape_m = - wrap_type({input_m, pre_mvn_shape_const_m}, - all_of({has_real_not_quantized_type, rank_equals(3), has_static_dim(1)})); + ov::pass::pattern::wrap_type({input_m, pre_mvn_shape_const_m}, + ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::rank_equals(3), ov::pass::pattern::has_static_dim(1)})); - auto mvn_reduction_axes_const_m = wrap_type(all_of({rank_equals(1), has_static_dim(0)})); - auto mvn_m = wrap_type({pre_mvn_reshape_m, mvn_reduction_axes_const_m}); + auto mvn_reduction_axes_const_m = ov::pass::pattern::wrap_type(ov::pass::pattern::all_of({ov::pass::pattern::rank_equals(1), ov::pass::pattern::has_static_dim(0)})); + auto mvn_m = ov::pass::pattern::wrap_type({pre_mvn_reshape_m, mvn_reduction_axes_const_m}); - auto instance_norm_gamma_m = any_input(all_of({has_real_not_quantized_type, has_static_shape()})); - auto instance_norm_opt_gamma_m = optional({mvn_m, instance_norm_gamma_m}); + auto instance_norm_gamma_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); + auto instance_norm_opt_gamma_m = ov::pass::pattern::optional({mvn_m, instance_norm_gamma_m}); - auto instance_norm_beta_m = any_input(all_of({has_real_not_quantized_type, has_static_shape()})); + auto instance_norm_beta_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); auto instance_norm_opt_gamma_opt_beta_m = - optional({instance_norm_opt_gamma_m, instance_norm_beta_m}); + ov::pass::pattern::optional({instance_norm_opt_gamma_m, instance_norm_beta_m}); - auto post_instance_norm_shape_m = any_input(all_of({rank_equals(1), has_static_dim(0)})); + auto post_instance_norm_shape_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({ov::pass::pattern::rank_equals(1), ov::pass::pattern::has_static_dim(0)})); auto post_instance_norm_reshape_m = - wrap_type({instance_norm_opt_gamma_opt_beta_m, post_instance_norm_shape_m}, - all_of({has_real_not_quantized_type, has_at_least_2d_shape, has_static_dim(1)})); + ov::pass::pattern::wrap_type({instance_norm_opt_gamma_opt_beta_m, post_instance_norm_shape_m}, + ov::pass::pattern::all_of({has_real_not_quantized_type, has_at_least_2d_shape, ov::pass::pattern::has_static_dim(1)})); - auto group_norm_gamma_m = any_input(all_of({has_real_not_quantized_type, has_static_shape()})); + auto group_norm_gamma_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); auto group_norm_gamma_multiply_m = - wrap_type({post_instance_norm_reshape_m, group_norm_gamma_m}); + ov::pass::pattern::wrap_type({post_instance_norm_reshape_m, group_norm_gamma_m}); - auto group_norm_beta_m = any_input(all_of({has_real_not_quantized_type, has_static_shape()})); - auto group_norm_beta_add_m = wrap_type({group_norm_gamma_multiply_m, group_norm_beta_m}); + auto group_norm_beta_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); + auto group_norm_beta_add_m = ov::pass::pattern::wrap_type({group_norm_gamma_multiply_m, group_norm_beta_m}); - ov::matcher_pass_callback callback = [=](Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& input = pattern_map.at(input_m); @@ -277,6 +274,6 @@ ov::pass::GroupNormalizationFusion::GroupNormalizationFusion() { return true; }; - auto m = std::make_shared(group_norm_beta_add_m, matcher_name); + auto m = std::make_shared(group_norm_beta_add_m, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/gru_cell_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/gru_cell_fusion.cpp index a33a1862e77fc6..e3e25073bb52a8 100644 --- a/src/common/transformations/src/transformations/common_optimizations/gru_cell_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/gru_cell_fusion.cpp @@ -29,8 +29,6 @@ using namespace std; using namespace ov::element; using namespace ov::pass; -using namespace ov::pass::pattern; - namespace { /** @@ -88,26 +86,26 @@ ov::pass::GRUCellFusion::GRUCellFusion() { return !(p_shape.rank().is_dynamic() || p_shape[1].is_dynamic()); }; - auto concat_1 = wrap_type({any_input(is_first_dim_static), any_input(is_first_dim_static)}); - auto matmul_1 = wrap_type({concat_1, any_input(is_first_dim_static)}); - auto add_1 = wrap_type({matmul_1, any_input()}); - auto optional_bias_add_1 = make_shared(OutputVector{matmul_1, add_1}); - auto activation_1 = wrap_type({optional_bias_add_1}); - auto split = wrap_type({activation_1, any_input()}); - - auto multiply_1 = wrap_type({split, any_input()}); - auto concat_2 = wrap_type({any_input(), multiply_1}); - auto matmul_2 = wrap_type({concat_2, any_input(is_first_dim_static)}); - auto add_2 = wrap_type({matmul_2, any_input()}); - auto optional_bias_add_2 = make_shared(OutputVector{matmul_2, add_2}); - auto activation_2 = wrap_type({optional_bias_add_2}); - - auto subtract = wrap_type({any_input(), split}); - auto multiply_2 = wrap_type({subtract, activation_2}); - auto multiply_3 = wrap_type({split, any_input()}); - auto add = wrap_type({multiply_2, multiply_3}); - - matcher_pass_callback callback = [=](pattern::Matcher& m) { + auto concat_1 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(is_first_dim_static), ov::pass::pattern::any_input(is_first_dim_static)}); + auto matmul_1 = ov::pass::pattern::wrap_type({concat_1, ov::pass::pattern::any_input(is_first_dim_static)}); + auto add_1 = ov::pass::pattern::wrap_type({matmul_1, ov::pass::pattern::any_input()}); + auto optional_bias_add_1 = make_shared(OutputVector{matmul_1, add_1}); + auto activation_1 = ov::pass::pattern::wrap_type({optional_bias_add_1}); + auto split = ov::pass::pattern::wrap_type({activation_1, ov::pass::pattern::any_input()}); + + auto multiply_1 = ov::pass::pattern::wrap_type({split, ov::pass::pattern::any_input()}); + auto concat_2 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), multiply_1}); + auto matmul_2 = ov::pass::pattern::wrap_type({concat_2, ov::pass::pattern::any_input(is_first_dim_static)}); + auto add_2 = ov::pass::pattern::wrap_type({matmul_2, ov::pass::pattern::any_input()}); + auto optional_bias_add_2 = make_shared(OutputVector{matmul_2, add_2}); + auto activation_2 = ov::pass::pattern::wrap_type({optional_bias_add_2}); + + auto subtract = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), split}); + auto multiply_2 = ov::pass::pattern::wrap_type({subtract, activation_2}); + auto multiply_3 = ov::pass::pattern::wrap_type({split, ov::pass::pattern::any_input()}); + auto add = ov::pass::pattern::wrap_type({multiply_2, multiply_3}); + + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { NodeRegistry rg; auto pattern_map = m.get_pattern_map(); auto concat = pattern_map.at(concat_1); @@ -195,6 +193,6 @@ ov::pass::GRUCellFusion::GRUCellFusion() { return true; }; - auto m = make_shared(add, matcher_name); + auto m = make_shared(add, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/hsigmoid_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/hsigmoid_fusion.cpp index 357bf455e4326a..74d2402e634c12 100644 --- a/src/common/transformations/src/transformations/common_optimizations/hsigmoid_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/hsigmoid_fusion.cpp @@ -24,7 +24,7 @@ ov::pass::HSigmoidFusionWithReluDiv::HSigmoidFusionWithReluDiv() { MATCHER_SCOPE(HSigmoidFusionWithReluDiv); // Replaces a sub-graph ((min(Relu(x + 3), 6)) / 6 with a HSigmoid op. - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto add_constant = ov::pass::pattern::wrap_type(); auto add = ov::pass::pattern::wrap_type({input, add_constant}); auto relu = ov::pass::pattern::wrap_type({add}); @@ -74,7 +74,7 @@ ov::pass::HSigmoidFusionWithReluDiv::HSigmoidFusionWithReluDiv() { ov::pass::HSigmoidFusionWithReluMul::HSigmoidFusionWithReluMul() { MATCHER_SCOPE(HSigmoidFusionWithReluMul); // Replaces a sub-graph ((min(Relu(x + 3), 6)) * const(1/6) with a HSigmoid op. - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto add_constant = ov::pass::pattern::wrap_type(); auto add = ov::pass::pattern::wrap_type({input, add_constant}); auto relu = ov::pass::pattern::wrap_type({add}); @@ -121,7 +121,7 @@ ov::pass::HSigmoidFusionWithReluMul::HSigmoidFusionWithReluMul() { ov::pass::HSigmoidFusionWithoutRelu::HSigmoidFusionWithoutRelu() { MATCHER_SCOPE(HSigmoidFusionWithoutRelu); // Replaces a sub-graph (min(max(x + 3, 0), 6) / 6) with a HSigmoid op. - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto add_constant = ov::pass::pattern::wrap_type(); auto add = ov::pass::pattern::wrap_type({input, add_constant}); auto max_constant = ov::pass::pattern::wrap_type(); @@ -173,7 +173,7 @@ ov::pass::HSigmoidFusionWithoutRelu::HSigmoidFusionWithoutRelu() { ov::pass::HSigmoidFusionWithClampMul::HSigmoidFusionWithClampMul() { MATCHER_SCOPE(HSigmoidFusionWithClampMul); // Replaces a sub-graph (Clamp(x + 3, 0, 6) * const(1/6)) with a HSigmoid op. - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto add_constant = ov::pass::pattern::wrap_type(); auto add = ov::pass::pattern::wrap_type({input, add_constant}); auto clamp = ov::pass::pattern::wrap_type({add}); @@ -218,7 +218,7 @@ ov::pass::HSigmoidFusionWithClampMul::HSigmoidFusionWithClampMul() { ov::pass::HSigmoidFusionWithClampDiv::HSigmoidFusionWithClampDiv() { MATCHER_SCOPE(HSigmoidFusionWithClampDiv); // Replaces a sub-graph (Clamp(x + 3, 0, 6) / 6) with a HSigmoid op. - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto add_constant = ov::pass::pattern::wrap_type(); auto add = ov::pass::pattern::wrap_type({input, add_constant}); auto clamp = ov::pass::pattern::wrap_type({add}); diff --git a/src/common/transformations/src/transformations/common_optimizations/hswish_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/hswish_fusion.cpp index d746ef265d5da5..c36d8991b650b8 100644 --- a/src/common/transformations/src/transformations/common_optimizations/hswish_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/hswish_fusion.cpp @@ -24,7 +24,7 @@ ov::pass::HSwishFusionWithReluDiv::HSwishFusionWithReluDiv() { MATCHER_SCOPE(HSwishFusionWithReluDiv); // Replaces a sub-graph (x * (min(Relu(x + 3), 6)) / 6 with a HSwish op. - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto add_constant = ov::pass::pattern::wrap_type(); auto add = std::make_shared(input, add_constant); auto relu = std::make_shared(add); @@ -79,7 +79,7 @@ ov::pass::HSwishFusionWithReluDiv::HSwishFusionWithReluDiv() { ov::pass::HSwishFusionWithReluMul::HSwishFusionWithReluMul() { MATCHER_SCOPE(HSwishFusionWithReluMul); // Replaces a sub-graph (x * (min(Relu(x + 3), 6)) * const(1/6) with a HSwish op. - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto add_constant = ov::pass::pattern::wrap_type(); auto add = std::make_shared(input, add_constant); auto relu = std::make_shared(add); @@ -131,9 +131,9 @@ ov::pass::HSwishFusionWithReluMul::HSwishFusionWithReluMul() { ov::pass::HSwishFusionWithHSigmoid::HSwishFusionWithHSigmoid() { MATCHER_SCOPE(HSwishFusionWithHSigmoid); // Replaces a sub-graph x * HSigmoid(x) with a HSwish op. - auto input = pattern::any_input(); - auto hsigmoid_pattern = pattern::wrap_type({input}, pattern::consumers_count(1)); - auto mul_pattern = pattern::wrap_type({input, hsigmoid_pattern}); + auto input = ov::pass::pattern::any_input(); + auto hsigmoid_pattern = ov::pass::pattern::wrap_type({input}, ov::pass::pattern::consumers_count(1)); + auto mul_pattern = ov::pass::pattern::wrap_type({input, hsigmoid_pattern}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); @@ -154,7 +154,7 @@ ov::pass::HSwishFusionWithHSigmoid::HSwishFusionWithHSigmoid() { ov::pass::HSwishFusionWithClamp::HSwishFusionWithClamp() { MATCHER_SCOPE(HSwishFusionWithClampMul); // Replaces a sub-graph (Clamp(x + 3, 0, 6) * x) with a HSwish * 6. - const auto input = pass::pattern::any_input(); + const auto input = ov::pass::pattern::any_input(); const auto add_constant = ov::pass::pattern::wrap_type(); const auto add = ov::pass::pattern::wrap_type({input, add_constant}); const auto clamp = ov::pass::pattern::wrap_type({add}); diff --git a/src/common/transformations/src/transformations/common_optimizations/leaky_relu_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/leaky_relu_fusion.cpp index 61fb6dcbceb66d..84c0c8d73463ee 100644 --- a/src/common/transformations/src/transformations/common_optimizations/leaky_relu_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/leaky_relu_fusion.cpp @@ -18,13 +18,13 @@ ov::pass::LeakyReluFusion::LeakyReluFusion() { MATCHER_SCOPE(LeakyReluFusion); - auto data_pattern = pass::pattern::any_input(); - auto alpha_pattern = pass::pattern::wrap_type(); + auto data_pattern = ov::pass::pattern::any_input(); + auto alpha_pattern = ov::pass::pattern::wrap_type(); auto multiply_pattern = - ov::pass::pattern::wrap_type({data_pattern, alpha_pattern}, pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({data_pattern, alpha_pattern}, ov::pass::pattern::consumers_count(1)); auto max_pattern = ov::pass::pattern::wrap_type({data_pattern, multiply_pattern}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& original_alpha_pattern = pattern_map.at(alpha_pattern); diff --git a/src/common/transformations/src/transformations/common_optimizations/lin_op_sequence_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/lin_op_sequence_fusion.cpp index 45baa17c0cfe40..cdceecf22550ba 100644 --- a/src/common/transformations/src/transformations/common_optimizations/lin_op_sequence_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/lin_op_sequence_fusion.cpp @@ -20,7 +20,7 @@ using namespace ov; namespace { const auto is_eltwise_supported_type = [](const Output& output) -> bool { - const auto is_single_output = pass::pattern::consumers_count(1); + const auto is_single_output = ov::pass::pattern::consumers_count(1); return is_single_output(output) && output.get_node()->has_evaluate(); }; } // namespace @@ -28,9 +28,9 @@ const auto is_eltwise_supported_type = [](const Output& output) -> bool { ov::pass::AddMultiplyFusion::AddMultiplyFusion() { MATCHER_SCOPE(AddMultiplyFusion); // Create Add->Multiply pattern where Add has exactly one consumer - auto m_data = pass::pattern::any_input(); + auto m_data = ov::pass::pattern::any_input(); auto m_add_constant = ov::pass::pattern::wrap_type(); - auto m_add = ov::pass::pattern::wrap_type({m_data, m_add_constant}, pattern::consumers_count(1)); + auto m_add = ov::pass::pattern::wrap_type({m_data, m_add_constant}, ov::pass::pattern::consumers_count(1)); auto m_mul_constant = ov::pass::pattern::wrap_type(); auto m_mul = ov::pass::pattern::wrap_type({m_add, m_mul_constant}); @@ -75,9 +75,9 @@ ov::pass::AddMultiplyFusion::AddMultiplyFusion() { ov::pass::AddAddFusion::AddAddFusion() { MATCHER_SCOPE(AddAddFusion); // Create Add->Add pattern where first Add has exactly one consumer - auto m_data = pass::pattern::any_input(); + auto m_data = ov::pass::pattern::any_input(); auto m_add1_constant = ov::pass::pattern::wrap_type(); - auto m_add1 = ov::pass::pattern::wrap_type({m_data, m_add1_constant}, pattern::consumers_count(1)); + auto m_add1 = ov::pass::pattern::wrap_type({m_data, m_add1_constant}, ov::pass::pattern::consumers_count(1)); auto m_add2_constant = ov::pass::pattern::wrap_type(); auto m_add2 = ov::pass::pattern::wrap_type({m_add1, m_add2_constant}); @@ -109,7 +109,7 @@ ov::pass::AddAddFusion::AddAddFusion() { ov::pass::MultiplyMultiplyFusion::MultiplyMultiplyFusion() { MATCHER_SCOPE(MultiplyMultiplyFusion); // Create Multiply->Multiply pattern where first Multiply has exactly one consumer - auto m_data = pass::pattern::any_input(); + auto m_data = ov::pass::pattern::any_input(); auto m_mul1_constant = ov::pass::pattern::wrap_type(); auto m_mul1 = ov::pass::pattern::wrap_type({m_data, m_mul1_constant}, is_eltwise_supported_type); diff --git a/src/common/transformations/src/transformations/common_optimizations/lora_subgraph_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/lora_subgraph_fusion.cpp index 95b754062c13b8..bc68f81890471d 100644 --- a/src/common/transformations/src/transformations/common_optimizations/lora_subgraph_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/lora_subgraph_fusion.cpp @@ -23,29 +23,28 @@ ov::pass::LoraSubgraphFusion::LoraSubgraphFusion() { MATCHER_SCOPE(LoraSubgraphFusion); - using namespace pass::pattern; - auto lora_input_m = any_input(); - auto transpose_const1_m = wrap_type(consumers_count(1)); - auto transpose1_m = optional({lora_input_m, transpose_const1_m}, consumers_count(1)); +auto lora_input_m = ov::pass::pattern::any_input(); + auto transpose_const1_m = ov::pass::pattern::wrap_type(ov::pass::pattern::consumers_count(1)); + auto transpose1_m = ov::pass::pattern::optional({lora_input_m, transpose_const1_m}, ov::pass::pattern::consumers_count(1)); - auto read_value1_m = wrap_type(); - auto convert1_m = optional(read_value1_m, consumers_count(1)); - auto matmul1_m = wrap_type({transpose1_m, convert1_m}, consumers_count(1)); + auto read_value1_m = ov::pass::pattern::wrap_type(); + auto convert1_m = ov::pass::pattern::optional(read_value1_m, ov::pass::pattern::consumers_count(1)); + auto matmul1_m = ov::pass::pattern::wrap_type({transpose1_m, convert1_m}, ov::pass::pattern::consumers_count(1)); - auto read_value2_m = wrap_type(); - auto convert2_m = optional(read_value2_m, consumers_count(1)); - auto multiply_m = wrap_type({matmul1_m, convert2_m}, consumers_count(1)); + auto read_value2_m = ov::pass::pattern::wrap_type(); + auto convert2_m = ov::pass::pattern::optional(read_value2_m, ov::pass::pattern::consumers_count(1)); + auto multiply_m = ov::pass::pattern::wrap_type({matmul1_m, convert2_m}, ov::pass::pattern::consumers_count(1)); - auto read_value3_m = wrap_type(); - auto convert3_m = optional(read_value3_m, consumers_count(1)); - auto matmul2_m = wrap_type({multiply_m, convert3_m}, consumers_count(1)); + auto read_value3_m = ov::pass::pattern::wrap_type(); + auto convert3_m = ov::pass::pattern::optional(read_value3_m, ov::pass::pattern::consumers_count(1)); + auto matmul2_m = ov::pass::pattern::wrap_type({multiply_m, convert3_m}, ov::pass::pattern::consumers_count(1)); - auto transpose_const2_m = wrap_type(consumers_count(1)); - auto transpose2_m = optional({matmul2_m, transpose_const2_m}, consumers_count(1)); - auto main_flow_m = wrap_type({lora_input_m, any_input()}); - auto add_m = wrap_type({transpose2_m, main_flow_m}); + auto transpose_const2_m = ov::pass::pattern::wrap_type(ov::pass::pattern::consumers_count(1)); + auto transpose2_m = ov::pass::pattern::optional({matmul2_m, transpose_const2_m}, ov::pass::pattern::consumers_count(1)); + auto main_flow_m = ov::pass::pattern::wrap_type({lora_input_m, ov::pass::pattern::any_input()}); + auto add_m = ov::pass::pattern::wrap_type({transpose2_m, main_flow_m}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& lora_input = pattern_map.at(lora_input_m); const auto& matmul1 = pattern_map.at(matmul1_m); @@ -114,6 +113,6 @@ ov::pass::LoraSubgraphFusion::LoraSubgraphFusion() { return true; }; - auto m = std::make_shared(add_m, matcher_name); + auto m = std::make_shared(add_m, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/lstm_cell_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/lstm_cell_fusion.cpp index 96c9c9470ef9bb..d752ce353962cd 100644 --- a/src/common/transformations/src/transformations/common_optimizations/lstm_cell_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/lstm_cell_fusion.cpp @@ -41,21 +41,21 @@ void generate_gate_pattern(const std::shared_ptr& x, std::shared_ptr& bi, std::shared_ptr& x_by_wi, std::shared_ptr& h_by_ri) { - wi = pattern::any_input([](const Output& output) { - return pattern::has_static_shape()(output) && pattern::rank_equals(2)(output); + wi = ov::pass::pattern::any_input([](const Output& output) { + return ov::pass::pattern::has_static_shape()(output) && ov::pass::pattern::rank_equals(2)(output); }); - ri = pattern::any_input([](const Output& output) { - return pattern::has_static_shape()(output) && pattern::rank_equals(2)(output); + ri = ov::pass::pattern::any_input([](const Output& output) { + return ov::pass::pattern::has_static_shape()(output) && ov::pass::pattern::rank_equals(2)(output); }); - bi = pattern::any_input([](const Output& output) { - return pattern::has_static_shape()(output) && pattern::rank_equals(1)(output); + bi = ov::pass::pattern::any_input([](const Output& output) { + return ov::pass::pattern::has_static_shape()(output) && ov::pass::pattern::rank_equals(1)(output); }); - x_by_wi = pattern::wrap_type({x, wi}); - auto x_by_wi_biased = pattern::wrap_type({x_by_wi, bi}); - h_by_ri = pattern::wrap_type({h, ri}); - it = pattern::wrap_type({x_by_wi_biased, h_by_ri}); - it = pattern::wrap_type({it}); + x_by_wi = ov::pass::pattern::wrap_type({x, wi}); + auto x_by_wi_biased = ov::pass::pattern::wrap_type({x_by_wi, bi}); + h_by_ri = ov::pass::pattern::wrap_type({h, ri}); + it = ov::pass::pattern::wrap_type({x_by_wi_biased, h_by_ri}); + it = ov::pass::pattern::wrap_type({it}); } bool check_weights_format(const ov::Output& w, @@ -211,31 +211,31 @@ ov::Output prepare_weight_fico(const ov::Output& f, ov::pass::LSTMCellFusionWithJointWeights::LSTMCellFusionWithJointWeights() { MATCHER_SCOPE(LSTMCellFusionWithJointWeights); - auto x_label = pattern::any_input(pattern::rank_equals(2)); - auto h_label = pattern::any_input(pattern::rank_equals(2)); - auto concat_label = pattern::wrap_type({x_label, h_label}); - auto weights_label = pattern::any_input([](const Output& output) { - return pattern::has_static_shape()(output) && pattern::rank_equals(2)(output); + auto x_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2)); + auto h_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2)); + auto concat_label = ov::pass::pattern::wrap_type({x_label, h_label}); + auto weights_label = ov::pass::pattern::any_input([](const Output& output) { + return ov::pass::pattern::has_static_shape()(output) && ov::pass::pattern::rank_equals(2)(output); }); - auto matmul_label = pattern::wrap_type({concat_label, weights_label}); - auto bias_label = pattern::any_input(pattern::has_static_shape()); - auto bias_add_label = pattern::wrap_type({matmul_label, bias_label}); - auto axis_label = pattern::wrap_type(); - auto split_label = pattern::wrap_type({bias_add_label, axis_label}); - auto it_label = pattern::wrap_type({split_label}); - auto ct_label = pattern::wrap_type({split_label}); - auto ft_additional_bias_label = pattern::wrap_type(); - auto add_label = pattern::wrap_type({split_label, ft_additional_bias_label}); - auto ft_label = pattern::wrap_type({add_label}); - auto ot_label = pattern::wrap_type({split_label}); - auto mul_label = pattern::wrap_type({it_label, ct_label}); - auto c_label = pattern::any_input(); - auto mul1_label = pattern::wrap_type({ft_label, c_label}); - auto Co_label = pattern::wrap_type({mul_label, mul1_label}); - auto Co_activation_label = pattern::wrap_type({Co_label}); - auto Ho_label = pattern::wrap_type({Co_activation_label, ot_label}); - - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + auto matmul_label = ov::pass::pattern::wrap_type({concat_label, weights_label}); + auto bias_label = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); + auto bias_add_label = ov::pass::pattern::wrap_type({matmul_label, bias_label}); + auto axis_label = ov::pass::pattern::wrap_type(); + auto split_label = ov::pass::pattern::wrap_type({bias_add_label, axis_label}); + auto it_label = ov::pass::pattern::wrap_type({split_label}); + auto ct_label = ov::pass::pattern::wrap_type({split_label}); + auto ft_additional_bias_label = ov::pass::pattern::wrap_type(); + auto add_label = ov::pass::pattern::wrap_type({split_label, ft_additional_bias_label}); + auto ft_label = ov::pass::pattern::wrap_type({add_label}); + auto ot_label = ov::pass::pattern::wrap_type({split_label}); + auto mul_label = ov::pass::pattern::wrap_type({it_label, ct_label}); + auto c_label = ov::pass::pattern::any_input(); + auto mul1_label = ov::pass::pattern::wrap_type({ft_label, c_label}); + auto Co_label = ov::pass::pattern::wrap_type({mul_label, mul1_label}); + auto Co_activation_label = ov::pass::pattern::wrap_type({Co_label}); + auto Ho_label = ov::pass::pattern::wrap_type({Co_activation_label, ot_label}); + + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& X = pattern_map.at(x_label); @@ -443,7 +443,7 @@ ov::pass::LSTMCellFusionWithJointWeights::LSTMCellFusionWithJointWeights() { return true; }; - auto m = std::make_shared(Ho_label, matcher_name); + auto m = std::make_shared(Ho_label, matcher_name); this->register_matcher(m, callback); } @@ -533,9 +533,9 @@ ov::pass::LSTMCellFusionWithJointWeights::LSTMCellFusionWithJointWeights() { ov::pass::LSTMCellFusionWithSplitWeights::LSTMCellFusionWithSplitWeights() { MATCHER_SCOPE(LSTMCellFusionWithSplitWeights); - auto x_label = pattern::any_input(pattern::rank_equals(2)); - auto h_label = pattern::any_input(pattern::rank_equals(2)); - auto c_label = pattern::any_input(pattern::rank_equals(2)); + auto x_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2)); + auto h_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2)); + auto c_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2)); // it expects a pattern with split weights (input, recurrent and bias) for each gate std::shared_ptr it_label, wi_label, ri_label, bi_label, x_by_wi_label, h_by_ri_label; @@ -547,14 +547,14 @@ ov::pass::LSTMCellFusionWithSplitWeights::LSTMCellFusionWithSplitWeights() { std::shared_ptr c1t_label, wc_label, rc_label, bc_label, x_by_wc_label, h_by_rc_label; generate_gate_pattern(x_label, h_label, c1t_label, wc_label, rc_label, bc_label, x_by_wc_label, h_by_rc_label); - auto it_mul_c1t_label = pattern::wrap_type({it_label, c1t_label}); - auto ft_mul_c_label = pattern::wrap_type({ft_label, c_label}); - auto ct_label = pattern::wrap_type({ft_mul_c_label, it_mul_c1t_label}); + auto it_mul_c1t_label = ov::pass::pattern::wrap_type({it_label, c1t_label}); + auto ft_mul_c_label = ov::pass::pattern::wrap_type({ft_label, c_label}); + auto ct_label = ov::pass::pattern::wrap_type({ft_mul_c_label, it_mul_c1t_label}); - auto ct_activated_label = pattern::wrap_type({ct_label}); - auto ht_label = pattern::wrap_type({ct_activated_label, ot_label}); + auto ct_activated_label = ov::pass::pattern::wrap_type({ct_label}); + auto ht_label = ov::pass::pattern::wrap_type({ct_activated_label, ot_label}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { NodeRegistry rg; const auto& pattern_map = m.get_pattern_value_map(); @@ -645,6 +645,6 @@ ov::pass::LSTMCellFusionWithSplitWeights::LSTMCellFusionWithSplitWeights() { return true; }; - auto m = std::make_shared(ht_label, matcher_name); + auto m = std::make_shared(ht_label, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/mark_rope_input_to_keep_in_mixed_precision.cpp b/src/common/transformations/src/transformations/common_optimizations/mark_rope_input_to_keep_in_mixed_precision.cpp index ef0b4c83c32f72..219899ba279122 100644 --- a/src/common/transformations/src/transformations/common_optimizations/mark_rope_input_to_keep_in_mixed_precision.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/mark_rope_input_to_keep_in_mixed_precision.cpp @@ -17,10 +17,9 @@ ov::pass::MarkRopeInputsToKeepInMixedPrecision::MarkRopeInputsToKeepInMixedPrecision() { MATCHER_SCOPE(MarkRopeInputsToKeepInMixedPrecision); - using namespace ov::pass::pattern; - auto cos_tab = any_input(); - auto sin_tab = any_input(); - auto rope = wrap_type({any_input(), cos_tab, sin_tab}); +auto cos_tab = ov::pass::pattern::any_input(); + auto sin_tab = ov::pass::pattern::any_input(); + auto rope = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), cos_tab, sin_tab}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/matmul_const_transposes_extraction.cpp b/src/common/transformations/src/transformations/common_optimizations/matmul_const_transposes_extraction.cpp index 62522eeeb0b574..b72f1d58316cfe 100644 --- a/src/common/transformations/src/transformations/common_optimizations/matmul_const_transposes_extraction.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/matmul_const_transposes_extraction.cpp @@ -13,16 +13,16 @@ #include "openvino/pass/pattern/op/wrap_type.hpp" ov::pass::MatMulConstTransposesExtraction::MatMulConstTransposesExtraction() { - auto data_pattern = pattern::any_input(); + auto data_pattern = ov::pass::pattern::any_input(); auto weights_pattern = - pattern::wrap_type([](Output node) -> bool { + ov::pass::pattern::wrap_type([](Output node) -> bool { const auto& pshape = node.get_partial_shape(); const auto& rank = pshape.rank(); return rank.is_static() && rank.get_length() >= 2 && std::count(pshape.begin(), pshape.end(), 1) >= rank.get_length() - 2; }); - auto matmul_pattern = pattern::wrap_type({data_pattern, weights_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + auto matmul_pattern = ov::pass::pattern::wrap_type({data_pattern, weights_pattern}); + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); auto matmul = as_type(node.get()); if (!matmul || matmul->get_transpose_b()) @@ -47,6 +47,6 @@ ov::pass::MatMulConstTransposesExtraction::MatMulConstTransposesExtraction() { return true; }; - auto m = std::make_shared(matmul_pattern, "MatMulConstTransposesExtraction"); + auto m = std::make_shared(matmul_pattern, "MatMulConstTransposesExtraction"); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/matmul_experts_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/matmul_experts_fusion.cpp index 3448526540df2e..c7ad459122f596 100644 --- a/src/common/transformations/src/transformations/common_optimizations/matmul_experts_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/matmul_experts_fusion.cpp @@ -30,49 +30,49 @@ using namespace ov::pass; ov::pass::FuseVectorizedMOE2GEMM::FuseVectorizedMOE2GEMM() { MATCHER_SCOPE(FuseVectorizedMOE2GEMM); - auto experts_input = pattern::wrap_type({pattern::any_input(), pattern::any_input()}); - auto tile = pattern::wrap_type({experts_input, pattern::any_input()}); - auto after_tile_reshape = pattern::wrap_type({tile, pattern::any_input()}); - auto gate_up_matmul = pattern::wrap_type({after_tile_reshape, pattern::any_input()}, + auto experts_input = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto tile = ov::pass::pattern::wrap_type({experts_input, ov::pass::pattern::any_input()}); + auto after_tile_reshape = ov::pass::pattern::wrap_type({tile, ov::pass::pattern::any_input()}); + auto gate_up_matmul = ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, {{"transpose_a", false}, {"transpose_b", true}}); - auto gate_up_add = pattern::wrap_type({gate_up_matmul, pattern::any_input()}); + auto gate_up_add = ov::pass::pattern::wrap_type({gate_up_matmul, ov::pass::pattern::any_input()}); // Branch 1: Slice_1 -> Clamp -> Add_1 - auto slice1 = pattern::wrap_type( - {gate_up_add, pattern::any_input(), pattern::any_input(), pattern::any_input(), pattern::any_input()}); - auto clamp = pattern::wrap_type({slice1}); - auto add1 = pattern::wrap_type({clamp, pattern::wrap_const()}); + auto slice1 = ov::pass::pattern::wrap_type( + {gate_up_add, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto clamp = ov::pass::pattern::wrap_type({slice1}); + auto add1 = ov::pass::pattern::wrap_type({clamp, ov::pass::pattern::wrap_const()}); // Branch 2: Slice_2 -> Minimum_1 -> Swish - auto slice2 = pattern::wrap_type( - {gate_up_add, pattern::any_input(), pattern::any_input(), pattern::any_input(), pattern::any_input()}); - auto minimum1 = pattern::wrap_type({slice2, pattern::wrap_const()}); - auto swish_beta = pattern::wrap_const(); - auto swish = pattern::wrap_type({minimum1, swish_beta}); + auto slice2 = ov::pass::pattern::wrap_type( + {gate_up_add, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto minimum1 = ov::pass::pattern::wrap_type({slice2, ov::pass::pattern::wrap_const()}); + auto swish_beta = ov::pass::pattern::wrap_const(); + auto swish = ov::pass::pattern::wrap_type({minimum1, swish_beta}); // Join: Multiply_2 - auto multiply2 = pattern::wrap_type({add1, swish}); + auto multiply2 = ov::pass::pattern::wrap_type({add1, swish}); // Down projection - auto down_proj_matmul = pattern::wrap_type({multiply2, pattern::any_input()}, + auto down_proj_matmul = ov::pass::pattern::wrap_type({multiply2, ov::pass::pattern::any_input()}, {{"transpose_a", false}, {"transpose_b", true}}); - auto down_proj_add = pattern::wrap_type({down_proj_matmul, pattern::wrap_const()}); - auto end_reshape = pattern::wrap_type({down_proj_add, pattern::any_input()}); + auto down_proj_add = ov::pass::pattern::wrap_type({down_proj_matmul, ov::pass::pattern::wrap_const()}); + auto end_reshape = ov::pass::pattern::wrap_type({down_proj_add, ov::pass::pattern::any_input()}); // Routing weights/mask - auto router_topk_indices = pattern::any_input(); - auto scatter_elements_update = pattern::wrap_type( - {pattern::any_input(), router_topk_indices, pattern::any_input(), pattern::any_input()}); + auto router_topk_indices = ov::pass::pattern::any_input(); + auto scatter_elements_update = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), router_topk_indices, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - auto router_transpose = pattern::wrap_type({scatter_elements_update, pattern::any_input()}); - auto router_reshape = pattern::wrap_type({router_transpose, pattern::any_input()}); - auto unsqueeze_routing_weights = pattern::wrap_type({router_reshape, pattern::any_input()}); + auto router_transpose = ov::pass::pattern::wrap_type({scatter_elements_update, ov::pass::pattern::any_input()}); + auto router_reshape = ov::pass::pattern::wrap_type({router_transpose, ov::pass::pattern::any_input()}); + auto unsqueeze_routing_weights = ov::pass::pattern::wrap_type({router_reshape, ov::pass::pattern::any_input()}); - auto mul3 = pattern::wrap_type({end_reshape, unsqueeze_routing_weights}); - auto reduce_sum = pattern::wrap_type({mul3, pattern::any_input()}, {{"keep_dims", false}}); + auto mul3 = ov::pass::pattern::wrap_type({end_reshape, unsqueeze_routing_weights}); + auto reduce_sum = ov::pass::pattern::wrap_type({mul3, ov::pass::pattern::any_input()}, {{"keep_dims", false}}); auto moe_pattern = reduce_sum; - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& pm = m.get_pattern_value_map(); if (transformation_callback(m.get_match_root())) { @@ -120,45 +120,45 @@ ov::pass::FuseVectorizedMOE2GEMM::FuseVectorizedMOE2GEMM() { return true; }; - auto matcher = std::make_shared(moe_pattern, matcher_name); + auto matcher = std::make_shared(moe_pattern, matcher_name); this->register_matcher(matcher, callback); } ov::pass::FuseVectorizedMOE3GEMM::FuseVectorizedMOE3GEMM() { MATCHER_SCOPE(FuseVectorizedMOE3GEMM); - auto experts_input = pattern::wrap_type({pattern::any_input(), pattern::any_input()}); - auto tile = pattern::wrap_type({experts_input, pattern::any_input()}); - auto after_tile_reshape = pattern::wrap_type({tile, pattern::any_input()}); + auto experts_input = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto tile = ov::pass::pattern::wrap_type({experts_input, ov::pass::pattern::any_input()}); + auto after_tile_reshape = ov::pass::pattern::wrap_type({tile, ov::pass::pattern::any_input()}); // First GEMM (activation gate) - auto gate_matmul = pattern::wrap_type({after_tile_reshape, pattern::any_input()}, + auto gate_matmul = ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, {{"transpose_a", false}, {"transpose_b", true}}); - auto swish = pattern::wrap_type({gate_matmul}); + auto swish = ov::pass::pattern::wrap_type({gate_matmul}); // Second GEMM (up_projection) - auto up_matmul = pattern::wrap_type({after_tile_reshape, pattern::any_input()}, + auto up_matmul = ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, {{"transpose_a", false}, {"transpose_b", true}}); // Join: Multiply (SwiGLU) - auto swiglu = pattern::wrap_type({swish, up_matmul}); + auto swiglu = ov::pass::pattern::wrap_type({swish, up_matmul}); // Third GEMM (down_projection) - auto down_matmul = pattern::wrap_type({swiglu, pattern::any_input()}, + auto down_matmul = ov::pass::pattern::wrap_type({swiglu, ov::pass::pattern::any_input()}, {{"transpose_a", false}, {"transpose_b", true}}); - auto end_reshape = pattern::wrap_type({down_matmul, pattern::any_input()}); + auto end_reshape = ov::pass::pattern::wrap_type({down_matmul, ov::pass::pattern::any_input()}); // Routing weights/mask - auto router_topk_indices = pattern::any_input(); - auto scatter_elements_update = pattern::wrap_type( - {pattern::any_input(), router_topk_indices, pattern::any_input(), pattern::any_input()}); - auto router_transpose = pattern::wrap_type({scatter_elements_update, pattern::any_input()}); - auto router_reshape = pattern::wrap_type({router_transpose, pattern::any_input()}); - auto unsqueeze_routing_weights = pattern::wrap_type({router_reshape, pattern::any_input()}); - - auto mul3 = pattern::wrap_type({end_reshape, unsqueeze_routing_weights}); - auto reduce_sum = pattern::wrap_type({mul3, pattern::any_input()}, {{"keep_dims", false}}); + auto router_topk_indices = ov::pass::pattern::any_input(); + auto scatter_elements_update = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), router_topk_indices, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto router_transpose = ov::pass::pattern::wrap_type({scatter_elements_update, ov::pass::pattern::any_input()}); + auto router_reshape = ov::pass::pattern::wrap_type({router_transpose, ov::pass::pattern::any_input()}); + auto unsqueeze_routing_weights = ov::pass::pattern::wrap_type({router_reshape, ov::pass::pattern::any_input()}); + + auto mul3 = ov::pass::pattern::wrap_type({end_reshape, unsqueeze_routing_weights}); + auto reduce_sum = ov::pass::pattern::wrap_type({mul3, ov::pass::pattern::any_input()}, {{"keep_dims", false}}); auto moe_pattern = reduce_sum; - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& pm = m.get_pattern_value_map(); if (transformation_callback(m.get_match_root())) { @@ -202,6 +202,6 @@ ov::pass::FuseVectorizedMOE3GEMM::FuseVectorizedMOE3GEMM() { return true; }; - auto matcher = std::make_shared(moe_pattern, matcher_name); + auto matcher = std::make_shared(moe_pattern, matcher_name); this->register_matcher(matcher, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/matmul_multiply_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/matmul_multiply_fusion.cpp index 47c8ec40f27e7f..488546ad345698 100644 --- a/src/common/transformations/src/transformations/common_optimizations/matmul_multiply_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/matmul_multiply_fusion.cpp @@ -149,14 +149,14 @@ static std::shared_ptr fuse_const_to_weights(const std::shared_ptr& pass::MatMulMultiplyFusion::MatMulMultiplyFusion() { MATCHER_SCOPE(MatMulMultiplyFusion); - auto input_pattern = pattern::any_input(); - auto weights_pattern = pattern::any_input(pattern::has_static_rank()); - auto mul_const_pattern = pattern::wrap_type(); + auto input_pattern = ov::pass::pattern::any_input(); + auto weights_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto mul_const_pattern = ov::pass::pattern::wrap_type(); auto matmul_pattern = - pattern::wrap_type({input_pattern, weights_pattern}, pattern::consumers_count(1)); - auto mul_pattern = pattern::wrap_type({matmul_pattern, mul_const_pattern}); + ov::pass::pattern::wrap_type({input_pattern, weights_pattern}, ov::pass::pattern::consumers_count(1)); + auto mul_pattern = ov::pass::pattern::wrap_type({matmul_pattern, mul_const_pattern}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& weights = pattern_map.at(weights_pattern); auto mul = pattern_map.at(mul_pattern).get_node_shared_ptr(); @@ -188,6 +188,6 @@ pass::MatMulMultiplyFusion::MatMulMultiplyFusion() { return true; }; - auto m = std::make_shared(mul_pattern, matcher_name); + auto m = std::make_shared(mul_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/mish_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/mish_fusion.cpp index a73c368554ec3b..5ce16db8763d09 100644 --- a/src/common/transformations/src/transformations/common_optimizations/mish_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/mish_fusion.cpp @@ -21,7 +21,7 @@ ov::pass::MishFusion::MishFusion() { MATCHER_SCOPE(MishFusion); - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto exp = std::make_shared(input); auto add = std::make_shared(exp, ov::pass::pattern::wrap_type()); auto log = std::make_shared(add); diff --git a/src/common/transformations/src/transformations/common_optimizations/moe_transpose_weights.cpp b/src/common/transformations/src/transformations/common_optimizations/moe_transpose_weights.cpp index ce0cc1229c1521..0fdb544deda81b 100644 --- a/src/common/transformations/src/transformations/common_optimizations/moe_transpose_weights.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/moe_transpose_weights.cpp @@ -34,44 +34,44 @@ using namespace ov::pass; ov::pass::VectorizedMOE2GEMMTransposeWeights::VectorizedMOE2GEMMTransposeWeights() { MATCHER_SCOPE(VectorizedMOE2GEMMTransposeWeights); - auto experts_input = pattern::wrap_type({pattern::any_input(), pattern::any_input()}); - auto tile = pattern::wrap_type({experts_input, pattern::any_input()}); - auto after_tile_reshape = pattern::wrap_type({tile, pattern::any_input()}); - auto gate_up_matmul = pattern::wrap_type({after_tile_reshape, pattern::any_input()}, + auto experts_input = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto tile = ov::pass::pattern::wrap_type({experts_input, ov::pass::pattern::any_input()}); + auto after_tile_reshape = ov::pass::pattern::wrap_type({tile, ov::pass::pattern::any_input()}); + auto gate_up_matmul = ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, {{"transpose_a", false}, {"transpose_b", false}}); - auto gate_up_add = pattern::wrap_type({gate_up_matmul, pattern::any_input()}); + auto gate_up_add = ov::pass::pattern::wrap_type({gate_up_matmul, ov::pass::pattern::any_input()}); - auto slice1 = pattern::wrap_type( - {gate_up_add, pattern::any_input(), pattern::any_input(), pattern::any_input(), pattern::any_input()}); - auto clamp = pattern::wrap_type({slice1}); - auto add1 = pattern::wrap_type({clamp, pattern::wrap_const()}); + auto slice1 = ov::pass::pattern::wrap_type( + {gate_up_add, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto clamp = ov::pass::pattern::wrap_type({slice1}); + auto add1 = ov::pass::pattern::wrap_type({clamp, ov::pass::pattern::wrap_const()}); - auto slice2 = pattern::wrap_type( - {gate_up_add, pattern::any_input(), pattern::any_input(), pattern::any_input(), pattern::any_input()}); - auto minimum1 = pattern::wrap_type({slice2, pattern::wrap_const()}); - auto swish_beta = pattern::wrap_const(); - auto swish = pattern::wrap_type({minimum1, swish_beta}); + auto slice2 = ov::pass::pattern::wrap_type( + {gate_up_add, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto minimum1 = ov::pass::pattern::wrap_type({slice2, ov::pass::pattern::wrap_const()}); + auto swish_beta = ov::pass::pattern::wrap_const(); + auto swish = ov::pass::pattern::wrap_type({minimum1, swish_beta}); - auto multiply2 = pattern::wrap_type({add1, swish}); + auto multiply2 = ov::pass::pattern::wrap_type({add1, swish}); - auto down_proj_matmul = pattern::wrap_type({multiply2, pattern::any_input()}, + auto down_proj_matmul = ov::pass::pattern::wrap_type({multiply2, ov::pass::pattern::any_input()}, {{"transpose_a", false}, {"transpose_b", false}}); - auto down_proj_add = pattern::wrap_type({down_proj_matmul, pattern::wrap_const()}); - auto end_reshape = pattern::wrap_type({down_proj_add, pattern::any_input()}); + auto down_proj_add = ov::pass::pattern::wrap_type({down_proj_matmul, ov::pass::pattern::wrap_const()}); + auto end_reshape = ov::pass::pattern::wrap_type({down_proj_add, ov::pass::pattern::any_input()}); - auto router_topk_indices = pattern::any_input(); - auto scatter_elements_update = pattern::wrap_type( - {pattern::any_input(), router_topk_indices, pattern::any_input(), pattern::any_input()}); + auto router_topk_indices = ov::pass::pattern::any_input(); + auto scatter_elements_update = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), router_topk_indices, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - auto router_transpose = pattern::wrap_type({scatter_elements_update, pattern::any_input()}); - auto router_reshape = pattern::wrap_type({router_transpose, pattern::any_input()}); - auto unsqueeze_routing_weights = pattern::wrap_type({router_reshape, pattern::any_input()}); + auto router_transpose = ov::pass::pattern::wrap_type({scatter_elements_update, ov::pass::pattern::any_input()}); + auto router_reshape = ov::pass::pattern::wrap_type({router_transpose, ov::pass::pattern::any_input()}); + auto unsqueeze_routing_weights = ov::pass::pattern::wrap_type({router_reshape, ov::pass::pattern::any_input()}); - auto mul3 = pattern::wrap_type({end_reshape, unsqueeze_routing_weights}); - auto reduce_sum = pattern::wrap_type({mul3, pattern::any_input()}, {{"keep_dims", false}}); + auto mul3 = ov::pass::pattern::wrap_type({end_reshape, unsqueeze_routing_weights}); + auto reduce_sum = ov::pass::pattern::wrap_type({mul3, ov::pass::pattern::any_input()}, {{"keep_dims", false}}); auto moe_pattern = reduce_sum; - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& pm = m.get_pattern_value_map(); if (transformation_callback(m.get_match_root())) { return false; @@ -143,6 +143,6 @@ ov::pass::VectorizedMOE2GEMMTransposeWeights::VectorizedMOE2GEMMTransposeWeights return true; }; - auto matcher = std::make_shared(moe_pattern, matcher_name); + auto matcher = std::make_shared(moe_pattern, matcher_name); this->register_matcher(matcher, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/move_eltwise_up_data_movement.cpp b/src/common/transformations/src/transformations/common_optimizations/move_eltwise_up_data_movement.cpp index ddfd2f9fc63117..dd113daf73420a 100644 --- a/src/common/transformations/src/transformations/common_optimizations/move_eltwise_up_data_movement.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/move_eltwise_up_data_movement.cpp @@ -179,7 +179,7 @@ ov::pass::MoveEltwiseUpThroughDataMovPerChannel::MoveEltwiseUpThroughDataMovPerC auto eltw_data_flow_in = ov::pass::pattern::wrap_type( - pattern::consumers_count(1)); + ov::pass::pattern::consumers_count(1)); auto eltw_const_in = ov::pass::pattern::wrap_type(const_predicate); auto eltwise_pattern = ov::pass::pattern::wrap_type({eltw_data_flow_in, eltw_const_in}, diff --git a/src/common/transformations/src/transformations/common_optimizations/mul_conv_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/mul_conv_fusion.cpp index 2a4a7fc1ade7b3..1aaba9072670d6 100644 --- a/src/common/transformations/src/transformations/common_optimizations/mul_conv_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/mul_conv_fusion.cpp @@ -22,14 +22,14 @@ ov::pass::MultiplyConvolutionFusion::MultiplyConvolutionFusion() { MATCHER_SCOPE(MultiplyConvolutionFusion); - auto input_pattern = pattern::any_input(pattern::has_static_rank()); + auto input_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); auto mul_const_pattern = ov::pass::pattern::wrap_type(); auto mul_pattern = ov::pass::pattern::wrap_type({input_pattern, mul_const_pattern}, - pattern::consumers_count(1)); - auto weights_pattern = pass::pattern::any_input(pattern::has_static_shape()); + ov::pass::pattern::consumers_count(1)); + auto weights_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); auto conv_pattern = ov::pass::pattern::wrap_type({mul_pattern, weights_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); // Can't fuse Multiply to Convolution if that Multiply is part of dequantization subgraph @@ -82,14 +82,14 @@ ov::pass::MultiplyConvolutionFusion::MultiplyConvolutionFusion() { ov::pass::MultiplyGroupConvolutionFusion::MultiplyGroupConvolutionFusion() { MATCHER_SCOPE(MultiplyGroupConvolutionFusion); - auto input_pattern = pattern::any_input(); + auto input_pattern = ov::pass::pattern::any_input(); auto mul_const_pattern = ov::pass::pattern::wrap_type(); auto mul_pattern = ov::pass::pattern::wrap_type({input_pattern, mul_const_pattern}, - pattern::consumers_count(1)); - auto weights_pattern = pass::pattern::any_input(pattern::has_static_shape()); + ov::pass::pattern::consumers_count(1)); + auto weights_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); auto conv_pattern = ov::pass::pattern::wrap_type({mul_pattern, weights_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); // Can't fuse Multiply to Convolution if that Multiply is part of dequantization subgraph @@ -157,15 +157,15 @@ ov::pass::MultiplyGroupConvolutionFusion::MultiplyGroupConvolutionFusion() { ov::pass::MultiplyConvolutionBackpropDataFusion::MultiplyConvolutionBackpropDataFusion() { MATCHER_SCOPE(MultiplyConvolutionBackpropDataFusion); - auto input_pattern = pattern::any_input(); + auto input_pattern = ov::pass::pattern::any_input(); auto mul_const_pattern = ov::pass::pattern::wrap_type(); auto mul_pattern = ov::pass::pattern::wrap_type({input_pattern, mul_const_pattern}, - pattern::consumers_count(1)); - auto weights_pattern = pass::pattern::any_input(pattern::has_static_shape()); + ov::pass::pattern::consumers_count(1)); + auto weights_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); auto conv_pattern = ov::pass::pattern::wrap_type({mul_pattern, weights_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); // Can't fuse Multiply to Convolution if that Multiply is part of dequantization subgraph @@ -234,15 +234,15 @@ ov::pass::MultiplyConvolutionBackpropDataFusion::MultiplyConvolutionBackpropData ov::pass::MultiplyGroupConvolutionBackpropDataFusion::MultiplyGroupConvolutionBackpropDataFusion() { MATCHER_SCOPE(MultiplyGroupConvolutionBackpropDataFusion); - auto input_pattern = pattern::any_input(); + auto input_pattern = ov::pass::pattern::any_input(); auto mul_const_pattern = ov::pass::pattern::wrap_type(); auto mul_pattern = ov::pass::pattern::wrap_type({input_pattern, mul_const_pattern}, - pattern::consumers_count(1)); - auto weights_pattern = pass::pattern::any_input(pattern::has_static_shape()); + ov::pass::pattern::consumers_count(1)); + auto weights_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); auto conv_pattern = ov::pass::pattern::wrap_type({mul_pattern, weights_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); // Can't fuse Multiply to Convolution if that Multiply is part of dequantization subgraph diff --git a/src/common/transformations/src/transformations/common_optimizations/mul_fake_quantize_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/mul_fake_quantize_fusion.cpp index fe0511e1df7882..0ad70c126499db 100644 --- a/src/common/transformations/src/transformations/common_optimizations/mul_fake_quantize_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/mul_fake_quantize_fusion.cpp @@ -22,16 +22,16 @@ ov::pass::MulFakeQuantizeFusion::MulFakeQuantizeFusion() { MATCHER_SCOPE(MulFakeQuantizeFusion); - auto input_pattern = pass::pattern::any_input(); + auto input_pattern = ov::pass::pattern::any_input(); auto const_pattern = ov::pass::pattern::wrap_type(); auto mul_pattern = - ov::pass::pattern::wrap_type({input_pattern, const_pattern}, pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({input_pattern, const_pattern}, ov::pass::pattern::consumers_count(1)); auto fq_pattern = ov::pass::pattern::wrap_type({mul_pattern, - pass::pattern::any_input(), - pass::pattern::any_input(), - pass::pattern::any_input(), - pass::pattern::any_input()}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_value_map = m.get_pattern_value_map(); const auto& input = pattern_value_map.at(input_pattern); const auto& type = input.get_element_type(); diff --git a/src/common/transformations/src/transformations/common_optimizations/mvn_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/mvn_fusion.cpp index 9d3096abf99b73..c1700b05024311 100644 --- a/src/common/transformations/src/transformations/common_optimizations/mvn_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/mvn_fusion.cpp @@ -41,74 +41,74 @@ ov::pass::MVNFusionWithoutConstants::MVNFusionWithoutConstants() { MATCHER_SCOPE(MVNFusionWithoutConstants); // Detect MVN decomposition pattern: // (x - ReduceMean(x, axes)) / (Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2)) + eps) - auto x = pattern::any_input(); + auto x = ov::pass::pattern::any_input(); // (x - ReduceMean(x, axes)) // `------mean1-------' - auto mean1_axes = pattern::wrap_type(); - auto mean1 = pattern::wrap_type({x, mean1_axes}); + auto mean1_axes = ov::pass::pattern::wrap_type(); + auto mean1 = ov::pass::pattern::wrap_type({x, mean1_axes}); // (x - ReduceMean(x, axes)) // `-sub1------------------' - auto sub1 = pattern::wrap_type({x, mean1}); + auto sub1 = ov::pass::pattern::wrap_type({x, mean1}); // Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2)) // `---mean2----------' - auto mean2_axes = pattern::wrap_type(); - auto mean2 = pattern::wrap_type({x, mean2_axes}); + auto mean2_axes = ov::pass::pattern::wrap_type(); + auto mean2 = ov::pass::pattern::wrap_type({x, mean2_axes}); // Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2)) // `-sub2------------------' - auto sub2 = pattern::wrap_type({x, mean2}); + auto sub2 = ov::pass::pattern::wrap_type({x, mean2}); - const auto reuseSub1OrNot = std::make_shared(OutputVector{sub1, sub2}); - const auto optionalConvert = pattern::optional(reuseSub1OrNot); + const auto reuseSub1OrNot = std::make_shared(OutputVector{sub1, sub2}); + const auto optionalConvert = ov::pass::pattern::optional(reuseSub1OrNot); // Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2)) // `---------------------power--' - auto const_2 = pattern::wrap_type(value_is_equal_to({2.0})); - auto power = pattern::wrap_type({optionalConvert, const_2}); + auto const_2 = ov::pass::pattern::wrap_type(value_is_equal_to({2.0})); + auto power = ov::pass::pattern::wrap_type({optionalConvert, const_2}); // Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2)) // `---mean3--------------------------------' - auto mean3_axes = pattern::wrap_type(); - auto mean3 = pattern::wrap_type({power, mean3_axes}); + auto mean3_axes = ov::pass::pattern::wrap_type(); + auto mean3 = ov::pass::pattern::wrap_type({power, mean3_axes}); - auto const_0_5 = pattern::wrap_type(value_is_equal_to({0.5})); - auto eps = pattern::wrap_type(); + auto const_0_5 = ov::pass::pattern::wrap_type(value_is_equal_to({0.5})); + auto eps = ov::pass::pattern::wrap_type(); // ------------------- OUTSIDE_SQRT ---------------------- // Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2)) // `--Power--------------------------------------' - auto power_sqrt_os = pattern::wrap_type({mean3, const_0_5}); - auto sqrt_os = pattern::wrap_type({mean3}); - const auto powerOrSqrt_os = std::make_shared(OutputVector{power_sqrt_os, sqrt_os}); + auto power_sqrt_os = ov::pass::pattern::wrap_type({mean3, const_0_5}); + auto sqrt_os = ov::pass::pattern::wrap_type({mean3}); + const auto powerOrSqrt_os = std::make_shared(OutputVector{power_sqrt_os, sqrt_os}); // Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2)) + eps // `----------------------------------------------Add---' - auto add_eps_os = pattern::wrap_type({powerOrSqrt_os, eps}); + auto add_eps_os = ov::pass::pattern::wrap_type({powerOrSqrt_os, eps}); // ------------------- INSIDE_SQRT ---------------------- // (Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps)) // `-----------------------------------------------Add---' - auto add_eps_is = pattern::wrap_type({mean3, eps}); + auto add_eps_is = ov::pass::pattern::wrap_type({mean3, eps}); // Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2)) // `--Power--------------------------------------' - auto power_sqrt_is = pattern::wrap_type({add_eps_is, const_0_5}); - auto sqrt_is = pattern::wrap_type({add_eps_is}); - const auto powerOrSqrt_is = std::make_shared(OutputVector{power_sqrt_is, sqrt_is}); + auto power_sqrt_is = ov::pass::pattern::wrap_type({add_eps_is, const_0_5}); + auto sqrt_is = ov::pass::pattern::wrap_type({add_eps_is}); + const auto powerOrSqrt_is = std::make_shared(OutputVector{power_sqrt_is, sqrt_is}); - auto outsideOrInside = std::make_shared(OutputVector{add_eps_os, powerOrSqrt_is}); + auto outsideOrInside = std::make_shared(OutputVector{add_eps_os, powerOrSqrt_is}); // Final Divide - auto const_neg_1 = pattern::wrap_type(value_is_equal_to({-1})); - auto power_div = pattern::wrap_type({outsideOrInside, const_neg_1}); - auto div = pattern::wrap_type({sub1, power_div}); + auto const_neg_1 = ov::pass::pattern::wrap_type(value_is_equal_to({-1})); + auto power_div = ov::pass::pattern::wrap_type({outsideOrInside, const_neg_1}); + auto div = ov::pass::pattern::wrap_type({sub1, power_div}); - auto div_alt = pattern::wrap_type({sub1, outsideOrInside}); - const auto powerMulOrDiv = std::make_shared(OutputVector{div, div_alt}); + auto div_alt = ov::pass::pattern::wrap_type({sub1, outsideOrInside}); + const auto powerMulOrDiv = std::make_shared(OutputVector{div, div_alt}); ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { auto& pattern_to_output = m.get_pattern_value_map(); @@ -205,55 +205,55 @@ ov::pass::MVNFusionWithConstantsInside::MVNFusionWithConstantsInside() { MATCHER_SCOPE(MVNFusionWithConstantsInside); // Detect MVN decomposition pattern: // (x - ReduceMean(x, axes)) * gamma / (Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2)) + eps) + beta - auto x = pattern::any_input(); + auto x = ov::pass::pattern::any_input(); // (x - ReduceMean(x, axes))^2 // `------mean1-------' - auto mean1_axes = pattern::wrap_type(); - auto mean1 = pattern::wrap_type({x, mean1_axes}); + auto mean1_axes = ov::pass::pattern::wrap_type(); + auto mean1 = ov::pass::pattern::wrap_type({x, mean1_axes}); // (x - ReduceMean(x, axes))^2 // `-squared_difference------' - auto squared_difference = pattern::wrap_type({x, mean1}); + auto squared_difference = ov::pass::pattern::wrap_type({x, mean1}); // 1 / Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps) // `---mean2--------------------------------' - auto mean2_axes = pattern::wrap_type(); - auto mean2 = pattern::wrap_type({squared_difference, mean2_axes}); + auto mean2_axes = ov::pass::pattern::wrap_type(); + auto mean2 = ov::pass::pattern::wrap_type({squared_difference, mean2_axes}); // 1 / Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps) // `------------------------------------------add--' - auto eps = pattern::wrap_type(); - auto add_eps = pattern::wrap_type({mean2, eps}); + auto eps = ov::pass::pattern::wrap_type(); + auto add_eps = ov::pass::pattern::wrap_type({mean2, eps}); // 1 / Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps) // `-power-------------------------------------------------' - auto const_0_5 = pattern::wrap_type(value_is_equal_to({-0.5})); - auto power = pattern::wrap_type({add_eps, const_0_5}); + auto const_0_5 = ov::pass::pattern::wrap_type(value_is_equal_to({-0.5})); + auto power = ov::pass::pattern::wrap_type({add_eps, const_0_5}); // gamma / Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps) // `---mul1----------------------------------------------------' - auto gamma = pattern::wrap_type(); - auto mul1 = pattern::wrap_type({power, gamma}); + auto gamma = ov::pass::pattern::wrap_type(); + auto mul1 = ov::pass::pattern::wrap_type({power, gamma}); // x * gamma / Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps) // `---mul2--------------------------------------------------------' - auto mul2 = pattern::wrap_type({x, mul1}); + auto mul2 = ov::pass::pattern::wrap_type({x, mul1}); // ReduceMean(x, axes) * gamma / Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps) - beta // `-------------------mul3----------------------------------------------------------' - auto mul3 = pattern::wrap_type({mul1, mean1}); + auto mul3 = ov::pass::pattern::wrap_type({mul1, mean1}); // beta - ReduceMean(x, axes) * gamma / Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps) // `---sub-----------------------------------------------------------------------------------' - auto beta = pattern::wrap_type(); - auto sub = pattern::wrap_type({beta, mul3}); + auto beta = ov::pass::pattern::wrap_type(); + auto sub = ov::pass::pattern::wrap_type({beta, mul3}); // Final Add // x * gamma / Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps) + // beta - ReduceMean(x, axes) * gamma / Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps) = // gamma * (x - ReduceMean(x, axes)) / Sqrt(ReduceMean((x - ReduceMean(x, axes)) ^ 2) + eps) + beta - auto add = pattern::wrap_type({mul2, sub}); + auto add = ov::pass::pattern::wrap_type({mul2, sub}); ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { auto& pattern_to_output = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/nearest_neighbor_upsampling_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/nearest_neighbor_upsampling_fusion.cpp index 2adf098bea63dd..0ee7753acdfba3 100644 --- a/src/common/transformations/src/transformations/common_optimizations/nearest_neighbor_upsampling_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/nearest_neighbor_upsampling_fusion.cpp @@ -274,13 +274,13 @@ ov::pass::NearestNeighborUpsamplingFusion::NearestNeighborUpsamplingFusion() { // 4) 'axes' input as a constant with the value [1, 2, ..., r - 2]. // // Of course, the replacement shouldn't be done, if all S_i are equal to 1. - auto input = pass::pattern::any_input(pattern::has_static_shape()); - auto concat_1 = pattern::wrap_type(); - auto concat_2 = pattern::wrap_type(); - auto reshape_1 = pattern::wrap_type({input, concat_1}); - auto mul_const = pattern::wrap_type(pattern::has_static_shape()); - auto mul = pattern::wrap_type({reshape_1, mul_const}); - auto reshape_2 = pattern::wrap_type({mul, concat_2}); + auto input = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); + auto concat_1 = ov::pass::pattern::wrap_type(); + auto concat_2 = ov::pass::pattern::wrap_type(); + auto reshape_1 = ov::pass::pattern::wrap_type({input, concat_1}); + auto mul_const = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_shape()); + auto mul = ov::pass::pattern::wrap_type({reshape_1, mul_const}); + auto reshape_2 = ov::pass::pattern::wrap_type({mul, concat_2}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/nonzero_horizontal_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/nonzero_horizontal_fusion.cpp index 9c7c27f6b8db00..29fb677381480d 100644 --- a/src/common/transformations/src/transformations/common_optimizations/nonzero_horizontal_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/nonzero_horizontal_fusion.cpp @@ -15,8 +15,8 @@ ov::pass::NonZeroHorizontalFusion::NonZeroHorizontalFusion() { MATCHER_SCOPE(NonZeroHorizontalFusion); - auto input_m = pass::pattern::any_input(ov::pass::pattern::consumers_more_than(1)); - auto nonzero_m = pass::pattern::wrap_type({input_m}); + auto input_m = ov::pass::pattern::any_input(ov::pass::pattern::consumers_more_than(1)); + auto nonzero_m = ov::pass::pattern::wrap_type({input_m}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp b/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp index 6f8305267e6c8f..df444c8bb8bf75 100644 --- a/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp @@ -375,14 +375,13 @@ SIMPLE_MATCHER_PASS_DEFINITION(EliminateGather, pass::EliminateReduceReshape::EliminateReduceReshape() { MATCHER_SCOPE(EliminateReduceReshape); - using namespace pass::pattern; - auto axes = wrap_type(); - auto reduce_pattern = wrap_type({any_input(), axes}); - auto requested_shape_pattern = wrap_type(); +auto axes = ov::pass::pattern::wrap_type(); + auto reduce_pattern = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), axes}); + auto requested_shape_pattern = ov::pass::pattern::wrap_type(); auto reshape_pattern = - wrap_type({reduce_pattern, requested_shape_pattern}, consumers_count(1)); + ov::pass::pattern::wrap_type({reduce_pattern, requested_shape_pattern}, ov::pass::pattern::consumers_count(1)); - matcher_pass_callback callback = [=](Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_map(); auto reshape_node = m.get_match_root(); auto reduce_node = pattern_map.at(reduce_pattern); @@ -422,15 +421,15 @@ pass::EliminateReduceReshape::EliminateReduceReshape() { } }; - auto m = make_shared(reshape_pattern, matcher_name); + auto m = make_shared(reshape_pattern, matcher_name); this->register_matcher(m, callback); } pass::EliminatePad::EliminatePad() { MATCHER_SCOPE(EliminatePad); - auto pad_node_pattern = pattern::wrap_type(); + auto pad_node_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto pad = m.get_match_root(); auto pad_begin_const = ov::util::get_constant_from_source(pad->input_value(1)); @@ -457,15 +456,15 @@ pass::EliminatePad::EliminatePad() { return replace_output_update_name(pad->output(0), pad->input_value(0)); }; - auto m = make_shared(pad_node_pattern, matcher_name); + auto m = make_shared(pad_node_pattern, matcher_name); this->register_matcher(m, callback); } pass::EliminateConvert::EliminateConvert() { MATCHER_SCOPE(EliminateConvert); - auto convert_pattern = pattern::wrap_type(); + auto convert_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto convert = ov::as_type_ptr(m.get_match_root()); if (!convert) { return false; @@ -476,17 +475,17 @@ pass::EliminateConvert::EliminateConvert() { return false; }; - auto m = make_shared(convert_pattern, matcher_name); + auto m = make_shared(convert_pattern, matcher_name); this->register_matcher(m, callback); } pass::EliminateIdentityConvert::EliminateIdentityConvert() { MATCHER_SCOPE(EliminateIdentityConvert); - auto convert_pattern = pattern::wrap_type(); - auto convert_identity_pattern = pattern::wrap_type(convert_pattern); - auto convert_identity_convert_pattern = pattern::wrap_type(convert_identity_pattern); + auto convert_pattern = ov::pass::pattern::wrap_type(); + auto convert_identity_pattern = ov::pass::pattern::wrap_type(convert_pattern); + auto convert_identity_convert_pattern = ov::pass::pattern::wrap_type(convert_identity_pattern); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); auto convert_begin = pattern_map.at(convert_pattern); auto identity = pattern_map.at(convert_identity_pattern); @@ -500,16 +499,16 @@ pass::EliminateIdentityConvert::EliminateIdentityConvert() { } return false; }; - auto m = make_shared(convert_identity_convert_pattern, matcher_name); + auto m = make_shared(convert_identity_convert_pattern, matcher_name); this->register_matcher(m, callback); } pass::EliminateConvertNonZero::EliminateConvertNonZero() { MATCHER_SCOPE(EliminateConvertNonZero); - auto convert_pattern = pattern::wrap_type(pattern::consumers_count(1)); - auto non_zero = pattern::wrap_type({convert_pattern}); + auto convert_pattern = ov::pass::pattern::wrap_type(ov::pass::pattern::consumers_count(1)); + auto non_zero = ov::pass::pattern::wrap_type({convert_pattern}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); auto convert = pattern_map.at(convert_pattern); // remove convert @@ -519,15 +518,15 @@ pass::EliminateConvertNonZero::EliminateConvertNonZero() { return true; }; - auto m = make_shared(non_zero, matcher_name); + auto m = make_shared(non_zero, matcher_name); this->register_matcher(m, callback); } pass::EliminateConcat::EliminateConcat() { MATCHER_SCOPE(EliminateConcat); - auto convert_pattern = pattern::wrap_type(); + auto convert_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto concat = m.get_match_root(); if (concat->inputs().size() == 1) { return replace_output_update_name(concat->output(0), concat->input_value(0)); @@ -535,15 +534,15 @@ pass::EliminateConcat::EliminateConcat() { return false; }; - auto m = make_shared(convert_pattern, matcher_name); + auto m = make_shared(convert_pattern, matcher_name); this->register_matcher(m, callback); } pass::EliminateConcatStridedSlice::EliminateConcatStridedSlice() { using node_index_info_map = std::vector, int64_t, int64_t>>; MATCHER_SCOPE(EliminateConcatStridedSlice); - auto pattern_concat = pattern::wrap_type(ov::pass::pattern::has_static_rank()); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + auto pattern_concat = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_rank()); + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); const auto concat = ov::as_type_ptr(pattern_map.at(pattern_concat)); if (concat->is_dynamic()) @@ -733,15 +732,15 @@ pass::EliminateConcatStridedSlice::EliminateConcatStridedSlice() { return true; }; - auto m = make_shared(pattern_concat, matcher_name); + auto m = make_shared(pattern_concat, matcher_name); this->register_matcher(m, callback); } pass::EliminateSplit::EliminateSplit() { MATCHER_SCOPE(EliminateSplit); - auto convert_pattern = pattern::wrap_type(); + auto convert_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto split = ov::as_type_ptr(m.get_match_root()); if (!split || split->get_num_splits() != 1) { return false; @@ -749,26 +748,26 @@ pass::EliminateSplit::EliminateSplit() { return replace_output_update_name(split->output(0), split->input_value(0)); }; - auto m = make_shared(convert_pattern, matcher_name); + auto m = make_shared(convert_pattern, matcher_name); this->register_matcher(m, callback); } pass::EliminateUnsqueeze::EliminateUnsqueeze() { MATCHER_SCOPE(EliminateUnsqueeze); - auto unsqueeze_pattern = pattern::wrap_type(); + auto unsqueeze_pattern = ov::pass::pattern::wrap_type(); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { return eliminate_unsqueeze(m.get_match_root()); }; - auto m = make_shared(unsqueeze_pattern, matcher_name); + auto m = make_shared(unsqueeze_pattern, matcher_name); this->register_matcher(m, callback); } pass::EliminateSqueeze::EliminateSqueeze() { MATCHER_SCOPE(EliminateSqueeze); - auto squeeze_pattern = pattern::wrap_type(); + auto squeeze_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { const auto node = m.get_match_root(); auto out_shape = node->get_output_partial_shape(0); // try to replace all unsqueeze/squeeze with reshape @@ -843,15 +842,15 @@ pass::EliminateSqueeze::EliminateSqueeze() { return false; }; - auto m = make_shared(squeeze_pattern, matcher_name); + auto m = make_shared(squeeze_pattern, matcher_name); this->register_matcher(m, callback); } pass::EliminateIdentity::EliminateIdentity() { MATCHER_SCOPE(EliminateIdentity); - auto identity_pattern = pattern::wrap_type(); + auto identity_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto identity = ov::as_type_ptr(m.get_match_root()); if (!identity) { return false; @@ -859,7 +858,7 @@ pass::EliminateIdentity::EliminateIdentity() { return replace_output_update_name(identity->output(0), identity->input_value(0)); }; - auto m = make_shared(identity_pattern, matcher_name); + auto m = make_shared(identity_pattern, matcher_name); this->register_matcher(m, callback); } @@ -1025,8 +1024,8 @@ shared_ptr check_all_inputs(const shared_ptr& concat) { ov::pass::EliminateSplitConcat::EliminateSplitConcat() { MATCHER_SCOPE(EliminateSplitConcat); - auto pattern_concat = pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + auto pattern_concat = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); const auto concat = ov::as_type_ptr(pattern_map.at(pattern_concat)); if (!concat) { @@ -1044,16 +1043,16 @@ ov::pass::EliminateSplitConcat::EliminateSplitConcat() { return replace_output_update_name(concat->output(0), split->input_value(0)); }; - auto m = make_shared(pattern_concat, matcher_name); + auto m = make_shared(pattern_concat, matcher_name); this->register_matcher(m, callback); } pass::EliminateTranspose::EliminateTranspose() { MATCHER_SCOPE(EliminateTranspose); - auto order = pattern::wrap_type(); - auto transpose_pattern = pattern::wrap_type({pattern::any_input(), order}); + auto order = ov::pass::pattern::wrap_type(); + auto transpose_pattern = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), order}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); auto order_const = ov::as_type_ptr(pattern_map.at(order)); if (!order_const) { @@ -1075,22 +1074,22 @@ pass::EliminateTranspose::EliminateTranspose() { return replace_output_update_name(transpose->output(0), transpose->input_value(0)); }; - auto m = make_shared(transpose_pattern, matcher_name); + auto m = make_shared(transpose_pattern, matcher_name); this->register_matcher(m, callback); } pass::EliminateEltwise::EliminateEltwise() { MATCHER_SCOPE(EliminateEltwise); - auto input = pattern::any_input(); - auto constant_pattern = pattern::wrap_type(); + auto input = ov::pass::pattern::any_input(); + auto constant_pattern = ov::pass::pattern::wrap_type(); auto eltwise_pattern = - pattern::wrap_type( + ov::pass::pattern::wrap_type( {input, constant_pattern}); auto subtract_pattern = - pattern::wrap_type({input, pattern::wrap_type({constant_pattern})}); - auto root = make_shared(OutputVector{eltwise_pattern, subtract_pattern}); + ov::pass::pattern::wrap_type({input, ov::pass::pattern::wrap_type({constant_pattern})}); + auto root = make_shared(OutputVector{eltwise_pattern, subtract_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto eltwise = m.get_match_root(); const auto& non_const_input = pattern_map.at(input); @@ -1102,18 +1101,18 @@ pass::EliminateEltwise::EliminateEltwise() { return replace_output_update_name(eltwise->output(0), non_const_input); }; - auto m = make_shared(root, matcher_name); + auto m = make_shared(root, matcher_name); this->register_matcher(m, callback); } pass::EliminateScatterUpdate::EliminateScatterUpdate() { MATCHER_SCOPE(EliminateScatterUpdate); - auto scatter_pattern = pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto scatter = m.get_match_root(); const auto& indices_pshape = scatter->get_input_partial_shape(1); const auto& updates_pshape = scatter->get_input_partial_shape(2); @@ -1128,36 +1127,36 @@ pass::EliminateScatterUpdate::EliminateScatterUpdate() { } }; - auto m = make_shared(scatter_pattern, matcher_name); + auto m = make_shared(scatter_pattern, matcher_name); this->register_matcher(m, callback); } ov::pass::EliminateNopBroadcast::EliminateNopBroadcast() { MATCHER_SCOPE(EliminateNopBroadcast); - auto root = pattern::wrap_type( + auto root = ov::pass::pattern::wrap_type( [](std::shared_ptr node) { auto input_rank = node->get_input_partial_shape(0).rank(); auto output_rank = node->get_output_partial_shape(0).rank(); return input_rank.is_static() && output_rank.is_static() && input_rank == output_rank; }); - ov::matcher_pass_callback matcher_pass_callback = [](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [](ov::pass::pattern::Matcher& m) { const auto& op = m.get_match_root(); if (ov::op::util::is_constant_and_all_values_equal_int(op->input_value(1), 1)) return replace_output_update_name(op->output(0), op->input_value(0)); return false; }; - auto m = std::make_shared(root, matcher_name); + auto m = std::make_shared(root, matcher_name); register_matcher(m, matcher_pass_callback); } ov::pass::EliminateSliceBeforeGatherElements::EliminateSliceBeforeGatherElements() { MATCHER_SCOPE(EliminateSliceBeforeGatherElements); - auto slice = pattern::wrap_type(); - auto gather = pattern::wrap_type({slice, pattern::any_input()}); + auto slice = ov::pass::pattern::wrap_type(); + auto gather = ov::pass::pattern::wrap_type({slice, ov::pass::pattern::any_input()}); - ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_to_node = m.get_pattern_map(); const auto& slice_node = pattern_to_node.at(slice); bool start_from_zero = ov::op::util::is_constant_and_all_values_equal_int(slice_node->input_value(1), 0); @@ -1169,20 +1168,20 @@ ov::pass::EliminateSliceBeforeGatherElements::EliminateSliceBeforeGatherElements return true; }; - auto m = std::make_shared(gather, matcher_name); + auto m = std::make_shared(gather, matcher_name); register_matcher(m, matcher_pass_callback); } ov::pass::EliminateSlice::EliminateSlice() { MATCHER_SCOPE(EliminateSlice); - auto input = pattern::any_input(); - auto begin_const = pattern::wrap_type(); - auto end_const = pattern::wrap_type(); - auto step_const = pattern::wrap_type(); - auto axes = pattern::any_input(); - auto pattern = pattern::wrap_type({input, begin_const, end_const, step_const, axes}); + auto input = ov::pass::pattern::any_input(); + auto begin_const = ov::pass::pattern::wrap_type(); + auto end_const = ov::pass::pattern::wrap_type(); + auto step_const = ov::pass::pattern::wrap_type(); + auto axes = ov::pass::pattern::any_input(); + auto pattern = ov::pass::pattern::wrap_type({input, begin_const, end_const, step_const, axes}); - ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { auto slice = ov::as_type_ptr(m.get_match_root()); if (!slice) { return false; @@ -1201,20 +1200,20 @@ ov::pass::EliminateSlice::EliminateSlice() { return false; } }; - auto m = std::make_shared(pattern, matcher_name); + auto m = std::make_shared(pattern, matcher_name); register_matcher(m, matcher_pass_callback); } ov::pass::EliminateStridedSlice::EliminateStridedSlice() { MATCHER_SCOPE(EliminateStridedSlice); - auto input = pattern::any_input(); - auto begin_const = pattern::wrap_type(); - auto end_const = pattern::wrap_type(); - auto optional_stride_const = pattern::wrap_type(); - auto pattern = pattern::wrap_type({input, begin_const, end_const, optional_stride_const}); + auto input = ov::pass::pattern::any_input(); + auto begin_const = ov::pass::pattern::wrap_type(); + auto end_const = ov::pass::pattern::wrap_type(); + auto optional_stride_const = ov::pass::pattern::wrap_type(); + auto pattern = ov::pass::pattern::wrap_type({input, begin_const, end_const, optional_stride_const}); - ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { auto strided_slice_node = ov::as_type_ptr(m.get_match_root()); if (!strided_slice_node) { return false; @@ -1289,24 +1288,24 @@ ov::pass::EliminateStridedSlice::EliminateStridedSlice() { } return replace_output_update_name(strided_slice_node->output(0), strided_slice_node->input_value(0)); }; - auto m = std::make_shared(pattern, matcher_name); + auto m = std::make_shared(pattern, matcher_name); register_matcher(m, matcher_pass_callback); } ov::pass::EliminateStridedSliceByShape::EliminateStridedSliceByShape() { MATCHER_SCOPE(EliminateStridedSliceByShape); - auto input = pattern::any_input(); - auto begin = pattern::any_input(); - auto end = pattern::any_input(); - auto optional_stride_const = pattern::wrap_type(); - auto strided_slice = pattern::wrap_type({input, begin, end, optional_stride_const}); + auto input = ov::pass::pattern::any_input(); + auto begin = ov::pass::pattern::any_input(); + auto end = ov::pass::pattern::any_input(); + auto optional_stride_const = ov::pass::pattern::wrap_type(); + auto strided_slice = ov::pass::pattern::wrap_type({input, begin, end, optional_stride_const}); - auto axes = pattern::any_input(); - auto slice = pattern::wrap_type({input, begin, end, optional_stride_const, axes}); - auto pattern = std::make_shared(OutputVector{strided_slice, slice}); + auto axes = ov::pass::pattern::any_input(); + auto slice = ov::pass::pattern::wrap_type({input, begin, end, optional_stride_const, axes}); + auto pattern = std::make_shared(OutputVector{strided_slice, slice}); - ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); if (node == nullptr) { return false; @@ -1345,25 +1344,25 @@ ov::pass::EliminateStridedSliceByShape::EliminateStridedSliceByShape() { return false; }; - auto m = std::make_shared(pattern, matcher_name); + auto m = std::make_shared(pattern, matcher_name); register_matcher(m, matcher_pass_callback); } ov::pass::PrepareShapeOpsForEliminationAroundBE::PrepareShapeOpsForEliminationAroundBE() { MATCHER_SCOPE(PrepareShapeOpsForEliminationAroundBE); - auto first_label = pattern:: - wrap_type( - pattern::rank_equals(0)); - auto other_input_label = pattern::any_input(pattern::rank_equals(0)); - auto binary_op_label = pattern::wrap_type( + ov::pass::pattern::rank_equals(0)); + auto other_input_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(0)); + auto binary_op_label = ov::pass::pattern::wrap_type({first_label, other_input_label}, - pattern::consumers_count(1)); + ov::pass::pattern::consumers_count(1)); auto second_label = - pattern::wrap_type({binary_op_label, pattern::any_input()}, - pattern::rank_equals(1)); + ov::pass::pattern::wrap_type({binary_op_label, ov::pass::pattern::any_input()}, + ov::pass::pattern::rank_equals(1)); - ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_node = m.get_pattern_map(); auto second_node = pattern_to_node.at(second_label); @@ -1387,7 +1386,7 @@ ov::pass::PrepareShapeOpsForEliminationAroundBE::PrepareShapeOpsForEliminationAr return true; }; - auto m = std::make_shared(second_label, matcher_name); + auto m = std::make_shared(second_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/normalize_l2_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/normalize_l2_fusion.cpp index a5b6446210ed3a..5d5c4ead3cbba9 100644 --- a/src/common/transformations/src/transformations/common_optimizations/normalize_l2_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/normalize_l2_fusion.cpp @@ -25,7 +25,7 @@ ov::pass::NormalizeL2Fusion::NormalizeL2Fusion() { MATCHER_SCOPE(NormalizeL2Fusion); - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto exp = ov::pass::pattern::wrap_type(); auto pow = std::make_shared(input, exp); @@ -35,20 +35,20 @@ ov::pass::NormalizeL2Fusion::NormalizeL2Fusion() { auto eps_const = ov::pass::pattern::wrap_type(); auto max = std::make_shared(reduce_sum, eps_const); auto add = std::make_shared(reduce_sum, eps_const); - auto max_or_add = std::make_shared(OutputVector{max, add}); + auto max_or_add = std::make_shared(OutputVector{max, add}); // Sqrt can be represented by Sqrt node or as Power node with exponent 0.5 auto sqrt = std::make_shared(max_or_add); auto exp2 = ov::pass::pattern::wrap_type(); auto pow_as_sqrt = std::make_shared(max_or_add, exp2); - auto power_or_sqrt = std::make_shared(OutputVector{sqrt, pow_as_sqrt}); + auto power_or_sqrt = std::make_shared(OutputVector{sqrt, pow_as_sqrt}); // divide(input,sqrt(..)) can be represented as mul(input, power(..., -0.5f)) auto divide = std::make_shared(input, power_or_sqrt); auto exp3 = ov::pass::pattern::wrap_type(); auto reversed_pow_as_sqrt = std::make_shared(max_or_add, exp3); auto mul = std::make_shared(input, reversed_pow_as_sqrt); - auto divide_or_mul = std::make_shared(OutputVector{divide, mul}); + auto divide_or_mul = std::make_shared(OutputVector{divide, mul}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp b/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp index 69f4eb9ecc7e54..3c1787083a750f 100644 --- a/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp @@ -395,25 +395,22 @@ bool ov::pass::GroupedSliceToVSplitOptimization::run_on_model(const std::shared_ ov::pass::SliceSequenceToSingleSlice::SliceSequenceToSingleSlice() { MATCHER_SCOPE(SliceSequenceToSingleSlice); - using namespace ov::op; - using namespace ov::op::util; - using namespace ov::pass::pattern; - - auto const_axes_1_pattern = wrap_type(); - auto const_axes_2_pattern = wrap_type(); +using namespace ov::op::util; +auto const_axes_1_pattern = ov::pass::pattern::wrap_type(); + auto const_axes_2_pattern = ov::pass::pattern::wrap_type(); auto slice_1_pattern = - wrap_type({any_input(), any_input(), any_input(), any_input(), const_axes_1_pattern}, - consumers_count(1)); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), const_axes_1_pattern}, + ov::pass::pattern::consumers_count(1)); auto slice_2_pattern = - wrap_type({slice_1_pattern, any_input(), any_input(), any_input(), const_axes_2_pattern}); + ov::pass::pattern::wrap_type({slice_1_pattern, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), const_axes_2_pattern}); - ov::matcher_pass_callback callback = [=](Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); auto slice_1 = pattern_to_output.at(slice_1_pattern); auto slice_2 = pattern_to_output.at(slice_2_pattern); - auto const_axes_1 = ov::as_type_ptr(pattern_to_output.at(const_axes_1_pattern)); - auto const_axes_2 = ov::as_type_ptr(pattern_to_output.at(const_axes_2_pattern)); + auto const_axes_1 = ov::as_type_ptr(pattern_to_output.at(const_axes_1_pattern)); + auto const_axes_2 = ov::as_type_ptr(pattern_to_output.at(const_axes_2_pattern)); auto axes_1_values = const_axes_1->cast_vector(); auto axes_2_values = const_axes_2->cast_vector(); diff --git a/src/common/transformations/src/transformations/common_optimizations/pad_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/pad_fusion.cpp index 828567884b8abd..8a1ced75d54285 100644 --- a/src/common/transformations/src/transformations/common_optimizations/pad_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/pad_fusion.cpp @@ -94,16 +94,16 @@ static std::tuple new_pooling_pad_values(const std::shared_ptr(); - auto pads_end_pattern = pattern::wrap_type(); - auto pad_value_pattern = pattern::any_input(); - auto pad_node_pattern = pattern::wrap_type( + auto data_pattern = ov::pass::pattern::any_input(); + auto pads_begin_pattern = ov::pass::pattern::wrap_type(); + auto pads_end_pattern = ov::pass::pattern::wrap_type(); + auto pad_value_pattern = ov::pass::pattern::any_input(); + auto pad_node_pattern = ov::pass::pattern::wrap_type( {data_pattern, pads_begin_pattern, pads_end_pattern, pad_value_pattern}, - pattern::consumers_count(1)); - auto avg_pool_pattern = pattern::wrap_type({pad_node_pattern}); + ov::pass::pattern::consumers_count(1)); + auto avg_pool_pattern = ov::pass::pattern::wrap_type({pad_node_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_value_map(); auto data = pattern_map[data_pattern]; auto pad = ov::as_type_ptr(pattern_map[pad_node_pattern].get_node_shared_ptr()); @@ -158,7 +158,7 @@ pass::PadFusionAvgPool::PadFusionAvgPool() { return true; }; - auto m = std::make_shared(avg_pool_pattern, matcher_name); + auto m = std::make_shared(avg_pool_pattern, matcher_name); this->register_matcher(m, callback); } @@ -192,17 +192,17 @@ static std::tuple new_conv_pad_values( pass::PadFusionConvolution::PadFusionConvolution() { MATCHER_SCOPE(PadFusionConvolution); - auto data_pattern = pattern::any_input(); - auto filter_pattern = pattern::any_input(); - auto pads_begin_pattern = pattern::wrap_type(); - auto pads_end_pattern = pattern::wrap_type(); - auto pad_value_pattern = pattern::any_input(); - auto pad_node_pattern = pattern::wrap_type( + auto data_pattern = ov::pass::pattern::any_input(); + auto filter_pattern = ov::pass::pattern::any_input(); + auto pads_begin_pattern = ov::pass::pattern::wrap_type(); + auto pads_end_pattern = ov::pass::pattern::wrap_type(); + auto pad_value_pattern = ov::pass::pattern::any_input(); + auto pad_node_pattern = ov::pass::pattern::wrap_type( {data_pattern, pads_begin_pattern, pads_end_pattern, pad_value_pattern}, - pattern::consumers_count(1)); - auto conv_pattern = pattern::wrap_type({pad_node_pattern, filter_pattern}); + ov::pass::pattern::consumers_count(1)); + auto conv_pattern = ov::pass::pattern::wrap_type({pad_node_pattern, filter_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_value_map(); auto data = pattern_map[data_pattern]; auto filter = pattern_map[filter_pattern]; @@ -231,23 +231,23 @@ pass::PadFusionConvolution::PadFusionConvolution() { return true; }; - auto m = std::make_shared(conv_pattern, matcher_name); + auto m = std::make_shared(conv_pattern, matcher_name); this->register_matcher(m, callback); } pass::PadFusionConvolutionBackpropData::PadFusionConvolutionBackpropData() { MATCHER_SCOPE(PadFusionConvolutionBackpropData); - auto data_pattern = pattern::any_input(); - auto filter_pattern = pattern::any_input(); - auto pads_begin_pattern = pattern::wrap_type(); - auto pads_end_pattern = pattern::wrap_type(); - auto pad_value_pattern = pattern::any_input(); - auto pad_node_pattern = pattern::wrap_type( + auto data_pattern = ov::pass::pattern::any_input(); + auto filter_pattern = ov::pass::pattern::any_input(); + auto pads_begin_pattern = ov::pass::pattern::wrap_type(); + auto pads_end_pattern = ov::pass::pattern::wrap_type(); + auto pad_value_pattern = ov::pass::pattern::any_input(); + auto pad_node_pattern = ov::pass::pattern::wrap_type( {data_pattern, pads_begin_pattern, pads_end_pattern, pad_value_pattern}, - pattern::consumers_count(1)); - auto conv_pattern = pattern::wrap_type({pad_node_pattern, filter_pattern}); + ov::pass::pattern::consumers_count(1)); + auto conv_pattern = ov::pass::pattern::wrap_type({pad_node_pattern, filter_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_value_map(); auto data = pattern_map[data_pattern]; auto filter = pattern_map[filter_pattern]; @@ -287,23 +287,23 @@ pass::PadFusionConvolutionBackpropData::PadFusionConvolutionBackpropData() { return true; }; - auto m = std::make_shared(conv_pattern, matcher_name); + auto m = std::make_shared(conv_pattern, matcher_name); this->register_matcher(m, callback); } pass::PadFusionGroupConvolution::PadFusionGroupConvolution() { MATCHER_SCOPE(PadFusionGroupConvolution); - auto data_pattern = pattern::any_input(); - auto filter_pattern = pattern::any_input(); - auto pads_begin_pattern = pattern::wrap_type(); - auto pads_end_pattern = pattern::wrap_type(); - auto pad_value_pattern = pattern::any_input(); - auto pad_node_pattern = pattern::wrap_type( + auto data_pattern = ov::pass::pattern::any_input(); + auto filter_pattern = ov::pass::pattern::any_input(); + auto pads_begin_pattern = ov::pass::pattern::wrap_type(); + auto pads_end_pattern = ov::pass::pattern::wrap_type(); + auto pad_value_pattern = ov::pass::pattern::any_input(); + auto pad_node_pattern = ov::pass::pattern::wrap_type( {data_pattern, pads_begin_pattern, pads_end_pattern, pad_value_pattern}, - pattern::consumers_count(1)); - auto conv_pattern = pattern::wrap_type({pad_node_pattern, filter_pattern}); + ov::pass::pattern::consumers_count(1)); + auto conv_pattern = ov::pass::pattern::wrap_type({pad_node_pattern, filter_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_value_map(); auto data = pattern_map[data_pattern]; auto filter = pattern_map[filter_pattern]; @@ -332,24 +332,24 @@ pass::PadFusionGroupConvolution::PadFusionGroupConvolution() { return true; }; - auto m = std::make_shared(conv_pattern, matcher_name); + auto m = std::make_shared(conv_pattern, matcher_name); this->register_matcher(m, callback); } pass::PadFusionGroupConvolutionBackpropData::PadFusionGroupConvolutionBackpropData() { MATCHER_SCOPE(PadFusionGroupConvolutionBackpropData); - auto data_pattern = pattern::any_input(); - auto filter_pattern = pattern::any_input(); - auto pads_begin_pattern = pattern::wrap_type(); - auto pads_end_pattern = pattern::wrap_type(); - auto pad_value_pattern = pattern::any_input(); - auto pad_node_pattern = pattern::wrap_type( + auto data_pattern = ov::pass::pattern::any_input(); + auto filter_pattern = ov::pass::pattern::any_input(); + auto pads_begin_pattern = ov::pass::pattern::wrap_type(); + auto pads_end_pattern = ov::pass::pattern::wrap_type(); + auto pad_value_pattern = ov::pass::pattern::any_input(); + auto pad_node_pattern = ov::pass::pattern::wrap_type( {data_pattern, pads_begin_pattern, pads_end_pattern, pad_value_pattern}, - pattern::consumers_count(1)); + ov::pass::pattern::consumers_count(1)); auto conv_pattern = - pattern::wrap_type({pad_node_pattern, filter_pattern}); + ov::pass::pattern::wrap_type({pad_node_pattern, filter_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_value_map(); auto data = pattern_map[data_pattern]; auto filter = pattern_map[filter_pattern]; @@ -389,6 +389,6 @@ pass::PadFusionGroupConvolutionBackpropData::PadFusionGroupConvolutionBackpropDa return true; }; - auto m = std::make_shared(conv_pattern, matcher_name); + auto m = std::make_shared(conv_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/prelu_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/prelu_fusion.cpp index 6d42dcd38c51d6..635283282ac97a 100644 --- a/src/common/transformations/src/transformations/common_optimizations/prelu_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/prelu_fusion.cpp @@ -25,7 +25,7 @@ ov::pass::PReluFusionNegativeAdd::PReluFusionNegativeAdd() { MATCHER_SCOPE(PReluFusionNegativeAdd); - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto relu_pos = ov::pass::pattern::wrap_type({input}); auto neg1 = ov::pass::pattern::wrap_type({input}); auto relu_neg = ov::pass::pattern::wrap_type({neg1}); @@ -57,7 +57,7 @@ ov::pass::PReluFusionNegativeAdd::PReluFusionNegativeAdd() { ov::pass::PReluFusionNegativeSub::PReluFusionNegativeSub() { MATCHER_SCOPE(PReluFusionNegativeSub); - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto relu_pos = ov::pass::pattern::wrap_type({input}); auto neg1 = ov::pass::pattern::wrap_type({input}); auto relu_neg = ov::pass::pattern::wrap_type({neg1}); @@ -101,7 +101,7 @@ static std::function)> constant_value(const float targ ov::pass::PReluFusionMultiplyAdd::PReluFusionMultiplyAdd() { MATCHER_SCOPE(PReluFusionMultiplyAdd); - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto relu_pos = ov::pass::pattern::wrap_type({input}); auto mul_neg_constant = ov::pass::pattern::wrap_type(constant_value(-1.0)); auto mul_neg = ov::pass::pattern::wrap_type({input, mul_neg_constant}); @@ -134,7 +134,7 @@ ov::pass::PReluFusionMultiplyAdd::PReluFusionMultiplyAdd() { ov::pass::PReluFusionMultiplySub::PReluFusionMultiplySub() { MATCHER_SCOPE(PReluFusionMultiplySub); - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto relu_pos = ov::pass::pattern::wrap_type({input}); auto mul_neg_constant = ov::pass::pattern::wrap_type(constant_value(-1.0)); auto mul_neg = ov::pass::pattern::wrap_type({input, mul_neg_constant}); @@ -176,17 +176,17 @@ ov::pass::PReluFusionAbsSubMulMulAdd::PReluFusionAbsSubMulMulAdd() { return constant && ov::op::util::get_single_value(constant, v) && v == 0.5f; }; - const auto input = pass::pattern::any_input(); - const auto relu = pattern::wrap_type({input}); - const auto abs = pattern::wrap_type({input}); - const auto sub = pattern::wrap_type({input, abs}); - const auto mul_1_constant = pattern::wrap_type(); - const auto mul_1 = pattern::wrap_type({sub, mul_1_constant}); - const auto mul_2_constant = pattern::wrap_type(equals_half); - const auto mul_2 = pattern::wrap_type({mul_1, mul_2_constant}); - const auto add = pattern::wrap_type({mul_2, relu}); - - matcher_pass_callback callback = [=](pattern::Matcher& m) { + const auto input = ov::pass::pattern::any_input(); + const auto relu = ov::pass::pattern::wrap_type({input}); + const auto abs = ov::pass::pattern::wrap_type({input}); + const auto sub = ov::pass::pattern::wrap_type({input, abs}); + const auto mul_1_constant = ov::pass::pattern::wrap_type(); + const auto mul_1 = ov::pass::pattern::wrap_type({sub, mul_1_constant}); + const auto mul_2_constant = ov::pass::pattern::wrap_type(equals_half); + const auto mul_2 = ov::pass::pattern::wrap_type({mul_1, mul_2_constant}); + const auto add = ov::pass::pattern::wrap_type({mul_2, relu}); + + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); const auto input_output = pattern_to_output.at(input); const auto add_node = pattern_to_output.at(add).get_node_shared_ptr(); @@ -204,7 +204,7 @@ ov::pass::PReluFusionAbsSubMulMulAdd::PReluFusionAbsSubMulMulAdd() { replace_node(add_node, prelu); return true; }; - auto m = make_shared(add, matcher_name); + auto m = make_shared(add, matcher_name); register_matcher(m, callback); } @@ -214,15 +214,15 @@ ov::pass::PReluFusionNegReluMulAdd::PReluFusionNegReluMulAdd() { using namespace std; using namespace ov; - const auto input = pass::pattern::any_input(); - const auto relu_pos = pattern::wrap_type({input}); - const auto neg1 = pattern::wrap_type({input}); - const auto relu_neg = pattern::wrap_type({neg1}); - const auto mul_constant = pattern::wrap_type(); - const auto mul = pattern::wrap_type({relu_neg, mul_constant}); - const auto add = pattern::wrap_type({relu_pos, mul}); + const auto input = ov::pass::pattern::any_input(); + const auto relu_pos = ov::pass::pattern::wrap_type({input}); + const auto neg1 = ov::pass::pattern::wrap_type({input}); + const auto relu_neg = ov::pass::pattern::wrap_type({neg1}); + const auto mul_constant = ov::pass::pattern::wrap_type(); + const auto mul = ov::pass::pattern::wrap_type({relu_neg, mul_constant}); + const auto add = ov::pass::pattern::wrap_type({relu_pos, mul}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); const auto input_output = pattern_to_output.at(input); const auto add_node = pattern_to_output.at(add).get_node_shared_ptr(); @@ -238,6 +238,6 @@ ov::pass::PReluFusionNegReluMulAdd::PReluFusionNegReluMulAdd() { replace_node(add_node, prelu); return true; }; - auto matcher = make_shared(add, matcher_name); + auto matcher = make_shared(add, matcher_name); register_matcher(matcher, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/pull_through_reduce.cpp b/src/common/transformations/src/transformations/common_optimizations/pull_through_reduce.cpp index dac8c84017f316..128de306c35115 100644 --- a/src/common/transformations/src/transformations/common_optimizations/pull_through_reduce.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/pull_through_reduce.cpp @@ -110,16 +110,16 @@ bool have_same_axes(const std::vector& unsqueeze_axes, const std::vecto ov::pass::PullUnsqueezeThroughReduce::PullUnsqueezeThroughReduce() { MATCHER_SCOPE(PullUnsqueezeThroughReduce); - const auto input = pattern::any_input(pattern::has_static_rank()); - const auto unsqueeze_axes = pattern::wrap_type(); + const auto input = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + const auto unsqueeze_axes = ov::pass::pattern::wrap_type(); const auto unsqueeze = - pattern::wrap_type({input, unsqueeze_axes}, pattern::consumers_count(1)); - const auto reduce_axes = pattern::wrap_type(); + ov::pass::pattern::wrap_type({input, unsqueeze_axes}, ov::pass::pattern::consumers_count(1)); + const auto reduce_axes = ov::pass::pattern::wrap_type(); const auto reduce = - pattern::wrap_type( + ov::pass::pattern::wrap_type( {unsqueeze, reduce_axes}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& pattern_map = m.get_pattern_value_map(); const auto input_node = pattern_map.at(input); const auto reduce_node = @@ -177,23 +177,23 @@ ov::pass::PullUnsqueezeThroughReduce::PullUnsqueezeThroughReduce() { return true; }; - auto m = std::make_shared(reduce, matcher_name); + auto m = std::make_shared(reduce, matcher_name); register_matcher(m, callback); } ov::pass::PullReshapeThroughReduce::PullReshapeThroughReduce() { MATCHER_SCOPE(PullReshapeThroughReduce); - const auto input = pattern::any_input(pattern::has_static_shape()); - const auto reshape_target_shape = pattern::wrap_type(); + const auto input = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); + const auto reshape_target_shape = ov::pass::pattern::wrap_type(); const auto reshape = - pattern::wrap_type({input, reshape_target_shape}, pattern::consumers_count(1)); - const auto reduce_axes = pattern::wrap_type(); + ov::pass::pattern::wrap_type({input, reshape_target_shape}, ov::pass::pattern::consumers_count(1)); + const auto reduce_axes = ov::pass::pattern::wrap_type(); const auto reduce = - pattern::wrap_type( + ov::pass::pattern::wrap_type( {reshape, reduce_axes}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& pattern_map = m.get_pattern_value_map(); const auto input_node = pattern_map.at(input); const auto reduce_node = @@ -245,6 +245,6 @@ ov::pass::PullReshapeThroughReduce::PullReshapeThroughReduce() { return true; }; - auto m = std::make_shared(reduce, matcher_name); + auto m = std::make_shared(reduce, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/pull_transpose_through_fq.cpp b/src/common/transformations/src/transformations/common_optimizations/pull_transpose_through_fq.cpp index 33f0953bb915dc..e8b79218e9b17d 100644 --- a/src/common/transformations/src/transformations/common_optimizations/pull_transpose_through_fq.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/pull_transpose_through_fq.cpp @@ -22,17 +22,17 @@ ov::pass::PullTransposeThroughFQUp::PullTransposeThroughFQUp() { MATCHER_SCOPE(PullTransposeThroughFQUp); const auto weights = ov::pass::pattern::wrap_type(); - const auto convert_p = ov::pass::pattern::optional(weights, pattern::consumers_count(1)); - auto m_fq = pattern::wrap_type({convert_p, - pattern::any_input(pattern::has_static_shape()), - pattern::any_input(pattern::has_static_shape()), - pattern::any_input(pattern::has_static_shape()), - pattern::any_input(pattern::has_static_shape())}, - pattern::consumers_count(1)); - auto m_transpose_perm = pattern::wrap_type(); - auto m_transpose = pattern::wrap_type({m_fq, m_transpose_perm}); + const auto convert_p = ov::pass::pattern::optional(weights, ov::pass::pattern::consumers_count(1)); + auto m_fq = ov::pass::pattern::wrap_type({convert_p, + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}, + ov::pass::pattern::consumers_count(1)); + auto m_transpose_perm = ov::pass::pattern::wrap_type(); + auto m_transpose = ov::pass::pattern::wrap_type({m_fq, m_transpose_perm}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto& pattern_map = m.get_pattern_value_map(); auto transpose = pattern_map[m_transpose].get_node_shared_ptr(); auto fq = pattern_map[m_fq].get_node_shared_ptr(); diff --git a/src/common/transformations/src/transformations/common_optimizations/random_uniform_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/random_uniform_fusion.cpp index 936c93e8bfd3bc..252fecdcc05c11 100644 --- a/src/common/transformations/src/transformations/common_optimizations/random_uniform_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/random_uniform_fusion.cpp @@ -21,19 +21,19 @@ ov::pass::RandomUniformFusion::RandomUniformFusion() { MATCHER_SCOPE(RandomUniformFusion); - const auto data_pattern = pass::pattern::any_input(); - const auto ru_min_input_pattern = pass::pattern::any_input(); - const auto ru_max_input_pattern = pass::pattern::any_input(); + const auto data_pattern = ov::pass::pattern::any_input(); + const auto ru_min_input_pattern = ov::pass::pattern::any_input(); + const auto ru_max_input_pattern = ov::pass::pattern::any_input(); const auto random_uniform_pattern = ov::pass::pattern::wrap_type( {data_pattern, ru_min_input_pattern, ru_max_input_pattern}, - pattern::consumers_count(1)); + ov::pass::pattern::consumers_count(1)); const auto const_pattern = ov::pass::pattern::wrap_type(); const auto optional_convert = ov::pass::pattern::optional(random_uniform_pattern); const auto mul_add_pattern = ov::pass::pattern::wrap_type({optional_convert, const_pattern}); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto data = pattern_map.at(data_pattern); const auto random_uniform = pattern_map.at(random_uniform_pattern); diff --git a/src/common/transformations/src/transformations/common_optimizations/reduce_merge.cpp b/src/common/transformations/src/transformations/common_optimizations/reduce_merge.cpp index 8c197cc3e4b6b3..592c5da8265bca 100644 --- a/src/common/transformations/src/transformations/common_optimizations/reduce_merge.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/reduce_merge.cpp @@ -30,11 +30,11 @@ using namespace ov::pass; template std::shared_ptr create_pattern() { - auto input = pattern::any_input(); - auto first_axis = pattern::any_input(); - auto reduce = pattern::wrap_type({input, first_axis}); - auto second_axis = pattern::any_input(); - return pattern::wrap_type({reduce, second_axis}); + auto input = ov::pass::pattern::any_input(); + auto first_axis = ov::pass::pattern::any_input(); + auto reduce = ov::pass::pattern::wrap_type({input, first_axis}); + auto second_axis = ov::pass::pattern::any_input(); + return ov::pass::pattern::wrap_type({reduce, second_axis}); } template @@ -115,7 +115,7 @@ pass::ReduceMerge::ReduceMerge() { auto reduce_prod_pattern = create_pattern(); auto reduce_sum_pattern = create_pattern(); - auto pattern = std::make_shared(OutputVector{reducel1_pattern, + auto pattern = std::make_shared(OutputVector{reducel1_pattern, reducel2_pattern, reduce_log_and_pattern, reduce_log_or_pattern, @@ -135,6 +135,6 @@ pass::ReduceMerge::ReduceMerge() { return false; } }; - auto m = std::make_shared(pattern, matcher_name); + auto m = std::make_shared(pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/reduce_reshape_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/reduce_reshape_fusion.cpp index 97269d5501df11..cb156c47ee8aeb 100644 --- a/src/common/transformations/src/transformations/common_optimizations/reduce_reshape_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/reduce_reshape_fusion.cpp @@ -22,15 +22,15 @@ ov::pass::ReduceReshapeFusion::ReduceReshapeFusion() { MATCHER_SCOPE(ReduceReshapeFusion); - const auto reduce_axes = pattern::wrap_type(); + const auto reduce_axes = ov::pass::pattern::wrap_type(); const auto reduce = - pattern::wrap_type( - {pattern::any_input(), reduce_axes}, - pattern::consumers_count(1)); + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), reduce_axes}, + ov::pass::pattern::consumers_count(1)); const auto reshape = - pattern::wrap_type({reduce, pattern::any_input()}, pattern::has_static_shape()); + ov::pass::pattern::wrap_type({reduce, ov::pass::pattern::any_input()}, ov::pass::pattern::has_static_shape()); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& pattern_map = m.get_pattern_value_map(); auto reshape_node = pattern_map.at(reshape).get_node_shared_ptr(); const auto reduce_node = @@ -72,6 +72,6 @@ ov::pass::ReduceReshapeFusion::ReduceReshapeFusion() { return true; }; - auto m = std::make_shared(reshape, matcher_name); + auto m = std::make_shared(reshape, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/relu_fake_quantize_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/relu_fake_quantize_fusion.cpp index 65015862c0b3c2..5c9090f65ac7fe 100644 --- a/src/common/transformations/src/transformations/common_optimizations/relu_fake_quantize_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/relu_fake_quantize_fusion.cpp @@ -18,16 +18,16 @@ ov::pass::ReluFakeQuantizeFusion::ReluFakeQuantizeFusion() { MATCHER_SCOPE(ReluFakeQuantizeFusion); - auto data_pattern = pass::pattern::any_input(); - auto relu_pattern = ov::pass::pattern::wrap_type({data_pattern}, pattern::consumers_count(1)); + auto data_pattern = ov::pass::pattern::any_input(); + auto relu_pattern = ov::pass::pattern::wrap_type({data_pattern}, ov::pass::pattern::consumers_count(1)); auto input_low_pattern = ov::pass::pattern::wrap_type(); auto fq_pattern = ov::pass::pattern::wrap_type({relu_pattern, input_low_pattern, - pass::pattern::any_input(), - pass::pattern::any_input(), - pass::pattern::any_input()}); + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_value_map(); auto data = pattern_map[data_pattern]; auto relu = pattern_map[relu_pattern]; diff --git a/src/common/transformations/src/transformations/common_optimizations/remove_concat_zero_dim_input.cpp b/src/common/transformations/src/transformations/common_optimizations/remove_concat_zero_dim_input.cpp index a6a1dec9846286..2e4caab3f75157 100644 --- a/src/common/transformations/src/transformations/common_optimizations/remove_concat_zero_dim_input.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/remove_concat_zero_dim_input.cpp @@ -17,8 +17,8 @@ ov::pass::RemoveConcatZeroDimInput::RemoveConcatZeroDimInput() { MATCHER_SCOPE(RemoveConcatZeroDimInput); - auto concat_pattern = pattern::wrap_type(); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + auto concat_pattern = ov::pass::pattern::wrap_type(); + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto concat = m.get_match_root(); const auto& rt_info = concat->get_rt_info(); if (rt_info.count(DisableRemoveConcatZeroDimInput::get_type_info_static())) { @@ -64,7 +64,7 @@ ov::pass::RemoveConcatZeroDimInput::RemoveConcatZeroDimInput() { } return inputs_removed; }; - auto m = std::make_shared(concat_pattern, matcher_name); + auto m = std::make_shared(concat_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/remove_filtering_boxes_by_size.cpp b/src/common/transformations/src/transformations/common_optimizations/remove_filtering_boxes_by_size.cpp index 58f0bd99f240cd..221840934b8900 100644 --- a/src/common/transformations/src/transformations/common_optimizations/remove_filtering_boxes_by_size.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/remove_filtering_boxes_by_size.cpp @@ -36,18 +36,18 @@ ov::pass::FuseFilteringBoxesBySize::FuseFilteringBoxesBySize() { ov::pass::RemoveFilteringBoxesBySize::RemoveFilteringBoxesBySize() { MATCHER_SCOPE(RemoveFilteringBoxesBySize); // variadic split - auto data = std::make_shared(element::f32, Shape{1000, 4}); + auto data = std::make_shared(element::f32, Shape{1000, 4}); auto sizes = ov::op::v0::Constant::create(element::i64, Shape{4}, std::vector({1, 1, 1, 1})); auto axis = ov::op::v0::Constant::create(element::i64, Shape{1}, std::vector({1})); auto split = std::make_shared(data, axis, sizes); // sub -> add auto sub_2_0 = std::make_shared(split->output(2), split->output(0)); - auto term_1 = std::make_shared(element::f32, Shape{1}); + auto term_1 = std::make_shared(element::f32, Shape{1}); auto add_1 = std::make_shared(sub_2_0, term_1); auto sub_3_1 = std::make_shared(split->output(3), split->output(1)); - auto term_2 = std::make_shared(element::f32, Shape{1}); + auto term_2 = std::make_shared(element::f32, Shape{1}); auto add_2 = std::make_shared(sub_3_1, term_2); // concat @@ -103,7 +103,7 @@ ov::pass::RemoveFilteringBoxesBySize::RemoveFilteringBoxesBySize() { auto cast = std::make_shared(squeeze_3, ov::element::i64); - ov::matcher_pass_callback callback = [data](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [data](ov::pass::pattern::Matcher& m) { auto start = ov::op::v0::Constant::create(element::i64, Shape{}, std::vector({0})); auto step = ov::op::v0::Constant::create(element::i64, Shape{}, std::vector({1})); @@ -127,6 +127,6 @@ ov::pass::RemoveFilteringBoxesBySize::RemoveFilteringBoxesBySize() { return true; }; - auto m = std::make_shared(cast, matcher_name); + auto m = std::make_shared(cast, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/reshape_prelu.cpp b/src/common/transformations/src/transformations/common_optimizations/reshape_prelu.cpp index 97fac3366f2a12..5be0c496924177 100644 --- a/src/common/transformations/src/transformations/common_optimizations/reshape_prelu.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/reshape_prelu.cpp @@ -17,11 +17,11 @@ using namespace ov::pass; ReshapePRelu::ReshapePRelu() { MATCHER_SCOPE(ReshapePRelu); - auto input_m = pattern::any_input(pattern::has_static_rank()); - auto slope_m = pattern::any_input(pattern::has_static_rank()); - auto prelu_m = pattern::wrap_type({input_m, slope_m}); + auto input_m = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto slope_m = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto prelu_m = ov::pass::pattern::wrap_type({input_m, slope_m}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto prelu = pattern_map.at(prelu_m).get_node_shared_ptr(); const auto input = pattern_map.at(input_m); diff --git a/src/common/transformations/src/transformations/common_optimizations/reshape_sequence_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/reshape_sequence_fusion.cpp index 1c82c17245a6e0..11a166a387abc8 100644 --- a/src/common/transformations/src/transformations/common_optimizations/reshape_sequence_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/reshape_sequence_fusion.cpp @@ -62,14 +62,14 @@ bool has_valid_pattern(const ov::Output& node_out) { ov::pass::ReshapeSequenceFusion::ReshapeSequenceFusion(bool use_shape_for_elimination) { MATCHER_SCOPE(ReshapeSequenceFusion); - auto reshape_input = pattern::any_input(); - auto reshape_a_pattern = pattern::wrap_type(); + auto reshape_input = ov::pass::pattern::any_input(); + auto reshape_a_pattern = ov::pass::pattern::wrap_type(); auto reshape_a = - pattern::wrap_type({reshape_input, reshape_a_pattern}, pattern::consumers_count(1)); - auto reshape_b_pattern = pattern::any_input(); - auto reshape_b = pattern::wrap_type({reshape_a, reshape_b_pattern}); + ov::pass::pattern::wrap_type({reshape_input, reshape_a_pattern}, ov::pass::pattern::consumers_count(1)); + auto reshape_b_pattern = ov::pass::pattern::any_input(); + auto reshape_b = ov::pass::pattern::wrap_type({reshape_a, reshape_b_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto input = pattern_map.at(reshape_input); auto reshape = m.get_match_root(); diff --git a/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp index a5067a60bef06d..c36f4f48557616 100644 --- a/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp @@ -227,10 +227,10 @@ class SplitConcat : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::init::SplitConcat"); SplitConcat(NodeVector& nodes_to_fuse) { MATCHER_SCOPE(SplitConcat); - auto split_p = pattern::wrap_type(); - auto pattern_root = pattern::wrap_type({split_p, split_p, split_p}); + auto split_p = ov::pass::pattern::wrap_type(); + auto pattern_root = ov::pass::pattern::wrap_type({split_p, split_p, split_p}); - auto callback = [=, &nodes_to_fuse](pattern::Matcher& m) { + auto callback = [=, &nodes_to_fuse](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto concat = ov::as_type_ptr(pattern_map.at(pattern_root).get_node_shared_ptr()); auto split = ov::as_type_ptr(pattern_map.at(split_p).get_node_shared_ptr()); @@ -274,7 +274,7 @@ class SplitConcat : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -284,12 +284,12 @@ class Gather : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::init::Gather"); Gather(NodeVector& nodes_to_fuse) { MATCHER_SCOPE(Gather); - auto input_p = pattern::any_input(pattern::has_static_rank()); - auto indices_p = pattern::any_input(); - auto axis_p = pattern::wrap_type(); - auto pattern_root = pattern::wrap_type({input_p, indices_p, axis_p}); + auto input_p = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto indices_p = ov::pass::pattern::any_input(); + auto axis_p = ov::pass::pattern::wrap_type(); + auto pattern_root = ov::pass::pattern::wrap_type({input_p, indices_p, axis_p}); - auto callback = [=, &nodes_to_fuse](pattern::Matcher& m) { + auto callback = [=, &nodes_to_fuse](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& output = pattern_map.at(pattern_root); @@ -333,7 +333,7 @@ class Gather : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -346,9 +346,9 @@ class Binary : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::prop::Binary"); Binary() { MATCHER_SCOPE(Binary); - auto pattern_root = pattern::wrap_type(); + auto pattern_root = ov::pass::pattern::wrap_type(); - auto callback = [=](pattern::Matcher& m) { + auto callback = [=](ov::pass::pattern::Matcher& m) { const auto& root = m.get_match_root(); const auto& inputs = root->inputs(); @@ -422,7 +422,7 @@ class Binary : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -432,10 +432,10 @@ class Convolution : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::prop::Convolution"); Convolution() { MATCHER_SCOPE(Convolution); - auto input_p = pattern::any_input(ric_attr::has>); - auto pattern_root = pattern::wrap_type( - {input_p, pattern::any_input(pattern::has_static_dim(1 /*output channel*/))}); - auto callback = [=](pattern::Matcher& m) { + auto input_p = ov::pass::pattern::any_input(ric_attr::has>); + auto pattern_root = ov::pass::pattern::wrap_type( + {input_p, ov::pass::pattern::any_input(ov::pass::pattern::has_static_dim(1 /*output channel*/))}); + auto callback = [=](ov::pass::pattern::Matcher& m) { auto conv = m.get_match_root(); auto ric = ric_attr::get(conv->input_value(0)).propagate(); if (ric.get_axis() != 1) @@ -445,7 +445,7 @@ class Convolution : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -455,11 +455,11 @@ class GroupConvolution : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::prop::GroupConvolution"); GroupConvolution() { MATCHER_SCOPE(GroupConvolution); - auto input_p = pattern::any_input(ric_attr::has>); - auto pattern_root = pattern::wrap_type( - {input_p, pattern::any_input(pattern::has_static_shape())}); + auto input_p = ov::pass::pattern::any_input(ric_attr::has>); + auto pattern_root = ov::pass::pattern::wrap_type( + {input_p, ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}); - auto callback = [=](pattern::Matcher& m) { + auto callback = [=](ov::pass::pattern::Matcher& m) { auto conv = m.get_match_root(); const auto& weights_shape = conv->input_value(1).get_shape(); const int64_t& group = static_cast(weights_shape.at(0)); @@ -502,7 +502,7 @@ class GroupConvolution : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -512,14 +512,14 @@ class ShapeOf : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::prop::ShapeOf"); ShapeOf() { MATCHER_SCOPE(ShapeOf); - auto pattern_root = pattern::wrap_type(); + auto pattern_root = ov::pass::pattern::wrap_type(); - auto callback = [=](pattern::Matcher& m) { + auto callback = [=](ov::pass::pattern::Matcher& m) { // Skip propagation for ShapeOf path return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -529,12 +529,12 @@ class PassThrough : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::prop::PassThrough"); PassThrough() { MATCHER_SCOPE(PassThrough); - auto pattern_root = pattern::wrap_type(); - auto callback = [=](pattern::Matcher& m) { + auto callback = [=](ov::pass::pattern::Matcher& m) { auto root = m.get_match_root(); if (!ric_attr::has(root->input_value(0))) return false; @@ -542,7 +542,7 @@ class PassThrough : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -552,11 +552,11 @@ class Transpose : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::prop::Transpose"); Transpose() { MATCHER_SCOPE(Transpose); - auto input_p = pattern::any_input(ric_attr::has>); - auto order_p = pattern::wrap_type(); - auto pattern_root = pattern::wrap_type({input_p, order_p}); + auto input_p = ov::pass::pattern::any_input(ric_attr::has>); + auto order_p = ov::pass::pattern::wrap_type(); + auto pattern_root = ov::pass::pattern::wrap_type({input_p, order_p}); - auto callback = [=](pattern::Matcher& m) { + auto callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto input = pattern_map.at(input_p); auto ric = ric_attr::get(input).propagate(); @@ -571,7 +571,7 @@ class Transpose : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -581,8 +581,8 @@ class Unsupported : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::prop::Unsupported"); Unsupported() { MATCHER_SCOPE(Unsupported); - auto pattern_root = pattern::any_input(); - auto callback = [=](pattern::Matcher& m) { + auto pattern_root = ov::pass::pattern::any_input(); + auto callback = [=](ov::pass::pattern::Matcher& m) { for (const auto& input : m.get_match_root()->input_values()) { if (ric_attr::has(input)) { auto ric = ric_attr::get(input); @@ -596,7 +596,7 @@ class Unsupported : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -617,8 +617,8 @@ class InsertReverseInputChannel : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::fuse::InsertReverseInputChannel"); InsertReverseInputChannel(NodeVector& fused_nodes) { MATCHER_SCOPE(InsertReverseInputChannel); - auto pattern_root = pattern::any_input(); - auto callback = [&fused_nodes](pattern::Matcher& m) { + auto pattern_root = ov::pass::pattern::any_input(); + auto callback = [&fused_nodes](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); for (const auto& input : node->inputs()) { if (!ric_attr::has(input)) @@ -631,7 +631,7 @@ class InsertReverseInputChannel : public ov::pass::MatcherPass { return false; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -641,11 +641,11 @@ class EraseSplitConcat : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::fuse::EraseSplitConcat"); EraseSplitConcat() { MATCHER_SCOPE(EraseSplitConcat); - auto input_p = pattern::any_input(); - auto split_p = pattern::wrap_type({input_p, pattern::any_input()}); - auto pattern_root = pattern::wrap_type({split_p, split_p, split_p}, need_to_erase_ric); + auto input_p = ov::pass::pattern::any_input(); + auto split_p = ov::pass::pattern::wrap_type({input_p, ov::pass::pattern::any_input()}); + auto pattern_root = ov::pass::pattern::wrap_type({split_p, split_p, split_p}, need_to_erase_ric); - auto callback = [=](pattern::Matcher& m) { + auto callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto output = pattern_map.at(pattern_root); auto input = pattern_map.at(input_p); @@ -653,7 +653,7 @@ class EraseSplitConcat : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -663,11 +663,11 @@ class EraseGather : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::fuse::EraseGather"); EraseGather() { MATCHER_SCOPE(EraseGather); - auto input_p = pattern::any_input(); + auto input_p = ov::pass::pattern::any_input(); auto pattern_root = - pattern::wrap_type({input_p, pattern::any_input(), pattern::any_input()}, + ov::pass::pattern::wrap_type({input_p, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, need_to_erase_ric); - auto callback = [=](pattern::Matcher& m) { + auto callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto output = pattern_map.at(pattern_root); auto input = pattern_map.at(input_p); @@ -675,7 +675,7 @@ class EraseGather : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -688,20 +688,20 @@ class Binary : public ov::pass::MatcherPass { Binary() { MATCHER_SCOPE(Binary); auto fake_quantize_pattern = - pattern::wrap_type({pattern::any_input(pattern::has_static_rank()), - pattern::any_input(pattern::has_static_rank()), - pattern::any_input(pattern::has_static_rank()), - pattern::any_input(pattern::has_static_rank()), - pattern::any_input(pattern::has_static_rank())}, - pattern::has_static_rank()); - auto binary_elementwise_pattern = pattern::wrap_type( - {pattern::any_input(pattern::has_static_rank()), pattern::any_input(pattern::has_static_rank())}, - pattern::has_static_rank()); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())}, + ov::pass::pattern::has_static_rank()); + auto binary_elementwise_pattern = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())}, + ov::pass::pattern::has_static_rank()); auto pattern_root = - std::make_shared(OutputVector{fake_quantize_pattern, binary_elementwise_pattern}); + std::make_shared(OutputVector{fake_quantize_pattern, binary_elementwise_pattern}); - auto callback = [=](pattern::Matcher& m) { + auto callback = [=](ov::pass::pattern::Matcher& m) { const auto& root = m.get_match_root(); const auto& output = root->output(0); auto inputs = output.get_target_inputs(); @@ -761,7 +761,7 @@ class Binary : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; @@ -771,8 +771,8 @@ class ConvertPassThrough : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::back_prop::ConvertPassThrough"); ConvertPassThrough() { MATCHER_SCOPE(ConvertPassThrough); - auto pattern_root = pattern::wrap_type(pattern::has_static_rank()); - auto callback = [=](pattern::Matcher& m) { + auto pattern_root = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_rank()); + auto callback = [=](ov::pass::pattern::Matcher& m) { auto root = m.get_match_root(); const auto& output = root->output(0); auto consumers = output.get_target_inputs(); @@ -811,7 +811,7 @@ class ConvertPassThrough : public ov::pass::MatcherPass { return true; }; - auto m = std::make_shared(pattern_root, matcher_name); + auto m = std::make_shared(pattern_root, matcher_name); register_matcher(m, callback); } }; diff --git a/src/common/transformations/src/transformations/common_optimizations/rms_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/rms_fusion.cpp index bf66f74188544e..ca5ccee79f45ab 100644 --- a/src/common/transformations/src/transformations/common_optimizations/rms_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/rms_fusion.cpp @@ -38,62 +38,60 @@ static std::function)> constant_value(const float targ } RMSFusion::RMSFusion(bool force_tail_convert, bool enable_div_x) { - using namespace ov::pass::pattern; - - // Detect RMS decomposition pattern +// Detect RMS decomposition pattern // x * 1/Sqrt(ReduceMean(x^2,axes)+eps) * gamma - auto x = any_input(); + auto x = ov::pass::pattern::any_input(); // x^2 - auto const_power = wrap_type(constant_value(2)); - auto const_power_convert = pattern::optional(const_power); - auto power = wrap_type({x, const_power_convert}); + auto const_power = ov::pass::pattern::wrap_type(constant_value(2)); + auto const_power_convert = ov::pass::pattern::optional(const_power); + auto power = ov::pass::pattern::wrap_type({x, const_power_convert}); // ReduceMean(x^2,axes) - auto mean_axes = wrap_type(constant_value(-1)); - auto mean = wrap_type({power, mean_axes}); + auto mean_axes = ov::pass::pattern::wrap_type(constant_value(-1)); + auto mean = ov::pass::pattern::wrap_type({power, mean_axes}); // ReduceMean(x^2,axes)+eps - auto eps = wrap_type(); - auto eps_convert = pattern::optional(eps); - auto add_eps = wrap_type({mean, eps_convert}); + auto eps = ov::pass::pattern::wrap_type(); + auto eps_convert = ov::pass::pattern::optional(eps); + auto add_eps = ov::pass::pattern::wrap_type({mean, eps_convert}); // Sqrt(ReduceMean(x^2,axes)+eps) - auto sqrt = wrap_type({add_eps}); + auto sqrt = ov::pass::pattern::wrap_type({add_eps}); // 1/Sqrt(ReduceMean(x^2,axes)+eps) - auto const_pow = wrap_type(constant_value(-1)); - auto const_pow_convert = pattern::optional(const_pow); - auto pow = wrap_type({sqrt, const_pow_convert}); + auto const_pow = ov::pass::pattern::wrap_type(constant_value(-1)); + auto const_pow_convert = ov::pass::pattern::optional(const_pow); + auto pow = ov::pass::pattern::wrap_type({sqrt, const_pow_convert}); - auto const_div = wrap_type(constant_value(1)); - auto const_div_convert = pattern::optional(const_div); - auto div = wrap_type({const_div_convert, sqrt}); - auto div_or_pow = std::make_shared(OutputVector{div, pow}); + auto const_div = ov::pass::pattern::wrap_type(constant_value(1)); + auto const_div_convert = ov::pass::pattern::optional(const_div); + auto div = ov::pass::pattern::wrap_type({const_div_convert, sqrt}); + auto div_or_pow = std::make_shared(OutputVector{div, pow}); // x * 1/Sqrt(ReduceMean(x^2,axes)+eps) - auto mul1 = wrap_type({x, div_or_pow}); + auto mul1 = ov::pass::pattern::wrap_type({x, div_or_pow}); - std::shared_ptr mul_or_div; + std::shared_ptr mul_or_div; // TODO: Check div_x pattern failed in CPU CI Pytorch layer test. if (enable_div_x) { // x / Sqrt(ReduceMean(x^2,axes)+eps) - auto div_x = wrap_type({x, sqrt}); - mul_or_div = std::make_shared(OutputVector{mul1, div_x}); + auto div_x = ov::pass::pattern::wrap_type({x, sqrt}); + mul_or_div = std::make_shared(OutputVector{mul1, div_x}); } else { - mul_or_div = std::make_shared(OutputVector{mul1}); + mul_or_div = std::make_shared(OutputVector{mul1}); } // x * 1/Sqrt(ReduceMean(x^2,axes)+eps) * gamma - auto gamma = wrap_type(); - auto gamma_convert = pattern::optional(gamma); + auto gamma = ov::pass::pattern::wrap_type(); + auto gamma_convert = ov::pass::pattern::optional(gamma); - auto mul2 = wrap_type({gamma_convert, mul_or_div}); + auto mul2 = ov::pass::pattern::wrap_type({gamma_convert, mul_or_div}); std::shared_ptr comp = mul2; if (force_tail_convert) { // compress RMS result - comp = wrap_type({mul2}); + comp = ov::pass::pattern::wrap_type({mul2}); } ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/sdpa_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/sdpa_fusion.cpp index 597031e8dc233b..90396627d1702a 100644 --- a/src/common/transformations/src/transformations/common_optimizations/sdpa_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/sdpa_fusion.cpp @@ -32,9 +32,6 @@ #include "openvino/util/pp.hpp" #include "transformations/symbolic_transformations/symbolic_optimizations.hpp" #include "transformations/utils/utils.hpp" - -using namespace ov::op; - namespace { std::vector get_order(const ov::pass::pattern::PatternSymbolValue& any_layout_sym, @@ -104,42 +101,38 @@ bool SDPAFusion::run_on_model(const std::shared_ptr& model) { SDPAReshapeFusion::SDPAReshapeFusion() { MATCHER_SCOPE(SDPAReshapeFusion); - - using namespace ov::op; - using namespace ov::pass::pattern; - - auto q = any_input(shape_matches("Batches..., S_q, D")); - auto k = any_input(shape_matches("AnyLayout...") && rank_more_than(2)); - auto v = any_input(shape_matches("Batches..., S_kv, D") && check_layout("AnyLayout")); - auto mask = any_input(has_static_rank()); +auto q = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("Batches..., S_q, D")); + auto k = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("AnyLayout...") && ov::pass::pattern::rank_more_than(2)); + auto v = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("Batches..., S_kv, D") && check_layout("AnyLayout")); + auto mask = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); // these Reshape/Unsqueeze may already exist in the graph - auto unsq_q = wrap_type({q, any_input()}); - auto unsq_k = wrap_type({k, any_input()}); - auto unsq_v = wrap_type({v, any_input()}); + auto unsq_q = ov::pass::pattern::wrap_type({q, ov::pass::pattern::any_input()}); + auto unsq_k = ov::pass::pattern::wrap_type({k, ov::pass::pattern::any_input()}); + auto unsq_v = ov::pass::pattern::wrap_type({v, ov::pass::pattern::any_input()}); // this Transpose may already exist in the graph - auto opt_original_transpose_k = optional({unsq_k, any_input()}); + auto opt_original_transpose_k = ov::pass::pattern::optional({unsq_k, ov::pass::pattern::any_input()}); // these Reshape/Unsqueeze may be inserted by SDPAFusionMatcher - auto opt_unsq_q = optional({unsq_q, any_input()}); - auto opt_unsq_k = optional({opt_original_transpose_k, any_input()}); - auto opt_unsq_v = optional({unsq_v, any_input()}); + auto opt_unsq_q = ov::pass::pattern::optional({unsq_q, ov::pass::pattern::any_input()}); + auto opt_unsq_k = ov::pass::pattern::optional({opt_original_transpose_k, ov::pass::pattern::any_input()}); + auto opt_unsq_v = ov::pass::pattern::optional({unsq_v, ov::pass::pattern::any_input()}); // this Transpose may be inserted by SDPAFusionMatcher - auto opt_transpose_k = optional({opt_unsq_k, any_input()}, shape_matches("..., S_kv, D")); + auto opt_transpose_k = ov::pass::pattern::optional({opt_unsq_k, ov::pass::pattern::any_input()}, ov::pass::pattern::shape_matches("..., S_kv, D")); - auto sdpa_pattern = wrap_type({ + auto sdpa_pattern = ov::pass::pattern::wrap_type({ opt_unsq_q, opt_transpose_k, opt_unsq_v, mask, - any_input(), + ov::pass::pattern::any_input(), }); - auto opt_sdpa_reshape = optional({sdpa_pattern, any_input()}); + auto opt_sdpa_reshape = ov::pass::pattern::optional({sdpa_pattern, ov::pass::pattern::any_input()}); auto post_sdpa = - wrap_type({opt_sdpa_reshape, any_input()}, shape_matches("Batches..., S_q, D")); + ov::pass::pattern::wrap_type({opt_sdpa_reshape, ov::pass::pattern::any_input()}, ov::pass::pattern::shape_matches("Batches..., S_q, D")); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pm = m.get_pattern_value_map(); @@ -184,7 +177,7 @@ SDPAReshapeFusion::SDPAReshapeFusion() { k_node = transpose; } else { if (!is_ascending_order) { - auto transpose_order = v0::Constant::create(ov::element::i64, {order.size()}, order); + auto transpose_order = ov::op::v0::Constant::create(ov::element::i64, {order.size()}, order); k_node = std::make_shared(k_node, transpose_order); ov::copy_runtime_info(m.get_matched_nodes(), {transpose_order, k_node.get_node_shared_ptr()}); } @@ -207,7 +200,7 @@ SDPAReshapeFusion::SDPAReshapeFusion() { return true; }; - auto m = std::make_shared(post_sdpa, "SDPAReshapeFusion"); + auto m = std::make_shared(post_sdpa, "SDPAReshapeFusion"); this->register_matcher(m, callback); } @@ -229,14 +222,14 @@ static std::shared_ptr get_scale(std::shared_ptr scale_patte return nullptr; } else { if (rank.get_length() > 1) { - scale_node = ov::op::util::make_try_fold(scale_node, - v0::Constant::create(ov::element::i64, {1}, {1}), + scale_node = ov::op::util::make_try_fold(scale_node, + ov::op::v0::Constant::create(ov::element::i64, {1}, {1}), false); } return scale_node.get_node_shared_ptr(); } } else { - return v0::Constant::create(default_scale_type, ov::Shape{}, {1.0}); + return ov::op::v0::Constant::create(default_scale_type, ov::Shape{}, {1.0}); } } @@ -261,7 +254,7 @@ static std::shared_ptr get_mask(std::shared_ptr mask_pattern // mask should be broadcastable to qk shape // Create temporary copy for broadcast_merge_into as it modifies the first argument auto qk_out_ps_temp = qk_out_ps; - if (!ov::PartialShape::broadcast_merge_into(qk_out_ps_temp, mask_input_ps, AutoBroadcastType::NUMPY)) + if (!ov::PartialShape::broadcast_merge_into(qk_out_ps_temp, mask_input_ps, ov::op::AutoBroadcastType::NUMPY)) return nullptr; if (mask_input_ps.size() < 2) { @@ -269,8 +262,8 @@ static std::shared_ptr get_mask(std::shared_ptr mask_pattern auto diff = 2 - mask_input_ps.size(); std::vector axes(diff); std::iota(axes.begin(), axes.end(), 0); - auto axes_const = v0::Constant::create(ov::element::i64, ov::Shape{axes.size()}, axes); - auto mask_unsqueeze = std::make_shared(mask_node, axes_const); + auto axes_const = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{axes.size()}, axes); + auto mask_unsqueeze = std::make_shared(mask_node, axes_const); mask_unsqueeze->set_friendly_name(mask_node.get_node_shared_ptr()->get_friendly_name() + "/Squeeze"); ov::copy_runtime_info(matcher.get_matched_nodes(), mask_unsqueeze); mask_node = mask_unsqueeze; @@ -285,8 +278,8 @@ static std::shared_ptr get_mask(std::shared_ptr mask_pattern } } if (!axes.empty()) { - auto axes_const = v0::Constant::create(ov::element::i64, ov::Shape{axes.size()}, axes); - auto mask_squeeze = std::make_shared(mask_node, axes_const); + auto axes_const = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{axes.size()}, axes); + auto mask_squeeze = std::make_shared(mask_node, axes_const); mask_squeeze->set_friendly_name(mask_node.get_node_shared_ptr()->get_friendly_name() + "/Squeeze"); ov::copy_runtime_info(matcher.get_matched_nodes(), mask_squeeze); mask_node = mask_squeeze; @@ -294,7 +287,7 @@ static std::shared_ptr get_mask(std::shared_ptr mask_pattern } return mask_node.get_node_shared_ptr(); } else { - return v0::Constant::create(default_mask_type, ov::Shape{}, {0}); + return ov::op::v0::Constant::create(default_mask_type, ov::Shape{}, {0}); } } @@ -319,8 +312,8 @@ static ov::OutputVector get_qkv(ov::OutputVector qkv, if (diff > 0) { std::vector axes(diff, 0); std::iota(axes.begin(), axes.end(), 0); - auto axes_node = v0::Constant::create(ov::element::i64, ov::Shape{static_cast(diff)}, axes); - auto reshape = std::make_shared(qkv[i], axes_node); + auto axes_node = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{static_cast(diff)}, axes); + auto reshape = std::make_shared(qkv[i], axes_node); qkv[i] = reshape; ov::copy_runtime_info(matcher.get_matched_nodes(), {reshape, axes_node}); } @@ -331,8 +324,8 @@ static ov::OutputVector get_qkv(ov::OutputVector qkv, std::vector axes_values(pshape.size()); std::iota(axes_values.begin(), axes_values.end(), 0); std::swap(axes_values[axes_values.size() - 1], axes_values[axes_values.size() - 2]); - auto axes = v0::Constant::create(ov::element::i64, {axes_values.size()}, axes_values); - qkv[i] = std::make_shared(qkv[i], axes); + auto axes = ov::op::v0::Constant::create(ov::element::i64, {axes_values.size()}, axes_values); + qkv[i] = std::make_shared(qkv[i], axes); ov::copy_runtime_info(matcher.get_matched_nodes(), {axes, qkv[i].get_node_shared_ptr()}); } } @@ -341,11 +334,7 @@ static ov::OutputVector get_qkv(ov::OutputVector qkv, SDPAFusionMatcher::SDPAFusionMatcher() { MATCHER_SCOPE(SDPAFusionMatcher); - - using namespace ov::op; - using namespace ov::pass::pattern; - - /* +/* * Corner Case: Dynamic Mask and Attention Scores * When the mask and the attention scores (after MatMul) have [..., -1, -1] shapes, * we cannot automatically determine symbols and propogate them. @@ -368,27 +357,27 @@ SDPAFusionMatcher::SDPAFusionMatcher() { return true; }; - auto q = any_input(shape_matches("..., H, S_q, E") || shape_matches("S_q, E")); - auto k = any_input(shape_matches("..., H, S_kv, E") || shape_matches("S_kv, E")); - auto kT = any_input(shape_matches("..., H, E, S_kv") || shape_matches("E, S_kv")); - auto v = any_input(shape_matches("..., H, S_kv, Ev") || shape_matches("S_kv, Ev")); + auto q = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, S_q, E") || ov::pass::pattern::shape_matches("S_q, E")); + auto k = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, S_kv, E") || ov::pass::pattern::shape_matches("S_kv, E")); + auto kT = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, E, S_kv") || ov::pass::pattern::shape_matches("E, S_kv")); + auto v = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, S_kv, Ev") || ov::pass::pattern::shape_matches("S_kv, Ev")); - auto attn_scale = any_input(); + auto attn_scale = ov::pass::pattern::any_input(); - auto opt_k_scale = optional({k, attn_scale}); - auto opt_kT_scale = optional({kT, attn_scale}); + auto opt_k_scale = ov::pass::pattern::optional({k, attn_scale}); + auto opt_kT_scale = ov::pass::pattern::optional({kT, attn_scale}); - auto qk_pred = (shape_matches("..., H, S_q, S_kv") || shape_matches("S_q, S_kv")) && consumers_count(1); - auto qk = wrap_type({q, opt_kT_scale}, qk_pred, {{"transpose_a", false}, {"transpose_b", false}}); + auto qk_pred = (ov::pass::pattern::shape_matches("..., H, S_q, S_kv") || ov::pass::pattern::shape_matches("S_q, S_kv")) && ov::pass::pattern::consumers_count(1); + auto qk = ov::pass::pattern::wrap_type({q, opt_kT_scale}, qk_pred, {{"transpose_a", false}, {"transpose_b", false}}); auto qk_transpose_b = - wrap_type({q, opt_k_scale}, qk_pred, {{"transpose_a", false}, {"transpose_b", true}}); + ov::pass::pattern::wrap_type({q, opt_k_scale}, qk_pred, {{"transpose_a", false}, {"transpose_b", true}}); auto qk_alternatives = qk | qk_transpose_b; // Optional unsqueeze that is converted to Reshape - auto unsqueeze_axis = wrap_type(); - auto qk_opt_unsqueeze = optional({qk_alternatives, unsqueeze_axis}); + auto unsqueeze_axis = ov::pass::pattern::wrap_type(); + auto qk_opt_unsqueeze = ov::pass::pattern::optional({qk_alternatives, unsqueeze_axis}); - auto qk_scaled = wrap_type({qk_opt_unsqueeze, attn_scale}); + auto qk_scaled = ov::pass::pattern::wrap_type({qk_opt_unsqueeze, attn_scale}); auto qk_opt_scaled = qk_scaled | qk_opt_unsqueeze; // Optional nodes: @@ -396,12 +385,12 @@ SDPAFusionMatcher::SDPAFusionMatcher() { // 2. Reshape before adding mask // 3. Mask add // 4. Reshape after adding mask - auto mask = any_input(has_static_rank()); - auto qk_opt_scaled_pre_mask_opt_reshaped = optional({qk_opt_scaled, any_input()}); + auto mask = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto qk_opt_scaled_pre_mask_opt_reshaped = ov::pass::pattern::optional({qk_opt_scaled, ov::pass::pattern::any_input()}); - auto add_pred = consumers_count(1) && corner_case_check; - auto qk_opt_scaled_opt_mask_added = optional({qk_opt_scaled_pre_mask_opt_reshaped, mask}, add_pred); - auto qk_post_mask_opt_reshaped = optional({qk_opt_scaled_opt_mask_added, any_input()}); + auto add_pred = ov::pass::pattern::consumers_count(1) && corner_case_check; + auto qk_opt_scaled_opt_mask_added = ov::pass::pattern::optional({qk_opt_scaled_pre_mask_opt_reshaped, mask}, add_pred); + auto qk_post_mask_opt_reshaped = ov::pass::pattern::optional({qk_opt_scaled_opt_mask_added, ov::pass::pattern::any_input()}); // Softmax axis can be: // Pattern 1: axis = -1 (last axis) @@ -417,13 +406,13 @@ SDPAFusionMatcher::SDPAFusionMatcher() { return static_cast(input_rank.get_length() - 1) == axis; }); auto softmax_pred = - consumers_count(1) && axis_predicate && (shape_matches("..., H, S_q, S_kv") || shape_matches("S_q, S_kv")); - auto softmax = wrap_type({qk_post_mask_opt_reshaped}, softmax_pred); - auto softmax_opt_reshaped = optional({softmax, any_input()}); + ov::pass::pattern::consumers_count(1) && axis_predicate && (ov::pass::pattern::shape_matches("..., H, S_q, S_kv") || ov::pass::pattern::shape_matches("S_q, S_kv")); + auto softmax = ov::pass::pattern::wrap_type({qk_post_mask_opt_reshaped}, softmax_pred); + auto softmax_opt_reshaped = ov::pass::pattern::optional({softmax, ov::pass::pattern::any_input()}); - auto qkv_shape = shape_matches("..., H, S_q, Ev") || shape_matches("S_q, Ev"); + auto qkv_shape = ov::pass::pattern::shape_matches("..., H, S_q, Ev") || ov::pass::pattern::shape_matches("S_q, Ev"); auto qkv = - wrap_type({softmax_opt_reshaped, v}, qkv_shape, {{"transpose_a", false}, {"transpose_b", false}}); + ov::pass::pattern::wrap_type({softmax_opt_reshaped, v}, qkv_shape, {{"transpose_a", false}, {"transpose_b", false}}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pm = m.get_pattern_value_map(); @@ -459,42 +448,38 @@ SDPAFusionMatcher::SDPAFusionMatcher() { return false; std::shared_ptr sdpa = - std::make_shared(qkv[0], qkv[1], qkv[2], mask_input, scale_node, false); + std::make_shared(qkv[0], qkv[1], qkv[2], mask_input, scale_node, false); sdpa->set_friendly_name(m.get_match_root()->get_friendly_name()); ov::copy_runtime_info(m.get_matched_nodes(), sdpa); ov::replace_node(m.get_match_root(), sdpa); return true; }; - auto m = std::make_shared(qkv, "SDPAFusionMatcher"); + auto m = std::make_shared(qkv, "SDPAFusionMatcher"); this->register_matcher(m, callback); } SDPAFusionMatcherSinks::SDPAFusionMatcherSinks() { MATCHER_SCOPE(SDPAFusionMatcherSinks); - - using namespace ov::op; - using namespace ov::pass::pattern; - - auto v = any_input(rank_equals(4)); - auto k = any_input(rank_equals(4)); - auto q = any_input(rank_equals(4)); +auto v = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto k = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto q = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto qk_transpose_b = - wrap_type({q, k}, consumers_count(1), {{"transpose_a", false}, {"transpose_b", true}}); + ov::pass::pattern::wrap_type({q, k}, ov::pass::pattern::consumers_count(1), {{"transpose_a", false}, {"transpose_b", true}}); - auto attn_scale = any_input(); - auto opt_qk_scaled = optional({qk_transpose_b, attn_scale}); + auto attn_scale = ov::pass::pattern::any_input(); + auto opt_qk_scaled = ov::pass::pattern::optional({qk_transpose_b, attn_scale}); - auto mask = any_input(has_static_rank()); - auto add_pred = consumers_count(1); - auto opt_mask_add = optional({opt_qk_scaled, mask}, add_pred); + auto mask = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto add_pred = ov::pass::pattern::consumers_count(1); + auto opt_mask_add = ov::pass::pattern::optional({opt_qk_scaled, mask}, add_pred); - auto sinks = any_input(); - auto sinks_broadcast = wrap_type({sinks, any_input()}); - auto sinks_concat = wrap_type({opt_mask_add, sinks_broadcast}); - auto sinks_rm = wrap_type({sinks_concat, any_input()}); - auto sinks_sub = wrap_type({sinks_concat, sinks_rm}); + auto sinks = ov::pass::pattern::any_input(); + auto sinks_broadcast = ov::pass::pattern::wrap_type({sinks, ov::pass::pattern::any_input()}); + auto sinks_concat = ov::pass::pattern::wrap_type({opt_mask_add, sinks_broadcast}); + auto sinks_rm = ov::pass::pattern::wrap_type({sinks_concat, ov::pass::pattern::any_input()}); + auto sinks_sub = ov::pass::pattern::wrap_type({sinks_concat, sinks_rm}); // Softmax axis can be: // Pattern 1: axis = -1 (last axis) @@ -509,12 +494,12 @@ SDPAFusionMatcherSinks::SDPAFusionMatcherSinks() { auto axis = ov::util::try_normalize_axis(softmax->get_axis(), input_rank, *softmax); return static_cast(input_rank.get_length() - 1) == axis; }); - auto softmax_pred = consumers_count(1) && axis_predicate; - auto softmax = wrap_type({sinks_sub}, softmax_pred); + auto softmax_pred = ov::pass::pattern::consumers_count(1) && axis_predicate; + auto softmax = ov::pass::pattern::wrap_type({sinks_sub}, softmax_pred); - auto sinks_slice = wrap_type({softmax, any_input(), any_input(), any_input()}) | - wrap_type({softmax, any_input(), any_input(), any_input(), any_input()}); - auto qkv = wrap_type({sinks_slice, v}); + auto sinks_slice = ov::pass::pattern::wrap_type({softmax, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}) | + ov::pass::pattern::wrap_type({softmax, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto qkv = ov::pass::pattern::wrap_type({sinks_slice, v}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pm = m.get_pattern_value_map(); @@ -548,7 +533,7 @@ SDPAFusionMatcherSinks::SDPAFusionMatcherSinks() { std::shared_ptr sdpa; if (sinks_present) { const auto& sinks_node = pm.at(sinks); - sdpa = std::make_shared(qkv[0], + sdpa = std::make_shared(qkv[0], qkv[1], qkv[2], mask_input, @@ -557,7 +542,7 @@ SDPAFusionMatcherSinks::SDPAFusionMatcherSinks() { false); } else { sdpa = - std::make_shared(qkv[0], qkv[1], qkv[2], mask_input, scale_node, false); + std::make_shared(qkv[0], qkv[1], qkv[2], mask_input, scale_node, false); } sdpa->set_friendly_name(m.get_match_root()->get_friendly_name()); ov::copy_runtime_info(m.get_matched_nodes(), sdpa); @@ -565,7 +550,7 @@ SDPAFusionMatcherSinks::SDPAFusionMatcherSinks() { return true; }; - auto m = std::make_shared(qkv, "SDPAFusionMatcherSinks"); + auto m = std::make_shared(qkv, "SDPAFusionMatcherSinks"); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/sdpa_scale_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/sdpa_scale_fusion.cpp index 47d24c963f8fc2..e40a0a5bad8622 100644 --- a/src/common/transformations/src/transformations/common_optimizations/sdpa_scale_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/sdpa_scale_fusion.cpp @@ -35,23 +35,21 @@ bool SDPAScaleFusion::run_on_model(const std::shared_ptr& model) { } SDPAScaleFusionPass::SDPAScaleFusionPass() { - using namespace ov::pass::pattern; - - auto q = any_input(rank_equals(4)); - auto k = any_input(rank_equals(4)); - auto v = any_input(rank_equals(4)); - auto mask = any_input(); - auto sdpa_scale = wrap_const(); - auto scale_q = any_input(shape_matches("[]") || shape_matches("[1]")); - auto scale_k = any_input(shape_matches("[]") || shape_matches("[1]")); - - auto scaled_q = optional({q, scale_q}); - auto scaled_k = optional({k, scale_k}); - auto sdpa_mask_scale = wrap_type({scaled_q, scaled_k, v, mask, sdpa_scale}, +auto q = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto k = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto v = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto mask = ov::pass::pattern::any_input(); + auto sdpa_scale = ov::pass::pattern::wrap_const(); + auto scale_q = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[]") || ov::pass::pattern::shape_matches("[1]")); + auto scale_k = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[]") || ov::pass::pattern::shape_matches("[1]")); + + auto scaled_q = ov::pass::pattern::optional({q, scale_q}); + auto scaled_k = ov::pass::pattern::optional({k, scale_k}); + auto sdpa_mask_scale = ov::pass::pattern::wrap_type({scaled_q, scaled_k, v, mask, sdpa_scale}, {{"causal", false}}); auto sdpa_mask = - wrap_type({scaled_q, scaled_k, v, mask}, {{"causal", false}}); - auto sdpa_simple = wrap_type({scaled_q, scaled_k, v}, {{"causal", false}}); + ov::pass::pattern::wrap_type({scaled_q, scaled_k, v, mask}, {{"causal", false}}); + auto sdpa_simple = ov::pass::pattern::wrap_type({scaled_q, scaled_k, v}, {{"causal", false}}); auto sdpa = sdpa_simple | sdpa_mask | sdpa_mask_scale; ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/select_with_one_value_condition.cpp b/src/common/transformations/src/transformations/common_optimizations/select_with_one_value_condition.cpp index c698b71f48e187..592a80bcdc585e 100644 --- a/src/common/transformations/src/transformations/common_optimizations/select_with_one_value_condition.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/select_with_one_value_condition.cpp @@ -23,12 +23,12 @@ using namespace ov::op::util; ov::pass::SelectWithOneValueCondition::SelectWithOneValueCondition() { MATCHER_SCOPE(SelectWithOneValueCondition); - auto condition = pattern::wrap_type(); - auto then_branch = pattern::any_input(); - auto else_branch = pattern::any_input(); + auto condition = ov::pass::pattern::wrap_type(); + auto then_branch = ov::pass::pattern::any_input(); + auto else_branch = ov::pass::pattern::any_input(); auto select_pattern = make_shared(condition, then_branch, else_branch); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { NodeRegistry copy_from; NodeRegistry copy_to; auto& pattern_map = m.get_pattern_value_map(); @@ -94,6 +94,6 @@ ov::pass::SelectWithOneValueCondition::SelectWithOneValueCondition() { return true; }; - auto m = make_shared(select_pattern, matcher_name); + auto m = make_shared(select_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/sequence_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/sequence_fusion.cpp index 8ae66cdddfb9dc..de2b8735d50698 100644 --- a/src/common/transformations/src/transformations/common_optimizations/sequence_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/sequence_fusion.cpp @@ -300,8 +300,8 @@ bool create_sequence(ov::pass::NodeRegistry& cp_to, ov::pass::SequenceFusion::SequenceFusion() { MATCHER_SCOPE(SequenceFusion); - auto cell = pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + auto cell = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { NodeRegistry copy_from; NodeRegistry copy_to; auto cell = m.get_match_root(); @@ -361,6 +361,6 @@ ov::pass::SequenceFusion::SequenceFusion() { return true; }; - auto m = make_shared(cell, matcher_name); + auto m = make_shared(cell, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/shared_ops_optimization.cpp b/src/common/transformations/src/transformations/common_optimizations/shared_ops_optimization.cpp index 502b015905b916..54cda0a64b717e 100644 --- a/src/common/transformations/src/transformations/common_optimizations/shared_ops_optimization.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/shared_ops_optimization.cpp @@ -13,8 +13,6 @@ using namespace std; using namespace ov; -using namespace ov::op; - namespace { #define ACCESSOR(type) \ void on_adapter(const std::string& name, ValueAccessor& adapter) override { \ @@ -64,8 +62,8 @@ bool inputs_from_same_source_or_equal_constants(const std::shared_ptr& lhs for (size_t i = 0; i < input_size; ++i) { if (ov::op::util::input_sources_are_equal(lhs, rhs, i)) continue; - auto lhs_constant = as_type(lhs->get_input_node_ptr(i)); - auto rhs_constant = as_type(rhs->get_input_node_ptr(i)); + auto lhs_constant = as_type(lhs->get_input_node_ptr(i)); + auto rhs_constant = as_type(rhs->get_input_node_ptr(i)); if (!lhs_constant || !rhs_constant) return false; if (lhs_constant->get_element_type() != rhs_constant->get_element_type()) @@ -191,8 +189,8 @@ bool shape_of_upgrade(const shared_ptr& model) { if (sub_graph) rewritten = shape_of_upgrade(sub_graph) || rewritten; } - } else if (auto v1_shape_of = ov::as_type_ptr(op)) { - auto v3_shape_of = std::make_shared(v1_shape_of->input_value(0), element::i64); + } else if (auto v1_shape_of = ov::as_type_ptr(op)) { + auto v3_shape_of = std::make_shared(v1_shape_of->input_value(0), element::i64); v3_shape_of->set_friendly_name(v1_shape_of->get_friendly_name()); ov::replace_output_update_name(v1_shape_of, v3_shape_of); rewritten = true; diff --git a/src/common/transformations/src/transformations/common_optimizations/shuffle_channels_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/shuffle_channels_fusion.cpp index d11eb084224762..e3cab3e451e3d9 100644 --- a/src/common/transformations/src/transformations/common_optimizations/shuffle_channels_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/shuffle_channels_fusion.cpp @@ -85,21 +85,21 @@ bool check_shapes(const ov::PartialShape& pshape_input, ov::pass::ShuffleChannelsFusion::ShuffleChannelsFusion(const bool reshape_constants_check) { MATCHER_SCOPE(ShuffleChannelsFusion); - auto input = pass::pattern::any_input(pattern::rank_equals(4)); + auto input = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto reshape_before_const_pattern = ov::pass::pattern::wrap_type(); auto transpose_const_pattern = ov::pass::pattern::wrap_type(); auto reshape_after_const_pattern = ov::pass::pattern::wrap_type(); auto reshape_before_pattern = ov::pass::pattern::wrap_type({input, reshape_before_const_pattern}, - pattern::consumers_count(1)); + ov::pass::pattern::consumers_count(1)); auto transpose_pattern = ov::pass::pattern::wrap_type({reshape_before_pattern, transpose_const_pattern}, - pattern::consumers_count(1)); + ov::pass::pattern::consumers_count(1)); auto reshape_after_pattern = ov::pass::pattern::wrap_type({transpose_pattern, reshape_after_const_pattern}); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto data = pattern_map.at(input); diff --git a/src/common/transformations/src/transformations/common_optimizations/simplify_shape_of_sub_graph.cpp b/src/common/transformations/src/transformations/common_optimizations/simplify_shape_of_sub_graph.cpp index 3b30226b31a104..d668a2d2bafafe 100644 --- a/src/common/transformations/src/transformations/common_optimizations/simplify_shape_of_sub_graph.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/simplify_shape_of_sub_graph.cpp @@ -30,14 +30,11 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::op; -using namespace ov::pass::pattern; - pass::GroupedGatherElimination::GroupedGatherElimination() { MATCHER_SCOPE(GroupedGatherElimination); - auto concat_label = wrap_type(rank_equals(1)); + auto concat_label = ov::pass::pattern::wrap_type(ov::pass::pattern::rank_equals(1)); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto concat = m.get_match_root(); OutputVector inputs = concat->input_values(); NodeRegistry new_ops; @@ -45,7 +42,7 @@ pass::GroupedGatherElimination::GroupedGatherElimination() { while (inputs.size() > i + 1) { auto curr = inputs[i].get_node_shared_ptr(), next = inputs[i + 1].get_node_shared_ptr(); if (curr->get_type_info() != next->get_type_info() || - (!is_type(curr) && !is_type(curr) && !is_type(curr)) || + (!is_type(curr) && !is_type(curr) && !is_type(curr)) || (curr->input_value(0) != next->input_value(0))) { ++i; continue; @@ -70,30 +67,30 @@ pass::GroupedGatherElimination::GroupedGatherElimination() { } else { constexpr auto common_type = element::i64; if (curr_et != common_type) { - curr_indices = new_ops.make(curr_indices, common_type); + curr_indices = new_ops.make(curr_indices, common_type); } if (next_et != common_type) { - next_indices = new_ops.make(next_indices, common_type); + next_indices = new_ops.make(next_indices, common_type); } } } // curr and next are the same type of gather which takes data from the same source auto joint_indices = - new_ops.add(ov::op::util::make_try_fold(OutputVector{curr_indices, next_indices}, 0)); + new_ops.add(ov::op::util::make_try_fold(OutputVector{curr_indices, next_indices}, 0)); std::shared_ptr new_gather; - if (is_type(curr)) { - new_gather = register_new_node(curr->input_value(0), + if (is_type(curr)) { + new_gather = register_new_node(curr->input_value(0), joint_indices->output(0), - v0::Constant::create(element::i64, {}, {0})->output(0)); - } else if (is_type(curr)) { - new_gather = register_new_node(curr->input_value(0), + ov::op::v0::Constant::create(element::i64, {}, {0})->output(0)); + } else if (is_type(curr)) { + new_gather = register_new_node(curr->input_value(0), joint_indices->output(0), - v0::Constant::create(element::i64, {}, {0})->output(0)); - } else if (is_type(curr)) { - new_gather = register_new_node(curr->input_value(0), + ov::op::v0::Constant::create(element::i64, {}, {0})->output(0)); + } else if (is_type(curr)) { + new_gather = register_new_node(curr->input_value(0), joint_indices->output(0), - v0::Constant::create(element::i64, {}, {0})->output(0)); + ov::op::v0::Constant::create(element::i64, {}, {0})->output(0)); } else { OPENVINO_THROW("Unexpected Gather version"); } @@ -106,7 +103,7 @@ pass::GroupedGatherElimination::GroupedGatherElimination() { if (inputs.size() == 1) // we can optimize out concat return replace_output_update_name(concat->output(0), inputs[0]); if (original_inputs_size > inputs.size()) { - auto new_concat = std::make_shared(inputs, 0); + auto new_concat = std::make_shared(inputs, 0); new_concat->set_friendly_name(concat->get_friendly_name()); ov::copy_runtime_info(concat, new_concat); ov::replace_node(concat, new_concat); @@ -115,16 +112,16 @@ pass::GroupedGatherElimination::GroupedGatherElimination() { return false; }; - auto m = std::make_shared(concat_label, matcher_name); + auto m = std::make_shared(concat_label, matcher_name); this->register_matcher(m, callback); } pass::GatherNopElimination::GatherNopElimination() { MATCHER_SCOPE(GatherNopElimination); - const auto gather_label = wrap_type( - {any_input(has_static_shape()), wrap_type(), wrap_type()}); + const auto gather_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}); - matcher_pass_callback callback = [](Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto gather = m.get_match_root(); const auto& number_of_indices = shape_size(gather->get_input_shape(1)); if (gather->get_input_shape(0) != gather->get_output_shape(0) || shape_size(gather->get_input_shape(2)) != 1 || @@ -139,23 +136,23 @@ pass::GatherNopElimination::GatherNopElimination() { } return replace_output_update_name(gather->output(0), gather->input_value(0)); }; - auto m = std::make_shared(gather_label, matcher_name); + auto m = std::make_shared(gather_label, matcher_name); this->register_matcher(m, callback); } pass::AbsSinking::AbsSinking() { MATCHER_SCOPE(AbsSinking); - const auto abs_label = wrap_type(pattern::rank_equals(1)); + const auto abs_label = ov::pass::pattern::wrap_type(ov::pass::pattern::rank_equals(1)); - matcher_pass_callback callback = [](Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { NodeVector abs_ops = {m.get_match_root()}; bool graph_got_changed = false; - if (auto concat = as_type_ptr(abs_ops[0]->get_input_node_shared_ptr(0))) { + if (auto concat = as_type_ptr(abs_ops[0]->get_input_node_shared_ptr(0))) { for (const auto& input : concat->inputs()) { - auto new_abs = ov::op::util::make_try_fold(input.get_source_output()); - if (!as_type_ptr(new_abs)) + auto new_abs = ov::op::util::make_try_fold(input.get_source_output()); + if (!as_type_ptr(new_abs)) abs_ops.push_back(new_abs); input.replace_source_output(new_abs); ov::copy_runtime_info(abs_ops[0], new_abs); @@ -168,7 +165,7 @@ pass::AbsSinking::AbsSinking() { // This is intentionally left to ConstantFolding pass which is better suited for this task for (const auto& abs : abs_ops) { // Skip Abs operations applied to constants - let ConstantFolding handle them - if (ov::is_type(abs->get_input_node_ptr(0))) { + if (ov::is_type(abs->get_input_node_ptr(0))) { continue; } @@ -180,19 +177,19 @@ pass::AbsSinking::AbsSinking() { } return graph_got_changed; }; - auto m = std::make_shared(abs_label, matcher_name); + auto m = std::make_shared(abs_label, matcher_name); this->register_matcher(m, callback); } pass::SimplifyGatherShapeOf::SimplifyGatherShapeOf() { MATCHER_SCOPE(SimplifyGatherShapeOf); - const auto data_pattern = pattern::any_input(pattern::has_static_rank()); - const auto indices_pattern = pattern::any_input(pattern::has_static_rank()); - const auto axis_pattern = wrap_type(); - const auto gather_pattern = wrap_type({data_pattern, indices_pattern, axis_pattern}); - const auto shape_of_pattern = wrap_type({gather_pattern}); + const auto data_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + const auto indices_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + const auto axis_pattern = ov::pass::pattern::wrap_type(); + const auto gather_pattern = ov::pass::pattern::wrap_type({data_pattern, indices_pattern, axis_pattern}); + const auto shape_of_pattern = ov::pass::pattern::wrap_type({gather_pattern}); - matcher_pass_callback callback = [](Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); auto gather = as_type_ptr(node->input_value(0).get_node_shared_ptr()); if (!gather || gather->get_batch_dims() != 0) { @@ -202,9 +199,9 @@ pass::SimplifyGatherShapeOf::SimplifyGatherShapeOf() { auto gather_in_rank = gather->get_input_partial_shape(0).rank(); auto indices_rank = gather->get_input_partial_shape(1).rank(); - auto zero_axis = v0::Constant::create(element::i64, Shape{}, {0}); + auto zero_axis = ov::op::v0::Constant::create(element::i64, Shape{}, {0}); NodeVector new_ops; - auto new_shapeof = std::make_shared(gather->input_value(0), node->get_output_element_type(0)); + auto new_shapeof = std::make_shared(gather->input_value(0), node->get_output_element_type(0)); new_ops.push_back(new_shapeof); std::shared_ptr replace_op; if (indices_rank.get_length() == 0) { @@ -216,21 +213,21 @@ pass::SimplifyGatherShapeOf::SimplifyGatherShapeOf() { vi.push_back(i); } } - auto new_indices = v0::Constant::create(element::i64, Shape{vi.size()}, vi); - replace_op = std::make_shared(new_shapeof, new_indices, zero_axis); + auto new_indices = ov::op::v0::Constant::create(element::i64, Shape{vi.size()}, vi); + replace_op = std::make_shared(new_shapeof, new_indices, zero_axis); new_ops.push_back(replace_op); } else { NodeVector concat_inputs; if (axis > 0) { std::vector vi(axis); std::iota(vi.begin(), vi.end(), 0); - auto indices = v0::Constant::create(element::i64, Shape{vi.size()}, vi); - auto new_gather = std::make_shared(new_shapeof, indices, zero_axis); + auto indices = ov::op::v0::Constant::create(element::i64, Shape{vi.size()}, vi); + auto new_gather = std::make_shared(new_shapeof, indices, zero_axis); new_ops.push_back(new_gather); concat_inputs.push_back(new_gather); } auto shapeof_indices = - std::make_shared(gather->input_value(1), node->get_output_element_type(0)); + std::make_shared(gather->input_value(1), node->get_output_element_type(0)); new_ops.push_back(shapeof_indices); concat_inputs.push_back(shapeof_indices); @@ -238,12 +235,12 @@ pass::SimplifyGatherShapeOf::SimplifyGatherShapeOf() { if (gather_in_rank.get_length() - 1 > axis) { std::vector vi(gather_in_rank.get_length() - (axis + 1)); std::iota(vi.begin(), vi.end(), axis + 1); - auto indices = v0::Constant::create(element::i64, Shape{vi.size()}, vi); - auto new_gather = std::make_shared(new_shapeof, indices, zero_axis); + auto indices = ov::op::v0::Constant::create(element::i64, Shape{vi.size()}, vi); + auto new_gather = std::make_shared(new_shapeof, indices, zero_axis); new_ops.push_back(new_gather); concat_inputs.push_back(new_gather); } - replace_op = std::make_shared(concat_inputs, 0); + replace_op = std::make_shared(concat_inputs, 0); new_ops.push_back(replace_op); } replace_op->set_friendly_name(node->get_friendly_name()); @@ -252,27 +249,27 @@ pass::SimplifyGatherShapeOf::SimplifyGatherShapeOf() { return true; }; - auto m = std::make_shared(shape_of_pattern, matcher_name); + auto m = std::make_shared(shape_of_pattern, matcher_name); this->register_matcher(m, callback); } pass::SimplifySecondInputOfReshape::SimplifySecondInputOfReshape() { MATCHER_SCOPE(SimplifySecondInputOfReshape); - const auto input = any_input(); + const auto input = ov::pass::pattern::any_input(); auto has_static_1d_shape = [](const Output& output) { - return has_static_shape()(output) && rank_equals(1)(output); + return ov::pass::pattern::has_static_shape()(output) && ov::pass::pattern::rank_equals(1)(output); }; - const auto concat = wrap_type(has_static_1d_shape); - const auto reshape_pattern = wrap_type({input, concat}); + const auto concat = ov::pass::pattern::wrap_type(has_static_1d_shape); + const auto reshape_pattern = ov::pass::pattern::wrap_type({input, concat}); - matcher_pass_callback callback = [=](Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); - const auto reshape = as_type_ptr(node); + const auto reshape = as_type_ptr(node); if (!reshape) { return false; } - const auto concat = as_type_ptr(reshape->get_input_node_shared_ptr(1)); + const auto concat = as_type_ptr(reshape->get_input_node_shared_ptr(1)); if (!concat) return false; @@ -280,7 +277,7 @@ pass::SimplifySecondInputOfReshape::SimplifySecondInputOfReshape() { OPENVINO_ASSERT(concat_axis == 0 || concat_axis == -1, "axis is not valid for matched Concat with 1D output"); auto data = m.get_pattern_value_map().at(input); - if (is_type(data.get_node_shared_ptr()) || + if (is_type(data.get_node_shared_ptr()) || ov::op::util::is_unary_elementwise_arithmetic(data.get_node_shared_ptr())) { data = data.get_node_shared_ptr()->input_value(0); } @@ -312,8 +309,8 @@ pass::SimplifySecondInputOfReshape::SimplifySecondInputOfReshape() { for (auto& concat_input : new_concat_inputs) { auto node = concat_input.get_node_shared_ptr(); if (ov::is_type(node) && - ov::is_type(node->get_input_node_shared_ptr(1)) && check_shape_of_gather(node)) { - auto indices_constant = as_type_ptr(node->get_input_node_shared_ptr(1)); + ov::is_type(node->get_input_node_shared_ptr(1)) && check_shape_of_gather(node)) { + auto indices_constant = as_type_ptr(node->get_input_node_shared_ptr(1)); bool gather_can_be_fused = true; const auto indices = indices_constant->cast_vector(); for (size_t i = 0; i < indices.size(); ++i) { @@ -326,14 +323,14 @@ pass::SimplifySecondInputOfReshape::SimplifySecondInputOfReshape() { if (gather_can_be_fused) { const size_t num_of_unchanged_dimensions = indices.size(); const auto subgraph_et = node->get_input_element_type(0); - concat_input = v0::Constant::create(subgraph_et, Shape{num_of_unchanged_dimensions}, {0}); + concat_input = ov::op::v0::Constant::create(subgraph_et, Shape{num_of_unchanged_dimensions}, {0}); gather_folded = true; } } else { if (!special_zero) { // If special zero is false - check if other inputs to Concat are Constants. // If any of those Constants contain zero - return false. - auto constant = as_type_ptr(node); + auto constant = as_type_ptr(node); if (!constant) return false; auto values = constant->cast_vector(); @@ -348,11 +345,11 @@ pass::SimplifySecondInputOfReshape::SimplifySecondInputOfReshape() { return false; } - const auto new_concat = ov::op::util::make_try_fold(new_concat_inputs, concat_axis); + const auto new_concat = ov::op::util::make_try_fold(new_concat_inputs, concat_axis); new_concat->set_friendly_name(concat->get_friendly_name()); copy_runtime_info(concat, new_concat); - const auto new_reshape = std::make_shared(reshape->input_value(0), new_concat, true); + const auto new_reshape = std::make_shared(reshape->input_value(0), new_concat, true); new_reshape->set_friendly_name(reshape->get_friendly_name()); copy_runtime_info(reshape, new_reshape); @@ -360,7 +357,7 @@ pass::SimplifySecondInputOfReshape::SimplifySecondInputOfReshape() { return true; }; - auto m = std::make_shared(reshape_pattern, matcher_name); + auto m = std::make_shared(reshape_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/skip_gather_before_transpose_and_reshape.cpp b/src/common/transformations/src/transformations/common_optimizations/skip_gather_before_transpose_and_reshape.cpp index dda0856f975983..decd4a59374279 100644 --- a/src/common/transformations/src/transformations/common_optimizations/skip_gather_before_transpose_and_reshape.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/skip_gather_before_transpose_and_reshape.cpp @@ -20,7 +20,7 @@ ov::pass::SkipGatherBeforeTransposeAndReshape::SkipGatherBeforeTransposeAndReshape() { MATCHER_SCOPE(SkipGatherBeforeTransposeAndReshape); - auto input_m = pass::pattern::any_input(ov::pass::pattern::has_static_dim(0)); + auto input_m = ov::pass::pattern::any_input(ov::pass::pattern::has_static_dim(0)); auto indices_m = ov::pass::pattern::wrap_type(); auto axis_m = ov::pass::pattern::wrap_type(); @@ -32,7 +32,7 @@ ov::pass::SkipGatherBeforeTransposeAndReshape::SkipGatherBeforeTransposeAndResha auto reshape_const_m = ov::pass::pattern::wrap_type(); auto reshape_m = ov::pass::pattern::wrap_type({transpose_m, reshape_const_m}); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& input = pattern_map.at(input_m); if (input.get_partial_shape()[0] != 1) { diff --git a/src/common/transformations/src/transformations/common_optimizations/softmax_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/softmax_fusion.cpp index f3807e83ca8fc0..d6301de0fdb63d 100644 --- a/src/common/transformations/src/transformations/common_optimizations/softmax_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/softmax_fusion.cpp @@ -24,13 +24,13 @@ ov::pass::SoftmaxFusion::SoftmaxFusion() { MATCHER_SCOPE(SoftmaxFusion); - auto data_pattern = pass::pattern::any_input(pass::pattern::has_static_rank()); + auto data_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); auto reduce_max_axes_pattern = ov::pass::pattern::wrap_type(); auto reduce_max_pattern = ov::pass::pattern::wrap_type({data_pattern, reduce_max_axes_pattern}); auto sub_pattern = ov::pass::pattern::wrap_type({data_pattern, reduce_max_pattern}); - auto exp_input = std::make_shared(OutputVector{sub_pattern, data_pattern}); + auto exp_input = std::make_shared(OutputVector{sub_pattern, data_pattern}); auto exp_pattern = ov::pass::pattern::wrap_type({exp_input}); auto reduce_sum_axes_pattern = ov::pass::pattern::wrap_type(); @@ -38,7 +38,7 @@ ov::pass::SoftmaxFusion::SoftmaxFusion() { ov::pass::pattern::wrap_type({exp_pattern, reduce_sum_axes_pattern}); auto div_pattern = ov::pass::pattern::wrap_type({exp_pattern, reduce_sum_pattern}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pass::pattern::Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { if (transformation_callback(m.get_match_root())) return false; diff --git a/src/common/transformations/src/transformations/common_optimizations/softplus_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/softplus_fusion.cpp index e0df7dec366c6e..eaeabfaa7f5942 100644 --- a/src/common/transformations/src/transformations/common_optimizations/softplus_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/softplus_fusion.cpp @@ -20,10 +20,10 @@ ov::pass::SoftPlusFusion::SoftPlusFusion() { MATCHER_SCOPE(SoftPlusFusion); // fuses ln(exp(x) + 1.0) operations into SoftPlus(x) - auto input = pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto exp = std::make_shared(input); auto add_constant = - ov::pass::pattern::wrap_type(pattern::type_matches_any({element::f32, element::f16})); + ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any({element::f32, element::f16})); auto add = std::make_shared(exp, add_constant); auto log = std::make_shared(add); diff --git a/src/common/transformations/src/transformations/common_optimizations/softplus_to_mish_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/softplus_to_mish_fusion.cpp index 2060fc6a0a1a7a..d8c4043a0dae7a 100644 --- a/src/common/transformations/src/transformations/common_optimizations/softplus_to_mish_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/softplus_to_mish_fusion.cpp @@ -18,9 +18,9 @@ ov::pass::SoftPlusToMishFusion::SoftPlusToMishFusion() { MATCHER_SCOPE(SoftPlusToMishFusion); - auto input = pass::pattern::any_input(); - auto softplus = ov::pass::pattern::wrap_type({input}, pattern::consumers_count(1)); - auto tanh = ov::pass::pattern::wrap_type({softplus}, pattern::consumers_count(1)); + auto input = ov::pass::pattern::any_input(); + auto softplus = ov::pass::pattern::wrap_type({input}, ov::pass::pattern::consumers_count(1)); + auto tanh = ov::pass::pattern::wrap_type({softplus}, ov::pass::pattern::consumers_count(1)); auto mul = std::make_shared(input, tanh); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/space_to_batch_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/space_to_batch_fusion.cpp index e5404373b458c6..2db5cdc0ed21e2 100644 --- a/src/common/transformations/src/transformations/common_optimizations/space_to_batch_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/space_to_batch_fusion.cpp @@ -22,32 +22,32 @@ ov::pass::SpaceToBatchFusion::SpaceToBatchFusion() { MATCHER_SCOPE(SpaceToBatchFusion); - auto data_pattern = pattern::any_input(); + auto data_pattern = ov::pass::pattern::any_input(); auto reshape_before_pattern = - pattern::wrap_type({data_pattern, pattern::wrap_type()}, - pattern::rank_equals(4)); + ov::pass::pattern::wrap_type({data_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto trans_before_pattern = - pattern::wrap_type({data_pattern, pattern::wrap_type()}, - pattern::rank_equals(4)); + ov::pass::pattern::wrap_type({data_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto reshape_or_transpose_before_pattern = - std::make_shared(OutputVector{reshape_before_pattern, trans_before_pattern}); - auto pads_begin_pattern = pattern::wrap_type(); - auto pads_end_pattern = pattern::wrap_type(); - auto pad_value = pattern::wrap_type(); - auto pad_pattern = pattern::wrap_type( + std::make_shared(OutputVector{reshape_before_pattern, trans_before_pattern}); + auto pads_begin_pattern = ov::pass::pattern::wrap_type(); + auto pads_end_pattern = ov::pass::pattern::wrap_type(); + auto pad_value = ov::pass::pattern::wrap_type(); + auto pad_pattern = ov::pass::pattern::wrap_type( {reshape_or_transpose_before_pattern, pads_begin_pattern, pads_end_pattern, pad_value}); auto space_to_depth_pattern = - pattern::wrap_type({pad_pattern}, pattern::has_static_shape()); + ov::pass::pattern::wrap_type({pad_pattern}, ov::pass::pattern::has_static_shape()); auto reshape_after_pattern = - pattern::wrap_type({space_to_depth_pattern, pattern::wrap_type()}, - pattern::rank_equals(4)); + ov::pass::pattern::wrap_type({space_to_depth_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto trans_after_pattern = - pattern::wrap_type({space_to_depth_pattern, pattern::wrap_type()}, - pattern::rank_equals(4)); + ov::pass::pattern::wrap_type({space_to_depth_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto reshape_or_transpose_after_pattern = - std::make_shared(OutputVector{reshape_after_pattern, trans_after_pattern}); + std::make_shared(OutputVector{reshape_after_pattern, trans_after_pattern}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto get_reshape_or_transpose = [&pattern_map]( @@ -139,6 +139,6 @@ ov::pass::SpaceToBatchFusion::SpaceToBatchFusion() { return true; }; - auto m = std::make_shared(reshape_or_transpose_after_pattern, matcher_name); + auto m = std::make_shared(reshape_or_transpose_after_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/strides_optimization.cpp b/src/common/transformations/src/transformations/common_optimizations/strides_optimization.cpp index 2ab0c9e5ba44ef..c3b47556046cbf 100644 --- a/src/common/transformations/src/transformations/common_optimizations/strides_optimization.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/strides_optimization.cpp @@ -110,7 +110,7 @@ static void remove_strides_property_from_nodes(std::vector>& ov::pass::ConvStridesPropagation::ConvStridesPropagation() { MATCHER_SCOPE(ConvStridesPropagation); - auto data = pattern::any_input([](const Output& node) -> bool { + auto data = ov::pass::pattern::any_input([](const Output& node) -> bool { const auto& shape = node.get_partial_shape(); const auto& rank = shape.rank(); if (rank.is_dynamic()) @@ -119,10 +119,10 @@ ov::pass::ConvStridesPropagation::ConvStridesPropagation() { return dim.is_static(); }); }); - auto weights = pattern::any_input(pattern::has_static_shape()); - auto conv_pattern = pattern::wrap_type({data, weights}); + auto weights = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); + auto conv_pattern = ov::pass::pattern::wrap_type({data, weights}); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto conv = ov::as_type_ptr(m.get_match_root()); if (!conv) return false; @@ -165,16 +165,16 @@ ov::pass::ConvStridesPropagation::ConvStridesPropagation() { return true; }; - auto m = std::make_shared(conv_pattern, matcher_name); + auto m = std::make_shared(conv_pattern, matcher_name); this->register_matcher(m, callback); } ov::pass::SupportedNodesStridesPropagation::SupportedNodesStridesPropagation() { MATCHER_SCOPE(SupportedNodesStridesPropagation); auto root = - pattern::wrap_type(); + ov::pass::pattern::wrap_type(); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); auto next_ops = ov::op::util::get_node_target_inputs(node); bool all_ops_are_valid; @@ -194,15 +194,15 @@ ov::pass::SupportedNodesStridesPropagation::SupportedNodesStridesPropagation() { return true; }; - auto m = std::make_shared(root, matcher_name); + auto m = std::make_shared(root, matcher_name); this->register_matcher(m, callback); } ov::pass::UnsupportedNodesStridesPropagation::UnsupportedNodesStridesPropagation() { MATCHER_SCOPE(UnsupportedNodesStridesPropagation); - auto root = pattern::any_input(); + auto root = ov::pass::pattern::any_input(); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); auto next_ops = ov::op::util::get_node_target_inputs(node); handle_not_equal_stride_props(next_ops); @@ -211,7 +211,7 @@ ov::pass::UnsupportedNodesStridesPropagation::UnsupportedNodesStridesPropagation return true; }; - auto m = std::make_shared(root, matcher_name); + auto m = std::make_shared(root, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/common_optimizations/subtract_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/subtract_fusion.cpp index f2c2f54b68ecf4..ae480f9d878a21 100644 --- a/src/common/transformations/src/transformations/common_optimizations/subtract_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/subtract_fusion.cpp @@ -20,19 +20,19 @@ ov::pass::SubtractFusion::SubtractFusion() { MATCHER_SCOPE(SubtractFusion); - auto p_input = pattern::any_input(); + auto p_input = ov::pass::pattern::any_input(); - auto p_mul_const = pattern::wrap_type(); - auto p_mul = pattern::wrap_type({p_input, p_mul_const}); + auto p_mul_const = ov::pass::pattern::wrap_type(); + auto p_mul = ov::pass::pattern::wrap_type({p_input, p_mul_const}); - auto p_neg = pattern::wrap_type({p_input}); + auto p_neg = ov::pass::pattern::wrap_type({p_input}); - auto p_mul_or_neg = std::make_shared(OutputVector({p_mul, p_neg})); + auto p_mul_or_neg = std::make_shared(OutputVector({p_mul, p_neg})); - auto p_add_input = pattern::any_input(); + auto p_add_input = ov::pass::pattern::any_input(); auto p_add = ov::pass::pattern::wrap_type({p_add_input, p_mul_or_neg}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); const auto& minuend_input = pattern_to_output.at(p_add_input); const auto& subtrahend_input = pattern_to_output.at(p_input); diff --git a/src/common/transformations/src/transformations/common_optimizations/swish_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/swish_fusion.cpp index 90757eb8c9decc..87a8d0ff6b75f0 100644 --- a/src/common/transformations/src/transformations/common_optimizations/swish_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/swish_fusion.cpp @@ -43,7 +43,7 @@ bool check_beta_value(const std::shared_ptr& constant) { ov::pass::SwishFusionWithSigmoid::SwishFusionWithSigmoid() { MATCHER_SCOPE(SwishFusionWithSigmoid); // replaces a sub-graphs x * Sigmoid(x) with a Swish op. - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto sigmoid = std::make_shared(input); auto mul = std::make_shared(input, sigmoid); @@ -68,8 +68,8 @@ ov::pass::SwishFusionWithSigmoid::SwishFusionWithSigmoid() { ov::pass::SwishFusionWithSigmoidWithBeta::SwishFusionWithSigmoidWithBeta() { MATCHER_SCOPE(SwishFusionWithSigmoidWithBeta); // replaces a sub-graphs x * Sigmoid(x * beta) with a Swish op. - auto input = pass::pattern::any_input(); - auto beta = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); + auto beta = ov::pass::pattern::any_input(); auto mul_beta = std::make_shared(input, beta); auto sigmoid = std::make_shared(mul_beta); auto mul = std::make_shared(input, sigmoid); @@ -114,8 +114,8 @@ ov::pass::SwishFusionWithSigmoidWithBeta::SwishFusionWithSigmoidWithBeta() { ov::pass::SwishFusionWithBeta::SwishFusionWithBeta() { MATCHER_SCOPE(SwishFusionWithBeta); // replaces a sub-graphs x / (1.0 + exp(-x * beta)) with a Swish op. - auto input = pass::pattern::any_input(); - auto beta = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); + auto beta = ov::pass::pattern::any_input(); auto mul = std::make_shared(input, beta); auto neg = std::make_shared(mul); auto exp = std::make_shared(neg); @@ -154,7 +154,7 @@ ov::pass::SwishFusionWithBeta::SwishFusionWithBeta() { ov::pass::SwishFusionWithoutBeta::SwishFusionWithoutBeta() { MATCHER_SCOPE(SwishFusionWithoutBeta); // replaces a sub-graphs x / (1.0 + exp(-x)) with a Swish op. - auto input = pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto neg = std::make_shared(input); auto exp = std::make_shared(neg); auto add_constant = ov::pass::pattern::wrap_type(); diff --git a/src/common/transformations/src/transformations/common_optimizations/transpose_reshape_elimination_for_matmul.cpp b/src/common/transformations/src/transformations/common_optimizations/transpose_reshape_elimination_for_matmul.cpp index d766e525f73c2a..09ba6767f08bb6 100644 --- a/src/common/transformations/src/transformations/common_optimizations/transpose_reshape_elimination_for_matmul.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/transpose_reshape_elimination_for_matmul.cpp @@ -114,12 +114,12 @@ bool check_input_reshape(const std::shared_ptr& reshape, ov::pass::TransposeReshapeEliminationForMatmul::TransposeReshapeEliminationForMatmul() { MATCHER_SCOPE(TransposeReshapeEliminationForMatmul); - auto input_1_pattern = pass::pattern::any_input([](const Output& node) -> bool { + auto input_1_pattern = ov::pass::pattern::any_input([](const Output& node) -> bool { const auto& shape = node.get_partial_shape(); const auto& rank = shape.rank(); return rank.is_static() && rank.get_length() == 2 && shape.is_static(); }); - auto input_2_pattern = pass::pattern::any_input([](const Output& node) -> bool { + auto input_2_pattern = ov::pass::pattern::any_input([](const Output& node) -> bool { return node.get_partial_shape().is_static(); }); @@ -148,7 +148,7 @@ ov::pass::TransposeReshapeEliminationForMatmul::TransposeReshapeEliminationForMa auto transpose_after_pattern = ov::pass::pattern::wrap_type({reshape_after_pattern, const_transpose_after_pattern}); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_value_map = m.get_pattern_value_map(); const auto& input_1 = pattern_value_map.at(input_1_pattern); const auto& input_2 = pattern_value_map.at(input_2_pattern); diff --git a/src/common/transformations/src/transformations/common_optimizations/transpose_sinking.cpp b/src/common/transformations/src/transformations/common_optimizations/transpose_sinking.cpp index 9db15c942d8223..5459846648e090 100644 --- a/src/common/transformations/src/transformations/common_optimizations/transpose_sinking.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/transpose_sinking.cpp @@ -75,16 +75,16 @@ std::shared_ptr get_reversed_order_constant( ov::pass::TransposeEltwise::TransposeEltwise() { MATCHER_SCOPE(TransposeEltwise); - auto eltwise_data_input_p = pattern::any_input(); - auto eltwise_const_input_p = pattern::wrap_type(); - auto eltwise_p = pattern::wrap_type( + auto eltwise_data_input_p = ov::pass::pattern::any_input(); + auto eltwise_const_input_p = ov::pass::pattern::wrap_type(); + auto eltwise_p = ov::pass::pattern::wrap_type( {eltwise_data_input_p, eltwise_const_input_p}, [](const Output& output) { return ov::is_preprocesing_node(output.get_node_shared_ptr()); }); auto transpose_p = - pattern::wrap_type({eltwise_p, pattern::wrap_type()}, - pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({eltwise_p, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); auto callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); @@ -126,9 +126,9 @@ ov::pass::TransposeConvert::TransposeConvert() { MATCHER_SCOPE(TransposeConvert); auto transpose_label = - pattern::wrap_type({pattern::any_input(), pattern::wrap_type()}, - pattern::consumers_count(1)); - auto convert_label = pattern::wrap_type({transpose_label}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); + auto convert_label = ov::pass::pattern::wrap_type({transpose_label}); matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); @@ -153,12 +153,12 @@ ov::pass::TransposeReduction::TransposeReduction() { MATCHER_SCOPE(TransposeReduction); auto transpose_label = - pattern::wrap_type({pattern::any_input(), pattern::wrap_type()}, - pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); auto reduce_or_squeeze_label = - pattern::wrap_type({transpose_label, pattern::wrap_type()}); + ov::op::v0::Squeeze>({transpose_label, ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); @@ -224,16 +224,16 @@ ov::pass::TransposeFQReduction::TransposeFQReduction() { MATCHER_SCOPE(TransposeFQReduction); auto transpose_label = - pattern::wrap_type({pattern::any_input(), pattern::wrap_type()}); - auto fq_label = pattern::wrap_type({transpose_label, - pattern::any_input(pattern::has_static_rank()), - pattern::any_input(pattern::has_static_rank()), - pattern::any_input(pattern::has_static_rank()), - pattern::any_input(pattern::has_static_rank())}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); + auto fq_label = ov::pass::pattern::wrap_type({transpose_label, + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())}); auto reduce_or_squeeze_label = - pattern::wrap_type({fq_label, pattern::wrap_type()}); + ov::op::v0::Squeeze>({fq_label, ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto& pattern_to_output = m.get_pattern_value_map(); @@ -294,10 +294,10 @@ ov::pass::TransposeFuse::TransposeFuse() { MATCHER_SCOPE(TransposeFuse); auto transpose_1 = - pattern::wrap_type({pattern::any_input(), pattern::wrap_type()}, - pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); auto transpose_2 = - pattern::wrap_type({transpose_1, pattern::wrap_type()}); + ov::pass::pattern::wrap_type({transpose_1, ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/transpose_to_reshape.cpp b/src/common/transformations/src/transformations/common_optimizations/transpose_to_reshape.cpp index 058ea200dc7755..7be837620f5e3b 100644 --- a/src/common/transformations/src/transformations/common_optimizations/transpose_to_reshape.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/transpose_to_reshape.cpp @@ -24,8 +24,8 @@ using namespace ov; ov::pass::TransposeToReshape::TransposeToReshape() { MATCHER_SCOPE(TransposeToReshape); - auto transpose_label = pattern::wrap_type( - {pattern::any_input(pattern::has_static_rank()), pattern::wrap_type()}); + auto transpose_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto transpose = m.get_match_root(); auto data = transpose->input_value(0); diff --git a/src/common/transformations/src/transformations/common_optimizations/weights_dequantize_to_fake_quantize.cpp b/src/common/transformations/src/transformations/common_optimizations/weights_dequantize_to_fake_quantize.cpp index c08c65520723b0..fc0437ed587fa4 100644 --- a/src/common/transformations/src/transformations/common_optimizations/weights_dequantize_to_fake_quantize.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/weights_dequantize_to_fake_quantize.cpp @@ -19,15 +19,15 @@ ov::pass::WeightsDequantizeToFakeQuantize::WeightsDequantizeToFakeQuantize() { MATCHER_SCOPE(WeightsDequantizeToFakeQuantize); - const auto weights = ov::pass::pattern::wrap_type(pattern::type_matches(element::i8)); + const auto weights = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::i8)); const auto convert = ov::pass::pattern::wrap_type({weights}); - const auto sub_c_integer = ov::pass::pattern::wrap_type(pattern::type_matches(element::i8)); + const auto sub_c_integer = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::i8)); const auto convert_sub_c_integer = ov::pass::pattern::wrap_type({sub_c_integer}); const auto sub_integer = ov::pass::pattern::wrap_type({convert, convert_sub_c_integer}); const auto sub_c = ov::pass::pattern::wrap_type(); const auto sub = ov::pass::pattern::wrap_type({convert, sub_c}); - const auto sub_or_sub_integer = std::make_shared(OutputVector{sub_integer, sub}); - const auto sub_or_convert = std::make_shared(OutputVector{convert, sub_or_sub_integer}); + const auto sub_or_sub_integer = std::make_shared(OutputVector{sub_integer, sub}); + const auto sub_or_convert = std::make_shared(OutputVector{convert, sub_or_sub_integer}); const auto mul_c = ov::pass::pattern::wrap_type(); const auto mul = ov::pass::pattern::wrap_type({sub_or_convert, mul_c}); diff --git a/src/common/transformations/src/transformations/common_optimizations/wrap_interpolate_into_transposes.cpp b/src/common/transformations/src/transformations/common_optimizations/wrap_interpolate_into_transposes.cpp index e5f307bf735ab2..521c0b18a05df4 100644 --- a/src/common/transformations/src/transformations/common_optimizations/wrap_interpolate_into_transposes.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/wrap_interpolate_into_transposes.cpp @@ -57,7 +57,7 @@ std::vector build_new_axes(size_t num_of_axes, size_t rank) { ov::pass::WrapInterpolateIntoTransposes::WrapInterpolateIntoTransposes() { MATCHER_SCOPE(WrapInterpolateIntoTransposes); auto interpolate_pattern = ov::pass::pattern::wrap_type(); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto interpolate = ov::as_type_ptr(m.get_match_root()); if (!interpolate || interpolate->get_input_partial_shape(0).rank().is_dynamic() || interpolate->inputs().size() != 4) @@ -106,6 +106,6 @@ ov::pass::WrapInterpolateIntoTransposes::WrapInterpolateIntoTransposes() { return true; }; - auto m = std::make_shared(interpolate_pattern, matcher_name); + auto m = std::make_shared(interpolate_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/flush_fp32_subnormals_to_zero.cpp b/src/common/transformations/src/transformations/flush_fp32_subnormals_to_zero.cpp index a864c18cc141a0..12d4d56d8527ef 100644 --- a/src/common/transformations/src/transformations/flush_fp32_subnormals_to_zero.cpp +++ b/src/common/transformations/src/transformations/flush_fp32_subnormals_to_zero.cpp @@ -20,9 +20,9 @@ using namespace pass; ov::pass::FlushFP32SubnormalsToZero::FlushFP32SubnormalsToZero() { MATCHER_SCOPE(FlushFP32SubnormalsToZero); - auto node_pattern = pattern::wrap_type(); + auto node_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = ov::as_type_ptr(m.get_match_root()); if (!node) @@ -60,6 +60,6 @@ ov::pass::FlushFP32SubnormalsToZero::FlushFP32SubnormalsToZero() { return true; }; - auto m = make_shared(node_pattern, matcher_name); + auto m = make_shared(node_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/fp16_compression/mark_decompression_convert_constant_folding.cpp b/src/common/transformations/src/transformations/fp16_compression/mark_decompression_convert_constant_folding.cpp index a28e97d583a2f0..e39e98be69d0e3 100644 --- a/src/common/transformations/src/transformations/fp16_compression/mark_decompression_convert_constant_folding.cpp +++ b/src/common/transformations/src/transformations/fp16_compression/mark_decompression_convert_constant_folding.cpp @@ -21,9 +21,9 @@ using namespace ov; pass::EnableDecompressionConvertConstantFolding::EnableDecompressionConvertConstantFolding() { MATCHER_SCOPE(EnableDecompressionConvertConstantFolding); - auto convert = pattern::wrap_type(); + auto convert = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); if (!is_decompression(node)) return false; @@ -31,15 +31,15 @@ pass::EnableDecompressionConvertConstantFolding::EnableDecompressionConvertConst return true; }; - auto m = std::make_shared(convert, matcher_name); + auto m = std::make_shared(convert, matcher_name); this->register_matcher(m, callback); } pass::DisableDecompressionConvertConstantFolding::DisableDecompressionConvertConstantFolding() { MATCHER_SCOPE(DisableDecompressionConvertConstantFolding); - auto convert = pattern::wrap_type(); + auto convert = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); if (!is_decompression(node)) return false; @@ -47,16 +47,16 @@ pass::DisableDecompressionConvertConstantFolding::DisableDecompressionConvertCon return true; }; - auto m = std::make_shared(convert, matcher_name); + auto m = std::make_shared(convert, matcher_name); this->register_matcher(m, callback); } pass::KeepConstAndDecompression::KeepConstAndDecompression() { MATCHER_SCOPE(KeepDecompressionsInFP32Matcher); - auto node_pattern = pattern::wrap_type(); + auto node_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); if (!is_decompression(node) || !is_type(node) || ov::is_shape_subgraph(node->shared_from_this())) @@ -74,15 +74,15 @@ pass::KeepConstAndDecompression::KeepConstAndDecompression() { return false; }; - auto m = std::make_shared(node_pattern, matcher_name); + auto m = std::make_shared(node_pattern, matcher_name); register_matcher(m, callback); } pass::KeepConstantsPrecisionAndAddConverts::KeepConstantsPrecisionAndAddConverts() { MATCHER_SCOPE(KeepConstantsPrecisionAndAddConverts); - auto const_pattern = pattern::wrap_type(); + auto const_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto const_node = m.get_match_root(); if (transformation_callback(const_node)) { @@ -117,17 +117,17 @@ pass::KeepConstantsPrecisionAndAddConverts::KeepConstantsPrecisionAndAddConverts return true; }; - auto m = std::make_shared(const_pattern, matcher_name); + auto m = std::make_shared(const_pattern, matcher_name); this->register_matcher(m, callback); } pass::MarkCompressedFloatConstants::MarkCompressedFloatConstants() { MATCHER_SCOPE(MarkCompressedFloatConstants); - auto constant = pattern::wrap_type(); - auto convert = pattern::wrap_type({constant}); + auto constant = ov::pass::pattern::wrap_type(); + auto convert = ov::pass::pattern::wrap_type({constant}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& convert_node = as_type_ptr(m.get_match_root()); if (convert_node == nullptr) return false; @@ -151,6 +151,6 @@ pass::MarkCompressedFloatConstants::MarkCompressedFloatConstants() { return false; }; - auto m = std::make_shared(convert, matcher_name); + auto m = std::make_shared(convert, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/fp16_compression/mark_floatpoint_range.cpp b/src/common/transformations/src/transformations/fp16_compression/mark_floatpoint_range.cpp index c4d6488d622307..ab5f1a9f3cd1cc 100644 --- a/src/common/transformations/src/transformations/fp16_compression/mark_floatpoint_range.cpp +++ b/src/common/transformations/src/transformations/fp16_compression/mark_floatpoint_range.cpp @@ -33,9 +33,8 @@ void ov::pass::erase_range_path(const std::shared_ptr& node) { ov::pass::MarkFloatingPointRange::MarkFloatingPointRange() { MATCHER_SCOPE(MarkFloatingPointRange); - using namespace ov::pass::pattern; - // through these nodes - const auto range_propagating_nodes = pattern::wrap_type(); - ov::matcher_pass_callback callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); if (!node) return false; diff --git a/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp b/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp index f0a091b65219f7..fdf65ab389398e 100644 --- a/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp +++ b/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp @@ -87,7 +87,7 @@ void erase_fq_path(const std::shared_ptr& node) { // Marking continues to propagate through these ops. const std::shared_ptr propagate_through_ops = - pattern::wrap_typeoutputs()) { @@ -149,7 +149,7 @@ class PropagateUpMarkToKeepInMixedPrecision : public pass::MatcherPass { return true; }; - auto m = make_shared(propagate_through_ops, matcher_name); + auto m = make_shared(propagate_through_ops, matcher_name); register_matcher(m, callback); } }; @@ -164,7 +164,7 @@ class PropagateDownMarkToKeepInMixedPrecision : public pass::MatcherPass { PropagateDownMarkToKeepInMixedPrecision() { MATCHER_SCOPE(PropagateDownMarkToKeepInMixedPrecision); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); if (!node) return false; @@ -191,7 +191,7 @@ class PropagateDownMarkToKeepInMixedPrecision : public pass::MatcherPass { } return is_changed; }; - auto m = make_shared(propagate_through_ops, matcher_name); + auto m = make_shared(propagate_through_ops, matcher_name); register_matcher(m, callback); } }; @@ -202,16 +202,16 @@ class InitMarkReduceOpPath : public pass::MatcherPass { InitMarkReduceOpPath() { MATCHER_SCOPE(InitMarkReduceOpPath); - auto reduce_ops = pattern::wrap_type(); + auto reduce_ops = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); if (!node) return false; mark_reduceop_path(node); return true; }; - auto m = make_shared(reduce_ops, matcher_name); + auto m = make_shared(reduce_ops, matcher_name); register_matcher(m, callback); } }; @@ -222,7 +222,7 @@ class PropagateMarkUpReduceOpPath : public pass::MatcherPass { PropagateMarkUpReduceOpPath() { MATCHER_SCOPE(PropagateMarkUpReduceOpPath); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); if (!node) return false; @@ -238,7 +238,7 @@ class PropagateMarkUpReduceOpPath : public pass::MatcherPass { } return false; }; - auto m = make_shared(propagate_through_ops, matcher_name); + auto m = make_shared(propagate_through_ops, matcher_name); register_matcher(m, callback); } }; @@ -249,9 +249,9 @@ class MarkExp : public pass::MatcherPass { // only exponent that go into ReduceOp should be marked as precision sensitive and kept in f32 MarkExp() { MATCHER_SCOPE(MarkExp); - auto exp_pattern = pattern::wrap_type(); + auto exp_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); if (!node) return false; @@ -262,7 +262,7 @@ class MarkExp : public pass::MatcherPass { disable_fp16_compression(node); return true; }; - auto m = make_shared(exp_pattern, matcher_name); + auto m = make_shared(exp_pattern, matcher_name); register_matcher(m, callback); } }; @@ -273,9 +273,9 @@ class MarkRandomUniform : public pass::MatcherPass { MarkRandomUniform() { MATCHER_SCOPE(MarkRandomUniform); - auto random_uniform_pattern = pattern::wrap_type(); + auto random_uniform_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); if (!node) return false; @@ -292,7 +292,7 @@ class MarkRandomUniform : public pass::MatcherPass { } return false; }; - auto m = make_shared(random_uniform_pattern, matcher_name); + auto m = make_shared(random_uniform_pattern, matcher_name); register_matcher(m, callback); } }; @@ -332,27 +332,27 @@ class MarkDivWithEps : public MatcherPass { // input_1 * Pow(Maximum(input_2, eps), -z) // input_1 * Pow(Add(input_2, eps), -z) - auto input_1 = pattern::any_input(); - auto input_2 = pattern::any_input(); + auto input_1 = ov::pass::pattern::any_input(); + auto input_2 = ov::pass::pattern::any_input(); - auto eps_const_pattern = pattern::wrap_type(); - auto optional_eps_convert = pattern::optional(eps_const_pattern); + auto eps_const_pattern = ov::pass::pattern::wrap_type(); + auto optional_eps_convert = ov::pass::pattern::optional(eps_const_pattern); auto max_or_add = - pattern::wrap_type(OutputVector{input_2, optional_eps_convert}); + ov::pass::pattern::wrap_type(OutputVector{input_2, optional_eps_convert}); - auto optional_sqrt = pattern::optional(max_or_add); + auto optional_sqrt = ov::pass::pattern::optional(max_or_add); // whether is divided directly or after sqrt (e.g. in L2Norm after sqrt, in MVN is divided directly) auto divide = std::make_shared(input_1, optional_sqrt); - auto pow_exp = pattern::wrap_type(); - auto optional_pow_convert = pattern::optional(pow_exp); + auto pow_exp = ov::pass::pattern::wrap_type(); + auto optional_pow_convert = ov::pass::pattern::optional(pow_exp); auto pow_pattern = std::make_shared(max_or_add, optional_pow_convert); auto mul_pattern = std::make_shared(input_1, pow_pattern); - auto div_or_mul_to_negative_pow = std::make_shared(OutputVector{divide, mul_pattern}); + auto div_or_mul_to_negative_pow = std::make_shared(OutputVector{divide, mul_pattern}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); if (!m.get_match_root()) return false; @@ -392,7 +392,7 @@ class MarkDivWithEps : public MatcherPass { return true; }; - auto m = make_shared(div_or_mul_to_negative_pow, matcher_name); + auto m = make_shared(div_or_mul_to_negative_pow, matcher_name); register_matcher(m, callback); } }; @@ -404,7 +404,7 @@ class PropagateDownDisableSensitivityForQuantized : public pass::MatcherPass { MATCHER_SCOPE(PropagateDownDisableSensitivityForQuantized); // through this nodes - const std::shared_ptr quantization_propagating_nodes = pattern::wrap_type quantization_propagating_nodes = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); if (!node) return false; @@ -453,7 +453,7 @@ class PropagateDownDisableSensitivityForQuantized : public pass::MatcherPass { return is_changed; }; - auto m = make_shared(quantization_propagating_nodes, matcher_name); + auto m = make_shared(quantization_propagating_nodes, matcher_name); register_matcher(m, callback); } }; diff --git a/src/common/transformations/src/transformations/low_precision/mark_dequantization_subgraph.cpp b/src/common/transformations/src/transformations/low_precision/mark_dequantization_subgraph.cpp index 3a7a8354054988..e51e5f4d4b5114 100644 --- a/src/common/transformations/src/transformations/low_precision/mark_dequantization_subgraph.cpp +++ b/src/common/transformations/src/transformations/low_precision/mark_dequantization_subgraph.cpp @@ -21,9 +21,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::op; -using namespace ov::pass::pattern; - static std::string write_precisions(const ov::element::TypeVector& precisions) { std::stringstream sstream; #ifdef OPENVINO_DEBUG @@ -46,7 +43,7 @@ ov::pass::pattern::op::Predicate check_precision(const ov::element::TypeVector& } using RTInfoSetter = std::function& node)>; -void set_rt_info(const PatternValueMap& pt_map, +void set_rt_info(const ov::pass::pattern::PatternValueMap& pt_map, const RTInfoSetter& rt_info_setter, const NodeVector& pattern_nodes, const ov::element::TypeVector& precisions) { @@ -55,7 +52,7 @@ void set_rt_info(const PatternValueMap& pt_map, auto node = pt_map.at(pattern_node).get_node_shared_ptr(); // we don't need to mark Converts with disable_cf attribute if the `from` type (input type) // is not in the `precisions` list. - if (ov::as_type_ptr(node) && !check_precision(precisions)(node->input_value(0))) { + if (ov::as_type_ptr(node) && !check_precision(precisions)(node->input_value(0))) { continue; } @@ -151,7 +148,7 @@ will be the same: forthe first branch step 1 is applied, for all the remainings step 2. */ -bool can_swap(const PatternValueMap& pt_map, +bool can_swap(const ov::pass::pattern::PatternValueMap& pt_map, const std::shared_ptr& first_pattern, const std::shared_ptr& second_pattern) { if (pt_map.count(first_pattern) && pt_map.count(second_pattern)) { @@ -186,7 +183,7 @@ bool can_swap(const PatternValueMap& pt_map, return false; } -bool swap_nodes(const PatternValueMap& pt_map, +bool swap_nodes(const ov::pass::pattern::PatternValueMap& pt_map, const std::shared_ptr& first, const std::shared_ptr& second) { if (can_swap(pt_map, first, second)) { @@ -213,22 +210,22 @@ ov::pass::MarkDequantization::MarkDequantization(const element::TypeVector& prec MATCHER_SCOPE(MarkDequantization); // data input: - auto input_pattern = any_input(check_precision(precisions)); - auto convert_pattern = wrap_type({input_pattern}, consumers_count(1)); + auto input_pattern = ov::pass::pattern::any_input(check_precision(precisions)); + auto convert_pattern = ov::pass::pattern::wrap_type({input_pattern}, ov::pass::pattern::consumers_count(1)); // zero points: - auto zp_pattern = any_input(); - auto zp_convert_pattern = pattern::optional(zp_pattern); - auto zp_reshape_pattern = pattern::optional({zp_convert_pattern, any_input()}); - auto subtract_pattern = pattern::optional({convert_pattern, zp_reshape_pattern}); + auto zp_pattern = ov::pass::pattern::any_input(); + auto zp_convert_pattern = ov::pass::pattern::optional(zp_pattern); + auto zp_reshape_pattern = ov::pass::pattern::optional({zp_convert_pattern, ov::pass::pattern::any_input()}); + auto subtract_pattern = ov::pass::pattern::optional({convert_pattern, zp_reshape_pattern}); // scale: - auto scale_pattern = any_input(); - auto scale_convert_pattern = pattern::optional(scale_pattern); - auto scale_reshape_pattern = pattern::optional({scale_convert_pattern, any_input()}); - auto multiply_pattern = wrap_type({subtract_pattern, scale_reshape_pattern}); + auto scale_pattern = ov::pass::pattern::any_input(); + auto scale_convert_pattern = ov::pass::pattern::optional(scale_pattern); + auto scale_reshape_pattern = ov::pass::pattern::optional({scale_convert_pattern, ov::pass::pattern::any_input()}); + auto multiply_pattern = ov::pass::pattern::wrap_type({subtract_pattern, scale_reshape_pattern}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) -> bool { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) -> bool { const auto& pt_map = m.get_pattern_value_map(); auto convert = pt_map.at(convert_pattern); auto input = pt_map.at(input_pattern); @@ -267,7 +264,7 @@ ov::pass::MarkDequantization::MarkDequantization(const element::TypeVector& prec return changed; }; - auto m = std::make_shared(multiply_pattern, "MarkDequantization"); + auto m = std::make_shared(multiply_pattern, "MarkDequantization"); this->register_matcher(m, callback); } @@ -277,22 +274,22 @@ ov::pass::KeepConstPrecision::KeepConstPrecision(const element::TypeVector& prec MATCHER_SCOPE(KeepConstPrecision); // data input: - auto input_pattern = any_input(); - auto convert_pattern = wrap_type({input_pattern}, consumers_count(1)); + auto input_pattern = ov::pass::pattern::any_input(); + auto convert_pattern = ov::pass::pattern::wrap_type({input_pattern}, ov::pass::pattern::consumers_count(1)); // zero points: - auto zp_pattern = any_input(); - auto zp_convert_pattern = pattern::optional(zp_pattern); - auto zp_reshape_pattern = pattern::optional({zp_convert_pattern, any_input()}); - auto subtract_pattern = pattern::optional({convert_pattern, zp_reshape_pattern}); + auto zp_pattern = ov::pass::pattern::any_input(); + auto zp_convert_pattern = ov::pass::pattern::optional(zp_pattern); + auto zp_reshape_pattern = ov::pass::pattern::optional({zp_convert_pattern, ov::pass::pattern::any_input()}); + auto subtract_pattern = ov::pass::pattern::optional({convert_pattern, zp_reshape_pattern}); // scale: - auto scale_pattern = any_input(); - auto scale_convert_pattern = pattern::optional(scale_pattern); - auto scale_reshape_pattern = pattern::optional({scale_convert_pattern, any_input()}); - auto multiply_pattern = wrap_type({subtract_pattern, scale_reshape_pattern}); + auto scale_pattern = ov::pass::pattern::any_input(); + auto scale_convert_pattern = ov::pass::pattern::optional(scale_pattern); + auto scale_reshape_pattern = ov::pass::pattern::optional({scale_convert_pattern, ov::pass::pattern::any_input()}); + auto multiply_pattern = ov::pass::pattern::wrap_type({subtract_pattern, scale_reshape_pattern}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) -> bool { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) -> bool { const auto& pt_map = m.get_pattern_value_map(); const auto multiply = m.get_match_root(); @@ -307,7 +304,7 @@ ov::pass::KeepConstPrecision::KeepConstPrecision(const element::TypeVector& prec for (const auto& pattern_node : keep_const_precisions) { if (pt_map.count(pattern_node.first)) { auto node = pt_map.at(pattern_node.first).get_node_shared_ptr(); - if (ov::as_type_ptr(node) && check_precision(precisions)(node->output(0))) { + if (ov::as_type_ptr(node) && check_precision(precisions)(node->output(0))) { if (pattern_node.second) { ov::disable_keep_const_precision(node); } else { @@ -319,7 +316,7 @@ ov::pass::KeepConstPrecision::KeepConstPrecision(const element::TypeVector& prec return false; }; - auto m = std::make_shared(multiply_pattern, "KeepConstPrecision"); + auto m = std::make_shared(multiply_pattern, "KeepConstPrecision"); this->register_matcher(m, callback); } @@ -327,22 +324,22 @@ ov::pass::KeepDequantizationPrecision::KeepDequantizationPrecision(const element bool add_precision_sensitive_convert) { MATCHER_SCOPE(KeepDequantizationPrecision); - auto input_pattern = pattern::wrap_type(pattern::type_matches_any(precisions)); - auto convert_pattern = pattern::wrap_type({input_pattern}, pattern::consumers_count(1)); + auto input_pattern = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any(precisions)); + auto convert_pattern = ov::pass::pattern::wrap_type({input_pattern}, ov::pass::pattern::consumers_count(1)); // zero points: - auto zp_pattern = pattern::wrap_type(); - auto zp_convert_pattern = pattern::optional(zp_pattern); - auto zp_reshape_pattern = pattern::optional({zp_convert_pattern, any_input()}); - auto subtract_pattern = pattern::optional({convert_pattern, zp_reshape_pattern}); + auto zp_pattern = ov::pass::pattern::wrap_type(); + auto zp_convert_pattern = ov::pass::pattern::optional(zp_pattern); + auto zp_reshape_pattern = ov::pass::pattern::optional({zp_convert_pattern, ov::pass::pattern::any_input()}); + auto subtract_pattern = ov::pass::pattern::optional({convert_pattern, zp_reshape_pattern}); // scale: - auto scale_pattern = pattern::wrap_type(); - auto scale_convert_pattern = pattern::optional(scale_pattern); - auto scale_reshape_pattern = pattern::optional({scale_convert_pattern, any_input()}); - auto multiply_pattern = pattern::wrap_type({subtract_pattern, scale_reshape_pattern}); + auto scale_pattern = ov::pass::pattern::wrap_type(); + auto scale_convert_pattern = ov::pass::pattern::optional(scale_pattern); + auto scale_reshape_pattern = ov::pass::pattern::optional({scale_convert_pattern, ov::pass::pattern::any_input()}); + auto multiply_pattern = ov::pass::pattern::wrap_type({subtract_pattern, scale_reshape_pattern}); - matcher_pass_callback callback = [=](Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pt_map = m.get_pattern_value_map(); auto multiply = m.get_match_root(); @@ -371,7 +368,7 @@ ov::pass::KeepDequantizationPrecision::KeepDequantizationPrecision(const element // Convert insertion (with disable_const_folding flag) inside AlignMixedFP32FP16Types transformation. Use // Multiply's output data type to ensure data type consistency. if (add_precision_sensitive_convert) { - auto convert = std::make_shared(multiply, multiply->get_output_element_type(0)); + auto convert = std::make_shared(multiply, multiply->get_output_element_type(0)); multiply->output(0).replace(convert); ov::mark_as_precision_sensitive(convert->input(0)); @@ -381,7 +378,7 @@ ov::pass::KeepDequantizationPrecision::KeepDequantizationPrecision(const element return false; }; - auto m = std::make_shared(multiply_pattern, "KeepDequantizationPrecision"); + auto m = std::make_shared(multiply_pattern, "KeepDequantizationPrecision"); this->register_matcher(m, callback); } @@ -390,18 +387,18 @@ ov::pass::MarkGatherSubgraph::MarkGatherSubgraph(const element::TypeVector& tabl MATCHER_SCOPE(MarkGatherSubgraph); // 1. Data input → (optional Convert) → (input to Gather[0]) - auto data_input = wrap_type(check_precision(table_values_precisions)); - auto data_convert = pattern::optional({data_input}); + auto data_input = ov::pass::pattern::wrap_type(check_precision(table_values_precisions)); + auto data_convert = ov::pass::pattern::optional({data_input}); // 2. Indices input → (optional Convert) → (input to Gather[1]) - auto indices_input = wrap_type(check_precision(indices_precisions)); - auto indices_convert = pattern::optional({indices_input}); + auto indices_input = ov::pass::pattern::wrap_type(check_precision(indices_precisions)); + auto indices_convert = ov::pass::pattern::optional({indices_input}); // Gather (fp, integral, any) - auto axis = any_input(value_matches("0")); - auto gather = wrap_type({data_convert, indices_convert, axis}); + auto axis = ov::pass::pattern::any_input(ov::pass::pattern::value_matches("0")); + auto gather = ov::pass::pattern::wrap_type({data_convert, indices_convert, axis}); - matcher_pass_callback callback = [=](Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pm = m.get_pattern_map(); auto gather_node = pm.at(gather); if (transformation_callback(gather_node)) { @@ -421,6 +418,6 @@ ov::pass::MarkGatherSubgraph::MarkGatherSubgraph(const element::TypeVector& tabl return false; }; - auto m = std::make_shared(gather, "MarkGatherSubgraph"); + auto m = std::make_shared(gather, "MarkGatherSubgraph"); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/batch_norm_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/batch_norm_decomposition.cpp index 290352485fa581..fc758b7fe83240 100644 --- a/src/common/transformations/src/transformations/op_conversions/batch_norm_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/batch_norm_decomposition.cpp @@ -29,16 +29,16 @@ using namespace ov; ov::pass::BatchNormDecomposition::BatchNormDecomposition() { MATCHER_SCOPE(BatchNormDecomposition); - auto bn_1 = pattern::wrap_type({pattern::any_input(), - pattern::any_input(), - pattern::any_input(pattern::has_static_rank()), - pattern::any_input(), - pattern::any_input()}); - auto bn_5 = pattern::wrap_type({pattern::any_input(pattern::has_static_rank()), - pattern::any_input(), - pattern::any_input(), - pattern::any_input(), - pattern::any_input()}); + auto bn_1 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); + auto bn_5 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto bn = std::make_shared(OutputVector{bn_1, bn_5}); matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/op_conversions/bidirectional_sequences_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/bidirectional_sequences_decomposition.cpp index 3e8398ac3db32f..819be5f75db354 100644 --- a/src/common/transformations/src/transformations/op_conversions/bidirectional_sequences_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/bidirectional_sequences_decomposition.cpp @@ -21,7 +21,7 @@ ov::pass::BidirectionalLSTMSequenceDecomposition::BidirectionalLSTMSequenceDecom MATCHER_SCOPE(BidirectionalLSTMSequenceDecomposition); auto lstm_sequence_ov = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto lstm_sequence = ov::as_type_ptr(m.get_match_root()); if (!lstm_sequence || transformation_callback(lstm_sequence)) { return false; @@ -94,7 +94,7 @@ ov::pass::BidirectionalGRUSequenceDecomposition::BidirectionalGRUSequenceDecompo MATCHER_SCOPE(BidirectionalGRUSequenceDecomposition); auto gru_sequence_ov = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto gru_sequence = ov::as_type_ptr(m.get_match_root()); if (!gru_sequence || transformation_callback(gru_sequence)) { return false; @@ -161,7 +161,7 @@ ov::pass::BidirectionalRNNSequenceDecomposition::BidirectionalRNNSequenceDecompo MATCHER_SCOPE(BidirectionalRNNSequenceDecomposition); auto rnn_sequence_ov = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto rnn_sequence = ov::as_type_ptr(m.get_match_root()); if (!rnn_sequence || transformation_callback(rnn_sequence)) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_avgpool_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_avgpool_downgrade.cpp index c2ced1382ffe5e..c1184b3396197a 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_avgpool_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_avgpool_downgrade.cpp @@ -23,9 +23,9 @@ ov::pass::ConvertAvgPool14ToAvgPool1::ConvertAvgPool14ToAvgPool1() { MATCHER_SCOPE(ConvertAvgPool14ToAvgPool1); - const auto avg_pool_v14_pattern = pattern::wrap_type(); + const auto avg_pool_v14_pattern = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto avg_pool_v14 = ov::as_type_ptr(m.get_match_root()); if (!avg_pool_v14 || transformation_callback(avg_pool_v14)) { return false; @@ -95,6 +95,6 @@ ov::pass::ConvertAvgPool14ToAvgPool1::ConvertAvgPool14ToAvgPool1() { return true; }; - auto m = std::make_shared(avg_pool_v14_pattern, matcher_name); + auto m = std::make_shared(avg_pool_v14_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_batch_to_space.cpp b/src/common/transformations/src/transformations/op_conversions/convert_batch_to_space.cpp index bcb529f2f712dc..c14409ed15e280 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_batch_to_space.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_batch_to_space.cpp @@ -32,8 +32,8 @@ using namespace ov::element; void ov::pass::ConvertBatchToSpace::convert_batch_to_space() { MATCHER_SCOPE(ConvertBatchToSpace_convert_batch_to_space); - const auto batch_to_space = pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + const auto batch_to_space = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { const auto batch_to_space = ov::as_type_ptr(m.get_match_root()); if (!batch_to_space || transformation_callback(batch_to_space)) { return false; @@ -113,14 +113,14 @@ void ov::pass::ConvertBatchToSpace::convert_batch_to_space() { return true; }; - const auto m = make_shared(batch_to_space, matcher_name); + const auto m = make_shared(batch_to_space, matcher_name); this->register_matcher(m, callback); } void ov::pass::ConvertBatchToSpace::convert_batch_to_space_by_elements() { MATCHER_SCOPE(ConvertBatchToSpace_convert_batch_to_space_by_elements); - const auto batch_to_space = pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + const auto batch_to_space = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { const auto batch_to_space = ov::as_type_ptr(m.get_match_root()); if (!batch_to_space || transformation_callback(batch_to_space)) { return false; @@ -230,6 +230,6 @@ void ov::pass::ConvertBatchToSpace::convert_batch_to_space_by_elements() { return true; }; - const auto m = make_shared(batch_to_space, matcher_name); + const auto m = make_shared(batch_to_space, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_bitwise_to_logical_bool.cpp b/src/common/transformations/src/transformations/op_conversions/convert_bitwise_to_logical_bool.cpp index 86ca3dc8a3d887..faa21b240189ed 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_bitwise_to_logical_bool.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_bitwise_to_logical_bool.cpp @@ -21,10 +21,10 @@ ov::pass::ConvertBitwiseAndToLogicalAnd::ConvertBitwiseAndToLogicalAnd() { MATCHER_SCOPE(ConvertBitwiseAndToLogicalAnd); auto pattern = - pattern::wrap_type({pattern::any_input(pattern::type_matches(element::boolean)), - pattern::any_input(pattern::type_matches(element::boolean))}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean)), + ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto bitwise = ov::as_type_ptr(m.get_match_root()); if (!bitwise || transformation_callback(bitwise)) { return false; @@ -40,15 +40,15 @@ ov::pass::ConvertBitwiseAndToLogicalAnd::ConvertBitwiseAndToLogicalAnd() { return true; }; - auto m = std::make_shared(pattern, matcher_name); + auto m = std::make_shared(pattern, matcher_name); register_matcher(m, callback); } ov::pass::ConvertBitwiseNotToLogicalNot::ConvertBitwiseNotToLogicalNot() { MATCHER_SCOPE(ConvertBitwiseNotToLogicalNot); auto pattern = - pattern::wrap_type({pattern::any_input(pattern::type_matches(element::boolean))}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto bitwise = ov::as_type_ptr(m.get_match_root()); if (!bitwise || transformation_callback(bitwise)) { return false; @@ -62,17 +62,17 @@ ov::pass::ConvertBitwiseNotToLogicalNot::ConvertBitwiseNotToLogicalNot() { return true; }; - auto m = std::make_shared(pattern, matcher_name); + auto m = std::make_shared(pattern, matcher_name); register_matcher(m, callback); } ov::pass::ConvertBitwiseOrToLogicalOr::ConvertBitwiseOrToLogicalOr() { MATCHER_SCOPE(ConvertBitwiseOrToLogicalOr); auto pattern = - pattern::wrap_type({pattern::any_input(pattern::type_matches(element::boolean)), - pattern::any_input(pattern::type_matches(element::boolean))}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean)), + ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto bitwise = ov::as_type_ptr(m.get_match_root()); if (!bitwise || transformation_callback(bitwise)) { return false; @@ -88,17 +88,17 @@ ov::pass::ConvertBitwiseOrToLogicalOr::ConvertBitwiseOrToLogicalOr() { return true; }; - auto m = std::make_shared(pattern, matcher_name); + auto m = std::make_shared(pattern, matcher_name); register_matcher(m, callback); } ov::pass::ConvertBitwiseXorToLogicalXor::ConvertBitwiseXorToLogicalXor() { MATCHER_SCOPE(ConvertBitwiseXorToLogicalXor); auto pattern = - pattern::wrap_type({pattern::any_input(pattern::type_matches(element::boolean)), - pattern::any_input(pattern::type_matches(element::boolean))}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean)), + ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto bitwise = ov::as_type_ptr(m.get_match_root()); if (!bitwise || transformation_callback(bitwise)) { return false; @@ -114,6 +114,6 @@ ov::pass::ConvertBitwiseXorToLogicalXor::ConvertBitwiseXorToLogicalXor() { return true; }; - auto m = std::make_shared(pattern, matcher_name); + auto m = std::make_shared(pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_broadcast3.cpp b/src/common/transformations/src/transformations/op_conversions/convert_broadcast3.cpp index a92f43e8f691b1..65425a57f92bf4 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_broadcast3.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_broadcast3.cpp @@ -62,9 +62,9 @@ bool make_compatible_shape(const ov::PartialShape& input_shape, std::vector(); + auto broadcast = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto broadcast = ov::as_type_ptr(m.get_match_root()); if (!broadcast) { return false; @@ -127,6 +127,6 @@ ov::pass::ConvertBroadcast3::ConvertBroadcast3() { return true; }; - auto m = std::make_shared(broadcast, matcher_name); + auto m = std::make_shared(broadcast, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_broadcast_to_tiles.cpp b/src/common/transformations/src/transformations/op_conversions/convert_broadcast_to_tiles.cpp index b090dfbc071101..6e4b9218ccd463 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_broadcast_to_tiles.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_broadcast_to_tiles.cpp @@ -20,7 +20,7 @@ ov::pass::ConvertBroadcastToTiles::ConvertBroadcastToTiles() { MATCHER_SCOPE(ConvertBroadcastToTiles); auto broadcast = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto broadcast = ov::as_type_ptr(m.get_match_root()); if (!broadcast) { diff --git a/src/common/transformations/src/transformations/op_conversions/convert_convertlike.cpp b/src/common/transformations/src/transformations/op_conversions/convert_convertlike.cpp index 5452fa7965039c..f63c4e96c88ffd 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_convertlike.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_convertlike.cpp @@ -19,9 +19,9 @@ using namespace ov; ov::pass::ConvertConvertLike::ConvertConvertLike() { MATCHER_SCOPE(ConvertConvertLike); - auto convertlike = pattern::wrap_type(); + auto convertlike = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto cvtlike = ov::as_type_ptr(m.get_match_root()); if (!cvtlike) { return false; @@ -40,6 +40,6 @@ ov::pass::ConvertConvertLike::ConvertConvertLike() { return true; }; - auto m = std::make_shared(convertlike, matcher_name); + auto m = std::make_shared(convertlike, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_convertpromotetypes.cpp b/src/common/transformations/src/transformations/op_conversions/convert_convertpromotetypes.cpp index 1cd5daaee319e1..78da3bf7a1d3db 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_convertpromotetypes.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_convertpromotetypes.cpp @@ -15,11 +15,11 @@ ov::pass::ConvertConvertPromoteTypes::ConvertConvertPromoteTypes() { MATCHER_SCOPE(ConvertConvertPromoteTypes); auto has_static_defined_type = [](const Output& output) -> bool { - return !pattern::type_matches_any({element::dynamic})(output); + return !ov::pass::pattern::type_matches_any({element::dynamic})(output); }; - auto convert_promote_types = pattern::wrap_type(has_static_defined_type); + auto convert_promote_types = ov::pass::pattern::wrap_type(has_static_defined_type); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto convert_promote_types = ov::as_type_ptr(m.get_match_root()); if (!convert_promote_types) { return false; @@ -38,6 +38,6 @@ ov::pass::ConvertConvertPromoteTypes::ConvertConvertPromoteTypes() { return true; }; - auto m = std::make_shared(convert_promote_types, matcher_name); + auto m = std::make_shared(convert_promote_types, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_deformable_conv_v8_to_v1.cpp b/src/common/transformations/src/transformations/op_conversions/convert_deformable_conv_v8_to_v1.cpp index 35985b96e4a05b..d98164bc9d6c39 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_deformable_conv_v8_to_v1.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_deformable_conv_v8_to_v1.cpp @@ -13,9 +13,9 @@ ov::pass::ConvertDeformableConv8To1::ConvertDeformableConv8To1() { MATCHER_SCOPE(ConvertDeformableConv8To1); - auto deformable_conv_v8 = pattern::wrap_type(); + auto deformable_conv_v8 = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto deformable_conv_v8_node = ov::as_type_ptr(m.get_match_root()); if (!deformable_conv_v8_node) return false; @@ -44,6 +44,6 @@ ov::pass::ConvertDeformableConv8To1::ConvertDeformableConv8To1() { return true; }; - auto m = std::make_shared(deformable_conv_v8, matcher_name); + auto m = std::make_shared(deformable_conv_v8, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_depth_to_space.cpp b/src/common/transformations/src/transformations/op_conversions/convert_depth_to_space.cpp index 9accea8ffb0775..dec8f57ff6e384 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_depth_to_space.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_depth_to_space.cpp @@ -19,9 +19,9 @@ ov::pass::ConvertDepthToSpace::ConvertDepthToSpace() { MATCHER_SCOPE(ConvertDepthToSpace); auto dts_node = - ov::pass::pattern::wrap_type({pattern::any_input(pattern::has_static_shape())}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto dts_node = ov::as_type_ptr(m.get_match_root()); if (!dts_node || transformation_callback(dts_node)) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_divide.cpp b/src/common/transformations/src/transformations/op_conversions/convert_divide.cpp index bad73ff5e13ee0..d15358b477871b 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_divide.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_divide.cpp @@ -61,7 +61,7 @@ ov::pass::ConvertDivide::ConvertDivide() { MATCHER_SCOPE(ConvertDivide); auto div = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { return convert_divide(m.get_match_root()); }; @@ -72,9 +72,9 @@ ov::pass::ConvertDivide::ConvertDivide() { ov::pass::ConvertDivideWithConstant::ConvertDivideWithConstant() { MATCHER_SCOPE(ConvertDivideWithConstant); auto div = ov::pass::pattern::wrap_type( - {pattern::any_input(), pattern::wrap_type()}); + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { return convert_divide(m.get_match_root()); }; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_embedding_bag_offsets15_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_embedding_bag_offsets15_downgrade.cpp index 57c768668cc87e..d34c1cb857f7db 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_embedding_bag_offsets15_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_embedding_bag_offsets15_downgrade.cpp @@ -16,9 +16,9 @@ ov::pass::ConvertEmbeddingBagOffsets15ToEmbeddingBagOffsetsSum3:: ConvertEmbeddingBagOffsets15ToEmbeddingBagOffsetsSum3() { MATCHER_SCOPE(ConvertEmbeddingBagOffsets15ToEmbeddingBagOffsetsSum3); - const auto emb_v15_pattern = pattern::wrap_type(); + const auto emb_v15_pattern = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto emb_v15 = ov::as_type_ptr(m.get_match_root()); if (!emb_v15 || transformation_callback(emb_v15) || emb_v15->get_reduction() != ov::op::v15::EmbeddingBagOffsets::Reduction::SUM) { @@ -51,6 +51,6 @@ ov::pass::ConvertEmbeddingBagOffsets15ToEmbeddingBagOffsetsSum3:: return true; }; - auto m = std::make_shared(emb_v15_pattern, matcher_name); + auto m = std::make_shared(emb_v15_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_embedding_bag_packed15_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_embedding_bag_packed15_downgrade.cpp index ab4df004a9fab6..71fd4c51c85259 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_embedding_bag_packed15_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_embedding_bag_packed15_downgrade.cpp @@ -15,9 +15,9 @@ ov::pass::ConvertEmbeddingBagPacked15ToEmbeddingBagPackedSum3::ConvertEmbeddingBagPacked15ToEmbeddingBagPackedSum3() { MATCHER_SCOPE(ConvertEmbeddingBagPacked15ToEmbeddingBagPackedSum3); - const auto emb_v15_pattern = pattern::wrap_type(); + const auto emb_v15_pattern = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto emb_v15 = ov::as_type_ptr(m.get_match_root()); if (!emb_v15 || transformation_callback(emb_v15) || emb_v15->get_reduction() != ov::op::v15::EmbeddingBagPacked::Reduction::SUM) { @@ -41,6 +41,6 @@ ov::pass::ConvertEmbeddingBagPacked15ToEmbeddingBagPackedSum3::ConvertEmbeddingB return true; }; - auto m = std::make_shared(emb_v15_pattern, matcher_name); + auto m = std::make_shared(emb_v15_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_fc_to_compressed.cpp b/src/common/transformations/src/transformations/op_conversions/convert_fc_to_compressed.cpp index b9c71b1b054236..51c37d5afb1854 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_fc_to_compressed.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_fc_to_compressed.cpp @@ -129,15 +129,13 @@ ov::pass::ConvertFullyConnectedToFullyConnectedCompressed::ConvertFullyConnected const std::vector& supported_weights_types, SupportsPredicate supports_config, bool convert_u4zp_to_u8) { - using namespace ov::pass::pattern; - - auto weights_block = +auto weights_block = std::make_shared(supported_weights_types, std::set{2}); - auto activation = any_input(type_matches_any(supported_activation_types)); - auto bias = any_input(); - auto fully_connected = wrap_type({activation, weights_block, bias}); + auto activation = ov::pass::pattern::any_input(ov::pass::pattern::type_matches_any(supported_activation_types)); + auto bias = ov::pass::pattern::any_input(); + auto fully_connected = ov::pass::pattern::wrap_type({activation, weights_block, bias}); - ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto fc = ov::as_type_ptr(pattern_map.at(fully_connected).get_node_shared_ptr()); @@ -181,6 +179,6 @@ ov::pass::ConvertFullyConnectedToFullyConnectedCompressed::ConvertFullyConnected return true; }; - auto m = std::make_shared(fully_connected, "ConvertFullyConnectedToFullyConnectedCompressed"); + auto m = std::make_shared(fully_connected, "ConvertFullyConnectedToFullyConnectedCompressed"); this->register_matcher(m, callback); } \ No newline at end of file diff --git a/src/common/transformations/src/transformations/op_conversions/convert_fc_to_quantized_legacy.cpp b/src/common/transformations/src/transformations/op_conversions/convert_fc_to_quantized_legacy.cpp index 6b0ceec6c7155a..530644b58c4579 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_fc_to_quantized_legacy.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_fc_to_quantized_legacy.cpp @@ -19,18 +19,16 @@ #include "transformations/utils/utils.hpp" ov::pass::ConvertFCToFCQuantizedLegacy::ConvertFCToFCQuantizedLegacy() { - using namespace ov::pass::pattern; - - std::vector activation_types{ov::element::u8, ov::element::i8}; +std::vector activation_types{ov::element::u8, ov::element::i8}; std::vector weights_types{ov::element::i8}; - auto activations_m = pattern::any_input(ov::pass::pattern::type_matches_any(activation_types)); - auto weights_m = pattern::any_input(); - auto bias_m = pattern::any_input(); + auto activations_m = ov::pass::pattern::any_input(ov::pass::pattern::type_matches_any(activation_types)); + auto weights_m = ov::pass::pattern::any_input(); + auto bias_m = ov::pass::pattern::any_input(); - auto fully_connected_m = wrap_type({activations_m, weights_m, bias_m}); - auto dequantization_scales_m = wrap_type(); - auto multiply_m = wrap_type({fully_connected_m, dequantization_scales_m}); + auto fully_connected_m = ov::pass::pattern::wrap_type({activations_m, weights_m, bias_m}); + auto dequantization_scales_m = ov::pass::pattern::wrap_type(); + auto multiply_m = ov::pass::pattern::wrap_type({fully_connected_m, dequantization_scales_m}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_gather_0d.cpp b/src/common/transformations/src/transformations/op_conversions/convert_gather_0d.cpp index 27b3182088b51f..e45d93ecbb8268 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_gather_0d.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_gather_0d.cpp @@ -20,7 +20,7 @@ ov::pass::ConvertGather0D::ConvertGather0D() { MATCHER_SCOPE(ConvertGather0D); auto gather = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto gather = ov::as_type_ptr(m.get_match_root()); if (!gather) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_gather_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_gather_downgrade.cpp index b0063f3648586a..a0ae69f327cb9b 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_gather_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_gather_downgrade.cpp @@ -16,9 +16,9 @@ using namespace ov; pass::ConvertGather7ToGather1::ConvertGather7ToGather1() { MATCHER_SCOPE(ConvertGather7ToGather1); - auto gather_v7_pattern = pattern::wrap_type(); + auto gather_v7_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto gather_v7_node = ov::as_type_ptr(m.get_match_root()); if (!gather_v7_node) return false; @@ -35,16 +35,16 @@ pass::ConvertGather7ToGather1::ConvertGather7ToGather1() { return true; }; - auto m = make_shared(gather_v7_pattern, matcher_name); + auto m = make_shared(gather_v7_pattern, matcher_name); register_matcher(m, callback); } pass::ConvertGather8ToGather7::ConvertGather8ToGather7() { MATCHER_SCOPE(ConvertGather8ToGather7); - auto gather_v8_pattern = pattern::wrap_type(); + auto gather_v8_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto gather_v8_node = ov::as_type_ptr(m.get_match_root()); if (!gather_v8_node) return false; @@ -111,6 +111,6 @@ pass::ConvertGather8ToGather7::ConvertGather8ToGather7() { return true; }; - auto m = make_shared(gather_v8_pattern, matcher_name); + auto m = make_shared(gather_v8_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp b/src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp index fd9d2a2ae6becd..f35fb7f7fc7c42 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp @@ -21,9 +21,7 @@ #include "transformations/utils/utils.hpp" ov::pass::ConvertGatherToGatherCompressed::ConvertGatherToGatherCompressed() { - using namespace ov::pass::pattern; - - auto compressed_constant = [](const ov::Output& output) { +auto compressed_constant = [](const ov::Output& output) { return (output.get_element_type() == ov::element::u8 || output.get_element_type() == ov::element::i8 || output.get_element_type() == ov::element::u4 || output.get_element_type() == ov::element::i4) && (output.get_shape().size() == 2 || output.get_shape().size() == 3); @@ -35,26 +33,26 @@ ov::pass::ConvertGatherToGatherCompressed::ConvertGatherToGatherCompressed() { return in_ps.rank().is_static() && out_ps.rank().is_static() && in_ps.size() == 3 && out_ps.size() == 2; }; - auto dicts_m = wrap_type(compressed_constant); - auto convert_m = wrap_type({dicts_m}); + auto dicts_m = ov::pass::pattern::wrap_type(compressed_constant); + auto convert_m = ov::pass::pattern::wrap_type({dicts_m}); auto sub_const_m = ov::pass::pattern::any_input(); // const or const+convert - auto subtract_m = wrap_type({convert_m, sub_const_m}); + auto subtract_m = ov::pass::pattern::wrap_type({convert_m, sub_const_m}); auto mul_const_m = ov::pass::pattern::any_input(); // const or const+convert - auto mul_with_sub_m = wrap_type({subtract_m, mul_const_m}); - auto mul_no_sub_m = wrap_type({convert_m, mul_const_m}); + auto mul_with_sub_m = ov::pass::pattern::wrap_type({subtract_m, mul_const_m}); + auto mul_no_sub_m = ov::pass::pattern::wrap_type({convert_m, mul_const_m}); auto mul_m = std::make_shared(ov::OutputVector{mul_with_sub_m, mul_no_sub_m}); - auto reshape_const_m = wrap_type(); - auto reshape_m = wrap_type({mul_m, reshape_const_m}, reshape_3d_to_2d); + auto reshape_const_m = ov::pass::pattern::wrap_type(); + auto reshape_m = ov::pass::pattern::wrap_type({mul_m, reshape_const_m}, reshape_3d_to_2d); auto last_convert_input = std::make_shared(ov::OutputVector{reshape_m, mul_m}); - auto last_convert_m = wrap_type({last_convert_input}); + auto last_convert_m = ov::pass::pattern::wrap_type({last_convert_input}); auto dicts_input_m = std::make_shared(ov::OutputVector{reshape_m, last_convert_m, mul_m}); - auto gather_m = wrap_type({dicts_input_m, any_input(), wrap_type()}); + auto gather_m = ov::pass::pattern::wrap_type({dicts_input_m, ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -150,14 +148,12 @@ ov::pass::ConvertGatherToGatherCompressed::ConvertGatherToGatherCompressed() { } ov::pass::MoveDecompressionAfterGather::MoveDecompressionAfterGather() { - using namespace ov::pass::pattern; - - auto dicts = wrap_type(pattern::type_matches_any({element::f16, element::bf16})); +auto dicts = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any({element::f16, element::bf16})); auto convert_predicate = [](ov::Output output) -> bool { - return pattern::consumers_count(1)(output) && pattern::type_matches(ov::element::f32)(output); + return ov::pass::pattern::consumers_count(1)(output) && ov::pass::pattern::type_matches(ov::element::f32)(output); }; - auto convert = wrap_type({dicts}, convert_predicate); - auto gather = wrap_type({convert, any_input(), wrap_type()}); + auto convert = ov::pass::pattern::wrap_type({dicts}, convert_predicate); + auto gather = ov::pass::pattern::wrap_type({convert, ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_gather_upgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_gather_upgrade.cpp index 716ab0e7206110..524106542c9102 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_gather_upgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_gather_upgrade.cpp @@ -16,9 +16,9 @@ using namespace ov; pass::ConvertGather1ToGather7::ConvertGather1ToGather7() { MATCHER_SCOPE(ConvertGather1ToGather7); - auto gather_v1_pattern = pattern::wrap_type(); + auto gather_v1_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto gather_v1_node = ov::as_type_ptr(m.get_match_root()); if (!gather_v1_node) return false; @@ -34,16 +34,16 @@ pass::ConvertGather1ToGather7::ConvertGather1ToGather7() { return true; }; - auto m = make_shared(gather_v1_pattern, matcher_name); + auto m = make_shared(gather_v1_pattern, matcher_name); register_matcher(m, callback); } pass::ConvertGather7ToGather8::ConvertGather7ToGather8() { MATCHER_SCOPE(ConvertGather7ToGather8); - auto gather_v7_pattern = pattern::wrap_type(); + auto gather_v7_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto gather_v7_node = ov::as_type_ptr(m.get_match_root()); if (!gather_v7_node) return false; @@ -59,6 +59,6 @@ pass::ConvertGather7ToGather8::ConvertGather7ToGather8() { return true; }; - auto m = make_shared(gather_v7_pattern, matcher_name); + auto m = make_shared(gather_v7_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_gelu.cpp b/src/common/transformations/src/transformations/op_conversions/convert_gelu.cpp index 16393b4fd49102..16e276a66df51a 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_gelu.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_gelu.cpp @@ -20,9 +20,9 @@ ov::pass::ConvertGELU::ConvertGELU() { MATCHER_SCOPE(ConvertGELU); - auto gelu = pattern::wrap_type(); + auto gelu = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto gelu = ov::as_type_ptr(m.get_match_root()); if (!gelu || transformation_callback(gelu)) return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_interpolate11_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_interpolate11_downgrade.cpp index 0c154513cca91a..c4a99cfa663925 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_interpolate11_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_interpolate11_downgrade.cpp @@ -56,9 +56,9 @@ std::pair, ov::Output> make_v4_inputs( ov::pass::ConvertInterpolate11ToInterpolate4::ConvertInterpolate11ToInterpolate4() { MATCHER_SCOPE(ConvertInterpolate11ToInterpolate4); - const auto interpolate_v11_pattern = pattern::wrap_type(); + const auto interpolate_v11_pattern = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto v4_compatible_interpolation_mode = [](const op::util::InterpolateBase::InterpolateMode mode) { constexpr std::array allowed_modes = { op::util::InterpolateBase::InterpolateMode::NEAREST, @@ -101,6 +101,6 @@ ov::pass::ConvertInterpolate11ToInterpolate4::ConvertInterpolate11ToInterpolate4 return true; }; - auto m = std::make_shared(interpolate_v11_pattern, matcher_name); + auto m = std::make_shared(interpolate_v11_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_interpolate1_to_interpolate4.cpp b/src/common/transformations/src/transformations/op_conversions/convert_interpolate1_to_interpolate4.cpp index b4d68bc959a21a..57f052f4de55af 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_interpolate1_to_interpolate4.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_interpolate1_to_interpolate4.cpp @@ -21,8 +21,8 @@ ov::pass::ConvertInterpolate1ToInterpolate4::ConvertInterpolate1ToInterpolate4() { MATCHER_SCOPE(ConvertInterpolate1ToInterpolate4); auto interpolate1 = ov::pass::pattern::wrap_type( - {pattern::any_input(pattern::has_static_rank()), pattern::any_input()}); - matcher_pass_callback callback = [](pattern::Matcher& m) { + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), ov::pass::pattern::any_input()}); + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto interpolationV0 = ov::as_type_ptr(m.get_match_root()); if (!interpolationV0) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_matrix_nms_to_matrix_nms_ie.cpp b/src/common/transformations/src/transformations/op_conversions/convert_matrix_nms_to_matrix_nms_ie.cpp index afc29ac9a0c52e..aedf4ababf89f5 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_matrix_nms_to_matrix_nms_ie.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_matrix_nms_to_matrix_nms_ie.cpp @@ -20,7 +20,7 @@ ov::pass::ConvertMatrixNmsToMatrixNmsIE::ConvertMatrixNmsToMatrixNmsIE(bool forc MATCHER_SCOPE(ConvertMatrixNmsToMatrixNmsIE); auto nms = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto nms = ov::as_type_ptr(m.get_match_root()); if (!nms || transformation_callback(nms)) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_maxpool_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_maxpool_downgrade.cpp index 4f6f935fcba058..fdc53c18edda89 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_maxpool_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_maxpool_downgrade.cpp @@ -29,9 +29,9 @@ ov::pass::ConvertMaxPool8ToMaxPool1::ConvertMaxPool8ToMaxPool1() { MATCHER_SCOPE(ConvertMaxPool8ToMaxPool1); - auto maxpool_v8_pattern = pattern::wrap_type(); + auto maxpool_v8_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto maxpool_v8_node = ov::as_type_ptr(m.get_match_root()); if (!maxpool_v8_node || maxpool_v8_node->get_output_target_inputs(1).size() != 0) @@ -61,15 +61,15 @@ ov::pass::ConvertMaxPool8ToMaxPool1::ConvertMaxPool8ToMaxPool1() { return true; }; - auto m = std::make_shared(maxpool_v8_pattern, matcher_name); + auto m = std::make_shared(maxpool_v8_pattern, matcher_name); register_matcher(m, callback); } ov::pass::ConvertMaxPool14ToMaxPool8::ConvertMaxPool14ToMaxPool8() { MATCHER_SCOPE(ConvertMaxPool14ToMaxPool8); - const auto max_pool_v14_pattern = pattern::wrap_type(); + const auto max_pool_v14_pattern = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { using ov::op::v0::Constant; using ov::op::v0::Concat; using ov::op::v1::Subtract; @@ -175,6 +175,6 @@ ov::pass::ConvertMaxPool14ToMaxPool8::ConvertMaxPool14ToMaxPool8() { return true; }; - auto m = std::make_shared(max_pool_v14_pattern, matcher_name); + auto m = std::make_shared(max_pool_v14_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_maxpool_upgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_maxpool_upgrade.cpp index 3ae3752be37ece..87767e1ff06b71 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_maxpool_upgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_maxpool_upgrade.cpp @@ -14,7 +14,7 @@ ov::pass::ConvertMaxPool1ToMaxPool8::ConvertMaxPool1ToMaxPool8() { MATCHER_SCOPE(ConvertMaxPool1ToMaxPool8); // Replaces v1::MaxPool with v8::MaxPool with default dilations, axis and index_element_type attributes - auto input = pattern::any_input(pattern::has_static_rank()); + auto input = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); auto maxpool_v1_pattern = ov::pass::pattern::wrap_type({input}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { @@ -47,6 +47,6 @@ ov::pass::ConvertMaxPool1ToMaxPool8::ConvertMaxPool1ToMaxPool8() { return true; }; - auto m = std::make_shared(maxpool_v1_pattern, matcher_name); + auto m = std::make_shared(maxpool_v1_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_mod.cpp b/src/common/transformations/src/transformations/op_conversions/convert_mod.cpp index 30eae263018ef1..05050c69a1a161 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_mod.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_mod.cpp @@ -24,7 +24,7 @@ ov::pass::ConvertMod::ConvertMod() { MATCHER_SCOPE(ConvertMod); auto mod = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto mod = ov::as_type_ptr(m.get_match_root()); if (!mod) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_multiclass_nms_to_multiclass_nms_ie.cpp b/src/common/transformations/src/transformations/op_conversions/convert_multiclass_nms_to_multiclass_nms_ie.cpp index 48e04d6a659ae6..490e2598d31657 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_multiclass_nms_to_multiclass_nms_ie.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_multiclass_nms_to_multiclass_nms_ie.cpp @@ -19,9 +19,9 @@ using namespace ov; pass::ConvertMulticlassNmsToMulticlassNmsIE::ConvertMulticlassNmsToMulticlassNmsIE(bool force_i32_output_type) { MATCHER_SCOPE(ConvertMulticlassNmsToMulticlassNmsIE); - auto nms = pattern::wrap_type(); + auto nms = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto nms = ov::as_type_ptr(m.get_match_root()); if (!nms || transformation_callback(nms)) { return false; @@ -75,6 +75,6 @@ pass::ConvertMulticlassNmsToMulticlassNmsIE::ConvertMulticlassNmsToMulticlassNms return true; }; - auto m = std::make_shared(nms, matcher_name); + auto m = std::make_shared(nms, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_multiclass_nms_upgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_multiclass_nms_upgrade.cpp index f7ef989bfe4fa6..0ccd34e4f2a54b 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_multiclass_nms_upgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_multiclass_nms_upgrade.cpp @@ -13,9 +13,9 @@ ov::pass::ConvertMulticlassNms8ToMulticlassNms9::ConvertMulticlassNms8ToMulticlassNms9() { MATCHER_SCOPE(ConvertMulticlassNms8ToMulticlassNms9); - auto nms_v8_pattern = pattern::wrap_type(); + auto nms_v8_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto nms_v8_node = ov::as_type_ptr(m.get_match_root()); if (!nms_v8_node) return false; @@ -32,6 +32,6 @@ ov::pass::ConvertMulticlassNms8ToMulticlassNms9::ConvertMulticlassNms8ToMulticla return true; }; - auto m = std::make_shared(nms_v8_pattern, matcher_name); + auto m = std::make_shared(nms_v8_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_mvn1_to_mvn6.cpp b/src/common/transformations/src/transformations/op_conversions/convert_mvn1_to_mvn6.cpp index 50b9cf15aa1217..350c34ca4115a5 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_mvn1_to_mvn6.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_mvn1_to_mvn6.cpp @@ -16,9 +16,9 @@ ov::pass::ConvertMVN1ToMVN6::ConvertMVN1ToMVN6() { MATCHER_SCOPE(ConvertMVN1ToMVN6); - auto mvn = pattern::wrap_type(); + auto mvn = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto mvn_node = ov::as_type_ptr(m.get_match_root()); if (!mvn_node) { return false; @@ -51,6 +51,6 @@ ov::pass::ConvertMVN1ToMVN6::ConvertMVN1ToMVN6() { return true; }; - auto m = std::make_shared(mvn, matcher_name); + auto m = std::make_shared(mvn, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_negative.cpp b/src/common/transformations/src/transformations/op_conversions/convert_negative.cpp index 808c9dceaaa02c..90775fe819db36 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_negative.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_negative.cpp @@ -19,7 +19,7 @@ ov::pass::ConvertNegative::ConvertNegative() { MATCHER_SCOPE(ConvertNegative); auto neg = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto neg = ov::as_type_ptr(m.get_match_root()); if (!neg) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_nms9_to_nms_ie_internal.cpp b/src/common/transformations/src/transformations/op_conversions/convert_nms9_to_nms_ie_internal.cpp index 8b1c572dfaa73d..b253f2dea5c6bd 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_nms9_to_nms_ie_internal.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_nms9_to_nms_ie_internal.cpp @@ -22,7 +22,7 @@ ov::pass::ConvertNMS9ToNMSIEInternal::ConvertNMS9ToNMSIEInternal() { MATCHER_SCOPE(ConvertNMS9ToNMSIEInternal); auto nms = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto nms_9 = ov::as_type_ptr(m.get_match_root()); if (!nms_9 || transformation_callback(nms_9)) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_nms_rotated_to_nms_ie_internal.cpp b/src/common/transformations/src/transformations/op_conversions/convert_nms_rotated_to_nms_ie_internal.cpp index 86a988d0588897..daec0b1396026d 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_nms_rotated_to_nms_ie_internal.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_nms_rotated_to_nms_ie_internal.cpp @@ -23,7 +23,7 @@ ov::pass::ConvertNMSRotatedToNMSIEInternal::ConvertNMSRotatedToNMSIEInternal() { MATCHER_SCOPE(ConvertNMSRotatedToNMSIEInternal); auto nms = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto nms_rotated = ov::as_type_ptr(m.get_match_root()); if (!nms_rotated || transformation_callback(nms_rotated)) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_nms_to_nms_ie_internal.cpp b/src/common/transformations/src/transformations/op_conversions/convert_nms_to_nms_ie_internal.cpp index ed1e46204c0776..c0933db9f76e7b 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_nms_to_nms_ie_internal.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_nms_to_nms_ie_internal.cpp @@ -22,7 +22,7 @@ ov::pass::ConvertNMSToNMSIEInternal::ConvertNMSToNMSIEInternal() { MATCHER_SCOPE(ConvertNMSToNMSIEInternal); auto nms = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto nms_5 = ov::as_type_ptr(m.get_match_root()); if (!nms_5 || transformation_callback(nms_5)) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_one_hot_v16_to_v1.cpp b/src/common/transformations/src/transformations/op_conversions/convert_one_hot_v16_to_v1.cpp index 3632ddf828419c..2edd0e41b344e6 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_one_hot_v16_to_v1.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_one_hot_v16_to_v1.cpp @@ -13,9 +13,9 @@ ov::pass::ConvertOneHot16To1::ConvertOneHot16To1() { MATCHER_SCOPE(ConvertOneHot16To1); - auto one_hot_v16 = pattern::wrap_type(); + auto one_hot_v16 = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto one_hot_v16_node = ov::as_type_ptr(m.get_match_root()); if (!one_hot_v16_node) return false; @@ -35,6 +35,6 @@ ov::pass::ConvertOneHot16To1::ConvertOneHot16To1() { return true; }; - auto m = std::make_shared(one_hot_v16, matcher_name); + auto m = std::make_shared(one_hot_v16, matcher_name); register_matcher(m, callback); } \ No newline at end of file diff --git a/src/common/transformations/src/transformations/op_conversions/convert_pad12_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_pad12_downgrade.cpp index 5a43083b2a33b0..edaeee9565f5f4 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_pad12_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_pad12_downgrade.cpp @@ -14,9 +14,9 @@ ov::pass::ConvertPad12ToPad1::ConvertPad12ToPad1() { MATCHER_SCOPE(ConvertPad12ToPad1); - const auto pad_v12_pattern = pattern::wrap_type(); + const auto pad_v12_pattern = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto pad_v12 = ov::as_type_ptr(m.get_match_root()); if (!pad_v12 || transformation_callback(pad_v12)) { return false; @@ -46,6 +46,6 @@ ov::pass::ConvertPad12ToPad1::ConvertPad12ToPad1() { return true; }; - auto m = std::make_shared(pad_v12_pattern, matcher_name); + auto m = std::make_shared(pad_v12_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_pad_to_group_conv.cpp b/src/common/transformations/src/transformations/op_conversions/convert_pad_to_group_conv.cpp index 039689e34b01da..33c240ac4786d9 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_pad_to_group_conv.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_pad_to_group_conv.cpp @@ -18,9 +18,9 @@ ov::pass::ConvertPadToGroupConvolution::ConvertPadToGroupConvolution() { MATCHER_SCOPE(ConvertPadToGroupConvolution); - auto neg = ov::pass::pattern::wrap_type(pattern::has_static_dim(1)); + auto neg = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_dim(1)); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto pad = ov::as_type_ptr(m.get_match_root()); if (!pad) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_previous_nms_to_nms_5.cpp b/src/common/transformations/src/transformations/op_conversions/convert_previous_nms_to_nms_5.cpp index 475f550f7b4212..2b1e93e30acd0f 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_previous_nms_to_nms_5.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_previous_nms_to_nms_5.cpp @@ -121,7 +121,7 @@ NMSAttributes get_nms_attrs(const std::shared_ptr& root) { return attrs; } -bool callback_func(pass::pattern::Matcher& m, pass::MatcherPass* impl) { +bool callback_func(ov::pass::pattern::Matcher& m, pass::MatcherPass* impl) { auto root = m.get_match_root(); auto attrs = get_nms_attrs(root); @@ -155,33 +155,33 @@ bool callback_func(pass::pattern::Matcher& m, pass::MatcherPass* impl) { ov::pass::ConvertNMS4ToNMS5::ConvertNMS4ToNMS5() { MATCHER_SCOPE(ConvertNMS4ToNMS5); - auto nms = pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + auto nms = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { return callback_func(m, this); }; - auto m = std::make_shared(nms, matcher_name); + auto m = std::make_shared(nms, matcher_name); this->register_matcher(m, callback); } ov::pass::ConvertNMS3ToNMS5::ConvertNMS3ToNMS5() { MATCHER_SCOPE(ConvertNMS3ToNMS5); - auto nms = pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + auto nms = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { return callback_func(m, this); }; - auto m = std::make_shared(nms, matcher_name); + auto m = std::make_shared(nms, matcher_name); this->register_matcher(m, callback); } ov::pass::ConvertNMS1ToNMS5::ConvertNMS1ToNMS5() { MATCHER_SCOPE(ConvertNMS1ToNMS5); - auto nms = pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + auto nms = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { return callback_func(m, this); }; - auto m = std::make_shared(nms, matcher_name); + auto m = std::make_shared(nms, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_previous_nms_to_nms_9.cpp b/src/common/transformations/src/transformations/op_conversions/convert_previous_nms_to_nms_9.cpp index 6f0ae15cc38e13..beee2b94afbdbb 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_previous_nms_to_nms_9.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_previous_nms_to_nms_9.cpp @@ -151,7 +151,7 @@ NMS9Attributes get_nms9_attrs(const std::shared_ptr& root) { return attrs; } -bool nms_to_nms9_callback_func(pass::pattern::Matcher& m, pass::MatcherPass* impl) { +bool nms_to_nms9_callback_func(ov::pass::pattern::Matcher& m, pass::MatcherPass* impl) { auto root = m.get_match_root(); auto attrs = get_nms9_attrs(root); @@ -195,44 +195,44 @@ bool nms_to_nms9_callback_func(pass::pattern::Matcher& m, pass::MatcherPass* imp ov::pass::ConvertNMS5ToNMS9::ConvertNMS5ToNMS9() { MATCHER_SCOPE(ConvertNMS5ToNMS9); - auto nms = pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + auto nms = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { return nms_to_nms9_callback_func(m, this); }; - auto m = std::make_shared(nms, matcher_name); + auto m = std::make_shared(nms, matcher_name); this->register_matcher(m, callback); } ov::pass::ConvertNMS4ToNMS9::ConvertNMS4ToNMS9() { MATCHER_SCOPE(ConvertNMS4ToNMS9); - auto nms = pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + auto nms = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { return nms_to_nms9_callback_func(m, this); }; - auto m = std::make_shared(nms, matcher_name); + auto m = std::make_shared(nms, matcher_name); this->register_matcher(m, callback); } ov::pass::ConvertNMS3ToNMS9::ConvertNMS3ToNMS9() { MATCHER_SCOPE(ConvertNMS3ToNMS9); - auto nms = pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + auto nms = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { return nms_to_nms9_callback_func(m, this); }; - auto m = std::make_shared(nms, matcher_name); + auto m = std::make_shared(nms, matcher_name); this->register_matcher(m, callback); } ov::pass::ConvertNMS1ToNMS9::ConvertNMS1ToNMS9() { MATCHER_SCOPE(ConvertNMS1ToNMS9); - auto nms = pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + auto nms = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { return nms_to_nms9_callback_func(m, this); }; - auto m = std::make_shared(nms, matcher_name); + auto m = std::make_shared(nms, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_prior_box_v8_to_v0.cpp b/src/common/transformations/src/transformations/op_conversions/convert_prior_box_v8_to_v0.cpp index 5142cf19d4611b..209accea79c34e 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_prior_box_v8_to_v0.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_prior_box_v8_to_v0.cpp @@ -13,9 +13,9 @@ ov::pass::ConvertPriorBox8To0::ConvertPriorBox8To0() { MATCHER_SCOPE(ConvertPriorBox8To0); - auto prior_box_v8 = pattern::wrap_type(); + auto prior_box_v8 = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto prior_box_v8_node = ov::as_type_ptr(m.get_match_root()); if (!prior_box_v8_node) return false; @@ -48,6 +48,6 @@ ov::pass::ConvertPriorBox8To0::ConvertPriorBox8To0() { return true; }; - auto m = std::make_shared(prior_box_v8, matcher_name); + auto m = std::make_shared(prior_box_v8, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_pooling.cpp b/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_pooling.cpp index 197f7b56c7d12f..13edc967aee070 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_pooling.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_pooling.cpp @@ -9,28 +9,28 @@ ov::pass::ConvertReduceMeanToPooling::ConvertReduceMeanToPooling() { MATCHER_SCOPE(ConvertReduceMeanToPooling); - auto m = std::make_shared( - pattern::wrap_type( - {pattern::any_input(pattern::has_static_shape()), pattern::wrap_type()}, - pattern::has_static_shape()), + auto m = std::make_shared( + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_pooling()); } ov::pass::ConvertReduceMaxToPooling::ConvertReduceMaxToPooling() { MATCHER_SCOPE(ConvertReduceMaxToPooling); - auto m = std::make_shared( - pattern::wrap_type( - {pattern::any_input(pattern::has_static_shape()), pattern::wrap_type()}, - pattern::has_static_shape()), + auto m = std::make_shared( + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_pooling()); } ov::pass::ConvertReduceSumToPooling::ConvertReduceSumToPooling() { MATCHER_SCOPE(ConvertReduceSumToPooling); - auto m = std::make_shared( - pattern::wrap_type( - {pattern::any_input(pattern::has_static_shape()), pattern::wrap_type()}, - pattern::has_static_shape()), + auto m = std::make_shared( + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_pooling()); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_reshape.cpp b/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_reshape.cpp index 8990c357c3df52..dfd9446d1e43b5 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_reshape.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_reshape.cpp @@ -23,70 +23,70 @@ bool CvtReduceBase::is_redundant(ov::Shape input, ov::Shape output) { ov::pass::ConvertReduceMeanToReshape::ConvertReduceMeanToReshape() { MATCHER_SCOPE(ConvertReduceMeanToReshape); - auto m = std::make_shared( - pattern::wrap_type( - {pattern::any_input(pattern::has_static_shape()), pattern::wrap_type()}, - pattern::has_static_shape()), + auto m = std::make_shared( + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); } ov::pass::ConvertReduceSumToReshape::ConvertReduceSumToReshape() { MATCHER_SCOPE(ConvertReduceSumToReshape); - auto m = std::make_shared( - pattern::wrap_type( - {pattern::any_input(pattern::has_static_shape()), pattern::wrap_type()}, - pattern::has_static_shape()), + auto m = std::make_shared( + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); } ov::pass::ConvertReduceProdToReshape::ConvertReduceProdToReshape() { MATCHER_SCOPE(ConvertReduceProdToReshape); - auto m = std::make_shared( - pattern::wrap_type( - {pattern::any_input(pattern::has_static_shape()), pattern::wrap_type()}, - pattern::has_static_shape()), + auto m = std::make_shared( + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); } ov::pass::ConvertReduceMaxToReshape::ConvertReduceMaxToReshape() { MATCHER_SCOPE(ConvertReduceMaxToReshape); - auto m = std::make_shared( - pattern::wrap_type( - {pattern::any_input(pattern::has_static_shape()), pattern::wrap_type()}, - pattern::has_static_shape()), + auto m = std::make_shared( + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); } ov::pass::ConvertReduceMinToReshape::ConvertReduceMinToReshape() { MATCHER_SCOPE(ConvertReduceMinToReshape); - auto m = std::make_shared( - pattern::wrap_type( - {pattern::any_input(pattern::has_static_shape()), pattern::wrap_type()}, - pattern::has_static_shape()), + auto m = std::make_shared( + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); } ov::pass::ConvertReduceLogicalAndToReshape::ConvertReduceLogicalAndToReshape() { MATCHER_SCOPE(ConvertReduceLogicalAndToReshape); - auto m = std::make_shared( - pattern::wrap_type( - {pattern::any_input(pattern::has_static_shape()), pattern::wrap_type()}, - pattern::has_static_shape()), + auto m = std::make_shared( + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); } ov::pass::ConvertReduceLogicalOrToReshape::ConvertReduceLogicalOrToReshape() { MATCHER_SCOPE(ConvertReduceLogicalOrToReshape); - auto m = std::make_shared( - pattern::wrap_type( - {pattern::any_input(pattern::has_static_shape()), pattern::wrap_type()}, - pattern::has_static_shape()), + auto m = std::make_shared( + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_roi_align_v3_to_v9.cpp b/src/common/transformations/src/transformations/op_conversions/convert_roi_align_v3_to_v9.cpp index 774100a5d71df8..06cbd0403054fd 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_roi_align_v3_to_v9.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_roi_align_v3_to_v9.cpp @@ -13,9 +13,9 @@ ov::pass::ConvertROIAlign3To9::ConvertROIAlign3To9() { MATCHER_SCOPE(ConvertROIAlign3To9); - auto roi_align_v3 = pattern::wrap_type(); + auto roi_align_v3 = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto roi_align_v3_node = ov::as_type_ptr(m.get_match_root()); if (!roi_align_v3_node) return false; @@ -55,6 +55,6 @@ ov::pass::ConvertROIAlign3To9::ConvertROIAlign3To9() { return true; }; - auto m = std::make_shared(roi_align_v3, matcher_name); + auto m = std::make_shared(roi_align_v3, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_roi_align_v9_to_v3.cpp b/src/common/transformations/src/transformations/op_conversions/convert_roi_align_v9_to_v3.cpp index 73ca8b21f91a09..97f080982adf01 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_roi_align_v9_to_v3.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_roi_align_v9_to_v3.cpp @@ -13,9 +13,9 @@ ov::pass::ConvertROIAlign9To3::ConvertROIAlign9To3() { MATCHER_SCOPE(ConvertROIAlign9To3); - auto roi_align_v9 = pattern::wrap_type(); + auto roi_align_v9 = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto roi_align_v9_node = ov::as_type_ptr(m.get_match_root()); if (!roi_align_v9_node) return false; @@ -59,6 +59,6 @@ ov::pass::ConvertROIAlign9To3::ConvertROIAlign9To3() { return true; }; - auto m = std::make_shared(roi_align_v9, matcher_name); + auto m = std::make_shared(roi_align_v9, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_scatter_elements_to_scatter.cpp b/src/common/transformations/src/transformations/op_conversions/convert_scatter_elements_to_scatter.cpp index a1af69fed8b17f..d41e5f8b93ebe5 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_scatter_elements_to_scatter.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_scatter_elements_to_scatter.cpp @@ -21,17 +21,17 @@ ov::pass::ConvertScatterElementsToScatter::ConvertScatterElementsToScatter() { MATCHER_SCOPE(ConvertScatterElementsToScatter); - auto data = std::make_shared(element::f32, Shape{1}); - auto indices = std::make_shared(element::i64, Shape{1}); - auto updates = std::make_shared(element::f32, Shape{1}); + auto data = std::make_shared(element::f32, Shape{1}); + auto indices = std::make_shared(element::i64, Shape{1}); + auto updates = std::make_shared(element::f32, Shape{1}); auto axis = ov::op::v0::Constant::create(element::i64, {1}, {0}); - auto broadcast_shape = std::make_shared(element::i64, Shape{1}); + auto broadcast_shape = std::make_shared(element::i64, Shape{1}); auto broadcast = std::make_shared(indices, broadcast_shape); auto scatter = std::make_shared(data, broadcast, updates, axis); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto scatter = m.get_match_root(); auto broadcast = scatter->input_value(1).get_node_shared_ptr(); auto axis_const = ov::as_type_ptr(scatter->input_value(3).get_node_shared_ptr()); @@ -219,6 +219,6 @@ ov::pass::ConvertScatterElementsToScatter::ConvertScatterElementsToScatter() { return true; }; - auto m = std::make_shared(scatter, matcher_name); + auto m = std::make_shared(scatter, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_scatter_elements_update12_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_scatter_elements_update12_downgrade.cpp index c98b4e47f8bb47..8b64662dc23649 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_scatter_elements_update12_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_scatter_elements_update12_downgrade.cpp @@ -15,9 +15,9 @@ ov::pass::ConvertScatterElementsUpdate12ToScatterElementsUpdate3:: ConvertScatterElementsUpdate12ToScatterElementsUpdate3() { MATCHER_SCOPE(ConvertScatterElementsUpdate12ToScatterElementsUpdate3); - const auto seu_v12_pattern = pattern::wrap_type(); + const auto seu_v12_pattern = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto seu_v12 = ov::as_type_ptr(m.get_match_root()); if (!seu_v12 || transformation_callback(seu_v12) || seu_v12->get_reduction() != ov::op::v12::ScatterElementsUpdate::Reduction::NONE) { @@ -36,6 +36,6 @@ ov::pass::ConvertScatterElementsUpdate12ToScatterElementsUpdate3:: return true; }; - auto m = std::make_shared(seu_v12_pattern, matcher_name); + auto m = std::make_shared(seu_v12_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_scatter_nd_update15_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_scatter_nd_update15_downgrade.cpp index c6a72cf6b4b180..49a05ed7d3fc1f 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_scatter_nd_update15_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_scatter_nd_update15_downgrade.cpp @@ -14,9 +14,9 @@ ov::pass::ConvertScatterNDUpdate15ToScatterNDUpdate3::ConvertScatterNDUpdate15ToScatterNDUpdate3() { MATCHER_SCOPE(ConvertScatterNDUpdate15ToScatterNDUpdate3); - const auto scatter_v15_pattern = pattern::wrap_type(); + const auto scatter_v15_pattern = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto scatter_v15 = ov::as_type_ptr(m.get_match_root()); if (!scatter_v15 || transformation_callback(scatter_v15)) { return false; @@ -35,6 +35,6 @@ ov::pass::ConvertScatterNDUpdate15ToScatterNDUpdate3::ConvertScatterNDUpdate15To return true; }; - auto m = std::make_shared(scatter_v15_pattern, matcher_name); + auto m = std::make_shared(scatter_v15_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_sequences_to_tensor_iterator.cpp b/src/common/transformations/src/transformations/op_conversions/convert_sequences_to_tensor_iterator.cpp index 4f872a3b7e2c5b..b3ee1c2710fd01 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_sequences_to_tensor_iterator.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_sequences_to_tensor_iterator.cpp @@ -346,12 +346,12 @@ bool convert_sequence_to_ti(const std::shared_ptr& sequence, ov::pass::ConvertRNNSequenceToTensorIterator::ConvertRNNSequenceToTensorIterator() { MATCHER_SCOPE(ConvertRNNSequenceToTensorIterator); - auto X_m = pattern::any_input(pattern::has_static_rank()); - auto H_t_m = pattern::any_input(); - auto seq_lengths_m = pattern::any_input(); - auto W_m = pattern::any_input(); - auto R_m = pattern::any_input(); - auto B_m = pattern::any_input(); + auto X_m = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto H_t_m = ov::pass::pattern::any_input(); + auto seq_lengths_m = ov::pass::pattern::any_input(); + auto W_m = ov::pass::pattern::any_input(); + auto R_m = ov::pass::pattern::any_input(); + auto B_m = ov::pass::pattern::any_input(); auto rnn_seq = ov::pass::pattern::wrap_type({X_m, H_t_m, seq_lengths_m, W_m, R_m, B_m}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { @@ -389,12 +389,12 @@ ov::pass::ConvertRNNSequenceToTensorIterator::ConvertRNNSequenceToTensorIterator ov::pass::ConvertGRUSequenceToTensorIterator::ConvertGRUSequenceToTensorIterator() { MATCHER_SCOPE(ConvertGRUSequenceToTensorIterator); - auto X_m = pattern::any_input(pattern::has_static_rank()); - auto H_t_m = pattern::any_input(); - auto seq_lengths_m = pattern::any_input(); - auto W_m = pattern::any_input(); - auto R_m = pattern::any_input(); - auto B_m = pattern::any_input(); + auto X_m = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto H_t_m = ov::pass::pattern::any_input(); + auto seq_lengths_m = ov::pass::pattern::any_input(); + auto W_m = ov::pass::pattern::any_input(); + auto R_m = ov::pass::pattern::any_input(); + auto B_m = ov::pass::pattern::any_input(); auto gru_seq = ov::pass::pattern::wrap_type({X_m, H_t_m, seq_lengths_m, W_m, R_m, B_m}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { @@ -432,13 +432,13 @@ ov::pass::ConvertGRUSequenceToTensorIterator::ConvertGRUSequenceToTensorIterator ov::pass::ConvertLSTMSequenceToTensorIterator::ConvertLSTMSequenceToTensorIterator() { MATCHER_SCOPE(ConvertLSTMSequenceToTensorIterator); - auto X_m = pattern::any_input(pattern::has_static_rank()); - auto H_t_m = pattern::any_input(); - auto C_t_m = pattern::any_input(); - auto seq_lengths_m = pattern::any_input(); - auto W_m = pattern::any_input(); - auto R_m = pattern::any_input(); - auto B_m = pattern::any_input(); + auto X_m = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto H_t_m = ov::pass::pattern::any_input(); + auto C_t_m = ov::pass::pattern::any_input(); + auto seq_lengths_m = ov::pass::pattern::any_input(); + auto W_m = ov::pass::pattern::any_input(); + auto R_m = ov::pass::pattern::any_input(); + auto B_m = ov::pass::pattern::any_input(); auto lstm_seq = ov::pass::pattern::wrap_type({X_m, H_t_m, C_t_m, seq_lengths_m, W_m, R_m, B_m}); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_shapeof3.cpp b/src/common/transformations/src/transformations/op_conversions/convert_shapeof3.cpp index 29796ae32fc498..f8ed9f84f5d87e 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_shapeof3.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_shapeof3.cpp @@ -16,9 +16,9 @@ ov::pass::ConvertShapeOf3::ConvertShapeOf3() { MATCHER_SCOPE(ConvertShapeOf3); - auto shapeof = pattern::wrap_type(); + auto shapeof = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto shapeof = ov::as_type_ptr(m.get_match_root()); if (!shapeof) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_shuffle_channels3.cpp b/src/common/transformations/src/transformations/op_conversions/convert_shuffle_channels3.cpp index fc52b714165d4a..6c464528125b63 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_shuffle_channels3.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_shuffle_channels3.cpp @@ -24,9 +24,9 @@ using namespace ov; ov::pass::ConvertShuffleChannels3::ConvertShuffleChannels3() { MATCHER_SCOPE(ConvertShuffleChannels3); - auto shuffle_channels = pattern::wrap_type(); + auto shuffle_channels = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto shuffle_channels = ov::as_type_ptr(m.get_match_root()); if (!shuffle_channels || transformation_callback(shuffle_channels)) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_slice_to_strided_slice.cpp b/src/common/transformations/src/transformations/op_conversions/convert_slice_to_strided_slice.cpp index 8b712958817e19..5189abe36e5e08 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_slice_to_strided_slice.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_slice_to_strided_slice.cpp @@ -65,8 +65,8 @@ std::vector axes_to_mask(const std::vector& axes, size_t slice ov::pass::SliceToStridedSlice::SliceToStridedSlice(bool use_shapes) { MATCHER_SCOPE(SliceToStridedSlice); - auto slice = pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + auto slice = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto slice_node = ov::as_type_ptr(m.get_match_root()); if (!slice_node) return false; @@ -150,6 +150,6 @@ ov::pass::SliceToStridedSlice::SliceToStridedSlice(bool use_shapes) { return true; }; - auto m = std::make_shared(slice, matcher_name); + auto m = std::make_shared(slice, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_slicescatter.cpp b/src/common/transformations/src/transformations/op_conversions/convert_slicescatter.cpp index 2ca2be54827046..daca2836f8d667 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_slicescatter.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_slicescatter.cpp @@ -23,9 +23,9 @@ ov::pass::ConvertSliceScatter::ConvertSliceScatter() { MATCHER_SCOPE(ConvertSliceScatter); - const auto& slicescatter = pattern::wrap_type(); + const auto& slicescatter = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [this](pattern::Matcher& m) { + const matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { const auto& slice_node = ov::as_type_ptr(m.get_match_root()); if (!slice_node || transformation_callback(slice_node)) { return false; @@ -73,6 +73,6 @@ ov::pass::ConvertSliceScatter::ConvertSliceScatter() { return true; }; - const auto& m = std::make_shared(slicescatter, matcher_name); + const auto& m = std::make_shared(slicescatter, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_softmax_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_softmax_downgrade.cpp index 8286a99749db6b..6c160996053639 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_softmax_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_softmax_downgrade.cpp @@ -14,10 +14,10 @@ ov::pass::ConvertSoftMax8ToSoftMax1::ConvertSoftMax8ToSoftMax1() { MATCHER_SCOPE(ConvertSoftMax8ToSoftMax1); - auto input = pattern::any_input(pattern::has_static_rank()); - auto softmax_v8_pattern = pattern::wrap_type({input}); + auto input = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto softmax_v8_pattern = ov::pass::pattern::wrap_type({input}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto softmax_v8_node = ov::as_type_ptr(m.get_match_root()); if (!softmax_v8_node) return false; @@ -34,6 +34,6 @@ ov::pass::ConvertSoftMax8ToSoftMax1::ConvertSoftMax8ToSoftMax1() { return true; }; - auto m = std::make_shared(softmax_v8_pattern, matcher_name); + auto m = std::make_shared(softmax_v8_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_softmax_upgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_softmax_upgrade.cpp index 3b62cbfdd96dbc..700a5dfa37ed77 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_softmax_upgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_softmax_upgrade.cpp @@ -13,9 +13,9 @@ ov::pass::ConvertSoftMax1ToSoftMax8::ConvertSoftMax1ToSoftMax8() { MATCHER_SCOPE(ConvertSoftMax1ToSoftMax8); - auto softmax_v1_pattern = pattern::wrap_type(); + auto softmax_v1_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto softmax_v1_node = ov::as_type_ptr(m.get_match_root()); if (!softmax_v1_node) return false; @@ -29,6 +29,6 @@ ov::pass::ConvertSoftMax1ToSoftMax8::ConvertSoftMax1ToSoftMax8() { return true; }; - auto m = std::make_shared(softmax_v1_pattern, matcher_name); + auto m = std::make_shared(softmax_v1_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_space_to_batch.cpp b/src/common/transformations/src/transformations/op_conversions/convert_space_to_batch.cpp index a6050faed3d18a..5bec73c0dc1444 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_space_to_batch.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_space_to_batch.cpp @@ -30,8 +30,8 @@ using namespace ov::element; void ov::pass::ConvertSpaceToBatch::convert_space_to_batch() { MATCHER_SCOPE(ConvertSpaceToBatch_convert_space_to_batch); - const auto space_to_batch = pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + const auto space_to_batch = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { const auto space_to_batch = ov::as_type_ptr(m.get_match_root()); if (!space_to_batch || transformation_callback(space_to_batch)) { return false; @@ -121,14 +121,14 @@ void ov::pass::ConvertSpaceToBatch::convert_space_to_batch() { return true; }; - const auto m = make_shared(space_to_batch, matcher_name); + const auto m = make_shared(space_to_batch, matcher_name); this->register_matcher(m, callback); } void ov::pass::ConvertSpaceToBatch::convert_space_to_batch_by_elements() { MATCHER_SCOPE(ConvertSpaceToBatch_convert_space_to_batch_by_elements); - const auto space_to_batch = pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + const auto space_to_batch = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { const auto space_to_batch = ov::as_type_ptr(m.get_match_root()); if (!space_to_batch || transformation_callback(space_to_batch)) { return false; @@ -223,6 +223,6 @@ void ov::pass::ConvertSpaceToBatch::convert_space_to_batch_by_elements() { return true; }; - const auto m = make_shared(space_to_batch, matcher_name); + const auto m = make_shared(space_to_batch, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_space_to_depth.cpp b/src/common/transformations/src/transformations/op_conversions/convert_space_to_depth.cpp index 3cbc3d7d967351..8325dc5aee5f37 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_space_to_depth.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_space_to_depth.cpp @@ -19,9 +19,9 @@ ov::pass::ConvertSpaceToDepth::ConvertSpaceToDepth() { MATCHER_SCOPE(ConvertSpaceToDepth); auto dts = - ov::pass::pattern::wrap_type({pattern::any_input(pattern::has_static_shape())}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto std_node = ov::as_type_ptr(m.get_match_root()); if (!std_node || transformation_callback(std_node)) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_squeeze15_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_squeeze15_downgrade.cpp index 9cf19624651606..78e5ba5f7aa7a0 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_squeeze15_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_squeeze15_downgrade.cpp @@ -14,9 +14,9 @@ ov::pass::ConvertSqueeze15ToSqueeze0::ConvertSqueeze15ToSqueeze0() { MATCHER_SCOPE(ConvertSqueeze15ToSqueeze0); - const auto& squeeze_v15_pattern = pattern::wrap_type(); + const auto& squeeze_v15_pattern = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& squeeze_v15 = ov::as_type_ptr(m.get_match_root()); if (!squeeze_v15 || transformation_callback(squeeze_v15)) { return false; @@ -36,6 +36,6 @@ ov::pass::ConvertSqueeze15ToSqueeze0::ConvertSqueeze15ToSqueeze0() { return true; }; - auto m = std::make_shared(squeeze_v15_pattern, matcher_name); + auto m = std::make_shared(squeeze_v15_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_subtract.cpp b/src/common/transformations/src/transformations/op_conversions/convert_subtract.cpp index 07a4d647d9ead2..61c03c45742f67 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_subtract.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_subtract.cpp @@ -53,27 +53,27 @@ static bool convert_subtract(const std::shared_ptr& node) { pass::ConvertSubtract::ConvertSubtract() { MATCHER_SCOPE(ConvertSubtract); - auto sub = pattern::wrap_type(); + auto sub = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); return convert_subtract(node); }; - auto m = std::make_shared(sub, matcher_name); + auto m = std::make_shared(sub, matcher_name); this->register_matcher(m, callback); } pass::ConvertSubtractWithConstant::ConvertSubtractWithConstant() { MATCHER_SCOPE(ConvertSubtractWithConstant); auto sub = - pattern::wrap_type({pattern::any_input(), pattern::wrap_type()}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); return convert_subtract(node); }; - auto m = std::make_shared(sub, matcher_name); + auto m = std::make_shared(sub, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp b/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp index 13da978dfa90f2..8ec46184e01e34 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp @@ -257,15 +257,15 @@ bool check_condition_increment_pattern( Output& num_iters_output) { // return a number of iterations if pattern matches // pattern for condition sub-graph in Loop operarion - auto num_iter_const_label = pattern::wrap_type(); - auto num_iter_param_label = pattern::wrap_type(); + auto num_iter_const_label = ov::pass::pattern::wrap_type(); + auto num_iter_param_label = ov::pass::pattern::wrap_type(); auto num_iterations_label = - std::make_shared(OutputVector{num_iter_const_label, num_iter_param_label}); - auto counter_label = pattern::wrap_type(); - auto counter_step_label = pattern::wrap_type(); - auto updated_counter_label = pattern::wrap_type({counter_label, counter_step_label}); - auto less_label = pattern::wrap_type({updated_counter_label, num_iterations_label}); - auto condition_label = pattern::wrap_type({less_label}); + std::make_shared(OutputVector{num_iter_const_label, num_iter_param_label}); + auto counter_label = ov::pass::pattern::wrap_type(); + auto counter_step_label = ov::pass::pattern::wrap_type(); + auto updated_counter_label = ov::pass::pattern::wrap_type({counter_label, counter_step_label}); + auto less_label = ov::pass::pattern::wrap_type({updated_counter_label, num_iterations_label}); + auto condition_label = ov::pass::pattern::wrap_type({less_label}); // check a pattern of condition graph and get a number of iterations ov::pass::pattern::Matcher condition_matcher(condition_label); @@ -340,8 +340,8 @@ bool check_condition_true_pattern(const std::shared_ptr& cond_re const std::shared_ptr& loop, Output& num_iters_output) { // return a number of iterations if pattern matches - auto cond_const_label = pattern::wrap_type(); - auto condition_label = pattern::wrap_type({cond_const_label}); + auto cond_const_label = ov::pass::pattern::wrap_type(); + auto condition_label = ov::pass::pattern::wrap_type({cond_const_label}); // check a pattern of condition graph and get a number of iterations ov::pass::pattern::Matcher condition_matcher(condition_label); @@ -365,20 +365,20 @@ void create_mul_by_one_pattern(std::shared_ptr& param, std::shared_ptr& broadcast_value, std::shared_ptr& mul, bool with_first_squeeze = false) { - param = pattern::wrap_type(); + param = ov::pass::pattern::wrap_type(); auto shape_of_input = param; if (with_first_squeeze) { - auto first_squeeze_axes = pattern::wrap_type(); - shape_of_input = pattern::wrap_type({param, first_squeeze_axes}); + auto first_squeeze_axes = ov::pass::pattern::wrap_type(); + shape_of_input = ov::pass::pattern::wrap_type({param, first_squeeze_axes}); } - auto shape_of = pattern::wrap_type({shape_of_input}); - auto concat_value = pattern::wrap_type(); - auto concat = pattern::wrap_type({concat_value, shape_of}); - broadcast_value = pattern::wrap_type(); - auto broadcast = pattern::wrap_type({broadcast_value, concat}); - auto squeeze_axes = pattern::wrap_type(); - auto squeeze = pattern::wrap_type({broadcast, squeeze_axes}); - mul = pattern::wrap_type({shape_of_input, squeeze}); + auto shape_of = ov::pass::pattern::wrap_type({shape_of_input}); + auto concat_value = ov::pass::pattern::wrap_type(); + auto concat = ov::pass::pattern::wrap_type({concat_value, shape_of}); + broadcast_value = ov::pass::pattern::wrap_type(); + auto broadcast = ov::pass::pattern::wrap_type({broadcast_value, concat}); + auto squeeze_axes = ov::pass::pattern::wrap_type(); + auto squeeze = ov::pass::pattern::wrap_type({broadcast, squeeze_axes}); + mul = ov::pass::pattern::wrap_type({shape_of_input, squeeze}); } bool check_const_one(const std::shared_ptr& node) { @@ -409,14 +409,14 @@ bool check_lstm_cell_pattern( // check pattern with LSMCell and return key points // required for fusion to LSTMSequence // pattern for LSTMCell in the body - auto xi_label = pattern::wrap_type(); - auto squeeze_axis_label = pattern::wrap_type(); - auto xi_reshape_label = pattern::wrap_type({xi_label, squeeze_axis_label}); - auto init_hidden_state_i_label = pattern::wrap_type(); - auto init_cell_state_i_label = pattern::wrap_type(); - auto W_label = pattern::wrap_type(); - auto R_label = pattern::wrap_type(); - auto B_label = pattern::wrap_type(); + auto xi_label = ov::pass::pattern::wrap_type(); + auto squeeze_axis_label = ov::pass::pattern::wrap_type(); + auto xi_reshape_label = ov::pass::pattern::wrap_type({xi_label, squeeze_axis_label}); + auto init_hidden_state_i_label = ov::pass::pattern::wrap_type(); + auto init_cell_state_i_label = ov::pass::pattern::wrap_type(); + auto W_label = ov::pass::pattern::wrap_type(); + auto R_label = ov::pass::pattern::wrap_type(); + auto B_label = ov::pass::pattern::wrap_type(); // TODO: 152648 - remove this WA // create multiply by one pattern for x input @@ -426,14 +426,14 @@ bool check_lstm_cell_pattern( std::shared_ptr h_param, h_broadcast_value, h_mul; create_mul_by_one_pattern(h_param, h_broadcast_value, h_mul, false); - auto xi_common_label = std::make_shared(OutputVector{xi_reshape_label, x_mul}); - auto hidden_common_label = std::make_shared(OutputVector{init_hidden_state_i_label, h_mul}); + auto xi_common_label = std::make_shared(OutputVector{xi_reshape_label, x_mul}); + auto hidden_common_label = std::make_shared(OutputVector{init_hidden_state_i_label, h_mul}); - auto lstm_cell_label = pattern::wrap_type( + auto lstm_cell_label = ov::pass::pattern::wrap_type( {xi_common_label, hidden_common_label, init_cell_state_i_label, W_label, R_label, B_label}); - auto unsqueeze_axis_label = pattern::wrap_type(); - auto unsqueeze_hidden_state_label = pattern::wrap_type({lstm_cell_label, unsqueeze_axis_label}); - auto result_hidden_state_label = pattern::wrap_type({unsqueeze_hidden_state_label}); + auto unsqueeze_axis_label = ov::pass::pattern::wrap_type(); + auto unsqueeze_hidden_state_label = ov::pass::pattern::wrap_type({lstm_cell_label, unsqueeze_axis_label}); + auto result_hidden_state_label = ov::pass::pattern::wrap_type({unsqueeze_hidden_state_label}); // check that body-graph contains a pattern corresponding LSTMCell ov::pass::pattern::Matcher lstm_cell_matcher(result_hidden_state_label); @@ -528,9 +528,9 @@ bool check_lstm_cell_pattern( ov::pass::ConvertTensorIteratorToLSTMSequence::ConvertTensorIteratorToLSTMSequence() { MATCHER_SCOPE(ConvertTensorIteratorToLSTMSequence); - auto tensor_iterator = pattern::wrap_type(); + auto tensor_iterator = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto ti = ov::as_type_ptr(m.get_match_root()); if (!ti || transformation_callback(ti)) return false; @@ -588,9 +588,9 @@ ov::pass::ConvertTensorIteratorToLSTMSequence::ConvertTensorIteratorToLSTMSequen ov::pass::ConvertTensorIteratorToRNNSequence::ConvertTensorIteratorToRNNSequence() { MATCHER_SCOPE(ConvertTensorIteratorToRNNSequence); - auto tensor_iterator = pattern::wrap_type(); + auto tensor_iterator = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto ti = ov::as_type_ptr(m.get_match_root()); if (!ti || transformation_callback(ti)) return false; @@ -646,9 +646,9 @@ ov::pass::ConvertTensorIteratorToRNNSequence::ConvertTensorIteratorToRNNSequence ov::pass::ConvertTensorIteratorToGRUSequence::ConvertTensorIteratorToGRUSequence() { MATCHER_SCOPE(ConvertTensorIteratorToGRUSequence); - auto tensor_iterator = pattern::wrap_type(); + auto tensor_iterator = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [this](pattern::Matcher& m) { + matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto ti = ov::as_type_ptr(m.get_match_root()); if (!ti || transformation_callback(ti)) return false; @@ -780,76 +780,76 @@ ov::pass::ConvertTensorIteratorToGRUSequence::ConvertTensorIteratorToGRUSequence ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpdateToLSTMSequence() { MATCHER_SCOPE(ConvertLoopWithScatterUpdateToLSTMSequence); - auto input_label = pattern::any_input(pattern::rank_equals(3)); - auto input_transpose_const_label = pattern::wrap_type(); + auto input_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(3)); + auto input_transpose_const_label = ov::pass::pattern::wrap_type(); auto input_transpose_label = - pattern::wrap_type({input_label, input_transpose_const_label}, - pattern::rank_equals(3)); - auto scatter_indexes_label = pattern::wrap_type(); - auto scatter_update_label = std::make_shared(OutputVector{input_transpose_label, input_label}); - auto scatter_label = pattern::wrap_type( - {pattern::any_input(), scatter_indexes_label, scatter_update_label}); - auto trip_count_label = pattern::wrap_type(); - auto cond_label = pattern::wrap_type(); - auto loop_label = pattern::wrap_type({trip_count_label, + ov::pass::pattern::wrap_type({input_label, input_transpose_const_label}, + ov::pass::pattern::rank_equals(3)); + auto scatter_indexes_label = ov::pass::pattern::wrap_type(); + auto scatter_update_label = std::make_shared(OutputVector{input_transpose_label, input_label}); + auto scatter_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), scatter_indexes_label, scatter_update_label}); + auto trip_count_label = ov::pass::pattern::wrap_type(); + auto cond_label = ov::pass::pattern::wrap_type(); + auto loop_label = ov::pass::pattern::wrap_type({trip_count_label, cond_label, - pattern::any_input(), - pattern::any_input(), - pattern::any_input(), - pattern::any_input(), - pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), scatter_label}); - auto output_transpose_const_label = pattern::wrap_type(); - auto output_transpose_label = pattern::wrap_type({loop_label, output_transpose_const_label}); + auto output_transpose_const_label = ov::pass::pattern::wrap_type(); + auto output_transpose_label = ov::pass::pattern::wrap_type({loop_label, output_transpose_const_label}); // Loop body pattern: - auto sequence_index_label = pattern::any_input(pattern::rank_equals(0)); - auto iteration_counter_label = pattern::any_input(); - auto iteration_counter_step_label = pattern::wrap_type(); + auto sequence_index_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(0)); + auto iteration_counter_label = ov::pass::pattern::any_input(); + auto iteration_counter_step_label = ov::pass::pattern::wrap_type(); auto iteration_counter_incremented_label = - pattern::wrap_type({iteration_counter_label, iteration_counter_step_label}); - auto iteration_counter_limit_label = pattern::wrap_type(); + ov::pass::pattern::wrap_type({iteration_counter_label, iteration_counter_step_label}); + auto iteration_counter_limit_label = ov::pass::pattern::wrap_type(); auto iteration_counter_less_than_limit_label = - pattern::wrap_type({iteration_counter_incremented_label, iteration_counter_limit_label}); - auto sequence_index_step_label = pattern::wrap_type(); + ov::pass::pattern::wrap_type({iteration_counter_incremented_label, iteration_counter_limit_label}); + auto sequence_index_step_label = ov::pass::pattern::wrap_type(); auto sequence_index_incremented_label = - pattern::wrap_type({sequence_index_label, sequence_index_step_label}); - auto sequence_index_limit_label = pattern::wrap_type(); + ov::pass::pattern::wrap_type({sequence_index_label, sequence_index_step_label}); + auto sequence_index_limit_label = ov::pass::pattern::wrap_type(); auto sequence_index_less_than_limit_label = - pattern::wrap_type({sequence_index_incremented_label, sequence_index_limit_label}); - auto and_label = pattern::wrap_type( + ov::pass::pattern::wrap_type({sequence_index_incremented_label, sequence_index_limit_label}); + auto and_label = ov::pass::pattern::wrap_type( {iteration_counter_less_than_limit_label, sequence_index_less_than_limit_label}); - auto loop_condition_label = pattern::wrap_type({and_label}); + auto loop_condition_label = ov::pass::pattern::wrap_type({and_label}); - auto X_body_label = pattern::any_input(pattern::rank_equals(3)); - auto C_body_label = pattern::any_input(pattern::rank_equals(2)); - auto H_body_label = pattern::any_input(pattern::rank_equals(2)); - auto gather_axis_label = pattern::wrap_type(); - auto sequence_index_new_shape_label = pattern::wrap_type(); + auto X_body_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(3)); + auto C_body_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2)); + auto H_body_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2)); + auto gather_axis_label = ov::pass::pattern::wrap_type(); + auto sequence_index_new_shape_label = ov::pass::pattern::wrap_type(); auto sequence_index_reshaped_label = - pattern::wrap_type({sequence_index_label, sequence_index_new_shape_label}); + ov::pass::pattern::wrap_type({sequence_index_label, sequence_index_new_shape_label}); auto sequence_index_or_label = - std::make_shared(OutputVector{sequence_index_label, sequence_index_reshaped_label}); + std::make_shared(OutputVector{sequence_index_label, sequence_index_reshaped_label}); auto gather_body_label = - pattern::wrap_type({X_body_label, sequence_index_or_label, gather_axis_label}, - pattern::rank_equals(2)); - auto W_label = pattern::any_input(); - auto R_label = pattern::any_input(); - auto B_label = pattern::wrap_type(); - auto lstm_cell_label = pattern::wrap_type( + ov::pass::pattern::wrap_type({X_body_label, sequence_index_or_label, gather_axis_label}, + ov::pass::pattern::rank_equals(2)); + auto W_label = ov::pass::pattern::any_input(); + auto R_label = ov::pass::pattern::any_input(); + auto B_label = ov::pass::pattern::wrap_type(); + auto lstm_cell_label = ov::pass::pattern::wrap_type( {gather_body_label, H_body_label, C_body_label, W_label, R_label, B_label}); - auto scatter_index_new_shape_label = pattern::wrap_type(); + auto scatter_index_new_shape_label = ov::pass::pattern::wrap_type(); auto scatter_index_body_label = - pattern::wrap_type({sequence_index_label, scatter_index_new_shape_label}); - auto updates_label = pattern::wrap_type( - {lstm_cell_label, pattern::wrap_type()}); - auto scatter_axis_label = pattern::wrap_type(); - auto scatter_body_label = pattern::wrap_type( - {pattern::any_input(), scatter_index_body_label, updates_label, scatter_axis_label}, - pattern::rank_equals(3)); - auto loop_output_label = pattern::wrap_type({scatter_body_label}); - - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::pass::pattern::wrap_type({sequence_index_label, scatter_index_new_shape_label}); + auto updates_label = ov::pass::pattern::wrap_type( + {lstm_cell_label, ov::pass::pattern::wrap_type()}); + auto scatter_axis_label = ov::pass::pattern::wrap_type(); + auto scatter_body_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), scatter_index_body_label, updates_label, scatter_axis_label}, + ov::pass::pattern::rank_equals(3)); + auto loop_output_label = ov::pass::pattern::wrap_type({scatter_body_label}); + + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto match_root = m.get_match_root(); @@ -1154,9 +1154,9 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda ov::pass::ConvertLoopWithSlicedInputConcatOutputToLSTMSequence::ConvertLoopWithSlicedInputConcatOutputToLSTMSequence() { MATCHER_SCOPE(ConvertLoopWithSlicedInputConcatOutputToLSTMSequence); - auto loop_label = pattern::wrap_type(); + auto loop_label = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto loop = ov::as_type_ptr(m.get_match_root()); if (!loop) { return false; @@ -1312,7 +1312,7 @@ ov::pass::ConvertLoopWithSlicedInputConcatOutputToLSTMSequence::ConvertLoopWithS return true; }; - auto m = std::make_shared(loop_label, matcher_name); + auto m = std::make_shared(loop_label, matcher_name); register_matcher(m, callback); } @@ -1323,20 +1323,20 @@ class EliminateGatherWithRange : public ov::pass::MatcherPass { using namespace ov; using namespace ov::pass; - auto data_label = pattern::any_input(pattern::rank_equals(3)); - auto shapeof_label = pattern::wrap_type({data_label}); - auto shapeof_gather_label = pattern::wrap_type( - {shapeof_label, pattern::wrap_type(), pattern::wrap_type()}); - auto shapeof_gather2_label = pattern::wrap_type( - {shapeof_gather_label, pattern::wrap_type(), pattern::wrap_type()}); + auto data_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(3)); + auto shapeof_label = ov::pass::pattern::wrap_type({data_label}); + auto shapeof_gather_label = ov::pass::pattern::wrap_type( + {shapeof_label, ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}); + auto shapeof_gather2_label = ov::pass::pattern::wrap_type( + {shapeof_gather_label, ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}); auto reshape_label = - pattern::wrap_type({shapeof_gather2_label, pattern::wrap_type()}); - auto range_label = pattern::wrap_type( - {pattern::wrap_type(), reshape_label, pattern::wrap_type()}); - auto match_node = pass::pattern::wrap_type( - {data_label, range_label, pattern::wrap_type()}); + ov::pass::pattern::wrap_type({shapeof_gather2_label, ov::pass::pattern::wrap_type()}); + auto range_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::wrap_type(), reshape_label, ov::pass::pattern::wrap_type()}); + auto match_node = ov::pass::pattern::wrap_type( + {data_label, range_label, ov::pass::pattern::wrap_type()}); - matcher_pass_callback callback = [=](pass::pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto gather = ov::as_type_ptr(m.get_match_root()); if (!gather) @@ -1380,7 +1380,7 @@ class EliminateGatherWithRange : public ov::pass::MatcherPass { return replace_output_update_name(gather->output(0), gather->input_value(0)); }; - auto m = std::make_shared(match_node, "EliminateGatherWithRange"); + auto m = std::make_shared(match_node, "EliminateGatherWithRange"); register_matcher(m, callback); } }; @@ -1388,29 +1388,29 @@ class EliminateGatherWithRange : public ov::pass::MatcherPass { ov::pass::FuseReverseLSTMSequence::FuseReverseLSTMSequence() { MATCHER_SCOPE(FuseReverseLSTMSequence); - auto data_label = pattern::any_input(pattern::rank_equals(3)); + auto data_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(3)); auto first_transpose_label = - pattern::wrap_type({data_label, pattern::wrap_type()}, - pattern::rank_equals(3)); + ov::pass::pattern::wrap_type({data_label, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(3)); auto input_to_first_reverse_sequence_label = - std::make_shared(OutputVector{first_transpose_label, data_label}); + std::make_shared(OutputVector{first_transpose_label, data_label}); auto first_reverse_sequence_label = - pattern::wrap_type({input_to_first_reverse_sequence_label, pattern::any_input()}); + ov::pass::pattern::wrap_type({input_to_first_reverse_sequence_label, ov::pass::pattern::any_input()}); auto second_transpose_label = - pattern::wrap_type({first_reverse_sequence_label, pattern::wrap_type()}); - auto lstm_label = pattern::wrap_type({second_transpose_label, - pattern::any_input(), - pattern::any_input(), - pattern::any_input(), - pattern::any_input(), - pattern::any_input(), - pattern::any_input()}, - pattern::consumers_count(1)); - auto squeeze_label = pattern::wrap_type({lstm_label, pattern::wrap_type()}); + ov::pass::pattern::wrap_type({first_reverse_sequence_label, ov::pass::pattern::wrap_type()}); + auto lstm_label = ov::pass::pattern::wrap_type({second_transpose_label, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}, + ov::pass::pattern::consumers_count(1)); + auto squeeze_label = ov::pass::pattern::wrap_type({lstm_label, ov::pass::pattern::wrap_type()}); auto second_reverse_sequence_label = - pattern::wrap_type({squeeze_label, pattern::any_input()}); + ov::pass::pattern::wrap_type({squeeze_label, ov::pass::pattern::any_input()}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); const auto& data = pattern_map.at(data_label); const auto second_transpose = pattern_map.at(second_transpose_label).get_node_shared_ptr(); @@ -1521,69 +1521,69 @@ ov::pass::FuseReverseLSTMSequence::FuseReverseLSTMSequence() { return true; }; - auto m = std::make_shared(second_reverse_sequence_label, matcher_name); + auto m = std::make_shared(second_reverse_sequence_label, matcher_name); register_matcher(m, callback); } ov::pass::FuseLSTMSequencesToBidirectionalLSTMSequence::FuseLSTMSequencesToBidirectionalLSTMSequence() { MATCHER_SCOPE(FuseLSTMSequencesToBidirectionalLSTMSequence); - auto data_label = pattern::any_input(); + auto data_label = ov::pass::pattern::any_input(); // forward pattern auto transpose_forward_label = - pattern::wrap_type({data_label, pattern::wrap_type()}); + ov::pass::pattern::wrap_type({data_label, ov::pass::pattern::wrap_type()}); auto lstm_sequence_forward_first_input_label = - std::make_shared(OutputVector{transpose_forward_label, data_label}); - auto shapeof_forward_label = pattern::wrap_type({lstm_sequence_forward_first_input_label}); - auto gather_forward_label = pattern::wrap_type( - {shapeof_forward_label, pattern::wrap_type(), pattern::wrap_type()}); - auto max_sequence_len_forward_label = pattern::wrap_type(); + std::make_shared(OutputVector{transpose_forward_label, data_label}); + auto shapeof_forward_label = ov::pass::pattern::wrap_type({lstm_sequence_forward_first_input_label}); + auto gather_forward_label = ov::pass::pattern::wrap_type( + {shapeof_forward_label, ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}); + auto max_sequence_len_forward_label = ov::pass::pattern::wrap_type(); auto broadcast_forward_label = - pattern::wrap_type({max_sequence_len_forward_label, gather_forward_label}); - auto const_sequence_lengths_forward_label = pattern::wrap_type(); + ov::pass::pattern::wrap_type({max_sequence_len_forward_label, gather_forward_label}); + auto const_sequence_lengths_forward_label = ov::pass::pattern::wrap_type(); auto sequence_lengths_forward_label = - std::make_shared(OutputVector{broadcast_forward_label, const_sequence_lengths_forward_label}); + std::make_shared(OutputVector{broadcast_forward_label, const_sequence_lengths_forward_label}); auto lstm_sequence_forward_label = - pattern::wrap_type({lstm_sequence_forward_first_input_label, - pattern::any_input(), - pattern::any_input(), + ov::pass::pattern::wrap_type({lstm_sequence_forward_first_input_label, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), sequence_lengths_forward_label, - pattern::any_input(), - pattern::any_input(), - pattern::any_input()}); + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto squeeze_forward_label = - pattern::wrap_type({lstm_sequence_forward_label, pattern::wrap_type()}, - pattern::rank_equals(3)); + ov::pass::pattern::wrap_type({lstm_sequence_forward_label, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(3)); // backward pattern auto transpose_reverse_label = - pattern::wrap_type({data_label, pattern::wrap_type()}); + ov::pass::pattern::wrap_type({data_label, ov::pass::pattern::wrap_type()}); auto lstm_sequence_reverse_first_input_label = - std::make_shared(OutputVector{transpose_reverse_label, data_label}); - auto shapeof_reverse_label = pattern::wrap_type({lstm_sequence_reverse_first_input_label}); - auto gather_reverse_label = pattern::wrap_type( - {shapeof_reverse_label, pattern::wrap_type(), pattern::wrap_type()}); - auto max_sequence_len_reverse_label = pattern::wrap_type(); + std::make_shared(OutputVector{transpose_reverse_label, data_label}); + auto shapeof_reverse_label = ov::pass::pattern::wrap_type({lstm_sequence_reverse_first_input_label}); + auto gather_reverse_label = ov::pass::pattern::wrap_type( + {shapeof_reverse_label, ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}); + auto max_sequence_len_reverse_label = ov::pass::pattern::wrap_type(); auto broadcast_reverse_label = - pattern::wrap_type({max_sequence_len_reverse_label, gather_reverse_label}); - auto const_sequence_lengths_reverse_label = pattern::wrap_type(); + ov::pass::pattern::wrap_type({max_sequence_len_reverse_label, gather_reverse_label}); + auto const_sequence_lengths_reverse_label = ov::pass::pattern::wrap_type(); auto sequence_lengths_reverse_label = - std::make_shared(OutputVector{broadcast_reverse_label, const_sequence_lengths_reverse_label}); + std::make_shared(OutputVector{broadcast_reverse_label, const_sequence_lengths_reverse_label}); auto lstm_sequence_reverse_label = - pattern::wrap_type({lstm_sequence_reverse_first_input_label, - pattern::any_input(), - pattern::any_input(), + ov::pass::pattern::wrap_type({lstm_sequence_reverse_first_input_label, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), sequence_lengths_reverse_label, - pattern::any_input(), - pattern::any_input(), - pattern::any_input()}); + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto squeeze_reverse_label = - pattern::wrap_type({lstm_sequence_reverse_label, pattern::wrap_type()}, - pattern::rank_equals(3)); + ov::pass::pattern::wrap_type({lstm_sequence_reverse_label, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(3)); - auto concat_label = pattern::wrap_type({squeeze_forward_label, squeeze_reverse_label}); + auto concat_label = ov::pass::pattern::wrap_type({squeeze_forward_label, squeeze_reverse_label}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); auto lstm_forward = ov::as_type_ptr(pattern_map.at(lstm_sequence_forward_label)); auto lstm_reverse = ov::as_type_ptr(pattern_map.at(lstm_sequence_reverse_label)); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_topk11_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/convert_topk11_downgrade.cpp index 9bea942713e073..8a0db8aafdc4d4 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_topk11_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_topk11_downgrade.cpp @@ -14,9 +14,9 @@ ov::pass::ConvertTopK11ToTopK3::ConvertTopK11ToTopK3() { MATCHER_SCOPE(ConvertTopK11ToTopK3); - const auto topk_v11_pattern = pattern::wrap_type(); + const auto topk_v11_pattern = ov::pass::pattern::wrap_type(); - const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto topk_v11 = ov::as_type_ptr(m.get_match_root()); if (!topk_v11 || transformation_callback(topk_v11)) { return false; @@ -40,6 +40,6 @@ ov::pass::ConvertTopK11ToTopK3::ConvertTopK11ToTopK3() { return true; }; - auto m = std::make_shared(topk_v11_pattern, matcher_name); + auto m = std::make_shared(topk_v11_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_topk3.cpp b/src/common/transformations/src/transformations/op_conversions/convert_topk3.cpp index dc72d0eebb3f7e..7066700ef9d9ff 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_topk3.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_topk3.cpp @@ -15,9 +15,9 @@ ov::pass::ConvertTopK3::ConvertTopK3() { MATCHER_SCOPE(ConvertTopK3); - auto topk = pattern::wrap_type(); + auto topk = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [](pattern::Matcher& m) { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto topk = ov::as_type_ptr(m.get_match_root()); if (!topk) { return false; diff --git a/src/common/transformations/src/transformations/op_conversions/convert_xor_to_logical_xor.cpp b/src/common/transformations/src/transformations/op_conversions/convert_xor_to_logical_xor.cpp index 4764facfe850b5..ffdf3c1874ce94 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_xor_to_logical_xor.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_xor_to_logical_xor.cpp @@ -14,9 +14,9 @@ ov::pass::ConvertXorToLogicalXor::ConvertXorToLogicalXor() { MATCHER_SCOPE(ConvertXorToLogicalXor); - auto xor_v1 = pattern::wrap_type(); + auto xor_v1 = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto xor_v1_node = ov::as_type_ptr(m.get_match_root()); if (!xor_v1_node) return false; @@ -33,6 +33,6 @@ ov::pass::ConvertXorToLogicalXor::ConvertXorToLogicalXor() { return true; }; - auto m = std::make_shared(xor_v1, matcher_name); + auto m = std::make_shared(xor_v1, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/detection_output_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/detection_output_downgrade.cpp index 4d5083e7173405..481f59f2b9fcdd 100644 --- a/src/common/transformations/src/transformations/op_conversions/detection_output_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/detection_output_downgrade.cpp @@ -18,9 +18,9 @@ using namespace ov::op::util; pass::ConvertDetectionOutput8ToDetectionOutput1::ConvertDetectionOutput8ToDetectionOutput1() { MATCHER_SCOPE(ConvertDetectionOutput8ToDetectionOutput1); - auto detection_output_v8_pattern = pattern::wrap_type(); + auto detection_output_v8_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto detection_output_v8_node = ov::as_type_ptr(m.get_match_root()); if (!detection_output_v8_node) return false; @@ -74,6 +74,6 @@ pass::ConvertDetectionOutput8ToDetectionOutput1::ConvertDetectionOutput8ToDetect return true; }; - auto m = make_shared(detection_output_v8_pattern, matcher_name); + auto m = make_shared(detection_output_v8_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/detection_output_upgrade.cpp b/src/common/transformations/src/transformations/op_conversions/detection_output_upgrade.cpp index 855f2f99415338..f2006be8246bd4 100644 --- a/src/common/transformations/src/transformations/op_conversions/detection_output_upgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/detection_output_upgrade.cpp @@ -17,9 +17,9 @@ using namespace ov::op::util; pass::ConvertDetectionOutput1ToDetectionOutput8::ConvertDetectionOutput1ToDetectionOutput8() { MATCHER_SCOPE(ConvertDetectionOutput1ToDetectionOutput8); - auto detection_output_v1_pattern = pattern::wrap_type(); + auto detection_output_v1_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto detection_output_v1_node = ov::as_type_ptr(m.get_match_root()); if (!detection_output_v1_node) return false; @@ -67,6 +67,6 @@ pass::ConvertDetectionOutput1ToDetectionOutput8::ConvertDetectionOutput1ToDetect return true; }; - auto m = make_shared(detection_output_v1_pattern, matcher_name); + auto m = make_shared(detection_output_v1_pattern, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/eye_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/eye_decomposition.cpp index e430c5e3976e1a..5641a7044b31cb 100644 --- a/src/common/transformations/src/transformations/op_conversions/eye_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/eye_decomposition.cpp @@ -33,8 +33,8 @@ namespace { /** \brief Check if output is rank one and data type can be i32 or i64. */ const auto is_rank_one_int_shape = [](const Output& output) -> bool { - return pattern::type_matches_any({element::i32, element::i64})(output) && pattern::has_static_shape()(output) && - pattern::rank_equals(1)(output); + return ov::pass::pattern::type_matches_any({element::i32, element::i64})(output) && ov::pass::pattern::has_static_shape()(output) && + ov::pass::pattern::rank_equals(1)(output); }; /** \brief Predicate to check eye k node is valid. */ @@ -118,17 +118,17 @@ std::shared_ptr make_eye_batches(NodeRegistry& reg, const Output& ey EyeDecomposition::EyeDecomposition() { MATCHER_SCOPE(EyeDecomposition); - auto p_height = pattern::any_input(); - auto p_width = pattern::any_input(); - auto p_k = pattern::wrap_type(k_predicate); - auto p_batch = pattern::wrap_type(batch_predicate); + auto p_height = ov::pass::pattern::any_input(); + auto p_width = ov::pass::pattern::any_input(); + auto p_k = ov::pass::pattern::wrap_type(k_predicate); + auto p_batch = ov::pass::pattern::wrap_type(batch_predicate); - auto p_eye_no_batch = pattern::wrap_type({p_height, p_width, p_k}); - auto p_eye_batch = pattern::wrap_type({p_height, p_width, p_k, p_batch}); + auto p_eye_no_batch = ov::pass::pattern::wrap_type({p_height, p_width, p_k}); + auto p_eye_batch = ov::pass::pattern::wrap_type({p_height, p_width, p_k, p_batch}); - auto p_eye = std::make_shared(OutputVector{p_eye_batch, p_eye_no_batch}); + auto p_eye = std::make_shared(OutputVector{p_eye_batch, p_eye_no_batch}); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto m_eye = ov::as_type_ptr(m.get_match_root()); if ((!m_eye) || transformation_callback(m_eye)) { @@ -155,7 +155,7 @@ EyeDecomposition::EyeDecomposition() { return true; }; - auto m = std::make_shared(p_eye, matcher_name); + auto m = std::make_shared(p_eye, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/fq_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/fq_decomposition.cpp index d88a5dc9fd20ff..0fd9a9be5d5a93 100644 --- a/src/common/transformations/src/transformations/op_conversions/fq_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/fq_decomposition.cpp @@ -47,7 +47,7 @@ bool isValidRangesInputs(const std::shared_ptr& fq) { ov::pass::FakeQuantizeDecomposition::FakeQuantizeDecomposition() { MATCHER_SCOPE(FakeQuantizeDecomposition); - auto data = pattern::any_input(); + auto data = ov::pass::pattern::any_input(); auto il = ov::pass::pattern::wrap_type(); auto ih = ov::pass::pattern::wrap_type(); auto ol = ov::pass::pattern::wrap_type(); diff --git a/src/common/transformations/src/transformations/op_conversions/group_normalization_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/group_normalization_decomposition.cpp index c4f189fd34fc7d..d72536449f9df8 100644 --- a/src/common/transformations/src/transformations/op_conversions/group_normalization_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/group_normalization_decomposition.cpp @@ -65,9 +65,9 @@ std::shared_ptr get_range(NodeRegistry& reg, int64_t start, int64_t stop) ov::pass::GroupNormalizationDecomposition::GroupNormalizationDecomposition() { MATCHER_SCOPE(GroupNormalizationDecomposition); - auto group_norm_pattern = pattern::wrap_type(); + auto group_norm_pattern = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& matcher) { + matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& matcher) { NodeRegistry reg; const auto group_norm_node = ov::as_type_ptr(matcher.get_match_root()); @@ -111,6 +111,6 @@ ov::pass::GroupNormalizationDecomposition::GroupNormalizationDecomposition() { return true; }; - auto m = make_shared(group_norm_pattern, matcher_name); + auto m = make_shared(group_norm_pattern, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/op_conversions/group_query_attention_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/group_query_attention_decomposition.cpp index f5a78387e2ae16..b00e2b61612128 100644 --- a/src/common/transformations/src/transformations/op_conversions/group_query_attention_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/group_query_attention_decomposition.cpp @@ -55,9 +55,7 @@ ov::pass::GroupQueryAttentionDecomposition::GroupQueryAttentionDecomposition() { ov::OutputVector ov::pass::GroupQueryAttentionDecomposition::decompose( std::shared_ptr node) { - using namespace ov::op; - - const auto num_heads = node->get_num_heads(); +const auto num_heads = node->get_num_heads(); const auto kv_num_heads = node->get_kv_num_heads(); const auto scale = node->get_scale(); const auto do_rotary = node->get_do_rotary(); @@ -77,37 +75,37 @@ ov::OutputVector ov::pass::GroupQueryAttentionDecomposition::decompose( // current = Q.shape[2], past = `seqlens_k` + 1 - current const auto T = Q.get_element_type(); - const auto q_shape = register_new_node(Q); + const auto q_shape = register_new_node(Q); const auto current_seqlen = get_dimensions(q_shape, {2}); const auto head_size_node = get_dimensions(q_shape, {3}); - const auto zero = register_new_node(v0::Constant::create(ov::element::i64, ov::Shape{1}, {0})); - const auto zero_without_shape = register_new_node(v0::Constant::create(ov::element::i64, ov::Shape{}, {0})); - const auto one = register_new_node(v0::Constant::create(ov::element::i64, ov::Shape{1}, {1})); - const auto one_without_shape = register_new_node(v0::Constant::create(ov::element::i64, ov::Shape{}, {1})); - const auto two = register_new_node(v0::Constant::create(ov::element::i64, ov::Shape{1}, {2})); - const auto seqlens_elemi64 = register_new_node(seqlens_k, ov::element::i64); - const auto real_seqlens = register_new_node(seqlens_elemi64, one); + const auto zero = register_new_node(ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {0})); + const auto zero_without_shape = register_new_node(ov::op::v0::Constant::create(ov::element::i64, ov::Shape{}, {0})); + const auto one = register_new_node(ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {1})); + const auto one_without_shape = register_new_node(ov::op::v0::Constant::create(ov::element::i64, ov::Shape{}, {1})); + const auto two = register_new_node(ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {2})); + const auto seqlens_elemi64 = register_new_node(seqlens_k, ov::element::i64); + const auto real_seqlens = register_new_node(seqlens_elemi64, one); // Only consider batch is 1 - const auto seqlens_1d = register_new_node(real_seqlens, one, false); - const auto past_seqlen = register_new_node(seqlens_1d, current_seqlen); - const auto curr_seqlen_scalar = register_new_node(current_seqlen); + const auto seqlens_1d = register_new_node(real_seqlens, one, false); + const auto past_seqlen = register_new_node(seqlens_1d, current_seqlen); + const auto curr_seqlen_scalar = register_new_node(current_seqlen); if (do_rotary) { ov::Output position_ids = - register_new_node(zero_without_shape, curr_seqlen_scalar, one_without_shape, ov::element::i64); - position_ids = register_new_node(position_ids, past_seqlen); + register_new_node(zero_without_shape, curr_seqlen_scalar, one_without_shape, ov::element::i64); + position_ids = register_new_node(position_ids, past_seqlen); - const auto cos = register_new_node(cos_cache, position_ids, zero); - const auto sin = register_new_node(sin_cache, position_ids, zero); + const auto cos = register_new_node(cos_cache, position_ids, zero); + const auto sin = register_new_node(sin_cache, position_ids, zero); Q = rotaryEmbedding(Q, cos, sin, rotary_interleaved); K = rotaryEmbedding(K, cos, sin, rotary_interleaved); } const auto is_static_input = K.get_partial_shape().is_static() && past_key.get_partial_shape().is_static(); auto construct_kv_cache = [&](const ov::Output& past, const ov::Output& current) { - return register_new_node(ov::OutputVector{past, current}, 2); + return register_new_node(ov::OutputVector{past, current}, 2); }; if (is_static_input) { // Cache memory layout for static shapes: @@ -116,11 +114,11 @@ ov::OutputVector ov::pass::GroupQueryAttentionDecomposition::decompose( // Here, padding 0 are lay on front of the buffer. // M = current_seqlen, which is always 1 for the KV cache model. const auto current_kv_len_const = register_new_node( - v0::Constant::create(ov::element::i64, ov::Shape{1}, {K.get_partial_shape()[2].get_length()})); + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {K.get_partial_shape()[2].get_length()})); const auto past_kv_len_const = register_new_node( - v0::Constant::create(ov::element::i64, ov::Shape{1}, {past_key.get_partial_shape()[2].get_length()})); - past_key = register_new_node(past_key, current_kv_len_const, past_kv_len_const, one, two); - past_value = register_new_node(past_value, current_kv_len_const, past_kv_len_const, one, two); + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {past_key.get_partial_shape()[2].get_length()})); + past_key = register_new_node(past_key, current_kv_len_const, past_kv_len_const, one, two); + past_value = register_new_node(past_value, current_kv_len_const, past_kv_len_const, one, two); } K = construct_kv_cache(past_key, K); V = construct_kv_cache(past_value, V); @@ -129,72 +127,72 @@ ov::OutputVector ov::pass::GroupQueryAttentionDecomposition::decompose( ov::Output present_v = V; const auto concat_kv_len = get_dimensions(K.get_node_shared_ptr(), {2}); - const auto concat_kv_len_scalar = register_new_node(concat_kv_len); + const auto concat_kv_len_scalar = register_new_node(concat_kv_len); // Broadcast KV if grouped query attention const size_t kv_num_heads_factor = num_heads / kv_num_heads; if (kv_num_heads_factor > 1) { - const auto kv_shape = register_new_node(K); + const auto kv_shape = register_new_node(K); const auto kv_shape_prev_2 = get_dimensions(kv_shape, {0, 1}); const auto kv_shape_last_2 = get_dimensions(kv_shape, {2, 3}); - auto new_kv_shape = register_new_node(ov::NodeVector{kv_shape_prev_2, one, kv_shape_last_2}, 0); - K = register_new_node(K, new_kv_shape, false); - V = register_new_node(V, new_kv_shape, false); - K = register_new_node(ov::OutputVector(kv_num_heads_factor, K), 2); - V = register_new_node(ov::OutputVector(kv_num_heads_factor, V), 2); - const auto q_shape = register_new_node(Q); + auto new_kv_shape = register_new_node(ov::NodeVector{kv_shape_prev_2, one, kv_shape_last_2}, 0); + K = register_new_node(K, new_kv_shape, false); + V = register_new_node(V, new_kv_shape, false); + K = register_new_node(ov::OutputVector(kv_num_heads_factor, K), 2); + V = register_new_node(ov::OutputVector(kv_num_heads_factor, V), 2); + const auto q_shape = register_new_node(Q); const auto q_shape_prev_2 = get_dimensions(q_shape, {0, 1}); - auto extended_kv_shape = register_new_node(ov::NodeVector{q_shape_prev_2, kv_shape_last_2}, 0); - K = register_new_node(K, extended_kv_shape, false); - V = register_new_node(V, extended_kv_shape, false); + auto extended_kv_shape = register_new_node(ov::NodeVector{q_shape_prev_2, kv_shape_last_2}, 0); + K = register_new_node(K, extended_kv_shape, false); + V = register_new_node(V, extended_kv_shape, false); } // Make attention mask std::shared_ptr mask; std::shared_ptr hori_range = - register_new_node(zero_without_shape, concat_kv_len_scalar, one_without_shape, ov::element::i64); - hori_range = register_new_node(hori_range, zero); + register_new_node(zero_without_shape, concat_kv_len_scalar, one_without_shape, ov::element::i64); + hori_range = register_new_node(hori_range, zero); std::shared_ptr vert_range = - register_new_node(zero_without_shape, curr_seqlen_scalar, one_without_shape, ov::element::i64); - vert_range = register_new_node(vert_range, one); + register_new_node(zero_without_shape, curr_seqlen_scalar, one_without_shape, ov::element::i64); + vert_range = register_new_node(vert_range, one); const auto past_k_node_len = get_dimensions(past_key.get_node_shared_ptr(), {2}); - vert_range = register_new_node(vert_range, past_k_node_len); + vert_range = register_new_node(vert_range, past_k_node_len); - const auto triu = register_new_node(hori_range, vert_range); - const auto typed_zero = register_new_node(v0::Constant::create(T, ov::Shape{}, {0})); + const auto triu = register_new_node(hori_range, vert_range); + const auto typed_zero = register_new_node(ov::op::v0::Constant::create(T, ov::Shape{}, {0})); // cf. make_attention_mask@src\plugins\intel_gpu\tests\common\subgraphs_builders.hpp std::shared_ptr minus_inf = nullptr; if (T == ov::element::f32) - minus_inf = register_new_node(v0::Constant::create(T, ov::Shape{}, {-std::numeric_limits::infinity()})); + minus_inf = register_new_node(ov::op::v0::Constant::create(T, ov::Shape{}, {-std::numeric_limits::infinity()})); else if (T == ov::element::f16) minus_inf = - register_new_node(v0::Constant::create(T, ov::Shape{}, {std::numeric_limits::lowest()})); - mask = register_new_node(triu, minus_inf, typed_zero); + register_new_node(ov::op::v0::Constant::create(T, ov::Shape{}, {std::numeric_limits::lowest()})); + mask = register_new_node(triu, minus_inf, typed_zero); if (is_static_input) { - const auto padding_len = register_new_node(concat_kv_len, seqlens_1d); - const auto padding_mask_vert_shape = register_new_node(ov::NodeVector{current_seqlen, one}, 0); - const auto padding_mask_vert = register_new_node(padding_len, padding_mask_vert_shape); - const auto padding_mask = register_new_node(hori_range, padding_mask_vert); - mask = register_new_node(padding_mask, mask, minus_inf); + const auto padding_len = register_new_node(concat_kv_len, seqlens_1d); + const auto padding_mask_vert_shape = register_new_node(ov::NodeVector{current_seqlen, one}, 0); + const auto padding_mask_vert = register_new_node(padding_len, padding_mask_vert_shape); + const auto padding_mask = register_new_node(hori_range, padding_mask_vert); + mask = register_new_node(padding_mask, mask, minus_inf); } std::shared_ptr qga_output; if (scale != 0.0f) { - auto scale_node = register_new_node(v0::Constant::create(T, Shape{}, {scale})); - qga_output = register_new_node(Q, K, V, mask, scale_node, false); + auto scale_node = register_new_node(ov::op::v0::Constant::create(T, Shape{}, {scale})); + qga_output = register_new_node(Q, K, V, mask, scale_node, false); } else { - qga_output = register_new_node(Q, K, V, mask, false); + qga_output = register_new_node(Q, K, V, mask, false); } // transpose the result from (batch_size, num_heads, sequence_length, head_size) // to (batch_size, sequence_length, num_heads * head_size) - auto perm = register_new_node(v0::Constant::create(ov::element::i64, ov::Shape{4}, {0, 2, 1, 3})); - auto qga_output_transposed = register_new_node(qga_output, perm); - auto dim_merge_shape = register_new_node(v0::Constant::create(ov::element::i32, ov::Shape{3}, {0, 0, -1})); - auto output = register_new_node(qga_output_transposed, dim_merge_shape, true)->output(0); + auto perm = register_new_node(ov::op::v0::Constant::create(ov::element::i64, ov::Shape{4}, {0, 2, 1, 3})); + auto qga_output_transposed = register_new_node(qga_output, perm); + auto dim_merge_shape = register_new_node(ov::op::v0::Constant::create(ov::element::i32, ov::Shape{3}, {0, 0, -1})); + auto output = register_new_node(qga_output_transposed, dim_merge_shape, true)->output(0); return {output, present_k, present_v}; } @@ -203,9 +201,8 @@ ov::OutputVector ov::pass::GroupQueryAttentionDecomposition::decompose( ov::OutputVector ov::pass::GroupQueryAttentionDecomposition::make_split(const ov::Output& value, int64_t num_splits, int64_t axis) { - using namespace ov::op; - const auto axis_node = register_new_node(v0::Constant::create(ov::element::i64, ov::Shape{}, {axis})); - const auto split = register_new_node(value, axis_node, num_splits); +const auto axis_node = register_new_node(ov::op::v0::Constant::create(ov::element::i64, ov::Shape{}, {axis})); + const auto split = register_new_node(value, axis_node, num_splits); return split->outputs(); } @@ -213,10 +210,9 @@ ov::OutputVector ov::pass::GroupQueryAttentionDecomposition::make_split(const ov std::shared_ptr ov::pass::GroupQueryAttentionDecomposition::get_dimensions( const std::shared_ptr& shape, const std::vector& dims) { - using namespace ov::op; - const auto zero = v0::Constant::create(ov::element::i32, ov::Shape{}, {0}); - const auto dims_const = v0::Constant::create(ov::element::i32, ov::Shape{dims.size()}, dims); - return register_new_node(shape, dims_const, zero); +const auto zero = ov::op::v0::Constant::create(ov::element::i32, ov::Shape{}, {0}); + const auto dims_const = ov::op::v0::Constant::create(ov::element::i32, ov::Shape{dims.size()}, dims); + return register_new_node(shape, dims_const, zero); } std::shared_ptr ov::pass::GroupQueryAttentionDecomposition::get_dimensions( @@ -229,43 +225,42 @@ std::shared_ptr ov::pass::GroupQueryAttentionDecomposition::rotaryEmbe ov::Output cos, ov::Output sin, bool interleaved) { - using namespace ov::op; - auto zero = v0::Constant::create(ov::element::i64, ov::Shape{1}, {0}); - auto one = v0::Constant::create(ov::element::i64, ov::Shape{1}, {1}); +auto zero = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {0}); + auto one = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {1}); if (interleaved) { - auto two = v0::Constant::create(ov::element::i64, ov::Shape{1}, {2}); + auto two = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {2}); auto cos_last_dim = get_dimensions(cos.get_node_shared_ptr(), {-1}); - auto input_shape = register_new_node(input); + auto input_shape = register_new_node(input); auto dim_bns = get_dimensions(input_shape, {0, 1, 2}); - auto negtive_one = v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}); - auto split_input_shape = register_new_node(ov::NodeVector{dim_bns, cos_last_dim, two}, 0); - auto reshaped_input = register_new_node(input, split_input_shape, false); + auto negtive_one = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}); + auto split_input_shape = register_new_node(ov::NodeVector{dim_bns, cos_last_dim, two}, 0); + auto reshaped_input = register_new_node(input, split_input_shape, false); auto in_split = make_split(reshaped_input, 2, -1); - split_input_shape = register_new_node(ov::NodeVector{dim_bns, cos_last_dim}, 0); - auto in_split_0 = register_new_node(in_split[0], split_input_shape, false); - auto in_split_1 = register_new_node(in_split[1], split_input_shape, false); + split_input_shape = register_new_node(ov::NodeVector{dim_bns, cos_last_dim}, 0); + auto in_split_0 = register_new_node(in_split[0], split_input_shape, false); + auto in_split_1 = register_new_node(in_split[1], split_input_shape, false); - auto res_0 = register_new_node(register_new_node(in_split_0, cos), - register_new_node(in_split_1, sin)); - auto res_1 = register_new_node(register_new_node(in_split_0, sin), - register_new_node(in_split_1, cos)); + auto res_0 = register_new_node(register_new_node(in_split_0, cos), + register_new_node(in_split_1, sin)); + auto res_1 = register_new_node(register_new_node(in_split_0, sin), + register_new_node(in_split_1, cos)); - split_input_shape = register_new_node(ov::NodeVector{dim_bns, cos_last_dim, one}, 0); - auto res_0_5d = register_new_node(res_0, split_input_shape, false); - auto res_1_5d = register_new_node(res_1, split_input_shape, false); + split_input_shape = register_new_node(ov::NodeVector{dim_bns, cos_last_dim, one}, 0); + auto res_0_5d = register_new_node(res_0, split_input_shape, false); + auto res_1_5d = register_new_node(res_1, split_input_shape, false); - auto concat_ret = register_new_node(ov::NodeVector{res_0_5d, res_1_5d}, -1); - return register_new_node(concat_ret, input_shape, false); + auto concat_ret = register_new_node(ov::NodeVector{res_0_5d, res_1_5d}, -1); + return register_new_node(concat_ret, input_shape, false); } else { auto in_split = make_split(input, 2, -1); - auto res_0 = register_new_node(register_new_node(in_split[0], cos), - register_new_node(in_split[1], sin)); - auto res_1 = register_new_node(register_new_node(in_split[0], sin), - register_new_node(in_split[1], cos)); + auto res_0 = register_new_node(register_new_node(in_split[0], cos), + register_new_node(in_split[1], sin)); + auto res_1 = register_new_node(register_new_node(in_split[0], sin), + register_new_node(in_split[1], cos)); - return register_new_node(ov::NodeVector{res_0, res_1}, -1); + return register_new_node(ov::NodeVector{res_0, res_1}, -1); } } diff --git a/src/common/transformations/src/transformations/op_conversions/lstm_cell_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/lstm_cell_decomposition.cpp index 7a414e9ad99e37..60a7b84d41c8bf 100644 --- a/src/common/transformations/src/transformations/op_conversions/lstm_cell_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/lstm_cell_decomposition.cpp @@ -22,7 +22,7 @@ ov::pass::LSTMCellDecomposition::LSTMCellDecomposition() { MATCHER_SCOPE(LSTMCellDecomposition); - auto any_lstm = pattern::wrap_type(); + auto any_lstm = ov::pass::pattern::wrap_type(); matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto lstm_cell = ov::as_type_ptr(m.get_match_root()); diff --git a/src/common/transformations/src/transformations/op_conversions/scaled_dot_product_attention_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/scaled_dot_product_attention_decomposition.cpp index cb9d65146bbd3c..d6f6d494a4b762 100644 --- a/src/common/transformations/src/transformations/op_conversions/scaled_dot_product_attention_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/scaled_dot_product_attention_decomposition.cpp @@ -89,23 +89,22 @@ ov::pass::ScaledDotProductAttentionDecomposition::ScaledDotProductAttentionDecom std::shared_ptr ov::pass::ScaledDotProductAttentionDecomposition::decompose( std::shared_ptr node) { - using namespace ov::op; - auto query = node->input_value(0); +auto query = node->input_value(0); auto key = node->input_value(1); auto value = node->input_value(2); - auto q_shape = register_new_node(query, element::i32); - auto k_shape = register_new_node(key, element::i32); - auto minus_one = register_new_node(v0::Constant::create(element::i32, Shape{}, {-1})); - auto minus_two = register_new_node(v0::Constant::create(element::i32, Shape{}, {-2})); - auto zero_i = register_new_node(v0::Constant::create(element::i32, Shape{}, {0})); - auto one_i = register_new_node(v0::Constant::create(element::i32, Shape{}, {1})); - auto one_f = register_new_node(one_i, query); - auto zero_f = register_new_node(zero_i, query); - - auto build_extract_dim_subgraph = [this, &zero_i](const std::shared_ptr& shape_of, + auto q_shape = register_new_node(query, element::i32); + auto k_shape = register_new_node(key, element::i32); + auto minus_one = register_new_node(ov::op::v0::Constant::create(element::i32, Shape{}, {-1})); + auto minus_two = register_new_node(ov::op::v0::Constant::create(element::i32, Shape{}, {-2})); + auto zero_i = register_new_node(ov::op::v0::Constant::create(element::i32, Shape{}, {0})); + auto one_i = register_new_node(ov::op::v0::Constant::create(element::i32, Shape{}, {1})); + auto one_f = register_new_node(one_i, query); + auto zero_f = register_new_node(zero_i, query); + + auto build_extract_dim_subgraph = [this, &zero_i](const std::shared_ptr& shape_of, const int64_t idx) -> std::shared_ptr { - const auto dim_to_extract_const = v0::Constant::create(element::i32, Shape{}, {idx}); - const auto gather = std::make_shared(shape_of, dim_to_extract_const, zero_i); + const auto dim_to_extract_const = ov::op::v0::Constant::create(element::i32, Shape{}, {idx}); + const auto gather = std::make_shared(shape_of, dim_to_extract_const, zero_i); // When dim_to_extract is static but the whole shape is dynamic, // ConstantFolding can't fold ShapeOf->Gather subgraph in this case. // So it's better to explicitly extract the needed dimension. @@ -121,9 +120,9 @@ std::shared_ptr ov::pass::ScaledDotProductAttentionDecomposition::deco bool has_sink = false; if (node->get_input_size() < 5) { scale = build_extract_dim_subgraph(q_shape, -1); - scale = register_new_node(scale, query); - auto sqrt_scale = register_new_node(scale); - scale = register_new_node(one_f, sqrt_scale); + scale = register_new_node(scale, query); + auto sqrt_scale = register_new_node(scale); + scale = register_new_node(one_f, sqrt_scale); } else { scale = node->input_value(4); if (node->get_input_size() == 6) { @@ -132,30 +131,30 @@ std::shared_ptr ov::pass::ScaledDotProductAttentionDecomposition::deco } } - auto k_rank = register_new_node(k_shape, element::i32)->output(0); - auto k_last_dim = register_new_node(k_rank, minus_one); - auto k_next_dim = register_new_node(k_rank, minus_two)->output(0); - k_rank = register_new_node(k_rank, zero_i); + auto k_rank = register_new_node(k_shape, element::i32)->output(0); + auto k_last_dim = register_new_node(k_rank, minus_one); + auto k_next_dim = register_new_node(k_rank, minus_two)->output(0); + k_rank = register_new_node(k_rank, zero_i); auto minus_inf = - register_new_node(v0::Constant::create(element::f32, Shape{}, {-std::numeric_limits::infinity()})) + register_new_node(ov::op::v0::Constant::create(element::f32, Shape{}, {-std::numeric_limits::infinity()})) ->output(0); - auto keep_dim_last = register_new_node(k_next_dim, zero_i); - auto k_dims_before_transpose = register_new_node(zero_i, keep_dim_last, one_i, element::i32); + auto keep_dim_last = register_new_node(k_next_dim, zero_i); + auto k_dims_before_transpose = register_new_node(zero_i, keep_dim_last, one_i, element::i32); auto transpose_dims = - register_new_node(OutputVector{k_dims_before_transpose, k_last_dim, k_next_dim}, 0); - auto k_transposed = register_new_node(key, transpose_dims); + register_new_node(OutputVector{k_dims_before_transpose, k_last_dim, k_next_dim}, 0); + auto k_transposed = register_new_node(key, transpose_dims); ov::Output scaled_atten; if (can_move_scale_after_matmul(query, k_transposed, scale)) { - auto atten = register_new_node(query, k_transposed)->output(0); - scaled_atten = register_new_node(atten, scale)->output(0); + auto atten = register_new_node(query, k_transposed)->output(0); + scaled_atten = register_new_node(atten, scale)->output(0); } else { - auto q_scaled = register_new_node(query, scale); - scaled_atten = register_new_node(q_scaled, k_transposed)->output(0); + auto q_scaled = register_new_node(query, scale); + scaled_atten = register_new_node(q_scaled, k_transposed)->output(0); } - minus_inf = register_new_node(minus_inf, scaled_atten); + minus_inf = register_new_node(minus_inf, scaled_atten); if (node->get_causal() || node->get_input_size() > 3) { Output mask; @@ -167,50 +166,50 @@ std::shared_ptr ov::pass::ScaledDotProductAttentionDecomposition::deco // take part in attention. A float mask of the same type as query, key, value that is added to the attention // score. if (mask.get_element_type() == element::boolean) { - atten_mask = register_new_node(mask, zero_f, minus_inf); + atten_mask = register_new_node(mask, zero_f, minus_inf); } else { atten_mask = mask; } } else { auto target_s_len = build_extract_dim_subgraph(q_shape, -2); auto source_s_len = build_extract_dim_subgraph(k_shape, -2); - auto ssl = register_new_node(source_s_len, zero_i); - auto tsl = register_new_node(target_s_len, zero_i); - auto mask_shape = register_new_node(OutputVector{tsl, ssl}, 0); - mask = register_new_node(minus_inf, mask_shape); - auto horizontal_range = register_new_node(zero_i, source_s_len, one_i, element::i32)->output(0); - horizontal_range = register_new_node(horizontal_range, zero_i); - auto stop = register_new_node(target_s_len, one_i); - auto vertical_range = register_new_node(one_i, stop, one_i, element::i32)->output(0); - vertical_range = register_new_node(vertical_range, one_i); - auto triu = register_new_node(horizontal_range, vertical_range); - atten_mask = register_new_node(triu, mask, zero_f); + auto ssl = register_new_node(source_s_len, zero_i); + auto tsl = register_new_node(target_s_len, zero_i); + auto mask_shape = register_new_node(OutputVector{tsl, ssl}, 0); + mask = register_new_node(minus_inf, mask_shape); + auto horizontal_range = register_new_node(zero_i, source_s_len, one_i, element::i32)->output(0); + horizontal_range = register_new_node(horizontal_range, zero_i); + auto stop = register_new_node(target_s_len, one_i); + auto vertical_range = register_new_node(one_i, stop, one_i, element::i32)->output(0); + vertical_range = register_new_node(vertical_range, one_i); + auto triu = register_new_node(horizontal_range, vertical_range); + atten_mask = register_new_node(triu, mask, zero_f); } - scaled_atten = register_new_node(scaled_atten, atten_mask); + scaled_atten = register_new_node(scaled_atten, atten_mask); } if (has_sink) { - auto minus_two = register_new_node(v0::Constant::create(element::i32, Shape{1}, {-2})); - auto minus_one = register_new_node(v0::Constant::create(element::i32, Shape{1}, {-1})); - auto zero_i = register_new_node(v0::Constant::create(element::i32, Shape{1}, {0})); - auto one_i = register_new_node(v0::Constant::create(element::i32, Shape{1}, {1})); - - auto q_last_but_one_dim = register_new_node(register_new_node(q_shape), - v0::Constant::create(element::i64, Shape{}, {1})); - auto sink_target_shape_1 = register_new_node(q_shape, zero_i, q_last_but_one_dim, one_i); - auto sink_target_shape = register_new_node(OutputVector{sink_target_shape_1, one_i}, 0); - auto sink_broadcast = register_new_node(sink, sink_target_shape); - - auto scaled_attn_sink = register_new_node(OutputVector{scaled_atten, sink_broadcast}, -1); - scaled_atten = register_new_node(scaled_attn_sink, -1); - - auto prev_seq_len = register_new_node(k_shape, minus_two, zero_i); - scaled_atten = register_new_node(scaled_atten, zero_i, prev_seq_len, one_i, minus_one); + auto minus_two = register_new_node(ov::op::v0::Constant::create(element::i32, Shape{1}, {-2})); + auto minus_one = register_new_node(ov::op::v0::Constant::create(element::i32, Shape{1}, {-1})); + auto zero_i = register_new_node(ov::op::v0::Constant::create(element::i32, Shape{1}, {0})); + auto one_i = register_new_node(ov::op::v0::Constant::create(element::i32, Shape{1}, {1})); + + auto q_last_but_one_dim = register_new_node(register_new_node(q_shape), + ov::op::v0::Constant::create(element::i64, Shape{}, {1})); + auto sink_target_shape_1 = register_new_node(q_shape, zero_i, q_last_but_one_dim, one_i); + auto sink_target_shape = register_new_node(OutputVector{sink_target_shape_1, one_i}, 0); + auto sink_broadcast = register_new_node(sink, sink_target_shape); + + auto scaled_attn_sink = register_new_node(OutputVector{scaled_atten, sink_broadcast}, -1); + scaled_atten = register_new_node(scaled_attn_sink, -1); + + auto prev_seq_len = register_new_node(k_shape, minus_two, zero_i); + scaled_atten = register_new_node(scaled_atten, zero_i, prev_seq_len, one_i, minus_one); } else { - scaled_atten = register_new_node(scaled_atten, -1); + scaled_atten = register_new_node(scaled_atten, -1); } - auto result = register_new_node(scaled_atten, value); + auto result = register_new_node(scaled_atten, value); result->set_friendly_name(node->get_friendly_name()); copy_runtime_info(node, get_new_nodes()); return result; diff --git a/src/common/transformations/src/transformations/op_conversions/simplify_ctc_greedy_decoder_seq_len.cpp b/src/common/transformations/src/transformations/op_conversions/simplify_ctc_greedy_decoder_seq_len.cpp index 384230914da8cd..3822d3e3818ecb 100644 --- a/src/common/transformations/src/transformations/op_conversions/simplify_ctc_greedy_decoder_seq_len.cpp +++ b/src/common/transformations/src/transformations/op_conversions/simplify_ctc_greedy_decoder_seq_len.cpp @@ -27,7 +27,7 @@ ov::pass::SimplifyCTCGreedyDecoderSeqLen::SimplifyCTCGreedyDecoderSeqLen() { MATCHER_SCOPE(SimplifyCTCGreedyDecoderSeqLen); - auto decoder = pattern::wrap_type(); + auto decoder = ov::pass::pattern::wrap_type(); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto decoder_seq_len = ov::as_type_ptr(m.get_match_root()); diff --git a/src/common/transformations/src/transformations/op_conversions/softmax_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/softmax_decomposition.cpp index edf1e0cac875e5..f89ecab8437943 100644 --- a/src/common/transformations/src/transformations/op_conversions/softmax_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/softmax_decomposition.cpp @@ -23,7 +23,7 @@ ov::pass::SoftmaxDecomposition::SoftmaxDecomposition() { MATCHER_SCOPE(SoftmaxDecomposition); - auto softmax = pattern::wrap_type(); + auto softmax = ov::pass::pattern::wrap_type(); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto m_softmax = m.get_match_root(); Output input; diff --git a/src/common/transformations/src/transformations/op_conversions/softplus_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/softplus_decomposition.cpp index df975a42dbb540..f2b1942b7341ef 100644 --- a/src/common/transformations/src/transformations/op_conversions/softplus_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/softplus_decomposition.cpp @@ -21,7 +21,7 @@ ov::pass::SoftPlusDecomposition::SoftPlusDecomposition() { MATCHER_SCOPE(SoftPlusDecomposition); // decomposes SoftPlus(x) operation into ln(exp(x) + 1.0) - auto input = pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto softplus = std::make_shared(input); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/op_conversions/softsign_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/softsign_decomposition.cpp index a2e52ca702345e..21d1135174bbf7 100644 --- a/src/common/transformations/src/transformations/op_conversions/softsign_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/softsign_decomposition.cpp @@ -19,7 +19,7 @@ ov::pass::SoftSignDecomposition::SoftSignDecomposition() { MATCHER_SCOPE(SoftSignDecomposition); - auto softsign = pattern::wrap_type(); + auto softsign = ov::pass::pattern::wrap_type(); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto m_softsign = m.get_match_root(); diff --git a/src/common/transformations/src/transformations/op_conversions/unique_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/unique_decomposition.cpp index b77708a3f9803e..d81fb53350f5b0 100644 --- a/src/common/transformations/src/transformations/op_conversions/unique_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/unique_decomposition.cpp @@ -52,9 +52,9 @@ Output get_elements_number_1d(const ov::Output& output, ov::pass::UniqueDecomposition::UniqueDecomposition() { MATCHER_SCOPE(UniqueDecomposition); - auto unique = pattern::wrap_type(); + auto unique = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& matcher) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& matcher) { NodeRegistry rg; auto unique_node = ov::as_type_ptr(matcher.get_match_root()); @@ -204,6 +204,6 @@ ov::pass::UniqueDecomposition::UniqueDecomposition() { return true; }; - auto m = make_shared(unique, matcher_name); + auto m = make_shared(unique, matcher_name); this->register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/pattern_blocks/compressed_weights_block.cpp b/src/common/transformations/src/transformations/pattern_blocks/compressed_weights_block.cpp index 0e13df6dae0c7b..a3ba9def440f28 100644 --- a/src/common/transformations/src/transformations/pattern_blocks/compressed_weights_block.cpp +++ b/src/common/transformations/src/transformations/pattern_blocks/compressed_weights_block.cpp @@ -23,27 +23,25 @@ #include "ov_ops/fully_connected.hpp" #include "ov_ops/fully_connected_compressed.hpp" #include "transformations/utils/utils.hpp" - -using namespace ov::pass::pattern; ov::pass::pattern::op::CompressedWeightsBlock::CompressedWeightsBlock( const std::vector& supported_weights_types, const std::set& supported_weights_ranks) : Block({}, {}, "CompressedWeightsBlock") { - auto weights = wrap_type(type_matches_any(supported_weights_types)); - auto convert = wrap_type({weights}); + auto weights = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any(supported_weights_types)); + auto convert = ov::pass::pattern::wrap_type({weights}); - auto sub_const = wrap_type(); - auto sub_convert_const = wrap_type({sub_const}); - auto sub_with_convert = wrap_type({convert, sub_convert_const}); - auto sub_no_convert = wrap_type({convert, sub_const}); + auto sub_const = ov::pass::pattern::wrap_type(); + auto sub_convert_const = ov::pass::pattern::wrap_type({sub_const}); + auto sub_with_convert = ov::pass::pattern::wrap_type({convert, sub_convert_const}); + auto sub_no_convert = ov::pass::pattern::wrap_type({convert, sub_const}); auto subtract = sub_with_convert | sub_no_convert; - auto mul_const = wrap_type(); - auto mul_convert_const = wrap_type({mul_const}); + auto mul_const = ov::pass::pattern::wrap_type(); + auto mul_convert_const = ov::pass::pattern::wrap_type({mul_const}); auto mul_scale = mul_const | mul_convert_const; - auto mul_with_sub = wrap_type({subtract, mul_scale}); - auto mul_no_sub = wrap_type({convert, mul_scale}); + auto mul_with_sub = ov::pass::pattern::wrap_type({subtract, mul_scale}); + auto mul_no_sub = ov::pass::pattern::wrap_type({convert, mul_scale}); auto mul = mul_with_sub | mul_no_sub; auto reshape_predicate = [supported_weights_ranks](const ov::Output& output) { @@ -57,14 +55,14 @@ ov::pass::pattern::op::CompressedWeightsBlock::CompressedWeightsBlock( supported_weights_ranks_before_reshape.count(in_ps.size()) && supported_weights_ranks.count(out_ps.size()); }; - auto reshape_const = wrap_type(); - auto reshape = wrap_type({mul, reshape_const}, reshape_predicate); + auto reshape_const = ov::pass::pattern::wrap_type(); + auto reshape = ov::pass::pattern::wrap_type({mul, reshape_const}, reshape_predicate); auto transpose_input = reshape | mul; - auto transpose_const = wrap_type(); - auto transpose = wrap_type({transpose_input, transpose_const}); + auto transpose_const = ov::pass::pattern::wrap_type(); + auto transpose = ov::pass::pattern::wrap_type({transpose_input, transpose_const}); - auto weights_input = optional({reshape | transpose | mul}); + auto weights_input = ov::pass::pattern::optional({reshape | transpose | mul}); // Block initialization m_inputs = ov::OutputVector{weights}; diff --git a/src/common/transformations/src/transformations/sdpa_to_paged_attention/position_ids_replacer.cpp b/src/common/transformations/src/transformations/sdpa_to_paged_attention/position_ids_replacer.cpp index ac718c8951f6d3..36fdab5629e6c7 100644 --- a/src/common/transformations/src/transformations/sdpa_to_paged_attention/position_ids_replacer.cpp +++ b/src/common/transformations/src/transformations/sdpa_to_paged_attention/position_ids_replacer.cpp @@ -25,36 +25,32 @@ #include "openvino/pass/pattern/op/optional.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" #include "transformations/utils/utils.hpp" - -using namespace ov::op; -using namespace ov::pass::pattern; - // TODO: Instead of using the following transformation that matches quite a specific place in a model graph in case when // position_ids parameter is missing, consider replacing always existing attention_mask parameter with a sub-graph using // a new slot_mapping parameter. ov::pass::PositionIDsReplacer::PositionIDsReplacer(const Output& position_ids) { MATCHER_SCOPE(PositionIDsReplacer); - auto input_ids = any_input(); - auto input_embed = wrap_type({any_input(), input_ids, any_input()}); + auto input_ids = ov::pass::pattern::any_input(); + auto input_embed = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), input_ids, ov::pass::pattern::any_input()}); - auto position_ids_pattern = any_input(); - auto offset = wrap_type(); - auto add_offset = wrap_type({position_ids_pattern, offset}); - auto convert = wrap_type({add_offset}); - auto position_embed = wrap_type({any_input(), convert, any_input()}); + auto position_ids_pattern = ov::pass::pattern::any_input(); + auto offset = ov::pass::pattern::wrap_type(); + auto add_offset = ov::pass::pattern::wrap_type({position_ids_pattern, offset}); + auto convert = ov::pass::pattern::wrap_type({add_offset}); + auto position_embed = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), convert, ov::pass::pattern::any_input()}); - auto mul = optional({input_embed, any_input()}); + auto mul = ov::pass::pattern::optional({input_embed, ov::pass::pattern::any_input()}); - auto add = wrap_type({mul, position_embed}); + auto add = ov::pass::pattern::wrap_type({mul, position_embed}); - ov::matcher_pass_callback callback = [=](Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); replace_node(pattern_map.at(position_ids_pattern).get_node_shared_ptr(), position_ids.get_node_shared_ptr()); return true; }; - auto m = std::make_shared(add, matcher_name); + auto m = std::make_shared(add, matcher_name); register_matcher(m, callback); } @@ -62,9 +58,9 @@ ov::pass::PositionIDsReplacerQwen::PositionIDsReplacerQwen(const Output& p MATCHER_SCOPE(PositionIDsReplacerQwen); // total seq len: - auto p_max_context_len = wrap_type(); - auto p_opt_convert = optional(p_max_context_len); - auto p_opt_reshape = optional({p_opt_convert, any_input()}); + auto p_max_context_len = ov::pass::pattern::wrap_type(); + auto p_opt_convert = ov::pass::pattern::optional(p_max_context_len); + auto p_opt_reshape = ov::pass::pattern::optional({p_opt_convert, ov::pass::pattern::any_input()}); // current seq len: // it might be present in 2 different ways: @@ -72,13 +68,13 @@ ov::pass::PositionIDsReplacerQwen::PositionIDsReplacerQwen(const Output& p // QKV -> variadic_split(Q or K) -> rope Q/K -> shape_of -> gather // Probably we can use the symbols to re-use one of these ways. // Currently, "any_input" is used to detect the both places. - auto p_shape_of = wrap_type({any_input()}); - auto p_current_len = wrap_type({p_shape_of, wrap_const(), wrap_const()}); + auto p_shape_of = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); + auto p_current_len = ov::pass::pattern::wrap_type({p_shape_of, ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const()}); - auto p_neg_const = wrap_type(); - auto p_neg_const_convert = optional(p_neg_const); - auto p_neg_const_reshape = optional({p_neg_const_convert, any_input()}); - auto p_neg_mul = wrap_type({p_current_len, p_neg_const_reshape}); + auto p_neg_const = ov::pass::pattern::wrap_type(); + auto p_neg_const_convert = ov::pass::pattern::optional(p_neg_const); + auto p_neg_const_reshape = ov::pass::pattern::optional({p_neg_const_convert, ov::pass::pattern::any_input()}); + auto p_neg_mul = ov::pass::pattern::wrap_type({p_current_len, p_neg_const_reshape}); // For now, it has always been a constant, but this may change in the future. // In case of model being in FP16, there will be a decompressing subgraph: @@ -86,13 +82,13 @@ ov::pass::PositionIDsReplacerQwen::PositionIDsReplacerQwen(const Output& p // // Also, it hasn't been observed yet, but, theoretically, there can also be a // dequantizing subgraph, so it's going to be any_input() here. - auto p_rotary_emb_sincos = pattern::any_input(); + auto p_rotary_emb_sincos = ov::pass::pattern::any_input(); // the rotary_emb_cos/rotary_emb_sin are sliced by the total length [1,..4096,1,128] auto p_slice_1 = - wrap_type({p_rotary_emb_sincos, wrap_const(), p_opt_reshape, wrap_const(), wrap_const()}); - auto p_slice_2 = wrap_type({p_slice_1, p_neg_mul, wrap_const(), wrap_const(), wrap_const()}); + ov::pass::pattern::wrap_type({p_rotary_emb_sincos, ov::pass::pattern::wrap_const(), p_opt_reshape, ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const()}); + auto p_slice_2 = ov::pass::pattern::wrap_type({p_slice_1, p_neg_mul, ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const()}); - ov::matcher_pass_callback callback = [=](Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto max_context_len = pattern_map.at(p_max_context_len).get_node_shared_ptr(); if (max_context_len->get_friendly_name() != "max_context_len") { @@ -102,10 +98,10 @@ ov::pass::PositionIDsReplacerQwen::PositionIDsReplacerQwen(const Output& p auto slice_1 = pattern_map.at(p_slice_1).get_node_shared_ptr(); auto slice_2 = pattern_map.at(p_slice_2).get_node_shared_ptr(); - auto axis = v0::Constant::create(element::i64, Shape{}, {1}); + auto axis = ov::op::v0::Constant::create(element::i64, Shape{}, {1}); // in case of PagedAttention (Continuous batching) the rotary_emb_cos/rotary_emb_sin // are used not in the sequential order, so we need to use position_ids to get the expected values. - auto gather = std::make_shared(slice_1->input_value(0), position_ids, axis); + auto gather = std::make_shared(slice_1->input_value(0), position_ids, axis); gather->set_friendly_name(slice_2->get_friendly_name()); gather->validate_and_infer_types(); @@ -119,51 +115,51 @@ ov::pass::PositionIDsReplacerQwen::PositionIDsReplacerQwen(const Output& p // so here we need to reshape the output tensor to move the seq dim (num tokens) to the batch // num_kv_heads * head_size are already handled in the StateManagementPattern transformation auto head_size = static_cast(pshape[3].get_length()); - auto new_shape = v0::Constant::create(element::i64, Shape{4}, std::vector{-1, 1, 1, head_size}); - auto reshape = std::make_shared(gather, new_shape, false); + auto new_shape = ov::op::v0::Constant::create(element::i64, Shape{4}, std::vector{-1, 1, 1, head_size}); + auto reshape = std::make_shared(gather, new_shape, false); replace_node(slice_2, reshape); return true; }; - auto m = std::make_shared(p_slice_2, matcher_name); + auto m = std::make_shared(p_slice_2, matcher_name); register_matcher(m, callback); } -ov::pass::PositionIDsReplacerCodeGen2::PositionIDsReplacerCodeGen2(const std::shared_ptr& position_ids) { +ov::pass::PositionIDsReplacerCodeGen2::PositionIDsReplacerCodeGen2(const std::shared_ptr& position_ids) { MATCHER_SCOPE(PositionIDsReplacerCodeGen2); - auto p_range = wrap_type(); - auto p_power = wrap_type(); - auto p_einsum = wrap_type({p_range, p_power}); - auto p_sin_cos = wrap_type({p_einsum}); - auto p_reshape = wrap_type({p_sin_cos, any_input()}); - auto p_tile = wrap_type({p_reshape, any_input()}); - auto p_opt_reshape = optional({p_tile, any_input()}); - auto p_opt_unsq = optional({p_opt_reshape, any_input()}); - - auto p_reshape_1in = wrap_type({any_input(), any_input()}); - auto p_add_2in = wrap_type({any_input(), any_input()}); - auto p_slice = wrap_type({p_opt_unsq, p_reshape_1in, p_add_2in, wrap_const(), wrap_const()}); - - auto p_add = wrap_type(); - matcher_pass_callback callback = [=, &position_ids](Matcher& m) { + auto p_range = ov::pass::pattern::wrap_type(); + auto p_power = ov::pass::pattern::wrap_type(); + auto p_einsum = ov::pass::pattern::wrap_type({p_range, p_power}); + auto p_sin_cos = ov::pass::pattern::wrap_type({p_einsum}); + auto p_reshape = ov::pass::pattern::wrap_type({p_sin_cos, ov::pass::pattern::any_input()}); + auto p_tile = ov::pass::pattern::wrap_type({p_reshape, ov::pass::pattern::any_input()}); + auto p_opt_reshape = ov::pass::pattern::optional({p_tile, ov::pass::pattern::any_input()}); + auto p_opt_unsq = ov::pass::pattern::optional({p_opt_reshape, ov::pass::pattern::any_input()}); + + auto p_reshape_1in = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto p_add_2in = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto p_slice = ov::pass::pattern::wrap_type({p_opt_unsq, p_reshape_1in, p_add_2in, ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const()}); + + auto p_add = ov::pass::pattern::wrap_type(); + matcher_pass_callback callback = [=, &position_ids](ov::pass::pattern::Matcher& m) { auto pvm = m.get_pattern_value_map(); auto slice = pvm.at(p_slice).get_node_shared_ptr(); - auto gather = std::make_shared(slice->input_value(0), + auto gather = std::make_shared(slice->input_value(0), position_ids, - v0::Constant::create(element::i64, Shape{}, {1})); + ov::op::v0::Constant::create(element::i64, Shape{}, {1})); if (gather->output(0).get_partial_shape().rank() != 3) { return false; } auto transpose = - std::make_shared(gather, v0::Constant::create(element::i64, Shape{3}, {1, 0, 2})); + std::make_shared(gather, ov::op::v0::Constant::create(element::i64, Shape{3}, {1, 0, 2})); replace_node(slice, transpose); return true; }; - auto m = std::make_shared(p_slice, matcher_name); + auto m = std::make_shared(p_slice, matcher_name); register_matcher(m, callback); } \ No newline at end of file diff --git a/src/common/transformations/src/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.cpp b/src/common/transformations/src/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.cpp index a180806e58563e..874bbf20aaccf7 100644 --- a/src/common/transformations/src/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.cpp +++ b/src/common/transformations/src/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.cpp @@ -12,9 +12,6 @@ #include "openvino/op/shape_of.hpp" #include "openvino/op/subtract.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" - -using namespace ov::op; - ov::pass::PrevSequenceLengthPattern::PrevSequenceLengthPattern(const std::shared_ptr& unsqueezed_input_ids, const std::shared_ptr& max_context_len, const std::shared_ptr& position_ids) { @@ -22,10 +19,10 @@ ov::pass::PrevSequenceLengthPattern::PrevSequenceLengthPattern(const std::shared // The transformation addresses two cases that look similar: (1) previous sequence length, (2) batch size in // kv-cache state In first case it should replace it by prev_max_seq_len. For the second case, connect to batch_dim. - auto kv_past = pattern::wrap_type({pattern::any_input()}); - auto kv_gather = pattern::wrap_type({kv_past, pattern::any_input(), pattern::any_input()}); - auto kv_shape = pattern::wrap_type({kv_gather}); - auto seq = pattern::wrap_type({kv_shape, pattern::any_input(), pattern::any_input()}); + auto kv_past = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); + auto kv_gather = ov::pass::pattern::wrap_type({kv_past, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto kv_shape = ov::pass::pattern::wrap_type({kv_gather}); + auto seq = ov::pass::pattern::wrap_type({kv_shape, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { // TODO: Check that seq has axis that really takes sequence len but not any other dimension -- use symbolics or @@ -42,22 +39,22 @@ ov::pass::PrevSequenceLengthPattern::PrevSequenceLengthPattern(const std::shared auto target_type = gather->get_output_element_type(0); std::shared_ptr replacement; if (kv_init_shape[axis].is_static() && kv_init_shape[axis].get_length() == 0) { - auto cur_seq_len = std::make_shared(std::make_shared(unsqueezed_input_ids), - v0::Constant::create(element::i64, Shape{}, {1}), - v0::Constant::create(element::i64, Shape{}, {0})); - auto cur_seq_len_i32 = std::make_shared(cur_seq_len, element::i32); - auto prev_max_seq_len = std::make_shared(max_context_len, cur_seq_len_i32); + auto cur_seq_len = std::make_shared(std::make_shared(unsqueezed_input_ids), + ov::op::v0::Constant::create(element::i64, Shape{}, {1}), + ov::op::v0::Constant::create(element::i64, Shape{}, {0})); + auto cur_seq_len_i32 = std::make_shared(cur_seq_len, element::i32); + auto prev_max_seq_len = std::make_shared(max_context_len, cur_seq_len_i32); replacement = prev_max_seq_len; } else { // it is not always required, so will be disposed if not needed - auto batch_dim = std::make_shared(position_ids); + auto batch_dim = std::make_shared(position_ids); // assumption that any other axis should point to batch dimension, precise reasoning is too complex // TODO: provide more reliable check replacement = batch_dim; } if (replacement->get_output_element_type(0) != target_type) { - replacement = std::make_shared(replacement, target_type); + replacement = std::make_shared(replacement, target_type); } auto required_shape = gather->get_output_partial_shape(0); if (replacement->get_output_partial_shape(0) != required_shape && required_shape.rank().is_static()) { diff --git a/src/common/transformations/src/transformations/sdpa_to_paged_attention/state_management_pattern.cpp b/src/common/transformations/src/transformations/sdpa_to_paged_attention/state_management_pattern.cpp index fb7563a373936a..766e462db31ccf 100644 --- a/src/common/transformations/src/transformations/sdpa_to_paged_attention/state_management_pattern.cpp +++ b/src/common/transformations/src/transformations/sdpa_to_paged_attention/state_management_pattern.cpp @@ -43,61 +43,59 @@ constexpr const char* NUM_K_HEADS = "num_k_heads"; constexpr const char* K_HEAD_SIZE = "k_head_size"; constexpr const char* NUM_V_HEADS = "num_v_heads"; constexpr const char* V_HEAD_SIZE = "v_head_size"; - -using namespace ov::op; using namespace ov::pass; using ov::OutputVector; static std::tuple, std::shared_ptr> general_alibi_pattern() { // Optional pattern to capture alibi slopes (based on pattern from bloom) - auto general_alibi = pattern::any_input(); + auto general_alibi = ov::pass::pattern::any_input(); auto general_sdpa_mask = - pattern::wrap_type({pattern::any_input(), general_alibi}); // apply input position_ids - general_sdpa_mask = pattern::wrap_type({general_sdpa_mask, pattern::any_input()}); - general_sdpa_mask = pattern::wrap_type({general_sdpa_mask, pattern::any_input()}); - general_sdpa_mask = pattern::wrap_type({pattern::any_input(), pattern::any_input(), general_sdpa_mask}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), general_alibi}); // apply input position_ids + general_sdpa_mask = ov::pass::pattern::wrap_type({general_sdpa_mask, ov::pass::pattern::any_input()}); + general_sdpa_mask = ov::pass::pattern::wrap_type({general_sdpa_mask, ov::pass::pattern::any_input()}); + general_sdpa_mask = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), general_sdpa_mask}); return {general_alibi, general_sdpa_mask}; } static std::tuple, std::shared_ptr> jais_13b_alibi_pattern() { - auto jais_13b_alibi = pattern::any_input(); - auto mirroring_abs = pattern::wrap_type({pattern::any_input()}); - auto unsqueeze = pattern::wrap_type({mirroring_abs, pattern::any_input()}); - auto jais_alibi_mask = pattern::wrap_type({jais_13b_alibi, unsqueeze}); - jais_alibi_mask = pattern::wrap_type({jais_alibi_mask, pattern::any_input()}); - jais_alibi_mask = pattern::wrap_type({jais_alibi_mask, pattern::any_input()}); - jais_alibi_mask = pattern::wrap_type({pattern::any_input(), jais_alibi_mask}); + auto jais_13b_alibi = ov::pass::pattern::any_input(); + auto mirroring_abs = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); + auto unsqueeze = ov::pass::pattern::wrap_type({mirroring_abs, ov::pass::pattern::any_input()}); + auto jais_alibi_mask = ov::pass::pattern::wrap_type({jais_13b_alibi, unsqueeze}); + jais_alibi_mask = ov::pass::pattern::wrap_type({jais_alibi_mask, ov::pass::pattern::any_input()}); + jais_alibi_mask = ov::pass::pattern::wrap_type({jais_alibi_mask, ov::pass::pattern::any_input()}); + jais_alibi_mask = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), jais_alibi_mask}); return {jais_13b_alibi, jais_alibi_mask}; } static std::tuple, std::shared_ptr> baichuan2_13b_alibi_pattern() { - auto baichuan2_alibi = pattern::any_input(); + auto baichuan2_alibi = ov::pass::pattern::any_input(); // this slice expected to be replaced with Slice(alibi_const, start {1, 1}, stop {2, 2}, step {1, 1}, axes{1, 2}); - auto alibi_slice_to_replace = pattern::wrap_type( - {baichuan2_alibi, pattern::any_input(), pattern::any_input(), pattern::any_input(), pattern::any_input()}); - auto alibi_path = pattern::wrap_type({alibi_slice_to_replace}); - alibi_path = pattern::wrap_type({alibi_path, pattern::any_input(), pattern::any_input()}); - alibi_path = pattern::wrap_type({pattern::any_input(), pattern::any_input(), alibi_path}); - alibi_path = pattern::wrap_type({pattern::any_input(), alibi_path}); - alibi_path = pattern::wrap_type({alibi_path}); - alibi_path = pattern::wrap_type({alibi_path, pattern::any_input()}); - alibi_path = pattern::wrap_type({pattern::any_input(), alibi_path}); - alibi_path = pattern::wrap_type({pattern::any_input(), pattern::any_input(), alibi_path}); - auto alibi_unsqueeze = pattern::wrap_type({alibi_slice_to_replace, pattern::any_input()}); - alibi_path = pattern::wrap_type({alibi_path, alibi_unsqueeze}); - auto mul = pattern::wrap_type({pattern::any_input(), pattern::any_input()}); - alibi_path = pattern::wrap_type( - {alibi_path, mul, pattern::any_input(), pattern::any_input(), pattern::any_input()}); + auto alibi_slice_to_replace = ov::pass::pattern::wrap_type( + {baichuan2_alibi, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto alibi_path = ov::pass::pattern::wrap_type({alibi_slice_to_replace}); + alibi_path = ov::pass::pattern::wrap_type({alibi_path, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + alibi_path = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), alibi_path}); + alibi_path = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), alibi_path}); + alibi_path = ov::pass::pattern::wrap_type({alibi_path}); + alibi_path = ov::pass::pattern::wrap_type({alibi_path, ov::pass::pattern::any_input()}); + alibi_path = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), alibi_path}); + alibi_path = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), alibi_path}); + auto alibi_unsqueeze = ov::pass::pattern::wrap_type({alibi_slice_to_replace, ov::pass::pattern::any_input()}); + alibi_path = ov::pass::pattern::wrap_type({alibi_path, alibi_unsqueeze}); + auto mul = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + alibi_path = ov::pass::pattern::wrap_type( + {alibi_path, mul, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); return {baichuan2_alibi, alibi_path}; } static std::shared_ptr handle_general_alibi(const std::shared_ptr& matched_general_alibi_slopes) { std::shared_ptr res_alibi_slopes = - std::make_shared(matched_general_alibi_slopes, - v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}), + std::make_shared(matched_general_alibi_slopes, + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}), false); if (res_alibi_slopes->get_element_type() != ov::element::f32) { - res_alibi_slopes = std::make_shared(res_alibi_slopes, ov::element::f32); + res_alibi_slopes = std::make_shared(res_alibi_slopes, ov::element::f32); } return res_alibi_slopes; @@ -113,7 +111,7 @@ static std::shared_ptr handle_jais_13b_alibi(const std::shared_ptr(matched_jais_13b_alibi_slopes)) { + if (auto alibi_constant = ov::as_type_ptr(matched_jais_13b_alibi_slopes)) { auto alibi_constant_values = alibi_constant->cast_vector(); bool all_values_nagative = std::all_of(alibi_constant_values.begin(), alibi_constant_values.end(), [&](float value) { @@ -122,13 +120,13 @@ static std::shared_ptr handle_jais_13b_alibi(const std::shared_ptr(res_alibi_slopes, - v0::Constant::create(res_alibi_slopes->get_element_type(), {}, {-1})); + std::make_shared(res_alibi_slopes, + ov::op::v0::Constant::create(res_alibi_slopes->get_element_type(), {}, {-1})); } } else { res_alibi_slopes = - std::make_shared(res_alibi_slopes, - v0::Constant::create(res_alibi_slopes->get_element_type(), {}, {-1})); + std::make_shared(res_alibi_slopes, + ov::op::v0::Constant::create(res_alibi_slopes->get_element_type(), {}, {-1})); } return res_alibi_slopes; @@ -169,68 +167,64 @@ static std::shared_ptr handle_baichuan2_13b_alibi( const std::shared_ptr& matched_baichuan2_13b_alibi_slopes) { std::shared_ptr res_alibi_slopes = matched_baichuan2_13b_alibi_slopes; - auto start = v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 1}); - auto stop = v0::Constant::create(ov::element::i64, ov::Shape{2}, {2, 2}); - auto step = v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 1}); - auto axes = v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 2}); + auto start = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 1}); + auto stop = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {2, 2}); + auto step = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 1}); + auto axes = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 2}); // the Slice to extract the correct values - res_alibi_slopes = std::make_shared(res_alibi_slopes, start, stop, step, axes); - res_alibi_slopes = std::make_shared(res_alibi_slopes, - v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}), + res_alibi_slopes = std::make_shared(res_alibi_slopes, start, stop, step, axes); + res_alibi_slopes = std::make_shared(res_alibi_slopes, + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}), false); if (res_alibi_slopes->get_element_type() != ov::element::f32) { - res_alibi_slopes = std::make_shared(res_alibi_slopes, ov::element::f32); + res_alibi_slopes = std::make_shared(res_alibi_slopes, ov::element::f32); } return res_alibi_slopes; } static std::tuple, std::shared_ptr> phi3_sliding_window_pattern() { - using namespace ov::pass::pattern; - - auto offset = wrap_type(); - auto t196 = wrap_type({any_input(), offset}); - auto t197 = pattern::optional(t196); - auto t200 = pattern::wrap_type({t197, any_input(), any_input()}); - auto t201 = pattern::wrap_type({t200, any_input()}); - auto t202 = pattern::wrap_type({any_input(), t201}); - auto t208 = pattern::wrap_type({t202, any_input(), any_input()}); - auto t209 = pattern::wrap_type({any_input(), t208}); - auto t210 = pattern::optional(t209); - auto t211 = pattern::wrap_type({t210, any_input(), any_input()}); - auto t213 = pattern::wrap_type({t211, any_input()}); - auto t214 = pattern::wrap_type({t213, any_input()}); - auto t218 = pattern::wrap_type({t214, any_input()}); - auto t219 = pattern::wrap_type({any_input(), any_input(), t218}); - auto mask = pattern::wrap_type({t219, any_input(), any_input(), any_input(), any_input()}); +auto offset = ov::pass::pattern::wrap_type(); + auto t196 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), offset}); + auto t197 = ov::pass::pattern::optional(t196); + auto t200 = ov::pass::pattern::wrap_type({t197, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto t201 = ov::pass::pattern::wrap_type({t200, ov::pass::pattern::any_input()}); + auto t202 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), t201}); + auto t208 = ov::pass::pattern::wrap_type({t202, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto t209 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), t208}); + auto t210 = ov::pass::pattern::optional(t209); + auto t211 = ov::pass::pattern::wrap_type({t210, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto t213 = ov::pass::pattern::wrap_type({t211, ov::pass::pattern::any_input()}); + auto t214 = ov::pass::pattern::wrap_type({t213, ov::pass::pattern::any_input()}); + auto t218 = ov::pass::pattern::wrap_type({t214, ov::pass::pattern::any_input()}); + auto t219 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), t218}); + auto mask = ov::pass::pattern::wrap_type({t219, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); return {mask, offset}; } static std::tuple, std::shared_ptr> gpt_oss_sliding_window_pattern() { - using namespace ov::pass::pattern; - - auto q_idx = pattern::any_input(); - auto kv_idx = pattern::any_input(); +auto q_idx = ov::pass::pattern::any_input(); + auto kv_idx = ov::pass::pattern::any_input(); - auto kv_idx_opt_conv = pattern::optional(kv_idx); + auto kv_idx_opt_conv = ov::pass::pattern::optional(kv_idx); - auto offset = wrap_type(); + auto offset = ov::pass::pattern::wrap_type(); - auto add = wrap_type({q_idx, offset}); - auto greater = pattern::wrap_type({kv_idx_opt_conv, add}); - auto bitwise_and = pattern::wrap_type({any_input(), greater}); - auto bitwise_and_1 = pattern::wrap_type({bitwise_and, any_input()}); - auto bitwise_and_2 = pattern::wrap_type({any_input(), bitwise_and_1}); - auto bitwise_and_3 = pattern::wrap_type({bitwise_and_2, any_input()}); - auto broadcast = pattern::wrap_type({bitwise_and_3, any_input()}); - auto select = pattern::wrap_type({broadcast, any_input(), any_input()}); - auto mask = pattern::wrap_type({select, any_input(), any_input(), any_input(), any_input()}); + auto add = ov::pass::pattern::wrap_type({q_idx, offset}); + auto greater = ov::pass::pattern::wrap_type({kv_idx_opt_conv, add}); + auto bitwise_and = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), greater}); + auto bitwise_and_1 = ov::pass::pattern::wrap_type({bitwise_and, ov::pass::pattern::any_input()}); + auto bitwise_and_2 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), bitwise_and_1}); + auto bitwise_and_3 = ov::pass::pattern::wrap_type({bitwise_and_2, ov::pass::pattern::any_input()}); + auto broadcast = ov::pass::pattern::wrap_type({bitwise_and_3, ov::pass::pattern::any_input()}); + auto select = ov::pass::pattern::wrap_type({broadcast, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto mask = ov::pass::pattern::wrap_type({select, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); return {mask, offset}; } // Exactly copied the function from another file. Maybe should be moved to some general file -static std::shared_ptr setName(std::shared_ptr node, const std::string& name) { +static std::shared_ptr setName(std::shared_ptr node, const std::string& name) { // Set name for both node and output tensor (should be only one tensor, and any other names will be overriden by a // given single name) node->set_friendly_name(name); @@ -244,20 +238,20 @@ typedef std:: node_tuple; static node_tuple kv_read_and_concat(ov::Output kv_current) { - auto kv_past_var = pattern::wrap_type({pattern::any_input()}); - auto kv_past_par = pattern::wrap_type(); - auto kv_past = std::make_shared( - OutputVector{pattern::wrap_type({kv_past_var, pattern::any_input(), pattern::any_input()}), + auto kv_past_var = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); + auto kv_past_par = ov::pass::pattern::wrap_type(); + auto kv_past = std::make_shared( + OutputVector{ov::pass::pattern::wrap_type({kv_past_var, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}), kv_past_par}); - kv_past = std::make_shared( + kv_past = std::make_shared( OutputVector{kv_past, - pattern::wrap_type( - {kv_past, pattern::any_input()})}); // Transpose is used when kv-cache is stored in a not + ov::pass::pattern::wrap_type( + {kv_past, ov::pass::pattern::any_input()})}); // Transpose is used when kv-cache is stored in a not // usual layout, example: bloom - auto kv_current2 = pattern::any_input(); - auto kv_current_reshaped = pattern::wrap_type({kv_current2, pattern::any_input()}); - auto kv_concat = pattern::wrap_type( - {kv_past, std::make_shared(OutputVector{kv_current_reshaped, kv_current})}); + auto kv_current2 = ov::pass::pattern::any_input(); + auto kv_current_reshaped = ov::pass::pattern::wrap_type({kv_current2, ov::pass::pattern::any_input()}); + auto kv_concat = ov::pass::pattern::wrap_type( + {kv_past, std::make_shared(OutputVector{kv_current_reshaped, kv_current})}); return node_tuple(kv_past_par, kv_current2, kv_current_reshaped, kv_concat); } @@ -318,11 +312,11 @@ ov::pass::StateManagementPattern::StateManagementPattern( const std::map>& optional_model_wide_params) { MATCHER_SCOPE(StateManagementPattern); - auto k_current = pattern::any_input(); + auto k_current = ov::pass::pattern::any_input(); std::shared_ptr k_past_par, k_current2, k_concat, k_current_reshaped; std::tie(k_past_par, k_current2, k_current_reshaped, k_concat) = kv_read_and_concat(k_current); - auto v_current = pattern::any_input(); + auto v_current = ov::pass::pattern::any_input(); std::shared_ptr v_past_par, v_current2, v_concat, v_current_reshaped; std::tie(v_past_par, v_current2, v_current_reshaped, v_concat) = kv_read_and_concat(v_current); @@ -332,35 +326,35 @@ ov::pass::StateManagementPattern::StateManagementPattern( // just sets more strict requirement for the graph. The risk with not specifying VariadicSplit is that it can be // ambiguous which part the matcher should take: KV merged part or where K and V are separate, requires experiments. auto qkv_current_split_node = - pattern::wrap_type({pattern::any_input(), pattern::any_input(), pattern::any_input()}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); qkv_current_split_node->set_output_size(2); auto kv_current = qkv_current_split_node->output(1); std::shared_ptr kv_past_par, kv_current2, kv_concat, kv_current_reshaped; std::tie(kv_past_par, kv_current2, kv_current_reshaped, kv_concat) = kv_read_and_concat(kv_current); auto kv_concat_split = - pattern::wrap_type({kv_concat, pattern::any_input(), pattern::any_input()}); + ov::pass::pattern::wrap_type({kv_concat, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); kv_concat_split->set_output_size(2); - k_concat = std::make_shared(OutputVector{kv_concat_split->output(0), k_concat}); - v_concat = std::make_shared(OutputVector{kv_concat_split->output(1), v_concat}); + k_concat = std::make_shared(OutputVector{kv_concat_split->output(0), k_concat}); + v_concat = std::make_shared(OutputVector{kv_concat_split->output(1), v_concat}); auto kv_shaping = [=](const std::shared_ptr& kv_concat, std::shared_ptr& unsqueeze) { // Return unsqeeze (return param) to deduce number of kv heads in // the place where they are being broadcases in case of GQA and MQ - auto interim = pattern::wrap_type( - {kv_concat, pattern::any_input(), pattern::any_input(), pattern::any_input()}); - interim = pattern::wrap_type( - {interim, pattern::any_input(), pattern::any_input(), pattern::any_input()}); - unsqueeze = pattern::wrap_type( - {std::make_shared(OutputVector{kv_concat, interim}), pattern::any_input()}); - interim = pattern::wrap_type( - {unsqueeze, pattern::any_input(), pattern::any_input(), pattern::any_input()}); - interim = pattern::wrap_type( - {interim, pattern::any_input(), pattern::any_input(), pattern::any_input()}); - interim = pattern::wrap_type( - {std::make_shared(OutputVector{unsqueeze, interim}), pattern::any_input()}); - interim = std::make_shared( - OutputVector{pattern::wrap_type({interim, pattern::any_input()}), + auto interim = ov::pass::pattern::wrap_type( + {kv_concat, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + interim = ov::pass::pattern::wrap_type( + {interim, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + unsqueeze = ov::pass::pattern::wrap_type( + {std::make_shared(OutputVector{kv_concat, interim}), ov::pass::pattern::any_input()}); + interim = ov::pass::pattern::wrap_type( + {unsqueeze, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + interim = ov::pass::pattern::wrap_type( + {interim, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + interim = ov::pass::pattern::wrap_type( + {std::make_shared(OutputVector{unsqueeze, interim}), ov::pass::pattern::any_input()}); + interim = std::make_shared( + OutputVector{ov::pass::pattern::wrap_type({interim, ov::pass::pattern::any_input()}), interim}); // Reshape is missing sometimes in MQA case return interim; }; @@ -370,17 +364,17 @@ ov::pass::StateManagementPattern::StateManagementPattern( auto k_shaped = kv_shaping(k_concat, k_heads_unsqueeze); auto v_shaped = kv_shaping(v_concat, v_heads_unsqueeze); - auto k_simply_shaped = pattern::wrap_type({k_concat, pattern::any_input()}); - auto v_simply_shaped = pattern::wrap_type({v_concat, pattern::any_input()}); + auto k_simply_shaped = ov::pass::pattern::wrap_type({k_concat, ov::pass::pattern::any_input()}); + auto v_simply_shaped = ov::pass::pattern::wrap_type({v_concat, ov::pass::pattern::any_input()}); - auto k_order = pattern::any_input(); - auto v_order = pattern::any_input(); + auto k_order = ov::pass::pattern::any_input(); + auto v_order = ov::pass::pattern::any_input(); // KV-path may already have Transposes that will be rewritten based on PA KV inputs required layout - auto k_shaped_transposed = pattern::wrap_type( - {std::make_shared(OutputVector{k_concat, k_shaped}), k_order}); - auto v_shaped_transposed = pattern::wrap_type( - {std::make_shared(OutputVector{v_concat, v_shaped}), v_order}); + auto k_shaped_transposed = ov::pass::pattern::wrap_type( + {std::make_shared(OutputVector{k_concat, k_shaped}), k_order}); + auto v_shaped_transposed = ov::pass::pattern::wrap_type( + {std::make_shared(OutputVector{v_concat, v_shaped}), v_order}); // Optional pattern to capture alibi slopes (based on pattern from bloom) std::shared_ptr general_alibi, general_alibi_mask; @@ -408,31 +402,31 @@ ov::pass::StateManagementPattern::StateManagementPattern( (output.get_partial_shape() == ov::PartialShape{1} && output.get_partial_shape()[0] == 1); }; - auto q = pattern::any_input(); - auto scale_input = pattern::any_input(scale_predicate); - auto sinks = pattern::any_input(pattern::has_static_shape() && pattern::rank_equals(4)); + auto q = ov::pass::pattern::any_input(); + auto scale_input = ov::pass::pattern::any_input(scale_predicate); + auto sinks = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape() && ov::pass::pattern::rank_equals(4)); auto k_to_sdpa = - std::make_shared(OutputVector{k_concat, k_shaped, k_shaped_transposed, k_simply_shaped}); + std::make_shared(OutputVector{k_concat, k_shaped, k_shaped_transposed, k_simply_shaped}); auto v_to_sdpa = - std::make_shared(OutputVector{v_concat, v_shaped, v_shaped_transposed, v_simply_shaped}); + std::make_shared(OutputVector{v_concat, v_shaped, v_shaped_transposed, v_simply_shaped}); - auto mask_to_sdpa = std::make_shared(OutputVector{phi3_mask, + auto mask_to_sdpa = std::make_shared(OutputVector{phi3_mask, general_alibi_mask, jais_alibi_mask, baichuan2_13b_alibi_mask, gpt_oss_mask, - pattern::any_input()}); + ov::pass::pattern::any_input()}); auto sdpa_with_4_inputs = - pattern::wrap_type({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa}); + ov::pass::pattern::wrap_type({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa}); auto sdpa_with_5_inputs = - pattern::wrap_type({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa, scale_input}); + ov::pass::pattern::wrap_type({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa, scale_input}); auto sdpa_with_6_inputs = - pattern::wrap_type({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa, scale_input, sinks}); + ov::pass::pattern::wrap_type({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa, scale_input, sinks}); auto sdpa_variants = - std::make_shared(OutputVector{sdpa_with_4_inputs, sdpa_with_5_inputs, sdpa_with_6_inputs}); + std::make_shared(OutputVector{sdpa_with_4_inputs, sdpa_with_5_inputs, sdpa_with_6_inputs}); ov::matcher_pass_callback callback = [=, &kv_parameters, @@ -473,19 +467,19 @@ ov::pass::StateManagementPattern::StateManagementPattern( auto num_v_heads = num_v_heads_dim.get_length(); std::string layer_index_str = std::to_string(layer_index); - auto k_parameter = setName(std::make_shared(element::dynamic, ov::PartialShape::dynamic(4)), + auto k_parameter = setName(std::make_shared(element::dynamic, ov::PartialShape::dynamic(4)), "key_cache." + layer_index_str); - auto v_parameter = setName(std::make_shared(element::dynamic, ov::PartialShape::dynamic(4)), + auto v_parameter = setName(std::make_shared(element::dynamic, ov::PartialShape::dynamic(4)), "value_cache." + layer_index_str); layer_index += 1; kv_parameters.push_back(k_parameter); kv_parameters.push_back(v_parameter); - auto kv_transpose_order = v0::Constant::create(element::i64, Shape{4}, {0, 2, 1, 3}); + auto kv_transpose_order = ov::op::v0::Constant::create(element::i64, Shape{4}, {0, 2, 1, 3}); - auto q_transpose = std::make_shared(real_q, kv_transpose_order); + auto q_transpose = std::make_shared(real_q, kv_transpose_order); auto q_reshape = - std::make_shared(q_transpose, v0::Constant::create(element::i64, Shape{2}, {0, -1}), true); + std::make_shared(q_transpose, ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -1}), true); ov::Output k_target_layout, v_target_layout; if (pattern_map.count(qkv_current_split_node)) { @@ -529,32 +523,32 @@ ov::pass::StateManagementPattern::StateManagementPattern( if (pattern_map.find(k_order) != pattern_map .end()) { // reapply transpose found in the graph by manipulating of indices of our Transpose - k_transpose_order = std::make_shared(pattern_map.at(k_order), + k_transpose_order = std::make_shared(pattern_map.at(k_order), kv_transpose_order, - v0::Constant::create(element::i64, Shape{}, {0})); + ov::op::v0::Constant::create(element::i64, Shape{}, {0})); } - k_target_layout = std::make_shared(real_k, k_transpose_order); + k_target_layout = std::make_shared(real_k, k_transpose_order); std::shared_ptr v_transpose_order = kv_transpose_order; if (pattern_map.find(v_order) != pattern_map .end()) { // reapply transpose found in the graph by manipulating of indices of our Transpose - v_transpose_order = std::make_shared(pattern_map.at(v_order), + v_transpose_order = std::make_shared(pattern_map.at(v_order), kv_transpose_order, - v0::Constant::create(element::i64, Shape{}, {0})); + ov::op::v0::Constant::create(element::i64, Shape{}, {0})); } - v_target_layout = std::make_shared(real_v, v_transpose_order); + v_target_layout = std::make_shared(real_v, v_transpose_order); } auto k_reshape = - std::make_shared(k_target_layout, v0::Constant::create(element::i64, Shape{2}, {0, -1}), true); + std::make_shared(k_target_layout, ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -1}), true); auto v_reshape = - std::make_shared(v_target_layout, v0::Constant::create(element::i64, Shape{2}, {0, -1}), true); + std::make_shared(v_target_layout, ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -1}), true); std::shared_ptr scale; if (pattern_map.count(scale_input)) { scale = pattern_map.at(scale_input).get_node_shared_ptr(); if (pattern_map.at(scale_input).get_partial_shape().rank() != 0) { - scale = std::make_shared(scale); + scale = std::make_shared(scale); } } else { auto real_q_ps = real_q.get_partial_shape(); @@ -562,18 +556,18 @@ ov::pass::StateManagementPattern::StateManagementPattern( bool rank_is_static = real_q_ps.rank().is_static(); if (rank_is_static && real_q_ps[real_q_ps.rank().get_length() - 1].is_static()) { auto hidden_dim_len = static_cast(real_q_ps[real_q_ps.rank().get_length() - 1].get_length()); - scale = v0::Constant::create(element::f32, Shape{}, {1.0 / std::sqrt(hidden_dim_len)}); + scale = ov::op::v0::Constant::create(element::f32, Shape{}, {1.0 / std::sqrt(hidden_dim_len)}); } else { // most likely `scale` below will always be a constant in real inference, but dynamic dimension // propagation may not always derive it as a constant. That's why a sub-graph computing `scale` is built // instead of just a constant node representing one of the dimensions. - auto hidden_shape = std::make_shared(real_q); - auto hidden_dim = std::make_shared(hidden_shape, - v0::Constant::create(element::i64, Shape{}, {-1}), - v0::Constant::create(element::i64, Shape{}, {0})); - scale = std::make_shared( - v0::Constant::create(element::f32, Shape{}, {1}), - std::make_shared(std::make_shared(hidden_dim, element::f32))); + auto hidden_shape = std::make_shared(real_q); + auto hidden_dim = std::make_shared(hidden_shape, + ov::op::v0::Constant::create(element::i64, Shape{}, {-1}), + ov::op::v0::Constant::create(element::i64, Shape{}, {0})); + scale = std::make_shared( + ov::op::v0::Constant::create(element::f32, Shape{}, {1}), + std::make_shared(std::make_shared(hidden_dim, element::f32))); } } @@ -585,7 +579,7 @@ ov::pass::StateManagementPattern::StateManagementPattern( } else if (pattern_map.find(baichuan2_13b_alibi) != pattern_map.end()) { alibi_slopes = handle_baichuan2_13b_alibi(pattern_map.at(baichuan2_13b_alibi).get_node_shared_ptr()); } else { - alibi_slopes = v0::Constant::create(element::f32, Shape{0}, {}); + alibi_slopes = ov::op::v0::Constant::create(element::f32, Shape{0}, {}); } OutputVector pa_arguments = {q_reshape, k_reshape, v_reshape, k_parameter, v_parameter}; @@ -595,20 +589,20 @@ ov::pass::StateManagementPattern::StateManagementPattern( if (pattern_map.count(phi3_offset)) { auto offset = pattern_map.at(phi3_offset).get_node_shared_ptr(); if (offset->get_element_type() != element::i32) { - offset = std::make_shared(offset, element::i32); + offset = std::make_shared(offset, element::i32); } - sliding_window = std::make_shared(v0::Constant::create(element::i32, Shape{}, {2}), offset); + sliding_window = std::make_shared(ov::op::v0::Constant::create(element::i32, Shape{}, {2}), offset); } else if (pattern_map.count(gpt_oss_offset)) { auto offset = pattern_map.at(gpt_oss_offset).get_node_shared_ptr(); if (pattern_map.at(gpt_oss_offset).get_partial_shape().rank() != 0) { - offset = std::make_shared(offset); + offset = std::make_shared(offset); } if (offset->get_element_type() != element::i32) { - offset = std::make_shared(offset, element::i32); + offset = std::make_shared(offset, element::i32); } - sliding_window = std::make_shared(offset, v0::Constant::create(element::i32, Shape{}, {-1})); + sliding_window = std::make_shared(offset, ov::op::v0::Constant::create(element::i32, Shape{}, {-1})); } else { - sliding_window = v0::Constant::create(element::i32, Shape{}, {0}); + sliding_window = ov::op::v0::Constant::create(element::i32, Shape{}, {0}); } std::initializer_list> additional_params = {scale, @@ -618,7 +612,7 @@ ov::pass::StateManagementPattern::StateManagementPattern( pa_arguments.insert(pa_arguments.end(), additional_params.begin(), additional_params.end()); if (use_per_layer_block_indices_inputs) { - auto block_indices = setName(std::make_shared(element::i32, PartialShape{-1}), + auto block_indices = setName(std::make_shared(element::i32, PartialShape{-1}), "block_indices." + std::to_string(layer_index - 1)); pa_arguments.insert(pa_arguments.begin() + 7, block_indices); block_indices_inputs_for_each_layer.push_back(block_indices); @@ -631,7 +625,7 @@ ov::pass::StateManagementPattern::StateManagementPattern( "an additional input (Parameter) called score_aggregation_window."); pa_arguments.insert(pa_arguments.end(), optional_model_wide_params.at("score_aggregation_window")); } else { - pa_arguments.insert(pa_arguments.end(), v0::Constant::create(element::i32, Shape{0}, {})); + pa_arguments.insert(pa_arguments.end(), ov::op::v0::Constant::create(element::i32, Shape{0}, {})); } OPENVINO_ASSERT(pa_arguments.size() == 14); @@ -640,9 +634,9 @@ ov::pass::StateManagementPattern::StateManagementPattern( optional_model_wide_params.find("model_rotation_trig_lut") != optional_model_wide_params.end(), "No model_rotation_trig_lut input found. For using cache rotation, the model have to contain " "an additional input (Parameter) called model_rotation_trig_lut."); - auto rotated_block_indices = setName(std::make_shared(element::i32, PartialShape{-1}), + auto rotated_block_indices = setName(std::make_shared(element::i32, PartialShape{-1}), "rotated_block_indices." + std::to_string(layer_index - 1)); - auto rotation_deltas = setName(std::make_shared(element::i32, PartialShape{-1, -1}), + auto rotation_deltas = setName(std::make_shared(element::i32, PartialShape{-1, -1}), "rotation_deltas." + std::to_string(layer_index - 1)); pa_arguments.insert(pa_arguments.begin() + 14, rotated_block_indices); @@ -652,11 +646,11 @@ ov::pass::StateManagementPattern::StateManagementPattern( rotated_block_indices_inputs_for_each_layer.push_back(rotated_block_indices); rotation_deltas_inputs_for_each_layer.push_back(rotation_deltas); } else { - auto rotated_block_indices = v0::Constant::create(element::i32, Shape{0}, {}); - auto rotation_deltas = v0::Constant::create(element::i32, Shape{0}, {}); + auto rotated_block_indices = ov::op::v0::Constant::create(element::i32, Shape{0}, {}); + auto rotation_deltas = ov::op::v0::Constant::create(element::i32, Shape{0}, {}); pa_arguments.insert(pa_arguments.begin() + 14, rotated_block_indices); pa_arguments.insert(pa_arguments.begin() + 15, rotation_deltas); - pa_arguments.insert(pa_arguments.begin() + 16, v0::Constant::create(element::f32, Shape{0}, {})); + pa_arguments.insert(pa_arguments.begin() + 16, ov::op::v0::Constant::create(element::f32, Shape{0}, {})); } OPENVINO_ASSERT(pa_arguments.size() == 17); @@ -668,17 +662,17 @@ ov::pass::StateManagementPattern::StateManagementPattern( OPENVINO_ASSERT(optional_model_wide_params.find("xattention_stride") != optional_model_wide_params.end(), "No xattention_stride input found. For using XAttention, the model have to contain " "an additional input (Parameter) called xattention_stride."); - auto xattention_threshold = setName(std::make_shared(element::f32, PartialShape{-1}), + auto xattention_threshold = setName(std::make_shared(element::f32, PartialShape{-1}), "xattention_threshold." + std::to_string(layer_index - 1)); pa_arguments.insert(pa_arguments.begin() + 17, xattention_threshold); pa_arguments.insert(pa_arguments.begin() + 18, optional_model_wide_params.at("xattention_block_size")); pa_arguments.insert(pa_arguments.begin() + 19, optional_model_wide_params.at("xattention_stride")); xattention_threshold_inputs_for_each_layer.push_back(xattention_threshold); } else { - auto xattention_threshold = v0::Constant::create(element::f32, Shape{0}, {}); + auto xattention_threshold = ov::op::v0::Constant::create(element::f32, Shape{0}, {}); pa_arguments.insert(pa_arguments.begin() + 17, xattention_threshold); - pa_arguments.insert(pa_arguments.begin() + 18, v0::Constant::create(element::i32, Shape{}, {0})); - pa_arguments.insert(pa_arguments.begin() + 19, v0::Constant::create(element::i32, Shape{}, {0})); + pa_arguments.insert(pa_arguments.begin() + 18, ov::op::v0::Constant::create(element::i32, Shape{}, {0})); + pa_arguments.insert(pa_arguments.begin() + 19, ov::op::v0::Constant::create(element::i32, Shape{}, {0})); } // For now we haven't seen sinks in any other model than gpt-oss, so taking -3 is generally safe @@ -689,11 +683,11 @@ ov::pass::StateManagementPattern::StateManagementPattern( pa_arguments.insert(pa_arguments.begin() + 20, sinks_val.get_node_shared_ptr()); } else { pa_arguments.insert(pa_arguments.begin() + 20, - v0::Constant::create(real_q.get_element_type(), Shape{0, 0, 0, 0}, {})); + ov::op::v0::Constant::create(real_q.get_element_type(), Shape{0, 0, 0, 0}, {})); } } else { pa_arguments.insert(pa_arguments.begin() + 20, - v0::Constant::create(real_q.get_element_type(), Shape{0, 0, 0, 0}, {})); + ov::op::v0::Constant::create(real_q.get_element_type(), Shape{0, 0, 0, 0}, {})); } OPENVINO_ASSERT(pa_arguments.size() == 21); @@ -706,22 +700,22 @@ ov::pass::StateManagementPattern::StateManagementPattern( // The output shape of PagedAttention will be converted to [batch, 1, head_num, head_size_v], the head_size_v // may be different from head_size_q/head_size_k. The head_size_v could be got from the shape of value input - auto hidden_dim_v = std::make_shared(std::make_shared(v_target_layout), - v0::Constant::create(element::i64, Shape{}, {-1}), - v0::Constant::create(element::i64, Shape{}, {0})); + auto hidden_dim_v = std::make_shared(std::make_shared(v_target_layout), + ov::op::v0::Constant::create(element::i64, Shape{}, {-1}), + ov::op::v0::Constant::create(element::i64, Shape{}, {0})); - auto pa_shape = std::make_shared( + auto pa_shape = std::make_shared( OutputVector{ - v0::Constant::create(element::i64, Shape{1}, {0}), - v0::Constant::create(element::i64, Shape{1}, {1}), - v0::Constant::create(element::i64, Shape{1}, {-1}), - std::make_shared(hidden_dim_v, v0::Constant::create(element::i64, Shape{}, {0})), + ov::op::v0::Constant::create(element::i64, Shape{1}, {0}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {-1}), + std::make_shared(hidden_dim_v, ov::op::v0::Constant::create(element::i64, Shape{}, {0})), }, 0); - auto pa_reshape = std::make_shared(paged_attention->output(0), pa_shape, true); - auto pa_transpose = std::make_shared(pa_reshape, kv_transpose_order); + auto pa_reshape = std::make_shared(paged_attention->output(0), pa_shape, true); + auto pa_transpose = std::make_shared(pa_reshape, kv_transpose_order); if (use_score_outputs) { - auto score_result = std::make_shared(paged_attention->output(1)); + auto score_result = std::make_shared(paged_attention->output(1)); score_result->get_output_tensor(0).set_names({"scores." + std::to_string(layer_index - 1)}); score_results.push_back(score_result); } @@ -735,7 +729,7 @@ ov::pass::StateManagementPattern::StateManagementPattern( // add_kv_parameter(mapping[v_gather]) if (pattern_map.find(v_past_par) != pattern_map.end()) { - auto param = ov::as_type_ptr(pattern_map.at(v_past_par).get_node_shared_ptr()); + auto param = ov::as_type_ptr(pattern_map.at(v_past_par).get_node_shared_ptr()); if (param) { return false; } @@ -743,7 +737,7 @@ ov::pass::StateManagementPattern::StateManagementPattern( } if (pattern_map.find(k_past_par) != pattern_map.end()) { - auto param = ov::as_type_ptr(pattern_map.at(k_past_par).get_node_shared_ptr()); + auto param = ov::as_type_ptr(pattern_map.at(k_past_par).get_node_shared_ptr()); if (param) { return false; } diff --git a/src/common/transformations/src/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.cpp b/src/common/transformations/src/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.cpp index 8efed4b772d3db..1f53ac65b13212 100644 --- a/src/common/transformations/src/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.cpp +++ b/src/common/transformations/src/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.cpp @@ -18,17 +18,13 @@ #include "openvino/pass/pattern/op/optional.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" #include "transformations/utils/utils.hpp" - -using namespace ov::op; -using namespace ov::pass::pattern; - namespace { void align_replacement(std::shared_ptr& replacement, const ov::PartialShape& required_shape, ov::element::Type target_type) { if (replacement->get_output_element_type(0) != target_type) { - replacement = std::make_shared(replacement, target_type); + replacement = std::make_shared(replacement, target_type); } if (replacement->get_output_partial_shape(0) != required_shape && required_shape.rank().is_static()) { @@ -42,22 +38,22 @@ ov::pass::TotalSequenceLengthPattern::TotalSequenceLengthPattern( const std::shared_ptr& max_context_len) { MATCHER_SCOPE(TotalSequenceLengthPattern); - auto kv_past = wrap_type({any_input()}); - auto kv_gather = wrap_type({kv_past, any_input(), any_input()}); - auto kv_current = any_input(); - auto kv_concat = wrap_type({kv_gather, kv_current}); - auto kv_shape = wrap_type({kv_concat}); - auto gather_idx_label = wrap_type(); - auto seq = wrap_type({kv_shape, gather_idx_label, any_input()}); + auto kv_past = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); + auto kv_gather = ov::pass::pattern::wrap_type({kv_past, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto kv_current = ov::pass::pattern::any_input(); + auto kv_concat = ov::pass::pattern::wrap_type({kv_gather, kv_current}); + auto kv_shape = ov::pass::pattern::wrap_type({kv_concat}); + auto gather_idx_label = ov::pass::pattern::wrap_type(); + auto seq = ov::pass::pattern::wrap_type({kv_shape, gather_idx_label, ov::pass::pattern::any_input()}); - ov::matcher_pass_callback callback = [=](Matcher& m) { + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { // TODO: Check that seq has axis that really takes sequence len but not any other dimension -- // use symbolic infra or look at the constant input const auto& pattern_map = m.get_pattern_value_map(); - auto concat = ov::as_type_ptr(pattern_map.at(kv_concat).get_node_shared_ptr()); + auto concat = ov::as_type_ptr(pattern_map.at(kv_concat).get_node_shared_ptr()); auto gather = pattern_map.at(seq).get_node_shared_ptr(); - auto gather_idx = ov::as_type_ptr(pattern_map.at(gather_idx_label).get_node_shared_ptr()); + auto gather_idx = ov::as_type_ptr(pattern_map.at(gather_idx_label).get_node_shared_ptr()); if (!concat || !gather || !gather_idx || !gather_idx) { return false; @@ -110,7 +106,7 @@ ov::pass::TotalSequenceLengthPattern::TotalSequenceLengthPattern( return true; }; - auto m = std::make_shared(seq, matcher_name); + auto m = std::make_shared(seq, matcher_name); register_matcher(m, callback); } @@ -118,21 +114,21 @@ ov::pass::TotalSequenceLengthPatternQwen::TotalSequenceLengthPatternQwen( const std::shared_ptr& max_context_len) { MATCHER_SCOPE(TotalSequenceLengthPatternQwen); - auto p_input_ids = wrap_type(); - auto p_unsqueeze = wrap_type({p_input_ids, any_input()}); - auto p_opt_reshape_1 = optional({p_unsqueeze, any_input()}); - auto p_opt_convert_1 = optional(p_opt_reshape_1); - auto p_kv_shape_current = wrap_type({p_opt_convert_1}); - auto p_seq_current = wrap_type({p_kv_shape_current, any_input(), any_input()}); - auto p_opt_convert_2 = optional(p_seq_current); - - auto p_max_context_len = wrap_type(); - auto p_prev_max_seq_len = wrap_type({p_max_context_len, any_input()}); - auto p_opt_convert_3 = optional(p_prev_max_seq_len); - auto p_opt_reshape_2 = optional({p_opt_convert_3, any_input()}); - auto p_total_seq = wrap_type({p_opt_convert_2, p_opt_reshape_2}); - - ov::matcher_pass_callback callback = [=](Matcher& m) { + auto p_input_ids = ov::pass::pattern::wrap_type(); + auto p_unsqueeze = ov::pass::pattern::wrap_type({p_input_ids, ov::pass::pattern::any_input()}); + auto p_opt_reshape_1 = ov::pass::pattern::optional({p_unsqueeze, ov::pass::pattern::any_input()}); + auto p_opt_convert_1 = ov::pass::pattern::optional(p_opt_reshape_1); + auto p_kv_shape_current = ov::pass::pattern::wrap_type({p_opt_convert_1}); + auto p_seq_current = ov::pass::pattern::wrap_type({p_kv_shape_current, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto p_opt_convert_2 = ov::pass::pattern::optional(p_seq_current); + + auto p_max_context_len = ov::pass::pattern::wrap_type(); + auto p_prev_max_seq_len = ov::pass::pattern::wrap_type({p_max_context_len, ov::pass::pattern::any_input()}); + auto p_opt_convert_3 = ov::pass::pattern::optional(p_prev_max_seq_len); + auto p_opt_reshape_2 = ov::pass::pattern::optional({p_opt_convert_3, ov::pass::pattern::any_input()}); + auto p_total_seq = ov::pass::pattern::wrap_type({p_opt_convert_2, p_opt_reshape_2}); + + ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto total_seq = pattern_map.at(p_total_seq).get_node_shared_ptr(); std::shared_ptr replacement = max_context_len; @@ -145,7 +141,7 @@ ov::pass::TotalSequenceLengthPatternQwen::TotalSequenceLengthPatternQwen( return true; }; - auto m = std::make_shared(p_total_seq, matcher_name); + auto m = std::make_shared(p_total_seq, matcher_name); register_matcher(m, callback); } @@ -153,16 +149,16 @@ ov::pass::TotalSequenceLengthPatternCodeGen2::TotalSequenceLengthPatternCodeGen2 const std::shared_ptr& max_context_len) { MATCHER_SCOPE(TotalSequenceLengthPatternCodeGen2); - auto p_max_context_len = wrap_type(); - auto p_sub = wrap_type({p_max_context_len, any_input()}); - auto p_conv = wrap_type({p_sub}); + auto p_max_context_len = ov::pass::pattern::wrap_type(); + auto p_sub = ov::pass::pattern::wrap_type({p_max_context_len, ov::pass::pattern::any_input()}); + auto p_conv = ov::pass::pattern::wrap_type({p_sub}); - auto p_var_split = wrap_type({any_input(), any_input(), any_input()}); - auto p_kv_shape_current = wrap_type({p_var_split}); - auto p_gather = wrap_type({p_kv_shape_current, any_input(), any_input()}); - auto p_total_seq = wrap_type({p_gather, p_conv}); + auto p_var_split = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto p_kv_shape_current = ov::pass::pattern::wrap_type({p_var_split}); + auto p_gather = ov::pass::pattern::wrap_type({p_kv_shape_current, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto p_total_seq = ov::pass::pattern::wrap_type({p_gather, p_conv}); - matcher_pass_callback callback = [=, &max_context_len](Matcher& m) { + matcher_pass_callback callback = [=, &max_context_len](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto total_seq = pattern_map.at(p_total_seq).get_node_shared_ptr(); std::shared_ptr replacement = max_context_len; @@ -175,6 +171,6 @@ ov::pass::TotalSequenceLengthPatternCodeGen2::TotalSequenceLengthPatternCodeGen2 return true; }; - auto m = std::make_shared(p_total_seq, matcher_name); + auto m = std::make_shared(p_total_seq, matcher_name); register_matcher(m, callback); } \ No newline at end of file diff --git a/src/common/transformations/src/transformations/smart_reshape/broadcast_const_range_replacement.cpp b/src/common/transformations/src/transformations/smart_reshape/broadcast_const_range_replacement.cpp index 85b868f60ea626..5070322af80a57 100644 --- a/src/common/transformations/src/transformations/smart_reshape/broadcast_const_range_replacement.cpp +++ b/src/common/transformations/src/transformations/smart_reshape/broadcast_const_range_replacement.cpp @@ -22,11 +22,11 @@ ov::pass::BroadcastConstRangeReplacement::BroadcastConstRangeReplacement() { MATCHER_SCOPE(BroadcastConstRangeReplacement); - auto data_input = pattern::wrap_type(); - auto target_shape = pattern::any_input(); - auto broadcast_pattern_node = pattern::wrap_type({data_input, target_shape}); + auto data_input = ov::pass::pattern::wrap_type(); + auto target_shape = ov::pass::pattern::any_input(); + auto broadcast_pattern_node = ov::pass::pattern::wrap_type({data_input, target_shape}); - matcher_pass_callback callback = [=](pattern::Matcher& m) { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto broadcast = m.get_match_root(); // The transformation was requested only for models with BroadcastType::BIDIRECTIONAL // Further analysis is needed for other broadcast modes enablement diff --git a/src/common/transformations/src/transformations/smart_reshape/matmul_sr.cpp b/src/common/transformations/src/transformations/smart_reshape/matmul_sr.cpp index ad2c7ea7afb77c..fc8abe3f602087 100644 --- a/src/common/transformations/src/transformations/smart_reshape/matmul_sr.cpp +++ b/src/common/transformations/src/transformations/smart_reshape/matmul_sr.cpp @@ -66,9 +66,9 @@ bool relax_hc_reshape_followed_by_matmul(const ov::pass::pattern::PatternValueMa ov::pass::ReshapeAMatMul::ReshapeAMatMul() { MATCHER_SCOPE(ReshapeAMatMul); - auto other_input_label = pattern::any_input(ov::pass::pattern::has_static_rank()); - auto reshape_input_label = pattern::any_input(); - auto reshape_pattern_label = pattern::any_input(); + auto other_input_label = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto reshape_input_label = ov::pass::pattern::any_input(); + auto reshape_pattern_label = ov::pass::pattern::any_input(); auto reshape_predicate = [](ov::Output output) -> bool { return ov::pass::pattern::rank_equals(2)(output) && ov::pass::pattern::consumers_count(1)(output); }; @@ -76,7 +76,7 @@ ov::pass::ReshapeAMatMul::ReshapeAMatMul() { reshape_predicate); auto matmul_label = ov::pass::pattern::wrap_type({reshape_label, other_input_label}); - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); return relax_hc_reshape_followed_by_matmul(pattern_to_output, matmul_label, @@ -91,9 +91,9 @@ ov::pass::ReshapeAMatMul::ReshapeAMatMul() { ov::pass::ReshapeBMatMul::ReshapeBMatMul() { MATCHER_SCOPE(ReshapeBMatMul); - auto other_input_label = pattern::any_input(ov::pass::pattern::has_static_rank()); - auto reshape_input_label = pattern::any_input(); - auto reshape_pattern_label = pattern::any_input(); + auto other_input_label = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto reshape_input_label = ov::pass::pattern::any_input(); + auto reshape_pattern_label = ov::pass::pattern::any_input(); auto reshape_predicate = [](ov::Output output) -> bool { return ov::pass::pattern::rank_equals(2)(output) && ov::pass::pattern::consumers_count(1)(output); }; @@ -101,7 +101,7 @@ ov::pass::ReshapeBMatMul::ReshapeBMatMul() { reshape_predicate); auto matmul_label = ov::pass::pattern::wrap_type({other_input_label, reshape_label}); - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); return relax_hc_reshape_followed_by_matmul(pattern_to_output, matmul_label, @@ -118,7 +118,7 @@ ov::pass::TransposeMatMul::TransposeMatMul() { MATCHER_SCOPE(TransposeMatMul); auto matmul_label = ov::pass::pattern::wrap_type(); - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { const auto& pattern_to_output = m.get_pattern_value_map(); auto matmul = ov::as_type_ptr(pattern_to_output.at(matmul_label).get_node_shared_ptr()); if (!matmul) diff --git a/src/common/transformations/src/transformations/smart_reshape/proposal_scales_stridedslice.cpp b/src/common/transformations/src/transformations/smart_reshape/proposal_scales_stridedslice.cpp index b0fd8a76e8c4de..4071d31cdb1cd0 100644 --- a/src/common/transformations/src/transformations/smart_reshape/proposal_scales_stridedslice.cpp +++ b/src/common/transformations/src/transformations/smart_reshape/proposal_scales_stridedslice.cpp @@ -47,16 +47,16 @@ ov::pass::Proposal1Scales::Proposal1Scales() { (shape[1].get_length() == 3 || shape[1].get_length() == 4); }); - auto optional_convert = pattern::optional(parameter_label); + auto optional_convert = ov::pass::pattern::optional(parameter_label); auto reshape_label = ov::pass::pattern::wrap_type( {optional_convert, ov::pass::pattern::wrap_type()}, [](const Output& output) { return output.get_partial_shape().rank().is_static() && output.get_partial_shape().rank().get_length() == 1; }); auto proposal_label = - ov::pass::pattern::wrap_type({pattern::any_input(), pattern::any_input(), reshape_label}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), reshape_label}); - matcher_pass_callback callback = [parameter_label, proposal_label](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [parameter_label, proposal_label](ov::pass::pattern::Matcher& m) -> bool { return crop_scales_for_proposal(m.get_pattern_value_map(), parameter_label, proposal_label); }; auto m = std::make_shared(proposal_label /*, matcher_name */); @@ -78,9 +78,9 @@ ov::pass::Proposal4Scales::Proposal4Scales() { return output.get_partial_shape().rank().is_static() && output.get_partial_shape().rank().get_length() == 1; }); auto proposal_label = - ov::pass::pattern::wrap_type({pattern::any_input(), pattern::any_input(), reshape_label}); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), reshape_label}); - matcher_pass_callback callback = [parameter_label, proposal_label](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [parameter_label, proposal_label](ov::pass::pattern::Matcher& m) -> bool { return crop_scales_for_proposal(m.get_pattern_value_map(), parameter_label, proposal_label); }; auto m = std::make_shared(proposal_label /*, matcher_name */); diff --git a/src/common/transformations/src/transformations/smart_reshape/reshape_sinking.cpp b/src/common/transformations/src/transformations/smart_reshape/reshape_sinking.cpp index 200d52fe47dc55..4975da7e269257 100644 --- a/src/common/transformations/src/transformations/smart_reshape/reshape_sinking.cpp +++ b/src/common/transformations/src/transformations/smart_reshape/reshape_sinking.cpp @@ -28,25 +28,25 @@ ov::pass::ReshapeSinkingMatMul::ReshapeSinkingMatMul() { * Reshape output_pattern=(B=1, S, O) Reshape output_pattern=(0, S, O) * | shape=[1, S, O] | shape=[B, S, O] */ - auto any_input = pattern::any_input(pattern::has_static_rank()); + auto any_input = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); auto reshape_label = ov::pass::pattern::wrap_type( - {pattern::any_input(), ov::pass::pattern::wrap_type()}, - pattern::rank_equals(2)); + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(2)); auto matmul_label = ov::pass::pattern::wrap_type( {reshape_label, ov::pass::pattern::wrap_type()}, - pattern::rank_equals(2)); + ov::pass::pattern::rank_equals(2)); auto add_label = ov::pass::pattern::wrap_type( {matmul_label, ov::pass::pattern::wrap_type()}, - pattern::rank_equals(2)); + ov::pass::pattern::rank_equals(2)); - auto matmul_or_matmul_add_label = make_shared(OutputVector{add_label, matmul_label}); + auto matmul_or_matmul_add_label = make_shared(OutputVector{add_label, matmul_label}); auto reshape_1_label = ov::pass::pattern::wrap_type( {matmul_or_matmul_add_label, ov::pass::pattern::wrap_type()}, - pattern::has_static_rank()); + ov::pass::pattern::has_static_rank()); - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { auto pattern_to_node = m.get_pattern_map(); // check first Reshape eligibility: has a constant output pattern in a form of [-1, K] diff --git a/src/common/transformations/src/transformations/smart_reshape/reshape_to_1D.cpp b/src/common/transformations/src/transformations/smart_reshape/reshape_to_1D.cpp index 15d0ddb672fb30..31215c9cd1f5f0 100644 --- a/src/common/transformations/src/transformations/smart_reshape/reshape_to_1D.cpp +++ b/src/common/transformations/src/transformations/smart_reshape/reshape_to_1D.cpp @@ -15,12 +15,12 @@ ov::pass::ReshapeTo1D::ReshapeTo1D() { // TODO: enable conditional compile // MATCHER_SCOPE(ReshapeTo1D); auto reshape_label = ov::pass::pattern::wrap_type( - {pattern::any_input(), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, [](const Output& output) { return output.get_partial_shape().rank().is_static() && output.get_partial_shape().rank().get_length() == 1; }); - matcher_pass_callback callback = [](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) -> bool { m.get_match_root()->input(1).replace_source_output(ov::op::v0::Constant::create(ov::element::i64, {1}, {-1})); return true; }; diff --git a/src/common/transformations/src/transformations/smart_reshape/shape_of_const_folding.cpp b/src/common/transformations/src/transformations/smart_reshape/shape_of_const_folding.cpp index 9dae1ea47935c7..2ad6fdef08c287 100644 --- a/src/common/transformations/src/transformations/smart_reshape/shape_of_const_folding.cpp +++ b/src/common/transformations/src/transformations/smart_reshape/shape_of_const_folding.cpp @@ -14,10 +14,10 @@ ov::pass::ShapeOfConstFolding::ShapeOfConstFolding() { MATCHER_SCOPE(ShapeOfConstFolding); - auto constant_label = pattern::wrap_type(); - auto shape_of_label = pattern::wrap_type({constant_label}); + auto constant_label = ov::pass::pattern::wrap_type(); + auto shape_of_label = ov::pass::pattern::wrap_type({constant_label}); - matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) -> bool { auto node = m.get_match_root(); if (auto constant = ov::util::get_constant_from_source(node)) { constant->set_friendly_name(node->get_friendly_name()); @@ -29,6 +29,6 @@ ov::pass::ShapeOfConstFolding::ShapeOfConstFolding() { return false; }; - auto m = std::make_shared(shape_of_label, matcher_name); + auto m = std::make_shared(shape_of_label, matcher_name); register_matcher(m, callback); } diff --git a/src/common/transformations/src/transformations/smart_reshape/strided_slice_squeeze.cpp b/src/common/transformations/src/transformations/smart_reshape/strided_slice_squeeze.cpp index 8457dad1d2a59b..68070212ccadbb 100644 --- a/src/common/transformations/src/transformations/smart_reshape/strided_slice_squeeze.cpp +++ b/src/common/transformations/src/transformations/smart_reshape/strided_slice_squeeze.cpp @@ -19,11 +19,11 @@ ov::pass::StridedSliceSqueeze::StridedSliceSqueeze() { // TODO: enable conditional compile // MATCHER_SCOPE(StridedSliceSqueeze); - auto ss_label = ov::pass::pattern::wrap_type(pattern::consumers_count(1)); + auto ss_label = ov::pass::pattern::wrap_type(ov::pass::pattern::consumers_count(1)); auto squeeze_label = ov::pass::pattern::wrap_type( {ss_label, ov::pass::pattern::wrap_type()}); - matcher_pass_callback callback = [](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) -> bool { const auto& squeeze = m.get_match_root(); const auto& const_axes = ov::as_type_ptr(squeeze->get_input_node_shared_ptr(1)); auto slice = ov::as_type_ptr(squeeze->get_input_node_shared_ptr(0)); @@ -116,12 +116,12 @@ ov::pass::SqueezeStridedSlice::SqueezeStridedSlice() { // TODO: enable conditional compile // MATCHER_SCOPE(SqueezeStridedSlice); auto squeeze_label = ov::pass::pattern::wrap_type( - {pattern::any_input(), ov::pass::pattern::wrap_type()}, - pattern::consumers_count(1)); + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); auto ss_label = ov::pass::pattern::wrap_type( - {squeeze_label, pattern::any_input(), pattern::any_input(), pattern::any_input()}); + {squeeze_label, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - matcher_pass_callback callback = [](pattern::Matcher& m) -> bool { + matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) -> bool { auto slice = ov::as_type_ptr(m.get_match_root()); if (!slice) return false; diff --git a/src/common/transformations/src/transformations/symbolic_transformations/chained_maximum.cpp b/src/common/transformations/src/transformations/symbolic_transformations/chained_maximum.cpp index b431a0db1098e6..d4cb1839edd4c0 100644 --- a/src/common/transformations/src/transformations/symbolic_transformations/chained_maximum.cpp +++ b/src/common/transformations/src/transformations/symbolic_transformations/chained_maximum.cpp @@ -15,13 +15,13 @@ using namespace ov::symbol::util; ov::pass::ChainedMaximumOptimization::ChainedMaximumOptimization() { MATCHER_SCOPE(ChainedMaximumOptimization); - auto A_input = pattern::any_input(); - auto B_input = pattern::any_input(); - auto C_input = pattern::any_input(); - auto first_maximum = pattern::wrap_type({A_input, B_input}); - auto maximum = pattern::wrap_type({first_maximum, C_input}); + auto A_input = ov::pass::pattern::any_input(); + auto B_input = ov::pass::pattern::any_input(); + auto C_input = ov::pass::pattern::any_input(); + auto first_maximum = ov::pass::pattern::wrap_type({A_input, B_input}); + auto maximum = ov::pass::pattern::wrap_type({first_maximum, C_input}); - ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { const auto& vm = m.get_pattern_value_map(); auto A = vm.at(A_input), B = vm.at(B_input), C = vm.at(C_input); @@ -45,6 +45,6 @@ ov::pass::ChainedMaximumOptimization::ChainedMaximumOptimization() { return false; }; - auto m = std::make_shared(maximum, matcher_name); + auto m = std::make_shared(maximum, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/symbolic_transformations/dereshape_matmul.cpp b/src/common/transformations/src/transformations/symbolic_transformations/dereshape_matmul.cpp index 84ff6c2667deeb..4d7b75576c44b3 100644 --- a/src/common/transformations/src/transformations/symbolic_transformations/dereshape_matmul.cpp +++ b/src/common/transformations/src/transformations/symbolic_transformations/dereshape_matmul.cpp @@ -185,12 +185,12 @@ void pull_reshape_through_optional_concat_and_bea(const ov::pass::pattern::Patte } // namespace #define IN_RESHAPE \ - pattern::wrap_type([](std::shared_ptr n) -> bool { \ - return pattern::consumers_count(1)(n->output(0)) && reshape_keeps_last_two_dims(n); \ + ov::pass::pattern::wrap_type([](std::shared_ptr n) -> bool { \ + return ov::pass::pattern::consumers_count(1)(n->output(0)) && reshape_keeps_last_two_dims(n); \ }); #define SCALAR_INPUT \ - pattern::any_input([](ov::Output out) { \ + ov::pass::pattern::any_input([](ov::Output out) { \ return out.get_partial_shape().is_static() && ov::shape_size(out.get_shape()) == 1; \ }); @@ -201,41 +201,41 @@ ov::pass::DeReshapeMatMul::DeReshapeMatMul() { // lhs of MatMul auto lhs_reshape = IN_RESHAPE; - auto lhs_concat_0 = pattern::wrap_type({pattern::any_input(), lhs_reshape}, concat_predicate); - auto lhs_concat_1 = pattern::wrap_type({lhs_reshape, pattern::any_input()}, concat_predicate); - auto lhs_concat = std::make_shared(OutputVector{lhs_concat_0, lhs_concat_1}); + auto lhs_concat_0 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), lhs_reshape}, concat_predicate); + auto lhs_concat_1 = ov::pass::pattern::wrap_type({lhs_reshape, ov::pass::pattern::any_input()}, concat_predicate); + auto lhs_concat = std::make_shared(OutputVector{lhs_concat_0, lhs_concat_1}); - auto lhs_reshape_or_concat = std::make_shared(OutputVector{lhs_reshape, lhs_concat}); + auto lhs_reshape_or_concat = std::make_shared(OutputVector{lhs_reshape, lhs_concat}); auto lhs_bea_scalar = SCALAR_INPUT; - auto lhs_bea = pattern::wrap_type({lhs_reshape_or_concat, lhs_bea_scalar}, - pattern::consumers_count(1)); + auto lhs_bea = ov::pass::pattern::wrap_type({lhs_reshape_or_concat, lhs_bea_scalar}, + ov::pass::pattern::consumers_count(1)); - auto lhs_bea_or_concat = std::make_shared(OutputVector{lhs_reshape_or_concat, lhs_bea}); + auto lhs_bea_or_concat = std::make_shared(OutputVector{lhs_reshape_or_concat, lhs_bea}); // rhs of MatMul auto rhs_reshape = IN_RESHAPE; - auto rhs_concat_0 = pattern::wrap_type({pattern::any_input(), rhs_reshape}, concat_predicate); - auto rhs_concat_1 = pattern::wrap_type({rhs_reshape, pattern::any_input()}, concat_predicate); - auto rhs_concat = std::make_shared(OutputVector{rhs_concat_0, rhs_concat_1}); + auto rhs_concat_0 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), rhs_reshape}, concat_predicate); + auto rhs_concat_1 = ov::pass::pattern::wrap_type({rhs_reshape, ov::pass::pattern::any_input()}, concat_predicate); + auto rhs_concat = std::make_shared(OutputVector{rhs_concat_0, rhs_concat_1}); - auto rhs_reshape_or_concat = std::make_shared(OutputVector{rhs_reshape, rhs_concat}); + auto rhs_reshape_or_concat = std::make_shared(OutputVector{rhs_reshape, rhs_concat}); auto rhs_bea_scalar = SCALAR_INPUT; - auto rhs_bea = pattern::wrap_type({rhs_reshape_or_concat, rhs_bea_scalar}, - pattern::consumers_count(1)); + auto rhs_bea = ov::pass::pattern::wrap_type({rhs_reshape_or_concat, rhs_bea_scalar}, + ov::pass::pattern::consumers_count(1)); - auto rhs_bea_or_concat = std::make_shared(OutputVector{rhs_reshape_or_concat, rhs_bea}); + auto rhs_bea_or_concat = std::make_shared(OutputVector{rhs_reshape_or_concat, rhs_bea}); // END: symmetrical patterns for MatMul inputs auto matmul = - pattern::wrap_type({lhs_bea_or_concat, rhs_bea_or_concat}, pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({lhs_bea_or_concat, rhs_bea_or_concat}, ov::pass::pattern::consumers_count(1)); - auto add = pattern::wrap_type( - OutputVector{matmul, pattern::any_input()}, + auto add = ov::pass::pattern::wrap_type( + OutputVector{matmul, ov::pass::pattern::any_input()}, [](ov::Output out) -> bool { - if (!pattern::consumers_count(1)(out)) + if (!ov::pass::pattern::consumers_count(1)(out)) return false; auto input_0_pshape = out.get_node_shared_ptr()->get_input_partial_shape(0); auto input_1_pshape = out.get_node_shared_ptr()->get_input_partial_shape(1); @@ -252,13 +252,13 @@ ov::pass::DeReshapeMatMul::DeReshapeMatMul() { } }); - auto matmul_or_add = std::make_shared(OutputVector{matmul, add}); + auto matmul_or_add = std::make_shared(OutputVector{matmul, add}); auto final_reshape = - pattern::wrap_type({matmul_or_add, pattern::any_input()}, [](std::shared_ptr n) -> bool { + ov::pass::pattern::wrap_type({matmul_or_add, ov::pass::pattern::any_input()}, [](std::shared_ptr n) -> bool { return reshape_keeps_last_two_dims(n); }); - ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { const auto& pm = m.get_pattern_map(); const auto& vm = m.get_pattern_value_map(); std::vector nodes_for_revalidation{pm.at(matmul).get()}; @@ -337,24 +337,21 @@ ov::pass::DeReshapeMatMul::DeReshapeMatMul() { return true; }; - auto m = std::make_shared(final_reshape, matcher_name); + auto m = std::make_shared(final_reshape, matcher_name); register_matcher(m, matcher_pass_callback); } ov::pass::DeReshapeFullyConnected::DeReshapeFullyConnected() { MATCHER_SCOPE(DeReshapeFullyConnected); - using namespace ov::op; - using namespace ov::pass::pattern; - - auto input = wrap_type({any_input(shape_matches("BATCHES_1...,Y")), any_input()}, - shape_matches("BATCHES_2...,Y")); - auto converted = pattern::optional(input, consumers_count(1)); - auto mm_label = wrap_type({converted, any_input(rank_equals(2))}, - consumers_count(1) && shape_matches("BATCHES_2...,Z"), +auto input = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("BATCHES_1...,Y")), ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("BATCHES_2...,Y")); + auto converted = ov::pass::pattern::optional(input, ov::pass::pattern::consumers_count(1)); + auto mm_label = ov::pass::pattern::wrap_type({converted, ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2))}, + ov::pass::pattern::consumers_count(1) && ov::pass::pattern::shape_matches("BATCHES_2...,Z"), {{"transpose_a", false}}); - auto output = wrap_type({mm_label, any_input()}, shape_matches("BATCHES_1...,Z")); + auto output = ov::pass::pattern::wrap_type({mm_label, ov::pass::pattern::any_input()}, ov::pass::pattern::shape_matches("BATCHES_1...,Z")); - ov::matcher_pass_callback matcher_pass_callback = [=](Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { const auto& pm = m.get_pattern_map(); const auto& in_reshape = pm.at(input); const auto& matmul = pm.at(mm_label); @@ -371,6 +368,6 @@ ov::pass::DeReshapeFullyConnected::DeReshapeFullyConnected() { return true; }; - auto m = std::make_shared(output, matcher_name); + auto m = std::make_shared(output, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/symbolic_transformations/nop_broadcast.cpp b/src/common/transformations/src/transformations/symbolic_transformations/nop_broadcast.cpp index 3558e77310c0e7..499dab68b088c6 100644 --- a/src/common/transformations/src/transformations/symbolic_transformations/nop_broadcast.cpp +++ b/src/common/transformations/src/transformations/symbolic_transformations/nop_broadcast.cpp @@ -18,7 +18,6 @@ using namespace std; using namespace ov; -using namespace ov::op; using namespace ov::symbol::util; namespace { @@ -34,17 +33,17 @@ shared_ptr broadcast_label(const OutputVector& inputs) { ov::pass::NopBroadcast::NopBroadcast() { MATCHER_SCOPE(NopBroadcast); - auto data_label = pattern::any_input(pattern::has_static_rank()); + auto data_label = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); - auto shape_label = pattern::wrap_type(); + auto shape_label = ov::pass::pattern::wrap_type(); auto ones = INT_CONSTANT_WITH_PREDICATE(std::all_of(value.begin(), value.end(), cmp::Equal(1))); - auto maximum = pattern::wrap_type({shape_label, ones}); + auto maximum = ov::pass::pattern::wrap_type({shape_label, ones}); - auto broadcast_3_ins = broadcast_label({data_label, maximum, pattern::any_input()}); + auto broadcast_3_ins = broadcast_label({data_label, maximum, ov::pass::pattern::any_input()}); auto broadcast_2_ins = broadcast_label({data_label, maximum}); - auto broadcast = make_shared(OutputVector{broadcast_2_ins, broadcast_3_ins}); + auto broadcast = make_shared(OutputVector{broadcast_2_ins, broadcast_3_ins}); - ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { const auto& vm = m.get_pattern_value_map(); auto data = vm.at(data_label); auto shape = vm.at(shape_label); @@ -56,6 +55,6 @@ ov::pass::NopBroadcast::NopBroadcast() { return ov::replace_output_update_name(m.get_match_root(), data); }; - auto m = std::make_shared(broadcast, matcher_name); + auto m = std::make_shared(broadcast, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/symbolic_transformations/reshape_optimizations.cpp b/src/common/transformations/src/transformations/symbolic_transformations/reshape_optimizations.cpp index ccaac5c761d995..8704d5c21c7f83 100644 --- a/src/common/transformations/src/transformations/symbolic_transformations/reshape_optimizations.cpp +++ b/src/common/transformations/src/transformations/symbolic_transformations/reshape_optimizations.cpp @@ -13,17 +13,16 @@ using namespace std; using namespace ov; -using namespace ov::op; using namespace ov::symbol::util; ov::pass::ReshapeOptimizations::ReshapeOptimizations() { MATCHER_SCOPE(ReshapeOptimizations); - auto data_label = pattern::any_input(pattern::has_static_rank()); - auto pattern_label = pattern::any_input(pattern::has_static_shape() && pattern::class_other_than()); - auto reshape_label = pattern::wrap_type({data_label, pattern_label}, pattern::has_static_rank()); + auto data_label = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); + auto pattern_label = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape() && ov::pass::pattern::class_other_than()); + auto reshape_label = ov::pass::pattern::wrap_type({data_label, pattern_label}, ov::pass::pattern::has_static_rank()); - ov::matcher_pass_callback matcher_pass_callback = [](pattern::Matcher& m) { - const auto& reshape = ov::as_type_ptr(m.get_match_root()); + ov::matcher_pass_callback matcher_pass_callback = [](ov::pass::pattern::Matcher& m) { + const auto& reshape = ov::as_type_ptr(m.get_match_root()); if (!reshape) return false; const auto& in_shape = reshape->get_input_partial_shape(0); @@ -57,6 +56,6 @@ ov::pass::ReshapeOptimizations::ReshapeOptimizations() { return false; }; - auto m = std::make_shared(reshape_label, matcher_name); + auto m = std::make_shared(reshape_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp b/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp index ef7c42b6dc08b6..905ff02ea331e6 100644 --- a/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp +++ b/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp @@ -119,17 +119,17 @@ bool ov::pass::SymbolicPropagation::run_on_model(const std::shared_ptr(); - auto input_reshape = pattern::wrap_type({add, pattern::any_input()}); + auto add = ov::pass::pattern::wrap_type(); + auto input_reshape = ov::pass::pattern::wrap_type({add, ov::pass::pattern::any_input()}); - auto select_then = pattern::wrap_type({pattern::any_input(), input_reshape, pattern::any_input()}); - auto select_else = pattern::wrap_type({pattern::any_input(), pattern::any_input(), input_reshape}); - auto select = std::make_shared(OutputVector{select_then, select_else}); + auto select_then = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), input_reshape, ov::pass::pattern::any_input()}); + auto select_else = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), input_reshape}); + auto select = std::make_shared(OutputVector{select_then, select_else}); - auto softmax = pattern::wrap_type({select}); - auto reshape = pattern::wrap_type({softmax, pattern::any_input()}); + auto softmax = ov::pass::pattern::wrap_type({select}); + auto reshape = ov::pass::pattern::wrap_type({softmax, ov::pass::pattern::any_input()}); - ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { const auto& value_map = m.get_pattern_value_map(); ov::TensorSymbol reshape_symbols, add_0_symbols, add_1_symbols; if (!get_symbols(value_map.at(reshape).get_partial_shape(), reshape_symbols)) @@ -167,7 +167,7 @@ ov::pass::LabelResolvingThroughSelect::LabelResolvingThroughSelect() { return true; }; - auto m = std::make_shared(reshape, matcher_name); + auto m = std::make_shared(reshape, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_base.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_base.cpp index 8a149af9fb1194..e55d058a06c798 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_base.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_base.cpp @@ -16,13 +16,12 @@ #include "transformations/transpose_sinking/ts_utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; void TSForwardBase::transpose_sinking(const std::string& pass_name, const TSForwardBase::sinking_function& sinking_transformation) { - ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); auto main_node = pattern_to_output.at(m_pattern).get_node_shared_ptr(); utils::TransposeInputsInfo transpose_input_info = @@ -50,7 +49,7 @@ void TSForwardBase::transpose_sinking(const std::string& pass_name, return res; }; - auto m = std::make_shared(m_pattern, pass_name); + auto m = std::make_shared(m_pattern, pass_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_binary.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_binary.cpp index 1986f5ddb746d3..e449cd5d6fcdac 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_binary.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_binary.cpp @@ -20,7 +20,6 @@ #include "transformations/transpose_sinking/ts_utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -86,22 +85,22 @@ bool IsSpecialPRelu(NodePtr node) { TSBinaryBackward::TSBinaryBackward() { MATCHER_SCOPE(TSBinaryBackward); - auto main_node_label = wrap_type([](const Output& output) -> bool { - return has_static_rank()(output) && CheckTransposeConsumers(output); + return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); }); - auto transpose_const_label = wrap_type(); + auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); auto transpose_const = as_type_ptr(pattern_to_output.at(transpose_const_label).get_node_shared_ptr()); @@ -124,6 +123,6 @@ TSBinaryBackward::TSBinaryBackward() { return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_concat.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_concat.cpp index 90ab08d5dc0fe4..a0e2486ae6826f 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_concat.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_concat.cpp @@ -15,7 +15,6 @@ #include "transformations/transpose_sinking/ts_utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -64,18 +63,18 @@ TSConcatForward::TSConcatForward() { TSConcatBackward::TSConcatBackward() { MATCHER_SCOPE(TSConcatBackward); - auto main_node_label = wrap_type([](const Output& output) -> bool { - return has_static_rank()(output) && CheckTransposeConsumers(output); + auto main_node_label = ov::pass::pattern::wrap_type([](const Output& output) -> bool { + return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); }); - auto transpose_const_label = wrap_type(); + auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); auto transpose_const = as_type_ptr(pattern_to_output.at(transpose_const_label).get_node_shared_ptr()); @@ -118,6 +117,6 @@ TSConcatBackward::TSConcatBackward() { return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_cumsum.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_cumsum.cpp index 6a732020752145..8aeb2cfaff0699 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_cumsum.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_cumsum.cpp @@ -15,7 +15,6 @@ #include "transformations/transpose_sinking/ts_utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -50,17 +49,17 @@ TSCumSumForward::TSCumSumForward() { TSCumSumBackward::TSCumSumBackward() { MATCHER_SCOPE(TSCumSumBackward); - auto main_node_label = wrap_type([](const Output& output) -> bool { - return has_static_rank()(output) && CheckTransposeConsumers(output); + auto main_node_label = ov::pass::pattern::wrap_type([](const Output& output) -> bool { + return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); }); - auto transpose_const_label = wrap_type(); + auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); auto transpose_const = as_type_ptr(pattern_to_output.at(transpose_const_label).get_node_shared_ptr()); @@ -87,6 +86,6 @@ TSCumSumBackward::TSCumSumBackward() { main_node->validate_and_infer_types(); return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_data_movement.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_data_movement.cpp index b695faa9360867..aeabafc240a35a 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_data_movement.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_data_movement.cpp @@ -19,7 +19,6 @@ #include "transformations/transpose_sinking/ts_utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -74,19 +73,19 @@ TSDataMovementBackward::TSDataMovementBackward() { MATCHER_SCOPE(TSDataMovementBackward); auto main_node_label = - wrap_type( + ov::pass::pattern::wrap_type( [](const Output& output) -> bool { - return has_static_rank()(output) && CheckTransposeConsumers(output); + return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); }); - auto transpose_const_label = wrap_type(); + auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); auto transpose_const = as_type_ptr(pattern_to_output.at(transpose_const_label).get_node_shared_ptr()); @@ -120,6 +119,6 @@ TSDataMovementBackward::TSDataMovementBackward() { return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_fuse.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_fuse.cpp index 0591649ab99212..ee6e59832eee8e 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_fuse.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_fuse.cpp @@ -23,11 +23,11 @@ using namespace ov::pass::transpose_sinking::utils; TSFuse::TSFuse() { MATCHER_SCOPE(TransposeFuse); auto transpose_1_label = - pattern::wrap_type({pattern::any_input(), pattern::wrap_type()}, + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, CheckTransposeConsumers); auto transpose_2_label = - pattern::wrap_type({transpose_1_label, pattern::wrap_type()}); - ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::pass::pattern::wrap_type({transpose_1_label, ov::pass::pattern::wrap_type()}); + ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); auto transpose1 = pattern_to_output.at(transpose_1_label); @@ -76,6 +76,6 @@ TSFuse::TSFuse() { return true; }; - auto m = std::make_shared(transpose_2_label, matcher_name); + auto m = std::make_shared(transpose_2_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_gather.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_gather.cpp index 4211ef68c4e7e9..1b36152a7a924e 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_gather.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_gather.cpp @@ -16,7 +16,6 @@ #include "transformations/transpose_sinking/ts_utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -155,14 +154,14 @@ TSGatherForward::TSGatherForward() { TSGatherBackward::TSGatherBackward() { MATCHER_SCOPE(TSGatherBackward); - auto gather_label = wrap_type({any_input(), any_input(), wrap_type()}, + auto gather_label = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, CheckTransposeConsumers); - auto transpose_label = wrap_type({gather_label, wrap_type()}, + auto transpose_label = ov::pass::pattern::wrap_type({gather_label, ov::pass::pattern::wrap_type()}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); auto transpose = as_type_ptr(pattern_to_output.at(transpose_label)); @@ -345,6 +344,6 @@ TSGatherBackward::TSGatherBackward() { return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_interpolate.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_interpolate.cpp index d3247d60315a07..f098815f7609b9 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_interpolate.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_interpolate.cpp @@ -17,7 +17,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -65,18 +64,18 @@ TSInterpolateForward::TSInterpolateForward() { TSInterpolateBackward::TSInterpolateBackward() { MATCHER_SCOPE(TSInterpolateBackward); - auto main_node_label = wrap_type([](const Output& output) -> bool { - return has_static_rank()(output) && CheckTransposeConsumers(output); + auto main_node_label = ov::pass::pattern::wrap_type([](const Output& output) -> bool { + return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); }); - auto transpose_const_label = wrap_type(); + auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); auto transpose_const = as_type_ptr(pattern_to_output.at(transpose_const_label).get_node_shared_ptr()); @@ -120,6 +119,6 @@ TSInterpolateBackward::TSInterpolateBackward() { return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_reduction.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_reduction.cpp index 2bbc2ad5331770..794c14a6929b59 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_reduction.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_reduction.cpp @@ -19,7 +19,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -92,15 +91,15 @@ TSReductionForward::TSReductionForward() { TSReductionBackward::TSReductionBackward() { MATCHER_SCOPE(TSReductionBackward); - auto reduce_label = wrap_type( - {any_input(), wrap_type()}, + auto reduce_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, CheckTransposeConsumers); - auto transpose_label = wrap_type({reduce_label, wrap_type()}, + auto transpose_label = ov::pass::pattern::wrap_type({reduce_label, ov::pass::pattern::wrap_type()}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); auto transpose = pattern_to_output.at(transpose_label); auto main_node = pattern_to_output.at(reduce_label); @@ -145,6 +144,6 @@ TSReductionBackward::TSReductionBackward() { return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_reset_no_sinking_attribute.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_reset_no_sinking_attribute.cpp index 20874330999729..ba0d73ad2d3bea 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_reset_no_sinking_attribute.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_reset_no_sinking_attribute.cpp @@ -11,23 +11,22 @@ #include "transformations/rt_info/transpose_sinking_attr.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; TSResetNoSinkingAttribute::TSResetNoSinkingAttribute() { MATCHER_SCOPE(TSResetNoSinkingAttribute); - auto transpose_label = wrap_type([](const Output& output) -> bool { + auto transpose_label = ov::pass::pattern::wrap_type([](const Output& output) -> bool { const auto& rt_info = output.get_node()->get_rt_info(); return rt_info.find(NoTransposeSinkingAttr::get_type_info_static()) != rt_info.end(); }); - ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); const auto& transpose = pattern_to_output.at(transpose_label); ov::reset_no_sinking_attribute(transpose); return false; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_slice.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_slice.cpp index 4183385193bf47..1cbcf27487a864 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_slice.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_slice.cpp @@ -17,7 +17,6 @@ #include "transformations/transpose_sinking/ts_utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -57,18 +56,18 @@ TSSliceForward::TSSliceForward() { TSSliceBackward::TSSliceBackward() { MATCHER_SCOPE(TSSliceBackward); - auto main_node_label = wrap_type([](const Output& output) -> bool { - return has_static_rank()(output) && CheckTransposeConsumers(output); + auto main_node_label = ov::pass::pattern::wrap_type([](const Output& output) -> bool { + return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); }); - auto transpose_const_label = wrap_type(); + auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); auto transpose_const = as_type_ptr(pattern_to_output.at(transpose_const_label).get_node_shared_ptr()); @@ -104,6 +103,6 @@ TSSliceBackward::TSSliceBackward() { return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_split.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_split.cpp index 7e418e6c7e5237..cee444f491c8b2 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_split.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_split.cpp @@ -15,8 +15,6 @@ #include "transformations/rt_info/transpose_sinking_attr.hpp" #include "transformations/transpose_sinking/ts_utils.hpp" #include "transformations/utils/utils.hpp" - -using namespace ov::pass::pattern; using namespace ov; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -158,10 +156,10 @@ TSSplitForward::TSSplitForward() { TSSplitBackward::TSSplitBackward() { MATCHER_SCOPE(TSSplitBackward); - auto transpose_const_label = wrap_type(); - auto transpose_label = wrap_type({any_input(), transpose_const_label}, IsSplitSinked); + auto transpose_const_label = ov::pass::pattern::wrap_type(); + auto transpose_label = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), transpose_const_label}, IsSplitSinked); - matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); auto transpose_label_node = pattern_to_output.at(transpose_label).get_node(); @@ -222,6 +220,6 @@ TSSplitBackward::TSSplitBackward() { return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_squeeze.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_squeeze.cpp index f74a526d845cbb..7edcd10b4294fe 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_squeeze.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_squeeze.cpp @@ -20,7 +20,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -184,17 +183,17 @@ TSSqueezeForward::TSSqueezeForward() { TSSqueezeBackward::TSSqueezeBackward() { MATCHER_SCOPE(TSSqueezeBackward); - auto squeeze_with_1_input = wrap_type({any_input()}, CheckTransposeConsumers); + auto squeeze_with_1_input = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}, CheckTransposeConsumers); auto squeeze_label = - wrap_type({any_input(), wrap_type()}, + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, CheckTransposeConsumers); - auto pattern = std::make_shared(OutputVector{squeeze_with_1_input, squeeze_label}); - auto transpose_label = wrap_type({pattern, wrap_type()}, + auto pattern = std::make_shared(OutputVector{squeeze_with_1_input, squeeze_label}); + auto transpose_label = ov::pass::pattern::wrap_type({pattern, ov::pass::pattern::wrap_type()}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); auto transpose = pattern_to_output.at(transpose_label); @@ -287,6 +286,6 @@ TSSqueezeBackward::TSSqueezeBackward() { return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_tile.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_tile.cpp index 0b1555ab67b69c..a605c38f7f08a4 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_tile.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_tile.cpp @@ -15,7 +15,6 @@ #include "transformations/transpose_sinking/ts_utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -51,17 +50,17 @@ TSTileForward::TSTileForward() { TSTileBackward::TSTileBackward() { MATCHER_SCOPE(TSTileBackward); - auto main_node_label = wrap_type([](const Output& output) -> bool { - return has_static_rank()(output) && CheckTransposeConsumers(output); + auto main_node_label = ov::pass::pattern::wrap_type([](const Output& output) -> bool { + return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); }); - auto transpose_const_label = wrap_type(); + auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); auto transpose_const = as_type_ptr(pattern_to_output.at(transpose_const_label).get_node_shared_ptr()); @@ -88,6 +87,6 @@ TSTileBackward::TSTileBackward() { main_node->validate_and_infer_types(); return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp index cec53d2728254b..1e50fea5d58c70 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp @@ -29,7 +29,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::op::util; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -82,7 +81,7 @@ TSUnaryBackward::TSUnaryBackward() { return CheckTransposeConsumers(output); }; - auto unary_with_1_input_label = wrap_type({any_input()}, unary_restrictions); + ov::op::v5::LogSoftmax>({ov::pass::pattern::any_input()}, unary_restrictions); auto unary_with_2_inputs_label = - wrap_type({any_input(), any_input()}, unary_restrictions); + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, unary_restrictions); auto unary_with_3_inputs_label = - wrap_type({any_input(), any_input(), any_input()}, + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, unary_restrictions); - auto unary_label = std::make_shared( + auto unary_label = std::make_shared( ov::OutputVector{unary_with_1_input_label, unary_with_2_inputs_label, unary_with_3_inputs_label}); - auto transpose_const_label = wrap_type(); + auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = wrap_type({unary_label, transpose_const_label}); + auto transpose_label = ov::pass::pattern::wrap_type({unary_label, transpose_const_label}); - ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); auto transpose_const = as_type_ptr(pattern_to_output.at(transpose_const_label).get_node_shared_ptr()); @@ -124,6 +123,6 @@ TSUnaryBackward::TSUnaryBackward() { return true; }; - auto m = std::make_shared(transpose_label, "ov::pass::TSUnaryBackward"); + auto m = std::make_shared(transpose_label, "ov::pass::TSUnaryBackward"); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_unsqueeze.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_unsqueeze.cpp index a4fc8684493f3e..3031c8092b032c 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_unsqueeze.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_unsqueeze.cpp @@ -18,7 +18,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::pass::pattern; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -198,14 +197,14 @@ TSUnsqueezeBackward::TSUnsqueezeBackward() { MATCHER_SCOPE(TSUnsqueezeBackward); auto unsqueeze_label = - wrap_type({any_input(), wrap_type()}, + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, CheckTransposeConsumers); - auto transpose_label = wrap_type({unsqueeze_label, wrap_type()}, + auto transpose_label = ov::pass::pattern::wrap_type({unsqueeze_label, ov::pass::pattern::wrap_type()}, [](const Output& output) -> bool { - return has_static_rank()(output); + return ov::pass::pattern::has_static_rank()(output); }); - ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) { + ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); auto transpose = pattern_to_output.at(transpose_label); @@ -305,6 +304,6 @@ TSUnsqueezeBackward::TSUnsqueezeBackward() { return true; }; - auto m = std::make_shared(transpose_label, matcher_name); + auto m = std::make_shared(transpose_label, matcher_name); register_matcher(m, matcher_pass_callback); } diff --git a/src/common/transformations/src/transformations/utils/utils.cpp b/src/common/transformations/src/transformations/utils/utils.cpp index 95ad0daebdb692..dbf5fa544c0d0d 100644 --- a/src/common/transformations/src/transformations/utils/utils.cpp +++ b/src/common/transformations/src/transformations/utils/utils.cpp @@ -147,18 +147,16 @@ bool has_f16_constants(const std::shared_ptr& function) { } bool is_large_language_model(const ov::Model& model, std::function)> func) { - using namespace ov::pass::pattern; - - const auto past = wrap_type(); +const auto past = ov::pass::pattern::wrap_type(); const auto convert_past = ov::pass::pattern::optional(past); - const auto beam_idx = wrap_type(); - const auto gather_past = wrap_type({convert_past, beam_idx, wrap_type()}); + const auto beam_idx = ov::pass::pattern::wrap_type(); + const auto gather_past = ov::pass::pattern::wrap_type({convert_past, beam_idx, ov::pass::pattern::wrap_type()}); const auto gather_convert = ov::pass::pattern::optional(gather_past); const auto concat_past_input = std::make_shared(OutputVector{convert_past, gather_convert}); - const auto concat = wrap_type({concat_past_input, any_input()}); + const auto concat = ov::pass::pattern::wrap_type({concat_past_input, ov::pass::pattern::any_input()}); const auto convert_present = ov::pass::pattern::optional(concat); - const auto present = wrap_type({convert_present}); + const auto present = ov::pass::pattern::wrap_type({convert_present}); const auto kvcache_matcher = std::make_shared(present, "KVCacheMatcher"); for (const auto& op : model.get_ops()) { @@ -589,7 +587,7 @@ std::shared_ptr NewGenSlice(const std::shared_ptr& data, begin_mask[axis] = 0; end_mask[axis] = 0; - auto opt2 = pattern::wrap_type({data, begin, end, stride}, + auto opt2 = ov::pass::pattern::wrap_type({data, begin, end, stride}, {{"begin_mask", begin_mask}, {"end_mask", end_mask}, {"new_axis_mask", new_axis_mask}, @@ -607,10 +605,8 @@ std::tuple, std::shared_ptr> match_multi_query_bcst(const std::shared_ptr& kv) { using namespace ov::pass; - using namespace ov::pass::pattern; - - auto reshape_kv = wrap_type({kv, any_input()}); - auto unsqueeze_kv = wrap_type({kv, any_input()}); +auto reshape_kv = ov::pass::pattern::wrap_type({kv, ov::pass::pattern::any_input()}); + auto unsqueeze_kv = ov::pass::pattern::wrap_type({kv, ov::pass::pattern::any_input()}); auto check_one = [](const Output& output) -> bool { auto node = ov::as_type_ptr(output.get_node_shared_ptr()); @@ -622,15 +618,15 @@ match_multi_query_bcst(const std::shared_ptr& kv) { return i == 1.0F; }); }; - auto constant_bcst = wrap_type(check_one); + auto constant_bcst = ov::pass::pattern::wrap_type(check_one); auto computed_bcst = - wrap_type({constant_bcst, any_input(), any_input()}, {{"mode", "numpy"}}); + ov::pass::pattern::wrap_type({constant_bcst, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, {{"mode", "numpy"}}); - auto multiply_kv = wrap_type({reshape_kv | unsqueeze_kv, constant_bcst | computed_bcst}); - auto computed_bcst3 = wrap_type({unsqueeze_kv, any_input()}, {{"mode", "bidirectional"}}); + auto multiply_kv = ov::pass::pattern::wrap_type({reshape_kv | unsqueeze_kv, constant_bcst | computed_bcst}); + auto computed_bcst3 = ov::pass::pattern::wrap_type({unsqueeze_kv, ov::pass::pattern::any_input()}, {{"mode", "bidirectional"}}); - auto result = wrap_type({multiply_kv | computed_bcst3, any_input()}); + auto result = ov::pass::pattern::wrap_type({multiply_kv | computed_bcst3, ov::pass::pattern::any_input()}); return std::make_tuple(result, reshape_kv, unsqueeze_kv, computed_bcst, multiply_kv, computed_bcst3); } diff --git a/src/common/transformations/tests/common_optimizations/convert_pagedattn_inputs.cpp b/src/common/transformations/tests/common_optimizations/convert_pagedattn_inputs.cpp index fb8afe1cfef589..217f4fada04ecb 100644 --- a/src/common/transformations/tests/common_optimizations/convert_pagedattn_inputs.cpp +++ b/src/common/transformations/tests/common_optimizations/convert_pagedattn_inputs.cpp @@ -14,7 +14,6 @@ using namespace ov::test; using namespace ov; -using namespace ov::op; using namespace ov::gen_pattern; using ConvertPagedAttnInputsParams = std::tuple, // cache_precision std::vector, // cache_group_size @@ -89,31 +88,31 @@ TEST_P(ConvertPagedAttnInputsTest, checkPrecisionAndShape) { numValueHeads = 2; valueHeadSize = 64; { - auto Q = std::make_shared(ov::element::f32, PartialShape{-1, 4 * 32}); - auto K = std::make_shared( + auto Q = std::make_shared(ov::element::f32, PartialShape{-1, 4 * 32}); + auto K = std::make_shared( ov::element::f32, PartialShape{-1, static_cast(numKeyHeads * keyHeadSize)}); - auto V = std::make_shared( + auto V = std::make_shared( ov::element::f32, PartialShape{-1, static_cast(numValueHeads * valueHeadSize)}); - auto max_context_len = std::make_shared(ov::element::i32, PartialShape{}); - auto block_indices_begins = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto block_indices = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto subsequence_begins = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto past_lens = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto key_cache_0 = std::make_shared(ov::element::dynamic, PartialShape::dynamic(4)); - auto value_cache_0 = std::make_shared(ov::element::dynamic, PartialShape::dynamic(4)); - auto scale = std::make_shared(element::f32, Shape{}, 0.5f); - auto sliding_window = std::make_shared(element::i32, Shape{}, 0); - auto alibi_slopes = std::make_shared(element::f32, Shape{0}); - auto score_aggregation_window = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto rotated_block_indices = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto rotation_deltas = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto rotation_trig_lut = std::make_shared(ov::element::f32, PartialShape{DYN}); - auto xattention_threshold = std::make_shared(ov::element::f32, PartialShape{DYN}); - auto xattention_block_size = std::make_shared(ov::element::i32, Shape{}); - auto xattention_stride = std::make_shared(ov::element::i32, Shape{}); - auto sinks = std::make_shared(element::f32, Shape{0}); + auto max_context_len = std::make_shared(ov::element::i32, PartialShape{}); + auto block_indices_begins = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto block_indices = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto subsequence_begins = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto past_lens = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto key_cache_0 = std::make_shared(ov::element::dynamic, PartialShape::dynamic(4)); + auto value_cache_0 = std::make_shared(ov::element::dynamic, PartialShape::dynamic(4)); + auto scale = std::make_shared(element::f32, Shape{}, 0.5f); + auto sliding_window = std::make_shared(element::i32, Shape{}, 0); + auto alibi_slopes = std::make_shared(element::f32, Shape{0}); + auto score_aggregation_window = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto rotated_block_indices = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto rotation_deltas = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto rotation_trig_lut = std::make_shared(ov::element::f32, PartialShape{DYN}); + auto xattention_threshold = std::make_shared(ov::element::f32, PartialShape{DYN}); + auto xattention_block_size = std::make_shared(ov::element::i32, Shape{}); + auto xattention_stride = std::make_shared(ov::element::i32, Shape{}); + auto sinks = std::make_shared(element::f32, Shape{0}); auto pa = std::make_shared(OutputVector{Q, K, @@ -198,39 +197,39 @@ TEST_P(ConvertPagedAttnInputsTest, checkPrecisionAndShape) { keyCachePrecision = getCachePrec(keyCachePrecision); valueCachePrecision = getCachePrec(valueCachePrecision); - auto Q = std::make_shared(ov::element::f32, PartialShape{-1, 4 * 32}); - auto K = std::make_shared( + auto Q = std::make_shared(ov::element::f32, PartialShape{-1, 4 * 32}); + auto K = std::make_shared( ov::element::f32, PartialShape{-1, static_cast(numKeyHeads * keyHeadSize)}); - auto V = std::make_shared( + auto V = std::make_shared( ov::element::f32, PartialShape{-1, static_cast(numValueHeads * valueHeadSize)}); - auto max_context_len = std::make_shared(ov::element::i32, PartialShape{}); - auto block_indices_begins = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto block_indices = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto subsequence_begins = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto past_lens = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto key_cache_0 = std::make_shared(keyCachePrecision, + auto max_context_len = std::make_shared(ov::element::i32, PartialShape{}); + auto block_indices_begins = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto block_indices = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto subsequence_begins = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto past_lens = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto key_cache_0 = std::make_shared(keyCachePrecision, getCacheShape(keyCachePrecision, numKeyHeads, keyHeadSize, keyCacheGroupSize, blockSize[0], quantKeybychannel)); - auto value_cache_0 = std::make_shared( + auto value_cache_0 = std::make_shared( valueCachePrecision, getCacheShape(valueCachePrecision, numKeyHeads, valueHeadSize, valueCacheGroupSize, blockSize[1], false)); - auto scale = std::make_shared(element::f32, Shape{}, 0.5f); - auto sliding_window = std::make_shared(element::i32, Shape{}, 0); - auto alibi_slopes = std::make_shared(element::f32, Shape{0}); - auto score_aggregation_window = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto rotated_block_indices = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto rotation_deltas = std::make_shared(ov::element::i32, PartialShape{DYN}); - auto rotation_trig_lut = std::make_shared(ov::element::f32, PartialShape{DYN}); - auto xattention_threshold = std::make_shared(ov::element::f32, PartialShape{DYN}); - auto xattention_block_size = std::make_shared(ov::element::i32, Shape{}); - auto xattention_stride = std::make_shared(ov::element::i32, Shape{}); - auto sinks = std::make_shared(element::f32, Shape{0}); + auto scale = std::make_shared(element::f32, Shape{}, 0.5f); + auto sliding_window = std::make_shared(element::i32, Shape{}, 0); + auto alibi_slopes = std::make_shared(element::f32, Shape{0}); + auto score_aggregation_window = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto rotated_block_indices = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto rotation_deltas = std::make_shared(ov::element::i32, PartialShape{DYN}); + auto rotation_trig_lut = std::make_shared(ov::element::f32, PartialShape{DYN}); + auto xattention_threshold = std::make_shared(ov::element::f32, PartialShape{DYN}); + auto xattention_block_size = std::make_shared(ov::element::i32, Shape{}); + auto xattention_stride = std::make_shared(ov::element::i32, Shape{}); + auto sinks = std::make_shared(element::f32, Shape{0}); auto pa = std::make_shared(OutputVector{Q, K, diff --git a/src/common/transformations/tests/common_optimizations/eliminate_loop_inputs_outputs_test.cpp b/src/common/transformations/tests/common_optimizations/eliminate_loop_inputs_outputs_test.cpp index 0c707573805dd6..718ea806ef1186 100644 --- a/src/common/transformations/tests/common_optimizations/eliminate_loop_inputs_outputs_test.cpp +++ b/src/common/transformations/tests/common_optimizations/eliminate_loop_inputs_outputs_test.cpp @@ -24,22 +24,20 @@ using namespace testing; using namespace ov; -using namespace ov::op; - TEST_F(TransformationTestsF, LoopInputsInvariantAndOutput) { { - auto main_param0 = std::make_shared(element::i32, Shape{1}); - auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); + auto main_param0 = std::make_shared(element::i32, Shape{1}); + auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); - auto trip_count = std::make_shared(element::i32, Shape{}, 10); - auto condition = std::make_shared(element::boolean, Shape{}, true); - auto loop = std::make_shared(trip_count, condition); + auto trip_count = std::make_shared(element::i32, Shape{}, 10); + auto condition = std::make_shared(element::boolean, Shape{}, true); + auto loop = std::make_shared(trip_count, condition); - auto param0 = std::make_shared(element::i32, Shape{1}); - auto param1 = std::make_shared(element::i32, Shape{1}); - auto add = std::make_shared(param0, param1); - auto result0 = std::make_shared(add); - auto result1 = std::make_shared(param1); + auto param0 = std::make_shared(element::i32, Shape{1}); + auto param1 = std::make_shared(element::i32, Shape{1}); + auto add = std::make_shared(param0, param1); + auto result0 = std::make_shared(add); + auto result1 = std::make_shared(param1); auto body = std::make_shared(OutputVector{condition, result0, result1}, ParameterVector{param0, param1}); loop->set_special_body_ports({-1, 0}); @@ -48,11 +46,11 @@ TEST_F(TransformationTestsF, LoopInputsInvariantAndOutput) { loop->set_invariant_input(param0, main_param0); loop->set_merged_input(param1, main_const1, result1); - auto tanh = std::make_shared(loop->get_iter_value(result0)); - auto sinh = std::make_shared(loop->get_iter_value(result1)); + auto tanh = std::make_shared(loop->get_iter_value(result0)); + auto sinh = std::make_shared(loop->get_iter_value(result1)); - auto main_result0 = std::make_shared(tanh); - auto main_result1 = std::make_shared(sinh); + auto main_result0 = std::make_shared(tanh); + auto main_result1 = std::make_shared(sinh); model = std::make_shared(OutputVector{main_result0, main_result1}, ParameterVector{main_param0}); @@ -60,18 +58,18 @@ TEST_F(TransformationTestsF, LoopInputsInvariantAndOutput) { } { - auto main_param0 = std::make_shared(element::i32, Shape{1}); - auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); + auto main_param0 = std::make_shared(element::i32, Shape{1}); + auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); - auto trip_count = std::make_shared(element::i32, Shape{}, 10); - auto condition = std::make_shared(element::boolean, Shape{}, true); - auto loop = std::make_shared(trip_count, condition); + auto trip_count = std::make_shared(element::i32, Shape{}, 10); + auto condition = std::make_shared(element::boolean, Shape{}, true); + auto loop = std::make_shared(trip_count, condition); - auto param0 = std::make_shared(element::i32, Shape{1}); - auto param1 = std::make_shared(element::i32, Shape{1}); - auto add = std::make_shared(param0, param1); - auto result0 = std::make_shared(add); - auto result1 = std::make_shared(param1); + auto param0 = std::make_shared(element::i32, Shape{1}); + auto param1 = std::make_shared(element::i32, Shape{1}); + auto add = std::make_shared(param0, param1); + auto result0 = std::make_shared(add); + auto result1 = std::make_shared(param1); auto body = std::make_shared(OutputVector{condition, result0}, ParameterVector{param0, param1}); loop->set_special_body_ports({-1, 0}); @@ -80,11 +78,11 @@ TEST_F(TransformationTestsF, LoopInputsInvariantAndOutput) { loop->set_invariant_input(param0, main_param0); loop->set_invariant_input(param1, main_const1); - auto tanh = std::make_shared(loop->get_iter_value(result0)); - auto sinh = std::make_shared(main_const1); + auto tanh = std::make_shared(loop->get_iter_value(result0)); + auto sinh = std::make_shared(main_const1); - auto main_result0 = std::make_shared(tanh); - auto main_result1 = std::make_shared(sinh); + auto main_result0 = std::make_shared(tanh); + auto main_result1 = std::make_shared(sinh); model_ref = std::make_shared(OutputVector{main_result0, main_result1}, ParameterVector{main_param0}); } @@ -92,18 +90,18 @@ TEST_F(TransformationTestsF, LoopInputsInvariantAndOutput) { TEST_F(TransformationTestsF, LoopInputsNothing) { { - auto main_param0 = std::make_shared(element::i32, Shape{1}); - auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); + auto main_param0 = std::make_shared(element::i32, Shape{1}); + auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); - auto trip_count = std::make_shared(element::i32, Shape{}, 10); - auto condition = std::make_shared(element::boolean, Shape{}, true); - auto loop = std::make_shared(trip_count, condition); + auto trip_count = std::make_shared(element::i32, Shape{}, 10); + auto condition = std::make_shared(element::boolean, Shape{}, true); + auto loop = std::make_shared(trip_count, condition); - auto param0 = std::make_shared(element::i32, Shape{1}); - auto param1 = std::make_shared(element::i32, Shape{1}); - auto add = std::make_shared(param0, param1); - auto result0 = std::make_shared(add); - auto result1 = std::make_shared(param1); + auto param0 = std::make_shared(element::i32, Shape{1}); + auto param1 = std::make_shared(element::i32, Shape{1}); + auto add = std::make_shared(param0, param1); + auto result0 = std::make_shared(add); + auto result1 = std::make_shared(param1); auto body = std::make_shared(OutputVector{condition, result0, result1}, ParameterVector{param0, param1}); loop->set_special_body_ports({-1, 0}); @@ -112,28 +110,28 @@ TEST_F(TransformationTestsF, LoopInputsNothing) { loop->set_invariant_input(param0, main_param0); loop->set_invariant_input(param1, main_const1); - auto tanh = std::make_shared(loop->get_iter_value(result0)); - auto sinh = std::make_shared(main_const1); + auto tanh = std::make_shared(loop->get_iter_value(result0)); + auto sinh = std::make_shared(main_const1); - auto main_result0 = std::make_shared(tanh); - auto main_result1 = std::make_shared(sinh); + auto main_result0 = std::make_shared(tanh); + auto main_result1 = std::make_shared(sinh); model = std::make_shared(OutputVector{main_result0, main_result1}, ParameterVector{main_param0}); manager.register_pass(); } { - auto main_param0 = std::make_shared(element::i32, Shape{1}); - auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); + auto main_param0 = std::make_shared(element::i32, Shape{1}); + auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); - auto trip_count = std::make_shared(element::i32, Shape{}, 10); - auto condition = std::make_shared(element::boolean, Shape{}, true); - auto loop = std::make_shared(trip_count, condition); + auto trip_count = std::make_shared(element::i32, Shape{}, 10); + auto condition = std::make_shared(element::boolean, Shape{}, true); + auto loop = std::make_shared(trip_count, condition); - auto param0 = std::make_shared(element::i32, Shape{1}); - auto param1 = std::make_shared(element::i32, Shape{1}); - auto add = std::make_shared(param0, param1); - auto result0 = std::make_shared(add); + auto param0 = std::make_shared(element::i32, Shape{1}); + auto param1 = std::make_shared(element::i32, Shape{1}); + auto add = std::make_shared(param0, param1); + auto result0 = std::make_shared(add); auto body = std::make_shared(OutputVector{condition, result0}, ParameterVector{param0, param1}); loop->set_special_body_ports({-1, 0}); @@ -142,11 +140,11 @@ TEST_F(TransformationTestsF, LoopInputsNothing) { loop->set_invariant_input(param0, main_param0); loop->set_invariant_input(param1, main_const1); - auto tanh = std::make_shared(loop->get_iter_value(result0)); - auto sinh = std::make_shared(main_const1); + auto tanh = std::make_shared(loop->get_iter_value(result0)); + auto sinh = std::make_shared(main_const1); - auto main_result0 = std::make_shared(tanh); - auto main_result1 = std::make_shared(sinh); + auto main_result0 = std::make_shared(tanh); + auto main_result1 = std::make_shared(sinh); model_ref = std::make_shared(OutputVector{main_result0, main_result1}, ParameterVector{main_param0}); } @@ -154,16 +152,16 @@ TEST_F(TransformationTestsF, LoopInputsNothing) { TEST_F(TransformationTestsF, LoopInputsTensorIteratorInvariantAndOutput) { { - auto main_param0 = std::make_shared(element::i32, Shape{1}); - auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); + auto main_param0 = std::make_shared(element::i32, Shape{1}); + auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); - auto loop = std::make_shared(); + auto loop = std::make_shared(); - auto param0 = std::make_shared(element::i32, Shape{1}); - auto param1 = std::make_shared(element::i32, Shape{1}); - auto add = std::make_shared(param0, param1); - auto result0 = std::make_shared(add); - auto result1 = std::make_shared(param1); + auto param0 = std::make_shared(element::i32, Shape{1}); + auto param1 = std::make_shared(element::i32, Shape{1}); + auto add = std::make_shared(param0, param1); + auto result0 = std::make_shared(add); + auto result1 = std::make_shared(param1); auto body = std::make_shared(OutputVector{result0, result1}, ParameterVector{param0, param1}); loop->set_function(body); @@ -171,11 +169,11 @@ TEST_F(TransformationTestsF, LoopInputsTensorIteratorInvariantAndOutput) { loop->set_invariant_input(param0, main_param0); loop->set_merged_input(param1, main_const1, result1); - auto tanh = std::make_shared(loop->get_iter_value(result0)); - auto sinh = std::make_shared(loop->get_iter_value(result1)); + auto tanh = std::make_shared(loop->get_iter_value(result0)); + auto sinh = std::make_shared(loop->get_iter_value(result1)); - auto main_result0 = std::make_shared(tanh); - auto main_result1 = std::make_shared(sinh); + auto main_result0 = std::make_shared(tanh); + auto main_result1 = std::make_shared(sinh); model = std::make_shared(OutputVector{main_result0, main_result1}, ParameterVector{main_param0}); @@ -183,15 +181,15 @@ TEST_F(TransformationTestsF, LoopInputsTensorIteratorInvariantAndOutput) { } { - auto main_param0 = std::make_shared(element::i32, Shape{1}); - auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); + auto main_param0 = std::make_shared(element::i32, Shape{1}); + auto main_const1 = std::make_shared(element::i32, Shape{1}, 1); - auto loop = std::make_shared(); + auto loop = std::make_shared(); - auto param0 = std::make_shared(element::i32, Shape{1}); - auto param1 = std::make_shared(element::i32, Shape{1}); - auto add = std::make_shared(param0, param1); - auto result0 = std::make_shared(add); + auto param0 = std::make_shared(element::i32, Shape{1}); + auto param1 = std::make_shared(element::i32, Shape{1}); + auto add = std::make_shared(param0, param1); + auto result0 = std::make_shared(add); auto body = std::make_shared(OutputVector{result0}, ParameterVector{param0, param1}); loop->set_function(body); @@ -199,11 +197,11 @@ TEST_F(TransformationTestsF, LoopInputsTensorIteratorInvariantAndOutput) { loop->set_invariant_input(param0, main_param0); loop->set_invariant_input(param1, main_const1); - auto tanh = std::make_shared(loop->get_iter_value(result0)); - auto sinh = std::make_shared(main_const1); + auto tanh = std::make_shared(loop->get_iter_value(result0)); + auto sinh = std::make_shared(main_const1); - auto main_result0 = std::make_shared(tanh); - auto main_result1 = std::make_shared(sinh); + auto main_result0 = std::make_shared(tanh); + auto main_result1 = std::make_shared(sinh); model_ref = std::make_shared(OutputVector{main_result0, main_result1}, ParameterVector{main_param0}); } diff --git a/src/common/transformations/tests/common_optimizations/eliminate_unsqueeze_gather.cpp b/src/common/transformations/tests/common_optimizations/eliminate_unsqueeze_gather.cpp index 8818c98e98e2b1..24e60c2ce8db1b 100644 --- a/src/common/transformations/tests/common_optimizations/eliminate_unsqueeze_gather.cpp +++ b/src/common/transformations/tests/common_optimizations/eliminate_unsqueeze_gather.cpp @@ -18,8 +18,6 @@ #include "transformations/common_optimizations/simplify_shape_of_sub_graph.hpp" using namespace ov; -using namespace ov::op; - namespace { using TensorType = ov::element::Type_t; @@ -41,19 +39,19 @@ class EliminateUnsqueezeGatherTest : public TransformationTestsF, protected: static std::shared_ptr transform(const TensorShape& inShape, const TensorType& inType, size_t axis) { - const auto parameter = std::make_shared(inType, inShape); + const auto parameter = std::make_shared(inType, inShape); const auto unsqueeze = - std::make_shared(parameter, v0::Constant::create(element::i64, Shape{1}, {axis})); - const auto gather = std::make_shared(unsqueeze, - v0::Constant::create(element::i64, Shape{1}, {0}), - v0::Constant::create(element::i64, Shape{1}, {axis})); - const auto relu = std::make_shared(gather); + std::make_shared(parameter, ov::op::v0::Constant::create(element::i64, Shape{1}, {axis})); + const auto gather = std::make_shared(unsqueeze, + ov::op::v0::Constant::create(element::i64, Shape{1}, {0}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {axis})); + const auto relu = std::make_shared(gather); return std::make_shared(OutputVector{relu}, ParameterVector{parameter}, "Actual"); } static std::shared_ptr reference(const TensorShape& inShape, const TensorType& inType) { - const auto parameter = std::make_shared(inType, inShape); - const auto relu = std::make_shared(parameter); + const auto parameter = std::make_shared(inType, inShape); + const auto relu = std::make_shared(parameter); return std::make_shared(OutputVector{relu}, ParameterVector{parameter}, "Reference"); } }; @@ -71,153 +69,153 @@ INSTANTIATE_TEST_SUITE_P( TEST_F(TransformationTestsF, GatherUnsqueeze) { { - auto data = std::make_shared(element::dynamic, PartialShape{-1}); - auto indices = std::make_shared(element::dynamic, PartialShape{}); - auto axis = v0::Constant::create(element::i32, Shape{}, {0}); + auto data = std::make_shared(element::dynamic, PartialShape{-1}); + auto indices = std::make_shared(element::dynamic, PartialShape{}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {0}); - auto gather = std::make_shared(data, indices, axis); - auto unsqueeze = std::make_shared(gather, axis); - const auto relu = std::make_shared(unsqueeze); + auto gather = std::make_shared(data, indices, axis); + auto unsqueeze = std::make_shared(gather, axis); + const auto relu = std::make_shared(unsqueeze); model = std::make_shared(OutputVector{relu}, ParameterVector{data, indices}); manager.register_pass(); } { - auto data = std::make_shared(element::dynamic, PartialShape{-1}); - auto indices = std::make_shared(element::dynamic, PartialShape{}); - auto axis = v0::Constant::create(element::i32, Shape{}, {0}); + auto data = std::make_shared(element::dynamic, PartialShape{-1}); + auto indices = std::make_shared(element::dynamic, PartialShape{}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {0}); auto updated_indices = - std::make_shared(indices, v0::Constant::create(element::i32, {1}, {1}), false); - auto gather = std::make_shared(data, updated_indices, axis); - const auto relu = std::make_shared(gather); + std::make_shared(indices, ov::op::v0::Constant::create(element::i32, {1}, {1}), false); + auto gather = std::make_shared(data, updated_indices, axis); + const auto relu = std::make_shared(gather); model_ref = std::make_shared(OutputVector{relu}, ParameterVector{data, indices}); } } TEST_F(TransformationTestsF, GatherUnsqueezeReshape) { { - auto data = std::make_shared(element::dynamic, PartialShape{-1}); - auto indices = std::make_shared(element::dynamic, PartialShape{}); - auto axis = v0::Constant::create(element::i32, Shape{}, {0}); + auto data = std::make_shared(element::dynamic, PartialShape{-1}); + auto indices = std::make_shared(element::dynamic, PartialShape{}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {0}); - auto gather = std::make_shared(data, indices, axis); + auto gather = std::make_shared(data, indices, axis); auto unsqueeze = - std::make_shared(gather, v0::Constant::create(element::i32, Shape{1}, {1}), false); - const auto relu = std::make_shared(unsqueeze); + std::make_shared(gather, ov::op::v0::Constant::create(element::i32, Shape{1}, {1}), false); + const auto relu = std::make_shared(unsqueeze); model = std::make_shared(OutputVector{relu}, ParameterVector{data, indices}); manager.register_pass(); } { - auto data = std::make_shared(element::dynamic, PartialShape{-1}); - auto indices = std::make_shared(element::dynamic, PartialShape{}); - auto axis = v0::Constant::create(element::i32, Shape{}, {0}); + auto data = std::make_shared(element::dynamic, PartialShape{-1}); + auto indices = std::make_shared(element::dynamic, PartialShape{}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {0}); auto updated_indices = - std::make_shared(indices, v0::Constant::create(element::i32, {1}, {1}), false); - auto gather = std::make_shared(data, updated_indices, axis); - const auto relu = std::make_shared(gather); + std::make_shared(indices, ov::op::v0::Constant::create(element::i32, {1}, {1}), false); + auto gather = std::make_shared(data, updated_indices, axis); + const auto relu = std::make_shared(gather); model_ref = std::make_shared(OutputVector{relu}, ParameterVector{data, indices}); } } TEST_F(TransformationTestsF, GatherUnsqueezeMul) { { - auto data = std::make_shared(element::dynamic, PartialShape{-1}); - auto indices = std::make_shared(element::dynamic, PartialShape{}); - auto axis = v0::Constant::create(element::i32, Shape{}, {0}); + auto data = std::make_shared(element::dynamic, PartialShape{-1}); + auto indices = std::make_shared(element::dynamic, PartialShape{}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {0}); - auto gather = std::make_shared(data, indices, axis); + auto gather = std::make_shared(data, indices, axis); - auto scalar = std::make_shared(element::dynamic, PartialShape{}); - auto bea = std::make_shared(gather, scalar); + auto scalar = std::make_shared(element::dynamic, PartialShape{}); + auto bea = std::make_shared(gather, scalar); - auto unsqueeze = std::make_shared(bea, axis); - const auto relu = std::make_shared(unsqueeze); + auto unsqueeze = std::make_shared(bea, axis); + const auto relu = std::make_shared(unsqueeze); model = std::make_shared(OutputVector{relu}, ParameterVector{data, indices, scalar}); manager.register_pass(); } { - auto data = std::make_shared(element::dynamic, PartialShape{-1}); - auto indices = std::make_shared(element::dynamic, PartialShape{}); - auto axis = v0::Constant::create(element::i32, Shape{}, {0}); + auto data = std::make_shared(element::dynamic, PartialShape{-1}); + auto indices = std::make_shared(element::dynamic, PartialShape{}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {0}); auto updated_indices = - std::make_shared(indices, v0::Constant::create(element::i32, {1}, {1}), false); - auto gather = std::make_shared(data, updated_indices, axis); + std::make_shared(indices, ov::op::v0::Constant::create(element::i32, {1}, {1}), false); + auto gather = std::make_shared(data, updated_indices, axis); - auto scalar = std::make_shared(element::dynamic, PartialShape{}); - auto bea = std::make_shared(gather, scalar); + auto scalar = std::make_shared(element::dynamic, PartialShape{}); + auto bea = std::make_shared(gather, scalar); - const auto relu = std::make_shared(bea); + const auto relu = std::make_shared(bea); model_ref = std::make_shared(OutputVector{relu}, ParameterVector{data, indices, scalar}); } } TEST_F(TransformationTestsF, GatherUnsqueezesMul) { { - auto data = std::make_shared(element::dynamic, PartialShape{-1}); - auto indices = std::make_shared(element::dynamic, PartialShape{}); - auto axis = v0::Constant::create(element::i32, Shape{}, {0}); + auto data = std::make_shared(element::dynamic, PartialShape{-1}); + auto indices = std::make_shared(element::dynamic, PartialShape{}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {0}); - auto gather = std::make_shared(data, indices, axis); + auto gather = std::make_shared(data, indices, axis); - auto scalar = std::make_shared(element::dynamic, PartialShape{}); - auto bea = std::make_shared(gather, scalar); + auto scalar = std::make_shared(element::dynamic, PartialShape{}); + auto bea = std::make_shared(gather, scalar); - auto unsqueeze_0 = std::make_shared(bea, axis); - auto unsqueeze_1 = std::make_shared(bea, axis); - auto unsqueeze_2 = std::make_shared(bea, axis); + auto unsqueeze_0 = std::make_shared(bea, axis); + auto unsqueeze_1 = std::make_shared(bea, axis); + auto unsqueeze_2 = std::make_shared(bea, axis); - auto concat = std::make_shared(OutputVector{unsqueeze_0, unsqueeze_1, unsqueeze_2}, 0); + auto concat = std::make_shared(OutputVector{unsqueeze_0, unsqueeze_1, unsqueeze_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data, indices, scalar}); manager.register_pass(); } { - auto data = std::make_shared(element::dynamic, PartialShape{-1}); - auto indices = std::make_shared(element::dynamic, PartialShape{}); - auto axis = v0::Constant::create(element::i32, Shape{}, {0}); + auto data = std::make_shared(element::dynamic, PartialShape{-1}); + auto indices = std::make_shared(element::dynamic, PartialShape{}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {0}); auto updated_indices = - std::make_shared(indices, v0::Constant::create(element::i32, {1}, {1}), false); - auto gather = std::make_shared(data, updated_indices, axis); + std::make_shared(indices, ov::op::v0::Constant::create(element::i32, {1}, {1}), false); + auto gather = std::make_shared(data, updated_indices, axis); - auto scalar = std::make_shared(element::dynamic, PartialShape{}); - auto bea = std::make_shared(gather, scalar); + auto scalar = std::make_shared(element::dynamic, PartialShape{}); + auto bea = std::make_shared(gather, scalar); - auto concat = std::make_shared(OutputVector{bea, bea, bea}, 0); + auto concat = std::make_shared(OutputVector{bea, bea, bea}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data, indices, scalar}); } } TEST_F(TransformationTestsF, GatherUnsqueezes) { { - auto data = std::make_shared(element::dynamic, PartialShape{-1}); - auto indices = std::make_shared(element::dynamic, PartialShape{}); - auto axis = v0::Constant::create(element::i32, Shape{1}, {0}); + auto data = std::make_shared(element::dynamic, PartialShape{-1}); + auto indices = std::make_shared(element::dynamic, PartialShape{}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{1}, {0}); - auto gather = std::make_shared(data, indices, axis); + auto gather = std::make_shared(data, indices, axis); - auto unsqueeze_0 = std::make_shared(gather, axis); - auto unsqueeze_1 = std::make_shared(gather, axis); - auto unsqueeze_2 = std::make_shared(gather, axis); + auto unsqueeze_0 = std::make_shared(gather, axis); + auto unsqueeze_1 = std::make_shared(gather, axis); + auto unsqueeze_2 = std::make_shared(gather, axis); - auto concat = std::make_shared(OutputVector{unsqueeze_0, unsqueeze_1, unsqueeze_2, axis}, 0); + auto concat = std::make_shared(OutputVector{unsqueeze_0, unsqueeze_1, unsqueeze_2, axis}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data, indices}); manager.register_pass(); manager.register_pass(); } { - auto data = std::make_shared(element::dynamic, PartialShape{-1}); - auto indices = std::make_shared(element::dynamic, PartialShape{}); - auto axis = v0::Constant::create(element::i32, Shape{1}, {0}); + auto data = std::make_shared(element::dynamic, PartialShape{-1}); + auto indices = std::make_shared(element::dynamic, PartialShape{}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{1}, {0}); auto updated_indices = - std::make_shared(indices, v0::Constant::create(element::i32, {1}, {1}), false); - auto gather = std::make_shared(data, updated_indices, axis); + std::make_shared(indices, ov::op::v0::Constant::create(element::i32, {1}, {1}), false); + auto gather = std::make_shared(data, updated_indices, axis); - auto concat = std::make_shared(OutputVector{gather, gather, gather, axis}, 0); + auto concat = std::make_shared(OutputVector{gather, gather, gather, axis}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data, indices}); } diff --git a/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp b/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp index 3ee1bf06a35493..3b75582aa812f1 100644 --- a/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp +++ b/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp @@ -36,8 +36,6 @@ using namespace testing; using namespace ov; using namespace std; using namespace ov::opset10; -using namespace ov::op; - TEST(TransformationTests, keep_precission_sensitive_fp32_1) { shared_ptr model, model_ref; pass::Manager manager; @@ -1368,13 +1366,13 @@ TEST(TransformationTests, MarkDivWithEpsToKeepInMixedPrecision_disable_for_quant } TEST_F(TransformationTestsF, MarkRandomUniformAsPrecisionSensitive) { - auto param = std::make_shared(ov::element::i32, ov::PartialShape{2}); - auto random_uniform = std::make_shared(param, - v0::Constant::create(element::f32, {}, {0}), - v0::Constant::create(element::f32, {}, {1}), + auto param = std::make_shared(ov::element::i32, ov::PartialShape{2}); + auto random_uniform = std::make_shared(param, + ov::op::v0::Constant::create(element::f32, {}, {0}), + ov::op::v0::Constant::create(element::f32, {}, {1}), element::f32); - auto less = std::make_shared(random_uniform, v0::Constant::create(element::f32, {1, 1}, {0.5})); - auto res = std::make_shared(less); + auto less = std::make_shared(random_uniform, ov::op::v0::Constant::create(element::f32, {1, 1}, {0.5})); + auto res = std::make_shared(less); model = std::make_shared(OutputVector{res}, ParameterVector{param}); diff --git a/src/common/transformations/tests/common_optimizations/moc_transformations.cpp b/src/common/transformations/tests/common_optimizations/moc_transformations.cpp index cea502725853b8..fa75ad158a21e4 100644 --- a/src/common/transformations/tests/common_optimizations/moc_transformations.cpp +++ b/src/common/transformations/tests/common_optimizations/moc_transformations.cpp @@ -121,17 +121,16 @@ TEST(TransformationTests, TestModelTensorsConsistencyUseShapesFalse) { TEST_F(TransformationTestsF, SqueezeRemainsSqueezeAfterMOC) { { - using namespace ov::op; - auto input = std::make_shared(element::f32, Shape{30}); - auto shape = v0::Constant::create(element::i64, Shape{5}, {2, 3, 1, 5, 1}); - auto reshape = std::make_shared(input, shape, false); - auto unsqueeze_axes = v0::Constant::create(element::i64, Shape{1}, {0}); - auto unsqueeze = std::make_shared(reshape, unsqueeze_axes); +auto input = std::make_shared(element::f32, Shape{30}); + auto shape = ov::op::v0::Constant::create(element::i64, Shape{5}, {2, 3, 1, 5, 1}); + auto reshape = std::make_shared(input, shape, false); + auto unsqueeze_axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {0}); + auto unsqueeze = std::make_shared(reshape, unsqueeze_axes); - auto squeeze_axes = v0::Constant::create(element::i64, Shape{2}, {3, 5}); - auto squeeze = std::make_shared(unsqueeze, squeeze_axes); + auto squeeze_axes = ov::op::v0::Constant::create(element::i64, Shape{2}, {3, 5}); + auto squeeze = std::make_shared(unsqueeze, squeeze_axes); - auto res = std::make_shared(squeeze); + auto res = std::make_shared(squeeze); model = std::make_shared(ov::ResultVector{res}, ov::ParameterVector{input}); manager.register_pass(false); } @@ -141,15 +140,14 @@ TEST_F(TransformationTestsF, MOCTest) { std::shared_ptr weights; std::shared_ptr weights_ref; { - using namespace ov::op; - auto data = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); - auto data1 = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); - auto a_mul = std::make_shared(data, data1); - weights = std::make_shared(element::f32, ov::Shape{3, 5}); - auto scale = std::make_shared(element::f32, ov::Shape{}, 0.194145); - auto matmul = std::make_shared(a_mul, weights, false, true); - auto mul = std::make_shared(matmul, scale); - auto res = std::make_shared(mul); +auto data = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); + auto data1 = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); + auto a_mul = std::make_shared(data, data1); + weights = std::make_shared(element::f32, ov::Shape{3, 5}); + auto scale = std::make_shared(element::f32, ov::Shape{}, 0.194145); + auto matmul = std::make_shared(a_mul, weights, false, true); + auto mul = std::make_shared(matmul, scale); + auto res = std::make_shared(mul); weights->set_friendly_name("self.model.layers.50.mlp.down_proj.weight"); @@ -157,15 +155,14 @@ TEST_F(TransformationTestsF, MOCTest) { manager.register_pass(false); } { - using namespace ov::op; - auto data = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); - auto data1 = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); - auto a_mul = std::make_shared(data, data1); - weights_ref = std::make_shared(element::f32, ov::Shape{3, 5}); - auto scale = std::make_shared(element::f32, ov::Shape{1, 1, 1}, 0.194145); - auto matmul = std::make_shared(a_mul, weights_ref, false, true); - auto mul = std::make_shared(matmul, scale); - auto res = std::make_shared(mul); +auto data = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); + auto data1 = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); + auto a_mul = std::make_shared(data, data1); + weights_ref = std::make_shared(element::f32, ov::Shape{3, 5}); + auto scale = std::make_shared(element::f32, ov::Shape{1, 1, 1}, 0.194145); + auto matmul = std::make_shared(a_mul, weights_ref, false, true); + auto mul = std::make_shared(matmul, scale); + auto res = std::make_shared(mul); weights_ref->set_friendly_name("self.model.layers.50.mlp.down_proj.weight"); diff --git a/src/common/transformations/tests/common_optimizations/sdpa_fusion_test.cpp b/src/common/transformations/tests/common_optimizations/sdpa_fusion_test.cpp index 7adb23161ed304..eeff8876da8f63 100644 --- a/src/common/transformations/tests/common_optimizations/sdpa_fusion_test.cpp +++ b/src/common/transformations/tests/common_optimizations/sdpa_fusion_test.cpp @@ -33,7 +33,6 @@ using namespace std; using namespace testing; using namespace ov; -using namespace ov::op; using namespace ov::pass; using namespace ov::element; @@ -55,7 +54,7 @@ class SDPA { void set_mask(const PartialShape& new_mask_pshape) { with_mask = true; - m_mask = make_shared(m_type, new_mask_pshape); + m_mask = make_shared(m_type, new_mask_pshape); params.push_back(m_mask); } @@ -73,9 +72,9 @@ class SDPA { m_sinks_slice_type = sinks_slice_type; std::vector broadcast_shape_value(sinks_broadcast_shape.begin(), sinks_broadcast_shape.end()); auto broadcast_to_shape = - v0::Constant::create(element::i32, Shape{sinks_broadcast_shape.size()}, broadcast_shape_value); - auto sinks_param = make_shared(element::f16, sinks_shape); - m_sinks = make_shared(sinks_param, broadcast_to_shape, BroadcastType::BIDIRECTIONAL); + ov::op::v0::Constant::create(element::i32, Shape{sinks_broadcast_shape.size()}, broadcast_shape_value); + auto sinks_param = make_shared(element::f16, sinks_shape); + m_sinks = make_shared(sinks_param, broadcast_to_shape, ov::op::BroadcastType::BIDIRECTIONAL); m_sinks_rank = sinks_broadcast_shape.size(); params.push_back(sinks_param); } @@ -151,10 +150,10 @@ class SDPA { attn_scores_with_mask = make_shared(attn_scores_scaled, m_mask); } if (with_sinks) { - attn_scores_with_mask = make_shared(OutputVector{attn_scores_with_mask, m_sinks}, -1); + attn_scores_with_mask = make_shared(OutputVector{attn_scores_with_mask, m_sinks}, -1); auto reduce_max = - make_shared(attn_scores_with_mask, op::v0::Constant::create(i64, {}, {-1})); - attn_scores_with_mask = make_shared(attn_scores_with_mask, reduce_max); + make_shared(attn_scores_with_mask, op::v0::Constant::create(i64, {}, {-1})); + attn_scores_with_mask = make_shared(attn_scores_with_mask, reduce_max); } std::shared_ptr softmax = make_shared(attn_scores_with_mask, softmax_axis); @@ -163,10 +162,10 @@ class SDPA { // For now, there has been only one model with sinks: gpt-oss if (m_sinks_slice_type == SinksSliceType::Slice) { softmax = make_shared(softmax, - v0::Constant::create(element::i64, Shape{1}, {0}), - v0::Constant::create(element::i64, Shape{1}, {-1}), - v0::Constant::create(element::i64, Shape{1}, {1}), - v0::Constant::create(element::i64, Shape{1}, {m_sinks_rank - 1})); + ov::op::v0::Constant::create(element::i64, Shape{1}, {0}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {-1}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {m_sinks_rank - 1})); } else { std::vector start(m_sinks_rank, 0); std::vector stop(m_sinks_rank, 0); @@ -180,9 +179,9 @@ class SDPA { softmax = make_shared(softmax, - v0::Constant::create(element::i64, Shape{m_sinks_rank}, start), - v0::Constant::create(element::i64, Shape{m_sinks_rank}, stop), - v0::Constant::create(element::i64, Shape{m_sinks_rank}, step), + ov::op::v0::Constant::create(element::i64, Shape{m_sinks_rank}, start), + ov::op::v0::Constant::create(element::i64, Shape{m_sinks_rank}, stop), + ov::op::v0::Constant::create(element::i64, Shape{m_sinks_rank}, step), begin_mask, end_mask); } @@ -198,7 +197,7 @@ class SDPA { shared_ptr mask_input = m_mask; if (!with_mask) { - mask_input = v0::Constant::create(m_type, {}, {0.f}); + mask_input = ov::op::v0::Constant::create(m_type, {}, {0.f}); } else { auto mask_input_ps = mask_input->get_output_partial_shape(0); auto mask_input_rank = mask_input_ps.size(); @@ -207,8 +206,8 @@ class SDPA { auto diff = 2 - mask_input_rank; std::vector axes(diff); std::iota(axes.begin(), axes.end(), 0); - auto axes_const = v0::Constant::create(ov::element::i64, ov::Shape{axes.size()}, axes); - auto mask_unsqueeze = std::make_shared(mask_input, axes_const); + auto axes_const = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{axes.size()}, axes); + auto mask_unsqueeze = std::make_shared(mask_input, axes_const); mask_input = mask_unsqueeze; } else { std::vector axes; @@ -221,8 +220,8 @@ class SDPA { } } if (!axes.empty()) { - auto axes_const = v0::Constant::create(ov::element::i64, ov::Shape{axes.size()}, axes); - auto mask_squeeze = std::make_shared(mask_input, axes_const); + auto axes_const = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{axes.size()}, axes); + auto mask_squeeze = std::make_shared(mask_input, axes_const); mask_input = mask_squeeze; } } @@ -259,7 +258,7 @@ class SDPA { } private: - shared_ptr m_mask; + shared_ptr m_mask; shared_ptr m_sinks; size_t m_sinks_rank; ParameterVector params; @@ -1019,9 +1018,9 @@ TEST_F(TransformationTestsF, SDPAFusionTest_Split) { // Preprocessing callback. auto callback = [](auto& nodes) { - auto concat = std::make_shared(OutputVector{nodes[InputType::Q], nodes[InputType::V]}, 3); - auto axis = v0::Constant::create(i64, {}, {3}); - auto split = std::make_shared(concat, axis, 2); + auto concat = std::make_shared(OutputVector{nodes[InputType::Q], nodes[InputType::V]}, 3); + auto axis = ov::op::v0::Constant::create(i64, {}, {3}); + auto split = std::make_shared(concat, axis, 2); nodes[InputType::Q] = split->output(0); nodes[InputType::V] = split->output(1); }; @@ -1204,14 +1203,14 @@ TEST_F(TransformationTestsF, SDPAFusionTest_4dAttentionMaskWithBatch2) { // Preprocessing callback. auto callback = [](auto& nodes) { int64_t axis = 0; - auto axes_node = v0::Constant::create(ov::element::i64, ov::Shape{1}, {axis}); - nodes[InputType::Q] = std::make_shared(nodes[InputType::Q], axes_node)->output(0); + auto axes_node = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {axis}); + nodes[InputType::Q] = std::make_shared(nodes[InputType::Q], axes_node)->output(0); - auto axes_node1 = v0::Constant::create(ov::element::i64, ov::Shape{1}, {axis}); - nodes[InputType::K] = std::make_shared(nodes[InputType::K], axes_node1)->output(0); + auto axes_node1 = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {axis}); + nodes[InputType::K] = std::make_shared(nodes[InputType::K], axes_node1)->output(0); - auto axes_node2 = v0::Constant::create(ov::element::i64, ov::Shape{1}, {axis}); - nodes[InputType::V] = std::make_shared(nodes[InputType::V], axes_node2)->output(0); + auto axes_node2 = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {axis}); + nodes[InputType::V] = std::make_shared(nodes[InputType::V], axes_node2)->output(0); }; // SDPA model. @@ -1248,8 +1247,8 @@ TEST_F(TransformationTestsF, SDPAFusionTest_KScaledInput) { // Preprocessing callback that scales the K input auto callback = [](auto& nodes) { - auto scale_const = v0::Constant::create(f16, Shape{}, {1.f}); - nodes[InputType::K] = std::make_shared(nodes[InputType::K], scale_const); + auto scale_const = ov::op::v0::Constant::create(f16, Shape{}, {1.f}); + nodes[InputType::K] = std::make_shared(nodes[InputType::K], scale_const); }; // SDPA model. @@ -1286,10 +1285,10 @@ TEST_F(TransformationTestsF, SDPAFusionTest_WithConvertAfterScale) { SDPA sdpa_ref(f16, query_shape, key_shape, value_shape); auto callback = [](auto& nodes) { - auto scale_const = v0::Constant::create(f16, {1}, {0.125f}); - nodes[InputType::Q] = std::make_shared(nodes[InputType::Q], scale_const); - auto mul_k = std::make_shared(nodes[InputType::K], scale_const); - nodes[InputType::K] = std::make_shared(mul_k, f16); + auto scale_const = ov::op::v0::Constant::create(f16, {1}, {0.125f}); + nodes[InputType::Q] = std::make_shared(nodes[InputType::Q], scale_const); + auto mul_k = std::make_shared(nodes[InputType::K], scale_const); + nodes[InputType::K] = std::make_shared(mul_k, f16); }; sdpa.set_preprocessing_callback(callback); @@ -1355,9 +1354,9 @@ TEST_F(TransformationTestsF, SDPAFusionTest_ConvertedInputs) { SDPA sdpa_ref(f16, query_shape, key_shape, value_shape); auto callback = [](auto& nodes) { - nodes[InputType::Q] = std::make_shared(nodes[InputType::Q], f16); - nodes[InputType::K] = std::make_shared(nodes[InputType::K], f16); - nodes[InputType::V] = std::make_shared(nodes[InputType::V], f16); + nodes[InputType::Q] = std::make_shared(nodes[InputType::Q], f16); + nodes[InputType::K] = std::make_shared(nodes[InputType::K], f16); + nodes[InputType::V] = std::make_shared(nodes[InputType::V], f16); }; sdpa.set_preprocessing_callback(callback); diff --git a/src/common/transformations/tests/common_optimizations/shared_ops_optimization.cpp b/src/common/transformations/tests/common_optimizations/shared_ops_optimization.cpp index 53bda363b187ba..a6a8ca435f086f 100644 --- a/src/common/transformations/tests/common_optimizations/shared_ops_optimization.cpp +++ b/src/common/transformations/tests/common_optimizations/shared_ops_optimization.cpp @@ -28,8 +28,6 @@ #include "openvino/op/unsqueeze.hpp" using namespace ov; -using namespace ov::op; - class SharedTransformationTestsF : public TransformationTestsF { public: void TearDown() override { @@ -44,25 +42,25 @@ class SharedTransformationTestsF : public TransformationTestsF { const int64_t& stop, const int64_t& step, const int64_t& axis) { - return std::make_shared(out, - v0::Constant::create(element::i64, Shape{1}, {start}), - v0::Constant::create(element::i64, Shape{1}, {stop}), - v0::Constant::create(element::i64, Shape{1}, {step}), - v0::Constant::create(element::i64, Shape{1}, {axis})); + return std::make_shared(out, + ov::op::v0::Constant::create(element::i64, Shape{1}, {start}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {stop}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {step}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {axis})); } static Output make_tile(const Output& out, const std::vector& repeats) { - return std::make_shared(out, v0::Constant::create(element::i64, Shape{repeats.size()}, repeats)); + return std::make_shared(out, ov::op::v0::Constant::create(element::i64, Shape{repeats.size()}, repeats)); } static Output make_reshape(const Output& out, const std::vector& order) { - return std::make_shared(out, v0::Constant::create(element::i64, Shape{order.size()}, order), true); + return std::make_shared(out, ov::op::v0::Constant::create(element::i64, Shape{order.size()}, order), true); } }; TEST_F(SharedTransformationTestsF, SharedSlice) { { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); auto slice_0 = make_slice(data, 1, 2, 3, 3); auto slice_1 = make_slice(data, 1, 2, 3, 3); @@ -70,24 +68,24 @@ TEST_F(SharedTransformationTestsF, SharedSlice) { auto slice_3 = make_slice(data, 1, 2, 3, 3); auto slice_4 = make_slice(data, 1, 2, 3, 3); - auto concat = std::make_shared(OutputVector{slice_0, slice_1, slice_2, slice_3, slice_4}, 0); + auto concat = std::make_shared(OutputVector{slice_0, slice_1, slice_2, slice_3, slice_4}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data}); manager.register_pass(); } { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); auto slice_0 = make_slice(data, 1, 2, 3, 3); auto slice_2 = make_slice(data, 1, 3, 3, 3); - auto concat = std::make_shared(OutputVector{slice_0, slice_0, slice_2, slice_0, slice_0}, 0); + auto concat = std::make_shared(OutputVector{slice_0, slice_0, slice_2, slice_0, slice_0}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data}); } } TEST_F(SharedTransformationTestsF, SharedRecursively) { { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); auto slice_0 = make_slice(data, 1, 2, 3, 3); auto slice_1 = make_slice(data, 1, 2, 3, 3); @@ -114,7 +112,7 @@ TEST_F(SharedTransformationTestsF, SharedRecursively) { auto tile_2_2 = make_tile(slice_2, {1, 2, 3, 4}); auto transpose_2_2 = make_reshape(slice_2, {0, 0, 0, -1}); - auto concat = std::make_shared( + auto concat = std::make_shared( OutputVector{// source from slice 0 tile_0_0, transpose_0_0, @@ -142,7 +140,7 @@ TEST_F(SharedTransformationTestsF, SharedRecursively) { manager.register_pass(); } { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); auto slice_0 = make_slice(data, 1, 2, 3, 3); auto slice_2 = make_slice(data, 1, 3, 3, 3); @@ -153,7 +151,7 @@ TEST_F(SharedTransformationTestsF, SharedRecursively) { auto tile_2_0 = make_tile(slice_2, {1, 2, 3, 4}); auto transpose_2_0 = make_reshape(slice_2, {0, 0, 0, -1}); - auto concat = std::make_shared( + auto concat = std::make_shared( OutputVector{// source from slice 0 tile_0_0, transpose_0_0, @@ -183,33 +181,33 @@ TEST_F(SharedTransformationTestsF, SharedRecursively) { TEST_F(SharedTransformationTestsF, SharedConcat) { { - auto pre_constant_0 = v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); - auto pre_constant_1 = v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); - auto data = std::make_shared(element::f32, PartialShape{-1}); - auto post_constant = v0::Constant::create(element::f32, Shape{1}, std::vector{3.14f}); + auto pre_constant_0 = ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); + auto pre_constant_1 = ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); + auto data = std::make_shared(element::f32, PartialShape{-1}); + auto post_constant = ov::op::v0::Constant::create(element::f32, Shape{1}, std::vector{3.14f}); - auto concat_0 = std::make_shared(OutputVector{pre_constant_0, data, post_constant}, 0); - auto concat_1 = std::make_shared(OutputVector{pre_constant_1, data, post_constant}, 0); + auto concat_0 = std::make_shared(OutputVector{pre_constant_0, data, post_constant}, 0); + auto concat_1 = std::make_shared(OutputVector{pre_constant_1, data, post_constant}, 0); - auto concat = std::make_shared(OutputVector{concat_0, concat_1}, 0); + auto concat = std::make_shared(OutputVector{concat_0, concat_1}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data}); manager.register_pass(); } { - auto pre_constant_0 = v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); - auto data = std::make_shared(element::f32, PartialShape{-1}); - auto post_constant = v0::Constant::create(element::f32, Shape{1}, std::vector{3.14f}); + auto pre_constant_0 = ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); + auto data = std::make_shared(element::f32, PartialShape{-1}); + auto post_constant = ov::op::v0::Constant::create(element::f32, Shape{1}, std::vector{3.14f}); - auto concat_0 = std::make_shared(OutputVector{pre_constant_0, data, post_constant}, 0); + auto concat_0 = std::make_shared(OutputVector{pre_constant_0, data, post_constant}, 0); - auto concat = std::make_shared(OutputVector{concat_0, concat_0}, 0); + auto concat = std::make_shared(OutputVector{concat_0, concat_0}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data}); } } TEST_F(SharedTransformationTestsF, SharedSliceInThreeGroups) { { - auto data = std::make_shared(element::f32, PartialShape::dynamic(10)); + auto data = std::make_shared(element::f32, PartialShape::dynamic(10)); auto slice_0_0 = make_slice(data, 1, 2, 3, 4); auto slice_1_0 = make_slice(data, 2, 3, 4, 5); @@ -223,7 +221,7 @@ TEST_F(SharedTransformationTestsF, SharedSliceInThreeGroups) { auto slice_1_2 = make_slice(data, 2, 3, 4, 5); auto slice_2_2 = make_slice(data, 3, 4, 5, 6); - auto concat = std::make_shared(OutputVector{slice_0_0, + auto concat = std::make_shared(OutputVector{slice_0_0, slice_1_0, slice_2_0, slice_0_1, @@ -238,13 +236,13 @@ TEST_F(SharedTransformationTestsF, SharedSliceInThreeGroups) { manager.register_pass(); } { - auto data = std::make_shared(element::f32, PartialShape::dynamic(10)); + auto data = std::make_shared(element::f32, PartialShape::dynamic(10)); auto slice_0_0 = make_slice(data, 1, 2, 3, 4); auto slice_1_0 = make_slice(data, 2, 3, 4, 5); auto slice_2_0 = make_slice(data, 3, 4, 5, 6); - auto concat = std::make_shared(OutputVector{slice_0_0, + auto concat = std::make_shared(OutputVector{slice_0_0, slice_1_0, slice_2_0, slice_0_0, @@ -261,13 +259,13 @@ TEST_F(SharedTransformationTestsF, SharedSliceInThreeGroups) { TEST_F(SharedTransformationTestsF, SharedConcatCheckOpWithResultIsntReplaced) { { - auto pre_constant_0 = v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); - auto pre_constant_1 = v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); - auto data = std::make_shared(element::f32, PartialShape{-1}); - auto post_constant = v0::Constant::create(element::f32, Shape{1}, std::vector{3.14f}); + auto pre_constant_0 = ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); + auto pre_constant_1 = ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); + auto data = std::make_shared(element::f32, PartialShape{-1}); + auto post_constant = ov::op::v0::Constant::create(element::f32, Shape{1}, std::vector{3.14f}); - auto concat_0 = std::make_shared(OutputVector{pre_constant_0, data, post_constant}, 0); - auto concat_1 = std::make_shared(OutputVector{pre_constant_1, data, post_constant}, 0); + auto concat_0 = std::make_shared(OutputVector{pre_constant_0, data, post_constant}, 0); + auto concat_1 = std::make_shared(OutputVector{pre_constant_1, data, post_constant}, 0); model = std::make_shared(OutputVector{concat_0, concat_1}, ParameterVector{data}); manager.register_pass(); @@ -277,21 +275,21 @@ TEST_F(SharedTransformationTestsF, SharedConcatCheckOpWithResultIsntReplaced) { TEST_F(SharedTransformationTestsF, SharedShapeOfTest) { Shape input_shape{120, 4}; { - auto input = std::make_shared(element::f32, input_shape); + auto input = std::make_shared(element::f32, input_shape); - auto shapeof1_i32 = std::make_shared(input, element::i32); - auto shapeof2_i64 = std::make_shared(input, element::i64); - auto shapeof3_i32 = std::make_shared(input, element::i32); - auto shapeof4_i32 = std::make_shared(input, element::i32); - auto shapeof5_i64 = std::make_shared(input, element::i64); - auto shapeof6_i32 = std::make_shared(input, element::i32); - auto shapeof7_i32 = std::make_shared(input, element::i32); + auto shapeof1_i32 = std::make_shared(input, element::i32); + auto shapeof2_i64 = std::make_shared(input, element::i64); + auto shapeof3_i32 = std::make_shared(input, element::i32); + auto shapeof4_i32 = std::make_shared(input, element::i32); + auto shapeof5_i64 = std::make_shared(input, element::i64); + auto shapeof6_i32 = std::make_shared(input, element::i32); + auto shapeof7_i32 = std::make_shared(input, element::i32); - auto shapeof1_i32_convert = std::make_shared(shapeof1_i32, element::i64); - auto shapeof3_i32_convert = std::make_shared(shapeof3_i32, element::i64); - auto shapeof4_i32_convert = std::make_shared(shapeof4_i32, element::i64); - auto shapeof6_i32_convert = std::make_shared(shapeof6_i32, element::i64); - auto shapeof7_i32_convert = std::make_shared(shapeof7_i32, element::i64); + auto shapeof1_i32_convert = std::make_shared(shapeof1_i32, element::i64); + auto shapeof3_i32_convert = std::make_shared(shapeof3_i32, element::i64); + auto shapeof4_i32_convert = std::make_shared(shapeof4_i32, element::i64); + auto shapeof6_i32_convert = std::make_shared(shapeof6_i32, element::i64); + auto shapeof7_i32_convert = std::make_shared(shapeof7_i32, element::i64); OutputVector inputs_of_concat{shapeof1_i32_convert, shapeof2_i64, @@ -301,17 +299,17 @@ TEST_F(SharedTransformationTestsF, SharedShapeOfTest) { shapeof6_i32_convert, shapeof7_i32_convert}; - auto concat = std::make_shared(inputs_of_concat, 0); + auto concat = std::make_shared(inputs_of_concat, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{input}); manager.register_pass(); } { - auto input = std::make_shared(element::f32, input_shape); + auto input = std::make_shared(element::f32, input_shape); - auto shapeof1_i32 = std::make_shared(input, element::i32); - auto shapeof2_i64 = std::make_shared(input, element::i64); + auto shapeof1_i32 = std::make_shared(input, element::i32); + auto shapeof2_i64 = std::make_shared(input, element::i64); - auto shapeof1_i32_convert = std::make_shared(shapeof1_i32, element::i64); + auto shapeof1_i32_convert = std::make_shared(shapeof1_i32, element::i64); OutputVector inputs_of_concat{shapeof1_i32_convert, shapeof2_i64, @@ -321,7 +319,7 @@ TEST_F(SharedTransformationTestsF, SharedShapeOfTest) { shapeof1_i32_convert, shapeof1_i32_convert}; - auto concat = std::make_shared(inputs_of_concat, 0); + auto concat = std::make_shared(inputs_of_concat, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{input}); } } @@ -329,67 +327,67 @@ TEST_F(SharedTransformationTestsF, SharedShapeOfTest) { TEST_F(SharedTransformationTestsF, SharedShapeOfTestI64Only) { Shape input_shape{120, 4}; { - auto input = std::make_shared(element::f32, input_shape); + auto input = std::make_shared(element::f32, input_shape); - auto shapeof1_i64 = std::make_shared(input, element::i64); - auto shapeof2_i64 = std::make_shared(input, element::i64); - auto shapeof3_i64 = std::make_shared(input, element::i64); + auto shapeof1_i64 = std::make_shared(input, element::i64); + auto shapeof2_i64 = std::make_shared(input, element::i64); + auto shapeof3_i64 = std::make_shared(input, element::i64); OutputVector inputs_of_concat{shapeof1_i64, shapeof2_i64, shapeof3_i64}; - auto concat = std::make_shared(inputs_of_concat, 0); + auto concat = std::make_shared(inputs_of_concat, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{input}); manager.register_pass(); } { - auto input = std::make_shared(element::f32, input_shape); - auto shapeof1_i64 = std::make_shared(input, element::i64); + auto input = std::make_shared(element::f32, input_shape); + auto shapeof1_i64 = std::make_shared(input, element::i64); OutputVector inputs_of_concat{shapeof1_i64, shapeof1_i64, shapeof1_i64}; - auto concat = std::make_shared(inputs_of_concat, 0); + auto concat = std::make_shared(inputs_of_concat, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{input}); } } TEST_F(SharedTransformationTestsF, Sharedv1Broadcasts) { { - auto input = std::make_shared(element::f32, PartialShape::dynamic()); - auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); - auto broadcast_v1_0 = std::make_shared(input, target_shape); - auto broadcast_v1_1 = std::make_shared(input, target_shape, AutoBroadcastType::PDPD); - auto broadcast_v1_2 = std::make_shared(input, target_shape); - auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_2}, 0); + auto input = std::make_shared(element::f32, PartialShape::dynamic()); + auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); + auto broadcast_v1_0 = std::make_shared(input, target_shape); + auto broadcast_v1_1 = std::make_shared(input, target_shape, ov::op::AutoBroadcastType::PDPD); + auto broadcast_v1_2 = std::make_shared(input, target_shape); + auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{input, target_shape}); manager.register_pass(); } { - auto input = std::make_shared(element::f32, PartialShape::dynamic()); - auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); - auto broadcast_v1_0 = std::make_shared(input, target_shape); - auto broadcast_v1_1 = std::make_shared(input, target_shape, AutoBroadcastType::PDPD); - auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_0}, 0); + auto input = std::make_shared(element::f32, PartialShape::dynamic()); + auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); + auto broadcast_v1_0 = std::make_shared(input, target_shape); + auto broadcast_v1_1 = std::make_shared(input, target_shape, ov::op::AutoBroadcastType::PDPD); + auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_0}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{input, target_shape}); } } TEST_F(SharedTransformationTestsF, Sharedv3Broadcasts) { { - auto input = std::make_shared(element::f32, PartialShape::dynamic()); - auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); - auto broadcast_v1_0 = std::make_shared(input, target_shape); - auto broadcast_v1_1 = std::make_shared(input, target_shape, BroadcastType::BIDIRECTIONAL); - auto broadcast_v1_2 = std::make_shared(input, target_shape); - auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_2}, 0); + auto input = std::make_shared(element::f32, PartialShape::dynamic()); + auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); + auto broadcast_v1_0 = std::make_shared(input, target_shape); + auto broadcast_v1_1 = std::make_shared(input, target_shape, ov::op::BroadcastType::BIDIRECTIONAL); + auto broadcast_v1_2 = std::make_shared(input, target_shape); + auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{input, target_shape}); manager.register_pass(); } { - auto input = std::make_shared(element::f32, PartialShape::dynamic()); - auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); - auto broadcast_v1_0 = std::make_shared(input, target_shape); - auto broadcast_v1_1 = std::make_shared(input, target_shape, BroadcastType::BIDIRECTIONAL); - auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_0}, 0); + auto input = std::make_shared(element::f32, PartialShape::dynamic()); + auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); + auto broadcast_v1_0 = std::make_shared(input, target_shape); + auto broadcast_v1_1 = std::make_shared(input, target_shape, ov::op::BroadcastType::BIDIRECTIONAL); + auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_0}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{input, target_shape}); } } @@ -397,19 +395,19 @@ TEST_F(SharedTransformationTestsF, Sharedv3Broadcasts) { TEST_F(SharedTransformationTestsF, SharedShapeOfTestI32Only) { Shape input_shape{120, 4}; { - auto input = std::make_shared(element::f32, input_shape); + auto input = std::make_shared(element::f32, input_shape); - auto shapeof1_i32 = std::make_shared(input, element::i32); - auto shapeof2_i32 = std::make_shared(input, element::i32); - auto shapeof3_i32 = std::make_shared(input, element::i32); - auto shapeof4_i32 = std::make_shared(input, element::i32); - auto shapeof5_i32 = std::make_shared(input, element::i32); + auto shapeof1_i32 = std::make_shared(input, element::i32); + auto shapeof2_i32 = std::make_shared(input, element::i32); + auto shapeof3_i32 = std::make_shared(input, element::i32); + auto shapeof4_i32 = std::make_shared(input, element::i32); + auto shapeof5_i32 = std::make_shared(input, element::i32); - auto shapeof1_i32_convert = std::make_shared(shapeof1_i32, element::i64); - auto shapeof2_i32_convert = std::make_shared(shapeof2_i32, element::i64); - auto shapeof3_i32_convert = std::make_shared(shapeof3_i32, element::i64); - auto shapeof4_i32_convert = std::make_shared(shapeof4_i32, element::i64); - auto shapeof5_i32_convert = std::make_shared(shapeof5_i32, element::i64); + auto shapeof1_i32_convert = std::make_shared(shapeof1_i32, element::i64); + auto shapeof2_i32_convert = std::make_shared(shapeof2_i32, element::i64); + auto shapeof3_i32_convert = std::make_shared(shapeof3_i32, element::i64); + auto shapeof4_i32_convert = std::make_shared(shapeof4_i32, element::i64); + auto shapeof5_i32_convert = std::make_shared(shapeof5_i32, element::i64); OutputVector inputs_of_concat{shapeof1_i32_convert, shapeof2_i32_convert, @@ -417,16 +415,16 @@ TEST_F(SharedTransformationTestsF, SharedShapeOfTestI32Only) { shapeof4_i32_convert, shapeof5_i32_convert}; - auto concat = std::make_shared(inputs_of_concat, 0); + auto concat = std::make_shared(inputs_of_concat, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{input}); manager.register_pass(); } { - auto input = std::make_shared(element::f32, input_shape); + auto input = std::make_shared(element::f32, input_shape); - auto shapeof1_i32 = std::make_shared(input, element::i32); + auto shapeof1_i32 = std::make_shared(input, element::i32); - auto shapeof1_i32_convert = std::make_shared(shapeof1_i32, element::i64); + auto shapeof1_i32_convert = std::make_shared(shapeof1_i32, element::i64); OutputVector inputs_of_concat{shapeof1_i32_convert, shapeof1_i32_convert, @@ -434,7 +432,7 @@ TEST_F(SharedTransformationTestsF, SharedShapeOfTestI32Only) { shapeof1_i32_convert, shapeof1_i32_convert}; - auto concat = std::make_shared(inputs_of_concat, 0); + auto concat = std::make_shared(inputs_of_concat, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{input}); } } @@ -442,19 +440,19 @@ TEST_F(SharedTransformationTestsF, SharedShapeOfTestI32Only) { TEST_F(SharedTransformationTestsF, SharedShapeOfTestMixed) { Shape input_shape{120, 4}; { - auto input = std::make_shared(element::f32, input_shape); + auto input = std::make_shared(element::f32, input_shape); - auto shapeof1 = std::make_shared(input); - auto shapeof2_i64 = std::make_shared(input, element::i64); - auto shapeof3_i32 = std::make_shared(input, element::i32); - auto shapeof4 = std::make_shared(input); - auto shapeof5_i64 = std::make_shared(input, element::i64); - auto shapeof6_i32 = std::make_shared(input, element::i32); - auto shapeof7_i32 = std::make_shared(input, element::i32); + auto shapeof1 = std::make_shared(input); + auto shapeof2_i64 = std::make_shared(input, element::i64); + auto shapeof3_i32 = std::make_shared(input, element::i32); + auto shapeof4 = std::make_shared(input); + auto shapeof5_i64 = std::make_shared(input, element::i64); + auto shapeof6_i32 = std::make_shared(input, element::i32); + auto shapeof7_i32 = std::make_shared(input, element::i32); - auto shapeof3_i32_convert = std::make_shared(shapeof3_i32, element::i64); - auto shapeof6_i32_convert = std::make_shared(shapeof6_i32, element::i64); - auto shapeof7_i32_convert = std::make_shared(shapeof7_i32, element::i64); + auto shapeof3_i32_convert = std::make_shared(shapeof3_i32, element::i64); + auto shapeof6_i32_convert = std::make_shared(shapeof6_i32, element::i64); + auto shapeof7_i32_convert = std::make_shared(shapeof7_i32, element::i64); OutputVector inputs_of_concat{shapeof1, shapeof2_i64, @@ -464,17 +462,17 @@ TEST_F(SharedTransformationTestsF, SharedShapeOfTestMixed) { shapeof6_i32_convert, shapeof7_i32_convert}; - auto concat = std::make_shared(inputs_of_concat, 0); + auto concat = std::make_shared(inputs_of_concat, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{input}); manager.register_pass(); } { - auto input = std::make_shared(element::f32, input_shape); + auto input = std::make_shared(element::f32, input_shape); - auto shapeof1 = std::make_shared(input, element::i64); - auto shapeof2_i32 = std::make_shared(input, element::i32); + auto shapeof1 = std::make_shared(input, element::i64); + auto shapeof2_i32 = std::make_shared(input, element::i32); - auto shapeof3_i32_convert = std::make_shared(shapeof2_i32, element::i64); + auto shapeof3_i32_convert = std::make_shared(shapeof2_i32, element::i64); OutputVector inputs_of_concat{shapeof1, shapeof1, @@ -484,7 +482,7 @@ TEST_F(SharedTransformationTestsF, SharedShapeOfTestMixed) { shapeof3_i32_convert, shapeof3_i32_convert}; - auto concat = std::make_shared(inputs_of_concat, 0); + auto concat = std::make_shared(inputs_of_concat, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{input}); } } @@ -496,12 +494,12 @@ OutputVector createShapeNodesInMemory(const std::vector& node_order_in_m const std::shared_ptr& input, element::Type output_type) { OutputVector outputs; - memory.reset(::malloc(node_order_in_memory.size() * sizeof(v3::ShapeOf)), ::free); + memory.reset(::malloc(node_order_in_memory.size() * sizeof(ov::op::v3::ShapeOf)), ::free); for (size_t i = 0; i < node_order_in_memory.size(); ++i) { - v3::ShapeOf* node_addr = static_cast(memory.get()) + node_order_in_memory[i]; + ov::op::v3::ShapeOf* node_addr = static_cast(memory.get()) + node_order_in_memory[i]; auto node_ptr = - std::shared_ptr(new (node_addr) v3::ShapeOf(input, output_type), [](v3::ShapeOf* node) { - node->v3::ShapeOf::~ShapeOf(); + std::shared_ptr(new (node_addr) ov::op::v3::ShapeOf(input, output_type), [](ov::op::v3::ShapeOf* node) { + node->ov::op::v3::ShapeOf::~ShapeOf(); }); std::stringstream ss; ss << node_name_prefix << i; @@ -516,16 +514,16 @@ std::shared_ptr createModelWithShapes(const Shape& input_shape, const std::vector& node_order_in_memory, const std::string& node_name_prefix, std::shared_ptr& buffer) { - auto input = std::make_shared(element::f32, input_shape); + auto input = std::make_shared(element::f32, input_shape); auto shape_nodes = createShapeNodesInMemory(node_order_in_memory, buffer, node_name_prefix, input, element::i64); NodeVector inputs_of_concat; for (const auto& shape_node : shape_nodes) { - auto node = std::make_shared(shape_node, element::i64); + auto node = std::make_shared(shape_node, element::i64); inputs_of_concat.push_back(node); } - auto concat = std::make_shared(inputs_of_concat, 0); + auto concat = std::make_shared(inputs_of_concat, 0); return std::make_shared(OutputVector{concat}, ParameterVector{input}); } } // namespace @@ -562,212 +560,212 @@ TEST(TransformationTests, SharedShapeOfTestRandomOrder) { TEST_F(SharedTransformationTestsF, SharedCeiling) { { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto ceiling_1 = std::make_shared(data); - auto ceiling_2 = std::make_shared(data); + auto ceiling_1 = std::make_shared(data); + auto ceiling_2 = std::make_shared(data); - auto concat = std::make_shared(OutputVector{ceiling_1, ceiling_2}, 0); + auto concat = std::make_shared(OutputVector{ceiling_1, ceiling_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data}); manager.register_pass(); } { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto ceiling_1 = std::make_shared(data); + auto ceiling_1 = std::make_shared(data); - auto concat = std::make_shared(OutputVector{ceiling_1, ceiling_1}, 0); + auto concat = std::make_shared(OutputVector{ceiling_1, ceiling_1}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data}); } } TEST_F(SharedTransformationTestsF, SharedFloor) { { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto op_1 = std::make_shared(data); - auto op_2 = std::make_shared(data); + auto op_1 = std::make_shared(data); + auto op_2 = std::make_shared(data); - auto concat = std::make_shared(OutputVector{op_1, op_2}, 0); + auto concat = std::make_shared(OutputVector{op_1, op_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data}); manager.register_pass(); } { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto op_1 = std::make_shared(data); + auto op_1 = std::make_shared(data); - auto concat = std::make_shared(OutputVector{op_1, op_1}, 0); + auto concat = std::make_shared(OutputVector{op_1, op_1}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data}); } } TEST_F(SharedTransformationTestsF, SharedRelu) { { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto op_1 = std::make_shared(data); - auto op_2 = std::make_shared(data); + auto op_1 = std::make_shared(data); + auto op_2 = std::make_shared(data); - auto concat = std::make_shared(OutputVector{op_1, op_2}, 0); + auto concat = std::make_shared(OutputVector{op_1, op_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data}); manager.register_pass(); } { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto op_1 = std::make_shared(data); + auto op_1 = std::make_shared(data); - auto concat = std::make_shared(OutputVector{op_1, op_1}, 0); + auto concat = std::make_shared(OutputVector{op_1, op_1}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data}); } } TEST_F(SharedTransformationTestsF, SharedMultiply) { { - auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto data_1 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data_1 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto op_0 = std::make_shared(data_0, data_1); - auto op_1 = std::make_shared(data_0, data_1); + auto op_0 = std::make_shared(data_0, data_1); + auto op_1 = std::make_shared(data_0, data_1); - auto concat = std::make_shared(OutputVector{op_0, op_1}, 0); + auto concat = std::make_shared(OutputVector{op_0, op_1}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data_0, data_1}); manager.register_pass(); } { - auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto data_1 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data_1 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto op_0 = std::make_shared(data_0, data_1); + auto op_0 = std::make_shared(data_0, data_1); - auto concat = std::make_shared(OutputVector{op_0, op_0}, 0); + auto concat = std::make_shared(OutputVector{op_0, op_0}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data_0, data_1}); } } TEST_F(SharedTransformationTestsF, SharedDivide) { { - auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto data_1 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data_1 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto op_0 = std::make_shared(data_0, data_1); - auto op_1 = std::make_shared(data_0, data_1); + auto op_0 = std::make_shared(data_0, data_1); + auto op_1 = std::make_shared(data_0, data_1); - auto concat = std::make_shared(OutputVector{op_0, op_1}, 0); + auto concat = std::make_shared(OutputVector{op_0, op_1}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data_0, data_1}); manager.register_pass(); } { - auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto data_1 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data_1 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto op_0 = std::make_shared(data_0, data_1); + auto op_0 = std::make_shared(data_0, data_1); - auto concat = std::make_shared(OutputVector{op_0, op_0}, 0); + auto concat = std::make_shared(OutputVector{op_0, op_0}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data_0, data_1}); } } TEST_F(SharedTransformationTestsF, SharedPad) { { - auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto data_1 = std::make_shared(element::i32, PartialShape{4}); - auto data_2 = std::make_shared(element::i32, PartialShape{4}); + auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data_1 = std::make_shared(element::i32, PartialShape{4}); + auto data_2 = std::make_shared(element::i32, PartialShape{4}); - auto op_1 = std::make_shared(data_0, data_1, data_2, PadMode::REFLECT); - auto op_2 = std::make_shared(data_0, data_1, data_2, PadMode::REFLECT); + auto op_1 = std::make_shared(data_0, data_1, data_2, ov::op::PadMode::REFLECT); + auto op_2 = std::make_shared(data_0, data_1, data_2, ov::op::PadMode::REFLECT); - auto concat = std::make_shared(OutputVector{op_1, op_2}, 0); + auto concat = std::make_shared(OutputVector{op_1, op_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data_0, data_1, data_2}); manager.register_pass(); } { - auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto data_1 = std::make_shared(element::i32, PartialShape{4}); - auto data_2 = std::make_shared(element::i32, PartialShape{4}); + auto data_0 = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data_1 = std::make_shared(element::i32, PartialShape{4}); + auto data_2 = std::make_shared(element::i32, PartialShape{4}); - auto op_1 = std::make_shared(data_0, data_1, data_2, PadMode::REFLECT); + auto op_1 = std::make_shared(data_0, data_1, data_2, ov::op::PadMode::REFLECT); - auto concat = std::make_shared(OutputVector{op_1, op_1}, 0); + auto concat = std::make_shared(OutputVector{op_1, op_1}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data_0, data_1, data_2}); } } TEST_F(SharedTransformationTestsF, SharedMaxPool) { { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); auto op_1 = - std::make_shared(data, Strides{1, 1}, Strides{1, 1}, Shape{1, 1}, Shape{1, 1}, Shape{3, 3}); + std::make_shared(data, Strides{1, 1}, Strides{1, 1}, Shape{1, 1}, Shape{1, 1}, Shape{3, 3}); auto op_2 = - std::make_shared(data, Strides{1, 1}, Strides{1, 1}, Shape{1, 1}, Shape{1, 1}, Shape{3, 3}); + std::make_shared(data, Strides{1, 1}, Strides{1, 1}, Shape{1, 1}, Shape{1, 1}, Shape{3, 3}); - auto concat = std::make_shared(OutputVector{op_1, op_2}, 0); + auto concat = std::make_shared(OutputVector{op_1, op_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data}); manager.register_pass(); } { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); auto op_1 = - std::make_shared(data, Strides{1, 1}, Strides{1, 1}, Shape{1, 1}, Shape{1, 1}, Shape{3, 3}); + std::make_shared(data, Strides{1, 1}, Strides{1, 1}, Shape{1, 1}, Shape{1, 1}, Shape{3, 3}); - auto concat = std::make_shared(OutputVector{op_1, op_1}, 0); + auto concat = std::make_shared(OutputVector{op_1, op_1}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data}); } } TEST_F(SharedTransformationTestsF, TopologicalOrder) { { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto shape_of = std::make_shared(data); + auto shape_of = std::make_shared(data); - auto gather_0 = std::make_shared(shape_of, - v0::Constant::create(element::i32, {1}, {0}), - v0::Constant::create(element::i32, {}, {0})); + auto gather_0 = std::make_shared(shape_of, + ov::op::v0::Constant::create(element::i32, {1}, {0}), + ov::op::v0::Constant::create(element::i32, {}, {0})); - auto gather_1 = std::make_shared(shape_of, - v0::Constant::create(element::i32, {1}, {0}), - v0::Constant::create(element::i32, {}, {0})); + auto gather_1 = std::make_shared(shape_of, + ov::op::v0::Constant::create(element::i32, {1}, {0}), + ov::op::v0::Constant::create(element::i32, {}, {0})); - auto gather_2 = std::make_shared(shape_of, - v0::Constant::create(element::i32, {1}, {0}), - v0::Constant::create(element::i32, {}, {0})); + auto gather_2 = std::make_shared(shape_of, + ov::op::v0::Constant::create(element::i32, {1}, {0}), + ov::op::v0::Constant::create(element::i32, {}, {0})); - auto add_0 = std::make_shared(gather_0, gather_0); - auto add_1 = std::make_shared(gather_1, gather_1); - auto add_2 = std::make_shared(gather_2, gather_2); + auto add_0 = std::make_shared(gather_0, gather_0); + auto add_1 = std::make_shared(gather_1, gather_1); + auto add_2 = std::make_shared(gather_2, gather_2); auto concat_0 = - std::make_shared(OutputVector{gather_0, add_0, v0::Constant::create(element::i64, {1}, {0})}, + std::make_shared(OutputVector{gather_0, add_0, ov::op::v0::Constant::create(element::i64, {1}, {0})}, 0); auto concat_1 = - std::make_shared(OutputVector{gather_1, add_1, v0::Constant::create(element::i64, {1}, {0})}, + std::make_shared(OutputVector{gather_1, add_1, ov::op::v0::Constant::create(element::i64, {1}, {0})}, 0); auto concat_2 = - std::make_shared(OutputVector{gather_2, add_2, v0::Constant::create(element::i64, {1}, {0})}, + std::make_shared(OutputVector{gather_2, add_2, ov::op::v0::Constant::create(element::i64, {1}, {0})}, 0); - auto concat = std::make_shared(OutputVector{concat_0, concat_1}, 0); - auto output = std::make_shared(OutputVector{concat, concat_2}, 0); + auto concat = std::make_shared(OutputVector{concat_0, concat_1}, 0); + auto output = std::make_shared(OutputVector{concat, concat_2}, 0); model = std::make_shared(OutputVector{output}, ParameterVector{data}); manager.register_pass(); } { - auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto shape_of = std::make_shared(data); - auto gather_0 = std::make_shared(shape_of, - v0::Constant::create(element::i32, {1}, {0}), - v0::Constant::create(element::i32, {}, {0})); - auto add_0 = std::make_shared(gather_0, gather_0); + auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); + auto shape_of = std::make_shared(data); + auto gather_0 = std::make_shared(shape_of, + ov::op::v0::Constant::create(element::i32, {1}, {0}), + ov::op::v0::Constant::create(element::i32, {}, {0})); + auto add_0 = std::make_shared(gather_0, gather_0); auto concat_0 = - std::make_shared(OutputVector{gather_0, add_0, v0::Constant::create(element::i64, {1}, {0})}, + std::make_shared(OutputVector{gather_0, add_0, ov::op::v0::Constant::create(element::i64, {1}, {0})}, 0); - auto concat = std::make_shared(OutputVector{concat_0, concat_0}, 0); - auto output = std::make_shared(OutputVector{concat, concat_0}, 0); + auto concat = std::make_shared(OutputVector{concat_0, concat_0}, 0); + auto output = std::make_shared(OutputVector{concat, concat_0}, 0); model_ref = std::make_shared(OutputVector{output}, ParameterVector{data}); } } diff --git a/src/common/transformations/tests/op_conversions/sdpa_to_paged_attention_test.cpp b/src/common/transformations/tests/op_conversions/sdpa_to_paged_attention_test.cpp index d7ec40db0b2cb1..e5e090cb4f6513 100644 --- a/src/common/transformations/tests/op_conversions/sdpa_to_paged_attention_test.cpp +++ b/src/common/transformations/tests/op_conversions/sdpa_to_paged_attention_test.cpp @@ -58,7 +58,6 @@ using namespace ov; using namespace std; using namespace testing; -using namespace ov::op; using namespace ov::gen_pattern; namespace { @@ -85,7 +84,7 @@ ov::ParameterVector nodes_to_params(const ov::NodeVector& node_vec) { ov::ParameterVector params; params.reserve(node_vec.size()); for (const auto& node : node_vec) { - params.push_back(ov::as_type_ptr(node)); + params.push_back(ov::as_type_ptr(node)); } return params; } @@ -93,7 +92,7 @@ ov::ParameterVector nodes_to_params(const ov::NodeVector& node_vec) { static std::shared_ptr make_param(const PartialShape& pshape, element::Type element_type, const std::string& name) { - auto param = makeOP({}, {{"shape", pshape}, {"element_type", element_type}}); + auto param = makeOP({}, {{"shape", pshape}, {"element_type", element_type}}); param->set_friendly_name(name); param->get_output_tensor(0).set_names({name}); return param; @@ -108,85 +107,85 @@ vector MOCK_VALUE = {1}; class Qwen7bChatSDPA { public: static std::shared_ptr gen_embeddings(const std::shared_ptr& input_ids) { - auto view_reshape = makeOP({input_ids, {-1, 0}}, {special_zero_true}); - auto input_ids_i64 = makeOP({view_reshape}, {dest_type_i64}); + auto view_reshape = makeOP({input_ids, {-1, 0}}, {special_zero_true}); + auto input_ids_i64 = makeOP({view_reshape}, {dest_type_i64}); auto weights = makeConst(element::u8, {WEIGHTS, 4096}, MOCK_VALUE); - auto weights_fp16 = makeOP({weights}, {dest_type_f16}); + auto weights_fp16 = makeOP({weights}, {dest_type_f16}); auto zero_point = makeConst(element::u8, {WEIGHTS, 1}, MOCK_VALUE); - auto zero_point_fp16 = makeOP({zero_point}, {dest_type_f16}); - auto zero_point_subtract = makeOP({weights_fp16, zero_point_fp16}, {numpy_broadcast}); + auto zero_point_fp16 = makeOP({zero_point}, {dest_type_f16}); + auto zero_point_subtract = makeOP({weights_fp16, zero_point_fp16}, {numpy_broadcast}); auto scale = makeConst(element::f16, {WEIGHTS, 1}, MOCK_VALUE); - auto mul_scale = makeOP({zero_point_subtract, scale}, {numpy_broadcast}); - auto fq_weights = makeOP({mul_scale}, {dest_type_f32}); + auto mul_scale = makeOP({zero_point_subtract, scale}, {numpy_broadcast}); + auto fq_weights = makeOP({mul_scale}, {dest_type_f32}); - return makeOP({fq_weights, input_ids_i64, 0}, {{"batch_dims", 0}}); + return makeOP({fq_weights, input_ids_i64, 0}, {{"batch_dims", 0}}); } static std::shared_ptr gen_attention_weights() { auto weights = makeConst(element::u8, {ATTENTION_WEIGHTS, 4096}, MOCK_VALUE); - auto weights_f16 = makeOP({weights}, {dest_type_f16}); + auto weights_f16 = makeOP({weights}, {dest_type_f16}); auto zero_points = makeConst(element::u8, {ATTENTION_WEIGHTS, 1}, MOCK_VALUE); - auto zero_points_f16 = makeOP({zero_points}, {dest_type_f16}); - auto subtract = makeOP({weights_f16, zero_points_f16}, {numpy_broadcast}); + auto zero_points_f16 = makeOP({zero_points}, {dest_type_f16}); + auto subtract = makeOP({weights_f16, zero_points_f16}, {numpy_broadcast}); auto scale = makeConst(element::f16, {ATTENTION_WEIGHTS, 1}, MOCK_VALUE); - auto mul = makeOP({subtract, scale}, {numpy_broadcast}); - return makeOP({mul}, {dest_type_f32}); + auto mul = makeOP({subtract, scale}, {numpy_broadcast}); + return makeOP({mul}, {dest_type_f32}); } static std::shared_ptr gen_qkv_proj(const std::shared_ptr& embeddings) { auto _const_0 = single_val(/*rank*/ 3, /*val*/ 2); - auto pow = makeOP({embeddings, _const_0}, {numpy_broadcast}); - auto mean = makeOP({pow, {-1}}, {{"keep_dims", true}}); + auto pow = makeOP({embeddings, _const_0}, {numpy_broadcast}); + auto mean = makeOP({pow, {-1}}, {{"keep_dims", true}}); auto _const_1 = single_val(/*rank*/ 3, /*val*/ 1); - auto add = makeOP({mean, _const_1}, {numpy_broadcast}); - auto sqrt = makeOP({add}); + auto add = makeOP({mean, _const_1}, {numpy_broadcast}); + auto sqrt = makeOP({add}); auto _const_2 = single_val(/*rank*/ 3, /*val*/ 1); - auto div = makeOP({_const_2, sqrt}, {numpy_broadcast, {"m_pythondiv", true}}); - auto mul_0 = makeOP({embeddings, div}, {numpy_broadcast}); + auto div = makeOP({_const_2, sqrt}, {numpy_broadcast, {"m_pythondiv", true}}); + auto mul_0 = makeOP({embeddings, div}, {numpy_broadcast}); auto _const_3 = makeConst(element::f32, {1, 1, 4096}, MOCK_VALUE); - auto mul_1 = makeOP({mul_0, _const_3}, {numpy_broadcast}); + auto mul_1 = makeOP({mul_0, _const_3}, {numpy_broadcast}); auto attention_weights = gen_attention_weights(); auto linear_matmul = - makeOP({mul_1, attention_weights}, {{"transpose_a", false}, {"transpose_b", true}}); + makeOP({mul_1, attention_weights}, {{"transpose_a", false}, {"transpose_b", true}}); auto _const_4 = makeConst(element::f32, {1, 1, ATTENTION_WEIGHTS}, MOCK_VALUE); - auto linear_add = makeOP({linear_matmul, _const_4}, {numpy_broadcast}); - return makeOP({linear_add, 2, {4096, 4096, -1}}); + auto linear_add = makeOP({linear_matmul, _const_4}, {numpy_broadcast}); + return makeOP({linear_add, 2, {4096, 4096, -1}}); } static std::shared_ptr gen_cache(const std::shared_ptr& input_ids, const std::shared_ptr& beam_idx, const std::string& name) { - auto shape_of = makeOP({input_ids}, {{"output_type", "i64"}}); - auto gather = makeOP({shape_of, {0}, 0}, {{"batch_dims", 0}}); - auto concat = makeOP({gather, {0ll}, {32ll}, {128ll}}, {{"axis", 0}}); - auto init_to_read = makeOP({0.000000f, concat}, {{"mode", "numpy"}}); - auto cache = makeOP( + auto shape_of = makeOP({input_ids}, {{"output_type", "i64"}}); + auto gather = makeOP({shape_of, {0}, 0}, {{"batch_dims", 0}}); + auto concat = makeOP({gather, {0ll}, {32ll}, {128ll}}, {{"axis", 0}}); + auto init_to_read = makeOP({0.000000f, concat}, {{"mode", "numpy"}}); + auto cache = makeOP( {init_to_read}, {{"variable_id", name}, {"variable_type", "f32"}, {"variable_shape", PartialShape{DYN, DYN, 32, 128}}}); - return makeOP({cache, beam_idx, 0}, {{"batch_dims", 0}}); + return makeOP({cache, beam_idx, 0}, {{"batch_dims", 0}}); } static std::shared_ptr gen_current_len(const std::shared_ptr& input_ids) { - auto shape_of = makeOP({input_ids}, {{"output_type", "i64"}}); - return makeOP({shape_of, {1}, 0}, {{"batch_dims", 0}}); + auto shape_of = makeOP({input_ids}, {{"output_type", "i64"}}); + return makeOP({shape_of, {1}, 0}, {{"batch_dims", 0}}); } static std::shared_ptr gen_past_len(const std::shared_ptr& k_cache) { - auto shape_of = makeOP({k_cache}, {{"output_type", "i64"}}); - return makeOP({shape_of, {1}, 0}, {{"batch_dims", 0}}); + auto shape_of = makeOP({k_cache}, {{"output_type", "i64"}}); + return makeOP({shape_of, {1}, 0}, {{"batch_dims", 0}}); } static std::shared_ptr gen_total_len(const std::shared_ptr& cur_len, const std::shared_ptr& past_len) { - return makeOP({cur_len, past_len}, {numpy_broadcast}); + return makeOP({cur_len, past_len}, {numpy_broadcast}); } static std::shared_ptr gen_rope(QKV idx, @@ -194,21 +193,21 @@ class Qwen7bChatSDPA { const std::shared_ptr& head_size, const std::shared_ptr& sliced_sin, const std::shared_ptr& sliced_cos) { - auto current_k = makeOP({qkv_proj->output(idx), {0, 0, 32, 128}}, {special_zero_true}); - auto sliced_k = makeOP({current_k, {0}, head_size, {1}, {3}}); - auto mul_1 = makeOP({sliced_k, sliced_cos}, {numpy_broadcast}); + auto current_k = makeOP({qkv_proj->output(idx), {0, 0, 32, 128}}, {special_zero_true}); + auto sliced_k = makeOP({current_k, {0}, head_size, {1}, {3}}); + auto mul_1 = makeOP({sliced_k, sliced_cos}, {numpy_broadcast}); - auto reshape = makeOP({sliced_k, {0, 0, 32, 2, 64}}, {special_zero_true}); - auto split_1 = makeOP({reshape, -2}, {{"num_splits", 2}}); - auto list_unpack_1 = makeOP({split_1->output(1), -2}); + auto reshape = makeOP({sliced_k, {0, 0, 32, 2, 64}}, {special_zero_true}); + auto split_1 = makeOP({reshape, -2}, {{"num_splits", 2}}); + auto list_unpack_1 = makeOP({split_1->output(1), -2}); auto _const = single_val(/*rank*/ 4, /*val*/ 1); - auto mul_2 = makeOP({list_unpack_1, _const}, {numpy_broadcast}); - auto list_unpack_2 = makeOP({split_1->output(0), -2}); - auto concat = makeOP({mul_2, list_unpack_2}, {{"axis", -1}}); + auto mul_2 = makeOP({list_unpack_1, _const}, {numpy_broadcast}); + auto list_unpack_2 = makeOP({split_1->output(0), -2}); + auto concat = makeOP({mul_2, list_unpack_2}, {{"axis", -1}}); - auto mul_3 = makeOP({concat, sliced_sin}, {numpy_broadcast}); - return makeOP({mul_1, mul_3}, {numpy_broadcast}); + auto mul_3 = makeOP({concat, sliced_sin}, {numpy_broadcast}); + return makeOP({mul_1, mul_3}, {numpy_broadcast}); } static std::shared_ptr gen_rope_emb_sin(const std::shared_ptr& total_seq_len, @@ -217,12 +216,12 @@ class Qwen7bChatSDPA { element::Type model_precision) { auto sin = makeConst(model_precision, {1, 4096, 1, 128}, MOCK_VALUE); if (model_precision != element::f32) { - sin = makeOP({sin}, {dest_type_f32}); + sin = makeOP({sin}, {dest_type_f32}); } - auto sliced_sin_by_total = makeOP({sin, {0}, total_seq_len, {1}, {1}}); - auto rotary_emb_sin_shape = makeOP({sliced_sin_by_total}, {{"output_type", "i64"}}); - head_size = makeOP({rotary_emb_sin_shape, {3}, 0}, {{"batch_dims", 0}}); - return makeOP({sliced_sin_by_total, neg_mul, {LLONG_MAX}, {1}, {1}}); + auto sliced_sin_by_total = makeOP({sin, {0}, total_seq_len, {1}, {1}}); + auto rotary_emb_sin_shape = makeOP({sliced_sin_by_total}, {{"output_type", "i64"}}); + head_size = makeOP({rotary_emb_sin_shape, {3}, 0}, {{"batch_dims", 0}}); + return makeOP({sliced_sin_by_total, neg_mul, {LLONG_MAX}, {1}, {1}}); } static std::shared_ptr gen_rope_emb_cos(const std::shared_ptr& total_seq_len, @@ -230,77 +229,77 @@ class Qwen7bChatSDPA { element::Type model_precision) { auto cos = makeConst(model_precision, {1, 4096, 1, 128}, MOCK_VALUE); if (model_precision != element::f32) { - cos = makeOP({cos}, {dest_type_f32}); + cos = makeOP({cos}, {dest_type_f32}); } - auto sliced_cos_by_total = makeOP({cos, {0}, total_seq_len, {1}, {1}}); - return makeOP({sliced_cos_by_total, neg_mul, {LLONG_MAX}, {1}, {1}}); + auto sliced_cos_by_total = makeOP({cos, {0}, total_seq_len, {1}, {1}}); + return makeOP({sliced_cos_by_total, neg_mul, {LLONG_MAX}, {1}, {1}}); } static std::shared_ptr neg_mul(const std::shared_ptr& current_seq_len) { - return makeOP({current_seq_len, {-1ll}}, {numpy_broadcast}); + return makeOP({current_seq_len, {-1ll}}, {numpy_broadcast}); } static std::shared_ptr gen_V(const std::shared_ptr& cache, const std::shared_ptr& qkv_proj) { - auto v_current = makeOP({qkv_proj->output(2), {0, 0, 32, 128}}, {special_zero_true}); - auto v_total = makeOP({cache, v_current}, {{"axis", 1}}); - return makeOP({v_total, {0, 2, 1, 3}}); + auto v_current = makeOP({qkv_proj->output(2), {0, 0, 32, 128}}, {special_zero_true}); + auto v_total = makeOP({cache, v_current}, {{"axis", 1}}); + return makeOP({v_total, {0, 2, 1, 3}}); } static std::shared_ptr gen_K(const std::shared_ptr& cache, const std::shared_ptr& rope_K) { - auto full_k = makeOP({cache, rope_K}, {{"axis", 1}}); - return makeOP({full_k, {0, 2, 1, 3}}); + auto full_k = makeOP({cache, rope_K}, {{"axis", 1}}); + return makeOP({full_k, {0, 2, 1, 3}}); } static std::shared_ptr gen_Q(const std::shared_ptr& past_seq_len_2, const std::shared_ptr& total_seq_len_2, const std::shared_ptr& rope_Q) { auto _const = makeConst(element::f32, {1, 32767, 1, 1}, MOCK_VALUE); - auto slice = makeOP({_const, past_seq_len_2, total_seq_len_2, {1}, {1}}); - auto mul = makeOP({rope_Q, slice}, {numpy_broadcast}); - return makeOP({mul, {0, 2, 1, 3}}); + auto slice = makeOP({_const, past_seq_len_2, total_seq_len_2, {1}, {1}}); + auto mul = makeOP({rope_Q, slice}, {numpy_broadcast}); + return makeOP({mul, {0, 2, 1, 3}}); } static std::shared_ptr gen_total_seq_len_2(const std::shared_ptr& past_k_len, const std::shared_ptr& rope_k) { - auto shape_rope_k = makeOP({rope_k}, {{"output_type", "i64"}}); - auto cur_len = makeOP({shape_rope_k, {1}, 0}, {{"batch_dims", 0}}); - return makeOP({past_k_len, cur_len}, {numpy_broadcast}); + auto shape_rope_k = makeOP({rope_k}, {{"output_type", "i64"}}); + auto cur_len = makeOP({shape_rope_k, {1}, 0}, {{"batch_dims", 0}}); + return makeOP({past_k_len, cur_len}, {numpy_broadcast}); } static std::shared_ptr gen_past_seq_len_2(const std::shared_ptr& total_seq_len, const std::shared_ptr& rope_q) { - auto shape_rope_q = makeOP({rope_q}, {{"output_type", "i64"}}); - auto cur_len = makeOP({shape_rope_q, {1}, 0}, {{"batch_dims", 0}}); - return makeOP({total_seq_len, cur_len}, {numpy_broadcast}); + auto shape_rope_q = makeOP({rope_q}, {{"output_type", "i64"}}); + auto cur_len = makeOP({shape_rope_q, {1}, 0}, {{"batch_dims", 0}}); + return makeOP({total_seq_len, cur_len}, {numpy_broadcast}); } static std::shared_ptr gen_attention_mask(const std::shared_ptr& Q_in, const std::shared_ptr& attention_mask_in, const std::shared_ptr& total_seq_len) { auto _const = makeConst(element::boolean, {1, 1, 8192, 8192}, MOCK_VALUE); - auto shape_of_q = makeOP({Q_in}, {{"output_type", "i64"}}); - auto gather = makeOP({shape_of_q, {2}, 0}, {{"batch_dims", 0}}); - auto sub_1 = makeOP({total_seq_len, gather}, {numpy_broadcast}); - auto concat = makeOP({sub_1, {0ll}}, {{"axis", 0}}); - auto broadcast = makeOP({total_seq_len, {2}}, {{"mode", "numpy"}}); - auto slice = makeOP({_const, concat, broadcast, {1, 1}, {2, 3}}); - auto bitwise_not = makeOP({slice}); + auto shape_of_q = makeOP({Q_in}, {{"output_type", "i64"}}); + auto gather = makeOP({shape_of_q, {2}, 0}, {{"batch_dims", 0}}); + auto sub_1 = makeOP({total_seq_len, gather}, {numpy_broadcast}); + auto concat = makeOP({sub_1, {0ll}}, {{"axis", 0}}); + auto broadcast = makeOP({total_seq_len, {2}}, {{"mode", "numpy"}}); + auto slice = makeOP({_const, concat, broadcast, {1, 1}, {2, 3}}); + auto bitwise_not = makeOP({slice}); auto _const_1 = single_val(/*rank*/ 4, /*val*/ 1); - auto view_reshape = makeOP({attention_mask_in, {0, 0}}, {special_zero_true}); - auto unsqueeze_0 = makeOP({view_reshape, 1}); - auto unsqueeze_1 = makeOP({unsqueeze_0, 2}); - auto convert_0 = makeOP({unsqueeze_1}, {dest_type_f32}); + auto view_reshape = makeOP({attention_mask_in, {0, 0}}, {special_zero_true}); + auto unsqueeze_0 = makeOP({view_reshape, 1}); + auto unsqueeze_1 = makeOP({unsqueeze_0, 2}); + auto convert_0 = makeOP({unsqueeze_1}, {dest_type_f32}); auto _const_2 = single_val(/*rank*/ 4, /*val*/ 1); - auto mul_1 = makeOP({convert_0, _const_2}, {numpy_broadcast}); - auto sub_2 = makeOP({_const_1, mul_1}, {numpy_broadcast}); + auto mul_1 = makeOP({convert_0, _const_2}, {numpy_broadcast}); + auto sub_2 = makeOP({_const_1, mul_1}, {numpy_broadcast}); auto _const_3 = single_val(/*rank*/ 4, /*val*/ 1); - auto mul_2 = makeOP({sub_2, _const_3}, {numpy_broadcast}); - auto list_construct = makeOP({{1ll}, {1ll}, gather, {1ll}}, {{"axis", 0}}); - auto expand_broadcast = makeOP({mul_2, list_construct}, {{"mode", "bidirectional"}}); - return makeOP({bitwise_not, -FLT_MAX, expand_broadcast}, {numpy_broadcast}); + auto mul_2 = makeOP({sub_2, _const_3}, {numpy_broadcast}); + auto list_construct = makeOP({{1ll}, {1ll}, gather, {1ll}}, {{"axis", 0}}); + auto expand_broadcast = makeOP({mul_2, list_construct}, {{"mode", "bidirectional"}}); + return makeOP({bitwise_not, -FLT_MAX, expand_broadcast}, {numpy_broadcast}); } }; @@ -308,51 +307,51 @@ class Qwen7bChatPA { public: static std::shared_ptr gen_embeddings(const std::shared_ptr& input_ids) { auto weights = makeConst(element::u8, {WEIGHTS, 4096}, MOCK_VALUE); - auto weights_fp16 = makeOP({weights}, {dest_type_f16}); + auto weights_fp16 = makeOP({weights}, {dest_type_f16}); auto zero_point = makeConst(element::u8, {WEIGHTS, 1}, MOCK_VALUE); - auto zero_point_fp16 = makeOP({zero_point}, {dest_type_f16}); - auto sub = makeOP({weights_fp16, zero_point_fp16}, {numpy_broadcast}); + auto zero_point_fp16 = makeOP({zero_point}, {dest_type_f16}); + auto sub = makeOP({weights_fp16, zero_point_fp16}, {numpy_broadcast}); auto scale = makeConst(element::f16, {WEIGHTS, 1}, MOCK_VALUE); - auto mul = makeOP({sub, scale}, {numpy_broadcast}); - auto mul_fp32 = makeOP({mul}, {dest_type_f32}); + auto mul = makeOP({sub, scale}, {numpy_broadcast}); + auto mul_fp32 = makeOP({mul}, {dest_type_f32}); - auto reshape_view = makeOP({input_ids, {-1, 0}}, {special_zero_true}); - auto reshape_view_i64 = makeOP({reshape_view}, {dest_type_i64}); - return makeOP({mul_fp32, reshape_view_i64, 0}, {{"batch_dims", 0}}); + auto reshape_view = makeOP({input_ids, {-1, 0}}, {special_zero_true}); + auto reshape_view_i64 = makeOP({reshape_view}, {dest_type_i64}); + return makeOP({mul_fp32, reshape_view_i64, 0}, {{"batch_dims", 0}}); } static std::shared_ptr gen_qkv_proj(const std::shared_ptr& embeddings) { auto _const_0 = makeConst(element::f32, {1, 1, 1}, MOCK_VALUE); - auto pow = makeOP({embeddings, _const_0}, {numpy_broadcast}); - auto mean = makeOP({pow, {-1}}, {{"keep_dims", true}}); + auto pow = makeOP({embeddings, _const_0}, {numpy_broadcast}); + auto mean = makeOP({pow, {-1}}, {{"keep_dims", true}}); auto _const_1 = makeConst(element::f32, {1, 1, 1}, MOCK_VALUE); - auto add_0 = makeOP({mean, _const_1}, {numpy_broadcast}); + auto add_0 = makeOP({mean, _const_1}, {numpy_broadcast}); - auto sqrt = makeOP({add_0}); + auto sqrt = makeOP({add_0}); auto _const_2 = makeConst(element::f32, {1, 1, 1}, MOCK_VALUE); - auto div = makeOP({_const_2, sqrt}, {numpy_broadcast, {"m_pythondiv", true}}); - auto mul_0 = makeOP({embeddings, div}, {numpy_broadcast}); + auto div = makeOP({_const_2, sqrt}, {numpy_broadcast, {"m_pythondiv", true}}); + auto mul_0 = makeOP({embeddings, div}, {numpy_broadcast}); auto _const_3 = makeConst(element::f32, {1, 1, 4096}, MOCK_VALUE); - auto mul_1 = makeOP({mul_0, _const_3}, {numpy_broadcast}); + auto mul_1 = makeOP({mul_0, _const_3}, {numpy_broadcast}); auto _const_4 = makeConst(element::u8, {ATTENTION_WEIGHTS, 4096}, MOCK_VALUE); - auto convert_0 = makeOP({_const_4}, {dest_type_f16}); + auto convert_0 = makeOP({_const_4}, {dest_type_f16}); auto _const_5 = makeConst(element::u8, {ATTENTION_WEIGHTS, 1}, MOCK_VALUE); - auto convert_1 = makeOP({_const_5}, {dest_type_f16}); - auto sub = makeOP({convert_0, convert_1}, {numpy_broadcast}); + auto convert_1 = makeOP({_const_5}, {dest_type_f16}); + auto sub = makeOP({convert_0, convert_1}, {numpy_broadcast}); auto _const_6 = makeConst(element::f16, {ATTENTION_WEIGHTS, 1}, MOCK_VALUE); - auto mul_2 = makeOP({sub, _const_6}, {numpy_broadcast}); - auto convert_2 = makeOP({mul_2}, {dest_type_f32}); - auto matmul = makeOP({mul_1, convert_2}, {{"transpose_a", false}, {"transpose_b", true}}); + auto mul_2 = makeOP({sub, _const_6}, {numpy_broadcast}); + auto convert_2 = makeOP({mul_2}, {dest_type_f32}); + auto matmul = makeOP({mul_1, convert_2}, {{"transpose_a", false}, {"transpose_b", true}}); auto Constant_270 = makeConst(element::f32, {1, 1, ATTENTION_WEIGHTS}, MOCK_VALUE); - auto add_1 = makeOP({matmul, Constant_270}, {numpy_broadcast}); + auto add_1 = makeOP({matmul, Constant_270}, {numpy_broadcast}); - return makeOP({add_1, 2, {4096, 4096, -1}}); + return makeOP({add_1, 2, {4096, 4096, -1}}); } static std::shared_ptr gen_rope(QKV idx, @@ -360,20 +359,20 @@ class Qwen7bChatPA { const std::shared_ptr& head_size, const std::shared_ptr& sin, const std::shared_ptr& cos) { - auto Q_or_K = makeOP({qkv_proj->output(idx), {0, 0, 32, 128}}, {special_zero_true}); - auto sliced = makeOP({Q_or_K, {0}, head_size, {1}, {3}}); - auto mul_0 = makeOP({sliced, sin}, {numpy_broadcast}); + auto Q_or_K = makeOP({qkv_proj->output(idx), {0, 0, 32, 128}}, {special_zero_true}); + auto sliced = makeOP({Q_or_K, {0}, head_size, {1}, {3}}); + auto mul_0 = makeOP({sliced, sin}, {numpy_broadcast}); - auto reshape = makeOP({sliced, {0, 0, 32, 2, 64}}, {special_zero_true}); - auto split = makeOP({reshape, -2}, {{"num_splits", 2}}); - auto squeeze_0 = makeOP({split->output(1), -2}); + auto reshape = makeOP({sliced, {0, 0, 32, 2, 64}}, {special_zero_true}); + auto split = makeOP({reshape, -2}, {{"num_splits", 2}}); + auto squeeze_0 = makeOP({split->output(1), -2}); auto _const_0 = makeConst(element::f32, {1, 1, 1, 1}, {1.000000f}); - auto mul_1 = makeOP({squeeze_0, _const_0}, {numpy_broadcast}); + auto mul_1 = makeOP({squeeze_0, _const_0}, {numpy_broadcast}); - auto squeeze_1 = makeOP({split->output(0), -2}); - auto concat = makeOP({mul_1, squeeze_1}, {{"axis", -1}}); - auto mul_2 = makeOP({concat, cos}, {numpy_broadcast}); - return makeOP({mul_0, mul_2}, {numpy_broadcast}); + auto squeeze_1 = makeOP({split->output(0), -2}); + auto concat = makeOP({mul_1, squeeze_1}, {{"axis", -1}}); + auto mul_2 = makeOP({concat, cos}, {numpy_broadcast}); + return makeOP({mul_0, mul_2}, {numpy_broadcast}); } static std::shared_ptr gen_rope_emb_sin(const std::shared_ptr& max_context_len, @@ -382,15 +381,15 @@ class Qwen7bChatPA { element::Type model_precision) { auto sin = makeConst(model_precision, {1, 4096, 1, 128}, MOCK_VALUE); if (model_precision != element::f32) { - sin = makeOP({sin}, {dest_type_f32}); + sin = makeOP({sin}, {dest_type_f32}); } - auto slice_sin = makeOP({sin, position_ids, 1}, {{"batch_dims", 0}}); + auto slice_sin = makeOP({sin, position_ids, 1}, {{"batch_dims", 0}}); - auto slice = makeOP({sin, {0}, max_context_len, {1}, {1}}); + auto slice = makeOP({sin, {0}, max_context_len, {1}, {1}}); auto shape_of = makeOP({slice}, {{"output_type", "i64"}}); - head_size = makeOP({shape_of, {3}, 0}, {{"batch_dims", 0}}); + head_size = makeOP({shape_of, {3}, 0}, {{"batch_dims", 0}}); - return makeOP({slice_sin, {-1, 1, 1, 128}}, {{"special_zero", false}}); + return makeOP({slice_sin, {-1, 1, 1, 128}}, {{"special_zero", false}}); } static std::shared_ptr gen_rope_emb_cos(const std::shared_ptr& max_context_len, @@ -398,71 +397,71 @@ class Qwen7bChatPA { element::Type model_precision) { auto cos = makeConst(model_precision, {1, 4096, 1, 128}, MOCK_VALUE); if (model_precision != element::f32) { - cos = makeOP({cos}, {dest_type_f32}); + cos = makeOP({cos}, {dest_type_f32}); } - auto slice = makeOP({cos, position_ids, 1}, {{"batch_dims", 0}}); - return makeOP({slice, {-1, 1, 1, 128}}, {{"special_zero", false}}); + auto slice = makeOP({cos, position_ids, 1}, {{"batch_dims", 0}}); + return makeOP({slice, {-1, 1, 1, 128}}, {{"special_zero", false}}); } static std::shared_ptr align_pa_layout(const std::shared_ptr& pa, const std::shared_ptr& head_size) { - auto shape = makeOP({{0ll}, {1ll}, {-1ll}, head_size}, {{"axis", 0}}); - auto reshaped = makeOP({pa->output(0), shape}, {special_zero_true}); - return makeOP({reshaped, {0, 2, 1, 3}}); + auto shape = makeOP({{0ll}, {1ll}, {-1ll}, head_size}, {{"axis", 0}}); + auto reshaped = makeOP({pa->output(0), shape}, {special_zero_true}); + return makeOP({reshaped, {0, 2, 1, 3}}); } static std::shared_ptr gen_current_len(const std::shared_ptr& rope_K) { auto shape_of = makeOP({rope_K}, {{"output_type", "i32"}}); - return makeOP({shape_of, {1}, 0ll}, {{"batch_dims", 0}}); + return makeOP({shape_of, {1}, 0ll}, {{"batch_dims", 0}}); } static std::shared_ptr gen_past_len(const std::shared_ptr& input_ids, const std::shared_ptr& max_context_len) { auto shape_of = makeOP({input_ids}, {{"output_type", "i64"}}); - auto cur_len = makeOP({shape_of, 1ll, 0ll}, {{"batch_dims", 0}}); - auto cur_len_i32 = makeOP({cur_len}, {{"destination_type", "i32"}}); + auto cur_len = makeOP({shape_of, 1ll, 0ll}, {{"batch_dims", 0}}); + auto cur_len_i32 = makeOP({cur_len}, {{"destination_type", "i32"}}); - auto past_len = makeOP({max_context_len, cur_len_i32}, {numpy_broadcast}); - auto past_len_i32 = makeOP({past_len}, {{"destination_type", "i32"}}); - return makeOP({past_len_i32, {1}}, {special_zero_true}); + auto past_len = makeOP({max_context_len, cur_len_i32}, {numpy_broadcast}); + auto past_len_i32 = makeOP({past_len}, {{"destination_type", "i32"}}); + return makeOP({past_len_i32, {1}}, {special_zero_true}); } static std::shared_ptr gen_total_len(const std::shared_ptr& cur_len, const std::shared_ptr& past_len) { - return makeOP({past_len, cur_len}, {numpy_broadcast}); + return makeOP({past_len, cur_len}, {numpy_broadcast}); } static std::shared_ptr gen_V(const std::shared_ptr& qkv_proj, std::shared_ptr& head_size) { - auto current_V = makeOP({qkv_proj->output(2), {0, 0, 32, 128}}, {special_zero_true}); - auto gather = makeOP({{0, 2, 1, 3}, {0, 2, 1, 3}, 0ll}, {{"batch_dims", 0}}); - auto transpose = makeOP({current_V, gather}); + auto current_V = makeOP({qkv_proj->output(2), {0, 0, 32, 128}}, {special_zero_true}); + auto gather = makeOP({{0, 2, 1, 3}, {0, 2, 1, 3}, 0ll}, {{"batch_dims", 0}}); + auto transpose = makeOP({current_V, gather}); auto shape_of = makeOP({transpose}, {{"output_type", "i64"}}); - auto gather_2 = makeOP({shape_of, -1ll, 0ll}, {{"batch_dims", 0}}); - head_size = makeOP({gather_2, 0}); + auto gather_2 = makeOP({shape_of, -1ll, 0ll}, {{"batch_dims", 0}}); + head_size = makeOP({gather_2, 0}); - return makeOP({transpose, {0, -1}}, {special_zero_true}); + return makeOP({transpose, {0, -1}}, {special_zero_true}); } static std::shared_ptr gen_K(const std::shared_ptr& rope_K) { - auto gather = makeOP({{0, 2, 1, 3}, {0, 2, 1, 3}, 0ll}, {{"batch_dims", 0}}); - auto transpose = makeOP({rope_K, gather}); - return makeOP({transpose, {0, -1}}, {special_zero_true}); + auto gather = makeOP({{0, 2, 1, 3}, {0, 2, 1, 3}, 0ll}, {{"batch_dims", 0}}); + auto transpose = makeOP({rope_K, gather}); + return makeOP({transpose, {0, -1}}, {special_zero_true}); } static std::shared_ptr gen_Q(const std::shared_ptr& total_seq_len, const std::shared_ptr& rope_Q) { auto _const_1 = makeConst(element::f32, {1, 32767, 1, 1}, MOCK_VALUE); auto shape_of = makeOP({rope_Q}, {{"output_type", "i32"}}); - auto current_seq_len = makeOP({shape_of, {1}, 0ll}, {{"batch_dims", 0}}); - auto past_seq_len = makeOP({total_seq_len, current_seq_len}, {numpy_broadcast}); + auto current_seq_len = makeOP({shape_of, {1}, 0ll}, {{"batch_dims", 0}}); + auto past_seq_len = makeOP({total_seq_len, current_seq_len}, {numpy_broadcast}); - auto slice = makeOP({_const_1, past_seq_len, total_seq_len, {1}, {1}}); - auto mul = makeOP({rope_Q, slice}, {numpy_broadcast}); - auto transpose_1 = makeOP({mul, {0, 2, 1, 3}}); + auto slice = makeOP({_const_1, past_seq_len, total_seq_len, {1}, {1}}); + auto mul = makeOP({rope_Q, slice}, {numpy_broadcast}); + auto transpose_1 = makeOP({mul, {0, 2, 1, 3}}); - auto transpose_2 = makeOP({transpose_1, {0, 2, 1, 3}}); - return makeOP({transpose_2, {0, -1}}, {special_zero_true}); + auto transpose_2 = makeOP({transpose_1, {0, 2, 1, 3}}); + return makeOP({transpose_2, {0, -1}}, {special_zero_true}); } }; @@ -521,8 +520,8 @@ TEST_P(SDPAToPATest, SDPAToPA_Qwen7bChat_General) { auto attention_mask_to_sdpa = Qwen7bChatSDPA::gen_attention_mask(Q, attention_mask, total_seq_len_2); // SDPA: - auto sdpa = makeOP({Q, K, V, attention_mask_to_sdpa}, {{"causal", false}}); - auto res = makeOP({sdpa}); + auto sdpa = makeOP({Q, K, V, attention_mask_to_sdpa}, {{"causal", false}}); + auto res = makeOP({sdpa}); model = std::make_shared(OutputVector{res}, params); manager.register_pass(); @@ -530,16 +529,16 @@ TEST_P(SDPAToPATest, SDPAToPA_Qwen7bChat_General) { { // Inputs to PA transformer: - auto max_context_len = makeOP({}, {{"shape", PartialShape{}}, el_type_i32}); - auto block_indices_begins = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i32}); - auto block_indices = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i32}); - auto subsequence_begins = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i32}); - auto past_lens = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i32}); + auto max_context_len = makeOP({}, {{"shape", PartialShape{}}, el_type_i32}); + auto block_indices_begins = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i32}); + auto block_indices = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i32}); + auto subsequence_begins = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i32}); + auto past_lens = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i32}); auto value_cache_0 = make_param(PartialShape{DYN, DYN, DYN, DYN}, element::dynamic, "value_cache.0"); auto key_cache_0 = make_param(PartialShape{DYN, DYN, DYN, DYN}, element::dynamic, "key_cache.0"); - auto input_ids = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i64}); - auto position_ids = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i64}); - auto score_aggregation_window = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i32}); + auto input_ids = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i64}); + auto position_ids = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i64}); + auto score_aggregation_window = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i32}); auto rotated_block_indices = makeConst(element::i32, ov::Shape({0}), {0}); auto rotation_deltas = makeConst(element::i32, ov::Shape{0}, {0}); @@ -560,10 +559,10 @@ TEST_P(SDPAToPATest, SDPAToPA_Qwen7bChat_General) { position_ids}); // Inputs pre-processing: - auto max_context_len_i64 = makeOP({max_context_len}, {dest_type_i64}); - auto max_context_len_aligned = makeOP({max_context_len_i64, {1}}, {special_zero_true}); - auto input_ids_aligned = makeOP({input_ids, 1}); - auto position_ids_aligned = makeOP({position_ids, 1}); + auto max_context_len_i64 = makeOP({max_context_len}, {dest_type_i64}); + auto max_context_len_aligned = makeOP({max_context_len_i64, {1}}, {special_zero_true}); + auto input_ids_aligned = makeOP({input_ids, 1}); + auto position_ids_aligned = makeOP({position_ids, 1}); // Embeddings processing: auto embeddings = Qwen7bChatPA::gen_embeddings(input_ids_aligned); @@ -592,11 +591,11 @@ TEST_P(SDPAToPATest, SDPAToPA_Qwen7bChat_General) { auto V = Qwen7bChatPA::gen_V(qkv_proj, head_size_2); // Additional PA arguments: - auto sliding_window = std::make_shared(element::i32, Shape{}, 0); - auto alibi_slopes = std::make_shared(element::f32, Shape{0}); - auto scale = std::make_shared(element::f32, Shape{}, MOCK_VALUE); - auto score_aggregation_window_const = std::make_shared(element::i32, Shape{0}, 0); - auto sinks = v0::Constant::create(element::f32, Shape{0, 0, 0, 0}, {}); + auto sliding_window = std::make_shared(element::i32, Shape{}, 0); + auto alibi_slopes = std::make_shared(element::f32, Shape{0}); + auto scale = std::make_shared(element::f32, Shape{}, MOCK_VALUE); + auto score_aggregation_window_const = std::make_shared(element::i32, Shape{0}, 0); + auto sinks = ov::op::v0::Constant::create(element::f32, Shape{0, 0, 0, 0}, {}); // PagedAttention: auto pa = std::make_shared(OutputVector{Q, @@ -622,7 +621,7 @@ TEST_P(SDPAToPATest, SDPAToPA_Qwen7bChat_General) { sinks}); pa->set_out_type(0, element::i64); auto pa_aligned = Qwen7bChatPA::align_pa_layout(pa, head_size_2); - auto res = makeOP({pa_aligned}); + auto res = makeOP({pa_aligned}); model_ref = std::make_shared(OutputVector{res}, params); } @@ -635,8 +634,8 @@ TEST_P(SDPAToPATest, SDPAToPA_Qwen7bChat_General) { TEST_F(SDPAToPATest, SDPAToPA_Qwen7bChat_TotalSequenceLengthPattern) { { // Inputs to SDPA transformer: - auto beam_idx = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i64}); - auto input_ids = makeOP({}, {{"shape", PartialShape{DYN, DYN}}, el_type_i64}); + auto beam_idx = makeOP({}, {{"shape", PartialShape{DYN}}, el_type_i64}); + auto input_ids = makeOP({}, {{"shape", PartialShape{DYN, DYN}}, el_type_i64}); ParameterVector params = nodes_to_params({input_ids, beam_idx}); // K cache @@ -646,17 +645,17 @@ TEST_F(SDPAToPATest, SDPAToPA_Qwen7bChat_TotalSequenceLengthPattern) { auto current_len = Qwen7bChatSDPA::gen_current_len(input_ids); auto past_len = Qwen7bChatSDPA::gen_past_len(k_cache); auto total_len = Qwen7bChatSDPA::gen_total_len(current_len, past_len); - auto result = std::make_shared(total_len); + auto result = std::make_shared(total_len); // Expected that these Nodes to be created inside SDPAToPagedAttention - auto new_input_ids = std::make_shared(element::i64, PartialShape{DYN}); - auto axis = v0::Constant::create(element::i32, Shape{}, {1}); - auto aligned_input_ids = std::make_shared(new_input_ids, axis); + auto new_input_ids = std::make_shared(element::i64, PartialShape{DYN}); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {1}); + auto aligned_input_ids = std::make_shared(new_input_ids, axis); input_ids->output(0).replace(aligned_input_ids); - auto max_context_len = std::make_shared(element::i32, PartialShape{}); + auto max_context_len = std::make_shared(element::i32, PartialShape{}); max_context_len->output(0).set_names({"max_context_len"}); - auto position_ids = std::make_shared(element::i64, PartialShape{DYN}); + auto position_ids = std::make_shared(element::i64, PartialShape{DYN}); position_ids->output(0).set_names({"position_ids"}); params.push_back(max_context_len); @@ -670,14 +669,14 @@ TEST_F(SDPAToPATest, SDPAToPA_Qwen7bChat_TotalSequenceLengthPattern) { { // Inputs to PA transformer: - auto max_context_len = makeOP({}, {{"shape", PartialShape{}}, el_type_i32}); + auto max_context_len = makeOP({}, {{"shape", PartialShape{}}, el_type_i32}); auto params = nodes_to_params({max_context_len}); // Inputs pre-processing: - auto max_context_len_i64 = makeOP({max_context_len}, {dest_type_i64}); - auto max_context_len_aligned = makeOP({max_context_len_i64, {1}}, {special_zero_true}); + auto max_context_len_i64 = makeOP({max_context_len}, {dest_type_i64}); + auto max_context_len_aligned = makeOP({max_context_len_i64, {1}}, {special_zero_true}); - auto result = std::make_shared(max_context_len_aligned); + auto result = std::make_shared(max_context_len_aligned); model_ref = std::make_shared(ResultVector{result}, params); } // TODO: align precisions, check the copying of "fuse_names" attr in SDPAToPagedAttention @@ -689,40 +688,40 @@ TEST_F(SDPAToPATest, SDPAToPA_Qwen7bChat_TotalSequenceLengthPattern) { TEST_F(SDPAToPATest, SDPAToPA_Qwen7bChat_PositionIDsReplacerQwenPattern) { { - auto max_context_len = std::make_shared(element::i32, PartialShape{}); - auto max_context_len_i64 = std::make_shared(max_context_len, element::i64); + auto max_context_len = std::make_shared(element::i32, PartialShape{}); + auto max_context_len_i64 = std::make_shared(max_context_len, element::i64); auto max_context_len_reshaped = - std::make_shared(max_context_len_i64, v0::Constant::create(element::i64, Shape{1}, {1}), true); + std::make_shared(max_context_len_i64, ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), true); max_context_len->set_friendly_name("max_context_len"); - auto rotary_emb_sincos = std::make_shared(element::f32, PartialShape{1, DYN, 1, 128}); - auto position_ids = std::make_shared(element::i64, PartialShape{DYN}); + auto rotary_emb_sincos = std::make_shared(element::f32, PartialShape{1, DYN, 1, 128}); + auto position_ids = std::make_shared(element::i64, PartialShape{DYN}); - auto fake_input = std::make_shared(element::i64, PartialShape{DYN, DYN}); - auto shape = std::make_shared(fake_input, element::i64); - auto gather = std::make_shared(shape, - v0::Constant::create(element::i64, Shape{1}, {1}), - v0::Constant::create(element::i64, Shape{1}, {0})); + auto fake_input = std::make_shared(element::i64, PartialShape{DYN, DYN}); + auto shape = std::make_shared(fake_input, element::i64); + auto gather = std::make_shared(shape, + ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {0})); - auto minus_one = v0::Constant::create(element::i32, Shape{1}, {-1}); - auto minus_one_converted = std::make_shared(minus_one, element::i64); - auto minus_one_reshaped = std::make_shared(minus_one_converted, - v0::Constant::create(element::i64, Shape{1}, {-1}), + auto minus_one = ov::op::v0::Constant::create(element::i32, Shape{1}, {-1}); + auto minus_one_converted = std::make_shared(minus_one, element::i64); + auto minus_one_reshaped = std::make_shared(minus_one_converted, + ov::op::v0::Constant::create(element::i64, Shape{1}, {-1}), true); - auto past_offset = std::make_shared(gather, minus_one_reshaped); + auto past_offset = std::make_shared(gather, minus_one_reshaped); - auto start_const = v0::Constant::create(element::i64, Shape{1}, {0}); - auto stop_const = v0::Constant::create(element::i64, Shape{1}, {std::numeric_limits().max()}); - auto step_const = v0::Constant::create(element::i64, Shape{1}, {1}); - auto axis_const = v0::Constant::create(element::i64, Shape{1}, {1}); + auto start_const = ov::op::v0::Constant::create(element::i64, Shape{1}, {0}); + auto stop_const = ov::op::v0::Constant::create(element::i64, Shape{1}, {std::numeric_limits().max()}); + auto step_const = ov::op::v0::Constant::create(element::i64, Shape{1}, {1}); + auto axis_const = ov::op::v0::Constant::create(element::i64, Shape{1}, {1}); - auto slice_1 = std::make_shared(rotary_emb_sincos, + auto slice_1 = std::make_shared(rotary_emb_sincos, start_const, max_context_len_reshaped, step_const, axis_const); - auto slice_2 = std::make_shared(slice_1, past_offset, stop_const, step_const, axis_const); - auto result = std::make_shared(slice_2); + auto slice_2 = std::make_shared(slice_1, past_offset, stop_const, step_const, axis_const); + auto result = std::make_shared(slice_2); model = std::make_shared(ResultVector{result}, ParameterVector{max_context_len, rotary_emb_sincos, fake_input, position_ids}); @@ -730,14 +729,14 @@ TEST_F(SDPAToPATest, SDPAToPA_Qwen7bChat_PositionIDsReplacerQwenPattern) { } { - auto rotary_emb_sincos = std::make_shared(element::f32, PartialShape{1, DYN, 1, 128}); - auto position_ids = std::make_shared(element::i64, PartialShape{DYN}); + auto rotary_emb_sincos = std::make_shared(element::f32, PartialShape{1, DYN, 1, 128}); + auto position_ids = std::make_shared(element::i64, PartialShape{DYN}); - auto gather_new = std::make_shared(rotary_emb_sincos, + auto gather_new = std::make_shared(rotary_emb_sincos, position_ids, - v0::Constant::create(element::i64, Shape{}, {1})); - auto new_shape = v0::Constant::create(element::i64, Shape{4}, {-1, 1, 1, 128}); - auto reshaped = std::make_shared(gather_new, new_shape, true); + ov::op::v0::Constant::create(element::i64, Shape{}, {1})); + auto new_shape = ov::op::v0::Constant::create(element::i64, Shape{4}, {-1, 1, 1, 128}); + auto reshaped = std::make_shared(gather_new, new_shape, true); model_ref = std::make_shared(OutputVector{reshaped}, ParameterVector{rotary_emb_sincos, position_ids}); } @@ -761,10 +760,10 @@ TEST_F(SDPAToPATest, SDPAToPA_Baichuan2_13b_General) { auto input_ids = make_param(PartialShape{DYN, DYN}, element::i64, "input_ids"); // gen_embeddings() { - auto ShapeOf5 = makeOP({beam_idx}, {{"output_type", "i64"}}); - auto Gather8 = makeOP({ShapeOf5, {0ll}, 0ll}, {{"batch_dims", 0}}); - auto Concat12 = makeOP({Gather8, {40ll}, {0ll}, {128ll}}, {{"axis", 0}}); - auto Broadcast13 = makeOP({0.0f, Concat12}, {{"mode", "numpy"}}); + auto ShapeOf5 = makeOP({beam_idx}, {{"output_type", "i64"}}); + auto Gather8 = makeOP({ShapeOf5, {0ll}, 0ll}, {{"batch_dims", 0}}); + auto Concat12 = makeOP({Gather8, {40ll}, {0ll}, {128ll}}, {{"axis", 0}}); + auto Broadcast13 = makeOP({0.0f, Concat12}, {{"mode", "numpy"}}); auto Constant18 = makeConst(element::u8, ov::Shape({125696, 5120}), MOCK_VALUE); auto Convert19 = makeOP({Constant18}, {{"destination_type", "f16"}}); auto Constant20 = makeConst(element::u8, ov::Shape({125696, 1}), MOCK_VALUE); @@ -884,9 +883,9 @@ TEST_F(SDPAToPATest, SDPAToPA_Baichuan2_13b_General) { auto Multiply143 = makeOP({Gather116, {-1l}}, {{"auto_broadcast", "numpy"}}); auto Slice147 = makeOP({Add141, Multiply143, {LLONG_MAX}, {1}, {2}}); auto sdpa = - makeOP({Transpose62, Concat72, Concat82, Slice147}, {{"causal", false}}); + makeOP({Transpose62, Concat72, Concat82, Slice147}, {{"causal", false}}); - auto res = makeOP({sdpa}); + auto res = makeOP({sdpa}); ParameterVector params = nodes_to_params({beam_idx, position_ids, attention_mask, input_ids}); model = std::make_shared(OutputVector{res}, params); @@ -979,7 +978,7 @@ TEST_F(SDPAToPATest, SDPAToPA_Baichuan2_13b_General) { // PA cannot be instantiated uding makeOP hence creating constants for it manually auto c1 = makeConst(element::f32, {}, {0.088388f}); auto c2 = makeConst(element::i32, {}, {0}); - auto sinks = v0::Constant::create(element::f32, Shape{0, 0, 0, 0}, {}); + auto sinks = ov::op::v0::Constant::create(element::f32, Shape{0, 0, 0, 0}, {}); auto PagedAttentionExtension168 = std::make_shared(ov::OutputVector{Reshape138, Reshape147, @@ -1010,7 +1009,7 @@ TEST_F(SDPAToPATest, SDPAToPA_Baichuan2_13b_General) { makeOP({PagedAttentionExtension168->output(0), Concat178}, {{"special_zero", true}}); auto Transpose180 = makeOP({Reshape179, {0, 2, 1, 3}}); - auto result = std::make_shared(Transpose180); + auto result = std::make_shared(Transpose180); model_ref = std::make_shared(ResultVector{result}, params); // checks are also disabled temporarily @@ -1198,11 +1197,11 @@ TEST_F(SDPAToPATest, SDPAToPA_nanoLLaVA_General) { auto pref_6_masked_fill_Select_1 = makeOP({pref_6_to_Convert_4, -FLT_MAX, pref_6_expand_Broadcast_1}, {{"auto_broadcast", "numpy"}}); - auto sdpa = makeOP( + auto sdpa = makeOP( {pref_1_add_Add, pref_1_reshape_Reshape, pref_1_reshape_Reshape_1, pref_6_masked_fill_Select_1}, {{"causal", false}}); - auto res = makeOP({sdpa}); + auto res = makeOP({sdpa}); ParameterVector params = nodes_to_params({beam_idx, position_ids, attention_mask, inputs_embeds}); model = std::make_shared(OutputVector{res}, params); @@ -1341,8 +1340,8 @@ TEST_F(SDPAToPATest, SDPAToPA_nanoLLaVA_General) { auto c1 = makeConst(element::f32, {}, {0.707107f}); auto c2 = makeConst(element::i32, {}, {0}); // an empty Constant needs to be created in a usual way, not using makeConst() - auto c3 = v0::Constant::create(element::f32, {0}, {}); - auto sinks = v0::Constant::create(element::f32, Shape{0, 0, 0, 0}, {}); + auto c3 = ov::op::v0::Constant::create(element::f32, {0}, {}); + auto sinks = ov::op::v0::Constant::create(element::f32, Shape{0, 0, 0, 0}, {}); auto PagedAttentionExtension_51962 = std::make_shared(ov::OutputVector{Reshape_51953, Reshape_51957, @@ -1374,7 +1373,7 @@ TEST_F(SDPAToPATest, SDPAToPA_nanoLLaVA_General) { auto pref_1_scaled_dot_product_attention_ScaledDotProductAttention = makeOP({Reshape_51973, {0, 2, 1, 3}}); - auto res = std::make_shared(pref_1_scaled_dot_product_attention_ScaledDotProductAttention); + auto res = std::make_shared(pref_1_scaled_dot_product_attention_ScaledDotProductAttention); model_ref = std::make_shared(ResultVector{res}, params); comparator.disable(FunctionsComparator::PRECISIONS); @@ -1541,8 +1540,8 @@ TEST_F(SDPAToPATest, SDPAToPA_Phi3_mini_4k_instruct) { auto Add9 = makeOP({Reshape6, Reshape4}, {{"auto_broadcast", "numpy"}}); auto attn_mask = makeOP({Select4, {0}, Add9, {1}, {3}}); auto ScaledDotProductAttention = - makeOP({Q, K, V, attn_mask}, {{"causal", false}}); - auto res = make_shared(ScaledDotProductAttention); + makeOP({Q, K, V, attn_mask}, {{"causal", false}}); + auto res = make_shared(ScaledDotProductAttention); model = std::make_shared(OutputVector{res}, params); manager.register_pass(); @@ -1659,9 +1658,9 @@ TEST_F(SDPAToPATest, SDPAToPA_Phi3_mini_4k_instruct) { auto offset = makeOP({-2046}, {{"destination_type", "i32"}}); auto sliding_window = makeOP({2, offset}, {{"auto_broadcast", "numpy"}}); - auto scale = v0::Constant::create(element::f32, {}, {0.102062f}); - auto alibi_slopes = v0::Constant::create(element::f32, Shape{0}, {}); - auto sinks = v0::Constant::create(element::f32, Shape{0, 0, 0, 0}, {}); + auto scale = ov::op::v0::Constant::create(element::f32, {}, {0.102062f}); + auto alibi_slopes = ov::op::v0::Constant::create(element::f32, Shape{0}, {}); + auto sinks = ov::op::v0::Constant::create(element::f32, Shape{0, 0, 0, 0}, {}); auto PagedAttentionExtension = std::make_shared(OutputVector{Q, K, @@ -1861,9 +1860,9 @@ TEST_F(SDPAToPATest, SDPAToPA_Codegen2) { auto Maximum0 = makeOP({ShapeOf5, Concat11}, {{"auto_broadcast", "numpy"}}); auto Broadcast4 = makeOP({Minimum0, Maximum0}, {{"mode", "numpy"}}); auto ScaledDotProductAttention = - makeOP({Transpose0, Concat7, Concat9, Broadcast4}, {{"causal", false}}); + makeOP({Transpose0, Concat7, Concat9, Broadcast4}, {{"causal", false}}); - auto res = make_shared(ScaledDotProductAttention); + auto res = make_shared(ScaledDotProductAttention); model = std::make_shared(OutputVector{res}, params); @@ -1996,10 +1995,10 @@ TEST_F(SDPAToPATest, SDPAToPA_Codegen2) { auto Transpose7 = makeOP({Transpose6, {0, 2, 1, 3}}); auto Reshape16 = makeOP({Transpose7, {0, -1}}, {{"special_zero", true}}); - auto sliding_window = v0::Constant::create(element::i32, {}, {0}); - auto scale = v0::Constant::create(element::f32, {}, {0.062500f}); - auto alibi_slopes_stub = v0::Constant::create(element::f32, Shape{0}, {}); - auto sinks = v0::Constant::create(element::f32, Shape{0, 0, 0, 0}, {}); + auto sliding_window = ov::op::v0::Constant::create(element::i32, {}, {0}); + auto scale = ov::op::v0::Constant::create(element::f32, {}, {0.062500f}); + auto alibi_slopes_stub = ov::op::v0::Constant::create(element::f32, Shape{0}, {}); + auto sinks = ov::op::v0::Constant::create(element::f32, Shape{0, 0, 0, 0}, {}); auto PagedAttentionExtension = std::make_shared(OutputVector{Reshape11, Reshape13, @@ -2047,33 +2046,33 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { auto input_ids = make_param(PartialShape{DYN, DYN}, element::i64, "input_ids"); auto params = nodes_to_params({beam_idx, position_ids, attention_mask, input_ids}); - auto ShapeOf0 = makeOP({input_ids}, {{"output_type", "i64"}}); - auto Gather0 = makeOP({ShapeOf0, {0}, 0}, {{"batch_dims", 0}}); + auto ShapeOf0 = makeOP({input_ids}, {{"output_type", "i64"}}); + auto Gather0 = makeOP({ShapeOf0, {0}, 0}, {{"batch_dims", 0}}); auto Constant0 = makeConst(element::u8, ov::Shape({ 201088, 2880, }), MOCK_VALUE); - auto Convert0 = makeOP({Constant0}, {{"destination_type", "f16"}}); + auto Convert0 = makeOP({Constant0}, {{"destination_type", "f16"}}); auto Constant1 = makeConst(element::u8, ov::Shape({ 201088, 1, }), MOCK_VALUE); - auto Convert1 = makeOP({Constant1}, {{"destination_type", "f16"}}); - auto Subtract0 = makeOP({Convert0, Convert1}, {{"auto_broadcast", "numpy"}}); + auto Convert1 = makeOP({Constant1}, {{"destination_type", "f16"}}); + auto Subtract0 = makeOP({Convert0, Convert1}, {{"auto_broadcast", "numpy"}}); auto Constant2 = makeConst(element::f16, ov::Shape({ 201088, 1, }), MOCK_VALUE); - auto Multiply0 = makeOP({Subtract0, Constant2}, {{"auto_broadcast", "numpy"}}); - auto Convert2 = makeOP({Multiply0}, {{"destination_type", "f32"}}); - auto Convert3 = makeOP({input_ids}, {{"destination_type", "i32"}}); - auto Gather1 = makeOP({Convert2, Convert3, 0}, {{"batch_dims", 0}}); + auto Multiply0 = makeOP({Subtract0, Constant2}, {{"auto_broadcast", "numpy"}}); + auto Convert2 = makeOP({Multiply0}, {{"destination_type", "f32"}}); + auto Convert3 = makeOP({input_ids}, {{"destination_type", "i32"}}); + auto Gather1 = makeOP({Convert2, Convert3, 0}, {{"batch_dims", 0}}); auto Constant3 = makeConst(element::f32, ov::Shape({ 1, @@ -2095,8 +2094,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), {2.000000f}); - auto Power0 = makeOP({Gather1, Constant5}, {{"auto_broadcast", "numpy"}}); - auto ReduceMean0 = makeOP({Power0, {-1}}, {{"keep_dims", true}}); + auto Power0 = makeOP({Gather1, Constant5}, {{"auto_broadcast", "numpy"}}); + auto ReduceMean0 = makeOP({Power0, {-1}}, {{"keep_dims", true}}); auto Constant6 = makeConst(element::f32, ov::Shape({ 1, @@ -2104,35 +2103,35 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), {0.000010f}); - auto Add0 = makeOP({ReduceMean0, Constant6}, {{"auto_broadcast", "numpy"}}); - auto Sqrt0 = makeOP({Add0}); - auto Divide0 = makeOP({Constant4, Sqrt0}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); - auto Multiply1 = makeOP({Gather1, Divide0}, {{"auto_broadcast", "numpy"}}); - auto Multiply2 = makeOP({Constant3, Multiply1}, {{"auto_broadcast", "numpy"}}); + auto Add0 = makeOP({ReduceMean0, Constant6}, {{"auto_broadcast", "numpy"}}); + auto Sqrt0 = makeOP({Add0}); + auto Divide0 = makeOP({Constant4, Sqrt0}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); + auto Multiply1 = makeOP({Gather1, Divide0}, {{"auto_broadcast", "numpy"}}); + auto Multiply2 = makeOP({Constant3, Multiply1}, {{"auto_broadcast", "numpy"}}); auto Constant7 = makeConst(element::u8, ov::Shape({ 4096, 2880, }), MOCK_VALUE); - auto Convert4 = makeOP({Constant7}, {{"destination_type", "f16"}}); + auto Convert4 = makeOP({Constant7}, {{"destination_type", "f16"}}); auto Constant8 = makeConst(element::u8, ov::Shape({ 4096, 1, }), MOCK_VALUE); - auto Convert5 = makeOP({Constant8}, {{"destination_type", "f16"}}); - auto Subtract1 = makeOP({Convert4, Convert5}, {{"auto_broadcast", "numpy"}}); + auto Convert5 = makeOP({Constant8}, {{"destination_type", "f16"}}); + auto Subtract1 = makeOP({Convert4, Convert5}, {{"auto_broadcast", "numpy"}}); auto Constant9 = makeConst(element::f16, ov::Shape({ 4096, 1, }), MOCK_VALUE); - auto Multiply3 = makeOP({Subtract1, Constant9}, {{"auto_broadcast", "numpy"}}); - auto Convert6 = makeOP({Multiply3}, {{"destination_type", "f32"}}); - auto MatMul0 = makeOP({Multiply2, Convert6}, {{"transpose_a", false}, {"transpose_b", true}}); + auto Multiply3 = makeOP({Subtract1, Constant9}, {{"auto_broadcast", "numpy"}}); + auto Convert6 = makeOP({Multiply3}, {{"destination_type", "f32"}}); + auto MatMul0 = makeOP({Multiply2, Convert6}, {{"transpose_a", false}, {"transpose_b", true}}); auto Constant10 = makeConst(element::f32, ov::Shape({ 1, @@ -2140,18 +2139,18 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 4096, }), MOCK_VALUE); - auto Add1 = makeOP({MatMul0, Constant10}, {{"auto_broadcast", "numpy"}}); - auto Reshape0 = makeOP({Add1, {0, 0, 64, 64}}, {{"special_zero", true}}); - auto Transpose0 = makeOP({Reshape0, {0, 2, 1, 3}}); - auto ShapeOf1 = makeOP({Transpose0}, {{"output_type", "i32"}}); - auto Gather2 = makeOP({ShapeOf1, -1, {0}}, {{"batch_dims", 0}}); - auto Divide1 = makeOP({Gather2, 2}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); - auto Mod0 = makeOP({Gather2, 2}, {{"auto_broadcast", "numpy"}}); - auto Greater0 = makeOP({Mod0, {0}}, {{"auto_broadcast", "numpy"}}); - auto Convert7 = makeOP({Greater0}, {{"destination_type", "i32"}}); - auto Add2 = makeOP({Divide1, Convert7}, {{"auto_broadcast", "numpy"}}); - auto Concat0 = makeOP({Add2, {-1}}, {{"axis", 0}}); - auto VariadicSplit0 = makeOP({Transpose0, -1, Concat0}); + auto Add1 = makeOP({MatMul0, Constant10}, {{"auto_broadcast", "numpy"}}); + auto Reshape0 = makeOP({Add1, {0, 0, 64, 64}}, {{"special_zero", true}}); + auto Transpose0 = makeOP({Reshape0, {0, 2, 1, 3}}); + auto ShapeOf1 = makeOP({Transpose0}, {{"output_type", "i32"}}); + auto Gather2 = makeOP({ShapeOf1, -1, {0}}, {{"batch_dims", 0}}); + auto Divide1 = makeOP({Gather2, 2}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); + auto Mod0 = makeOP({Gather2, 2}, {{"auto_broadcast", "numpy"}}); + auto Greater0 = makeOP({Mod0, {0}}, {{"auto_broadcast", "numpy"}}); + auto Convert7 = makeOP({Greater0}, {{"destination_type", "i32"}}); + auto Add2 = makeOP({Divide1, Convert7}, {{"auto_broadcast", "numpy"}}); + auto Concat0 = makeOP({Add2, {-1}}, {{"axis", 0}}); + auto VariadicSplit0 = makeOP({Transpose0, -1, Concat0}); auto Constant11 = makeConst(element::f32, ov::Shape({ 1, @@ -2159,15 +2158,15 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), MOCK_VALUE); - auto ShapeOf2 = makeOP({position_ids}, {{"output_type", "i64"}}); - auto Gather3 = makeOP({ShapeOf2, {0}, 0}, {{"batch_dims", 0}}); - auto Concat1 = makeOP({Gather3, {1l}, {1l}}, {{"axis", 0}}); - auto Broadcast0 = makeOP({Constant11, Concat1}, {{"mode", "bidirectional"}}); - auto Unsqueeze0 = makeOP({position_ids, 1}); - auto Convert8 = makeOP({Unsqueeze0}, {{"destination_type", "f32"}}); - auto MatMul1 = makeOP({Broadcast0, Convert8}, {{"transpose_a", false}, {"transpose_b", false}}); - auto Transpose1 = makeOP({MatMul1, {0, 2, 1}}); - auto Cos0 = makeOP({Transpose1}); + auto ShapeOf2 = makeOP({position_ids}, {{"output_type", "i64"}}); + auto Gather3 = makeOP({ShapeOf2, {0}, 0}, {{"batch_dims", 0}}); + auto Concat1 = makeOP({Gather3, {1l}, {1l}}, {{"axis", 0}}); + auto Broadcast0 = makeOP({Constant11, Concat1}, {{"mode", "bidirectional"}}); + auto Unsqueeze0 = makeOP({position_ids, 1}); + auto Convert8 = makeOP({Unsqueeze0}, {{"destination_type", "f32"}}); + auto MatMul1 = makeOP({Broadcast0, Convert8}, {{"transpose_a", false}, {"transpose_b", false}}); + auto Transpose1 = makeOP({MatMul1, {0, 2, 1}}); + auto Cos0 = makeOP({Transpose1}); auto Constant12 = makeConst(element::f32, ov::Shape({ 1, @@ -2175,10 +2174,10 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), {1.346574f}); - auto Multiply4 = makeOP({Cos0, Constant12}, {{"auto_broadcast", "numpy"}}); - auto Unsqueeze1 = makeOP({Multiply4, 1}); - auto Multiply5 = makeOP({VariadicSplit0->output(0), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); - auto Sin0 = makeOP({Transpose1}); + auto Multiply4 = makeOP({Cos0, Constant12}, {{"auto_broadcast", "numpy"}}); + auto Unsqueeze1 = makeOP({Multiply4, 1}); + auto Multiply5 = makeOP({VariadicSplit0->output(0), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); + auto Sin0 = makeOP({Transpose1}); auto Constant13 = makeConst(element::f32, ov::Shape({ 1, @@ -2186,100 +2185,100 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), {1.346574f}); - auto Multiply6 = makeOP({Sin0, Constant13}, {{"auto_broadcast", "numpy"}}); - auto Unsqueeze2 = makeOP({Multiply6, 1}); - auto Multiply7 = makeOP({VariadicSplit0->output(1), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); - auto Subtract2 = makeOP({Multiply5, Multiply7}, {{"auto_broadcast", "numpy"}}); - auto Multiply8 = makeOP({VariadicSplit0->output(1), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); - auto Multiply9 = makeOP({VariadicSplit0->output(0), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); - auto Add3 = makeOP({Multiply8, Multiply9}, {{"auto_broadcast", "numpy"}}); - auto Concat2 = makeOP({Subtract2, Add3}, {{"axis", -1}}); - auto Concat3 = makeOP({Gather0, {8l}, {0l}, {64l}}, {{"axis", 0}}); - auto Broadcast1 = makeOP({0.000000f, Concat3}, {{"mode", "numpy"}}); - auto ReadValue0 = makeOP( + auto Multiply6 = makeOP({Sin0, Constant13}, {{"auto_broadcast", "numpy"}}); + auto Unsqueeze2 = makeOP({Multiply6, 1}); + auto Multiply7 = makeOP({VariadicSplit0->output(1), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); + auto Subtract2 = makeOP({Multiply5, Multiply7}, {{"auto_broadcast", "numpy"}}); + auto Multiply8 = makeOP({VariadicSplit0->output(1), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); + auto Multiply9 = makeOP({VariadicSplit0->output(0), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); + auto Add3 = makeOP({Multiply8, Multiply9}, {{"auto_broadcast", "numpy"}}); + auto Concat2 = makeOP({Subtract2, Add3}, {{"axis", -1}}); + auto Concat3 = makeOP({Gather0, {8l}, {0l}, {64l}}, {{"axis", 0}}); + auto Broadcast1 = makeOP({0.000000f, Concat3}, {{"mode", "numpy"}}); + auto ReadValue0 = makeOP( {Broadcast1}, {{"variable_id", "var1"}, {"variable_type", "f32"}, {"variable_shape", PartialShape{DYN, 8, DYN, 64}}}); - auto Gather4 = makeOP({ReadValue0, beam_idx, 0}, {{"batch_dims", 0}}); + auto Gather4 = makeOP({ReadValue0, beam_idx, 0}, {{"batch_dims", 0}}); auto Constant14 = makeConst(element::u8, ov::Shape({ 512, 2880, }), MOCK_VALUE); - auto Convert9 = makeOP({Constant14}, {{"destination_type", "f16"}}); + auto Convert9 = makeOP({Constant14}, {{"destination_type", "f16"}}); auto Constant15 = makeConst(element::u8, ov::Shape({ 512, 1, }), MOCK_VALUE); - auto Convert10 = makeOP({Constant15}, {{"destination_type", "f16"}}); - auto Subtract3 = makeOP({Convert9, Convert10}, {{"auto_broadcast", "numpy"}}); + auto Convert10 = makeOP({Constant15}, {{"destination_type", "f16"}}); + auto Subtract3 = makeOP({Convert9, Convert10}, {{"auto_broadcast", "numpy"}}); auto Constant16 = makeConst(element::f16, ov::Shape({ 512, 1, }), MOCK_VALUE); - auto Multiply10 = makeOP({Subtract3, Constant16}, {{"auto_broadcast", "numpy"}}); - auto Convert11 = makeOP({Multiply10}, {{"destination_type", "f32"}}); - auto MatMul2 = makeOP({Multiply2, Convert11}, {{"transpose_a", false}, {"transpose_b", true}}); - auto Reshape1 = makeOP({MatMul2, {0, 0, 8, 64}}, {{"special_zero", true}}); - auto Transpose2 = makeOP({Reshape1, {0, 2, 1, 3}}); - auto ShapeOf3 = makeOP({Transpose2}, {{"output_type", "i32"}}); - auto Gather5 = makeOP({ShapeOf3, -1, {0}}, {{"batch_dims", 0}}); - auto Divide2 = makeOP({Gather5, 2}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); - auto Mod1 = makeOP({Gather5, 2}, {{"auto_broadcast", "numpy"}}); - auto Greater1 = makeOP({Mod1, {0}}, {{"auto_broadcast", "numpy"}}); - auto Convert12 = makeOP({Greater1}, {{"destination_type", "i32"}}); - auto Add4 = makeOP({Divide2, Convert12}, {{"auto_broadcast", "numpy"}}); - auto Concat4 = makeOP({Add4, {-1}}, {{"axis", 0}}); - auto VariadicSplit1 = makeOP({Transpose2, -1, Concat4}); - auto Multiply11 = makeOP({VariadicSplit1->output(0), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); - auto Multiply12 = makeOP({VariadicSplit1->output(1), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); - auto Subtract4 = makeOP({Multiply11, Multiply12}, {{"auto_broadcast", "numpy"}}); - auto Multiply13 = makeOP({VariadicSplit1->output(1), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); - auto Multiply14 = makeOP({VariadicSplit1->output(0), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); - auto Add5 = makeOP({Multiply13, Multiply14}, {{"auto_broadcast", "numpy"}}); - auto Concat5 = makeOP({Subtract4, Add5}, {{"axis", -1}}); - auto Concat6 = makeOP({Gather4, Concat5}, {{"axis", -2}}); - auto Unsqueeze3 = makeOP({Concat6, 2}); - auto ShapeOf4 = makeOP({Concat6}, {{"output_type", "i64"}}); - auto Gather6 = makeOP({ShapeOf4, {0, 1}, 0}, {{"batch_dims", 0}}); - auto Gather7 = makeOP({ShapeOf4, {2, 3}, 0}, {{"batch_dims", 0}}); - auto Concat7 = makeOP({Gather6, {8l}, Gather7}, {{"axis", 0}}); - auto Broadcast2 = makeOP({Unsqueeze3, Concat7}, {{"mode", "bidirectional"}}); - auto Reshape2 = makeOP({Broadcast2, {0, 64, -1, 64}}, {{"special_zero", true}}); - auto Concat8 = makeOP({Gather0, {8l}, {0l}, {64l}}, {{"axis", 0}}); - auto Broadcast3 = makeOP({0.0f, Concat8}, {{"mode", "numpy"}}); - auto ReadValue1 = makeOP( + auto Multiply10 = makeOP({Subtract3, Constant16}, {{"auto_broadcast", "numpy"}}); + auto Convert11 = makeOP({Multiply10}, {{"destination_type", "f32"}}); + auto MatMul2 = makeOP({Multiply2, Convert11}, {{"transpose_a", false}, {"transpose_b", true}}); + auto Reshape1 = makeOP({MatMul2, {0, 0, 8, 64}}, {{"special_zero", true}}); + auto Transpose2 = makeOP({Reshape1, {0, 2, 1, 3}}); + auto ShapeOf3 = makeOP({Transpose2}, {{"output_type", "i32"}}); + auto Gather5 = makeOP({ShapeOf3, -1, {0}}, {{"batch_dims", 0}}); + auto Divide2 = makeOP({Gather5, 2}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); + auto Mod1 = makeOP({Gather5, 2}, {{"auto_broadcast", "numpy"}}); + auto Greater1 = makeOP({Mod1, {0}}, {{"auto_broadcast", "numpy"}}); + auto Convert12 = makeOP({Greater1}, {{"destination_type", "i32"}}); + auto Add4 = makeOP({Divide2, Convert12}, {{"auto_broadcast", "numpy"}}); + auto Concat4 = makeOP({Add4, {-1}}, {{"axis", 0}}); + auto VariadicSplit1 = makeOP({Transpose2, -1, Concat4}); + auto Multiply11 = makeOP({VariadicSplit1->output(0), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); + auto Multiply12 = makeOP({VariadicSplit1->output(1), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); + auto Subtract4 = makeOP({Multiply11, Multiply12}, {{"auto_broadcast", "numpy"}}); + auto Multiply13 = makeOP({VariadicSplit1->output(1), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); + auto Multiply14 = makeOP({VariadicSplit1->output(0), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); + auto Add5 = makeOP({Multiply13, Multiply14}, {{"auto_broadcast", "numpy"}}); + auto Concat5 = makeOP({Subtract4, Add5}, {{"axis", -1}}); + auto Concat6 = makeOP({Gather4, Concat5}, {{"axis", -2}}); + auto Unsqueeze3 = makeOP({Concat6, 2}); + auto ShapeOf4 = makeOP({Concat6}, {{"output_type", "i64"}}); + auto Gather6 = makeOP({ShapeOf4, {0, 1}, 0}, {{"batch_dims", 0}}); + auto Gather7 = makeOP({ShapeOf4, {2, 3}, 0}, {{"batch_dims", 0}}); + auto Concat7 = makeOP({Gather6, {8l}, Gather7}, {{"axis", 0}}); + auto Broadcast2 = makeOP({Unsqueeze3, Concat7}, {{"mode", "bidirectional"}}); + auto Reshape2 = makeOP({Broadcast2, {0, 64, -1, 64}}, {{"special_zero", true}}); + auto Concat8 = makeOP({Gather0, {8l}, {0l}, {64l}}, {{"axis", 0}}); + auto Broadcast3 = makeOP({0.0f, Concat8}, {{"mode", "numpy"}}); + auto ReadValue1 = makeOP( {Broadcast3}, {{"variable_id", "var2"}, {"variable_type", "f32"}, {"variable_shape", PartialShape{DYN, 8, DYN, 64}}}); - auto Gather8 = makeOP({ReadValue1, beam_idx, 0}, {{"batch_dims", 0}}); + auto Gather8 = makeOP({ReadValue1, beam_idx, 0}, {{"batch_dims", 0}}); auto Constant17 = makeConst(element::u8, ov::Shape({ 512, 2880, }), MOCK_VALUE); - auto Convert13 = makeOP({Constant17}, {{"destination_type", "f16"}}); + auto Convert13 = makeOP({Constant17}, {{"destination_type", "f16"}}); auto Constant18 = makeConst(element::u8, ov::Shape({ 512, 1, }), MOCK_VALUE); - auto Convert14 = makeOP({Constant18}, {{"destination_type", "f16"}}); - auto Subtract5 = makeOP({Convert13, Convert14}, {{"auto_broadcast", "numpy"}}); + auto Convert14 = makeOP({Constant18}, {{"destination_type", "f16"}}); + auto Subtract5 = makeOP({Convert13, Convert14}, {{"auto_broadcast", "numpy"}}); auto Constant19 = makeConst(element::f16, ov::Shape({ 512, 1, }), MOCK_VALUE); - auto Multiply15 = makeOP({Subtract5, Constant19}, {{"auto_broadcast", "numpy"}}); - auto Convert15 = makeOP({Multiply15}, {{"destination_type", "f32"}}); - auto MatMul3 = makeOP({Multiply2, Convert15}, {{"transpose_a", false}, {"transpose_b", true}}); + auto Multiply15 = makeOP({Subtract5, Constant19}, {{"auto_broadcast", "numpy"}}); + auto Convert15 = makeOP({Multiply15}, {{"destination_type", "f32"}}); + auto MatMul3 = makeOP({Multiply2, Convert15}, {{"transpose_a", false}, {"transpose_b", true}}); auto Constant20 = makeConst(element::f32, ov::Shape({ 1, @@ -2287,31 +2286,31 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 512, }), MOCK_VALUE); - auto Add6 = makeOP({MatMul3, Constant20}, {{"auto_broadcast", "numpy"}}); - auto Reshape3 = makeOP({Add6, {0, 0, 8, 64}}, {{"special_zero", true}}); - auto Transpose3 = makeOP({Reshape3, {0, 2, 1, 3}}); - auto Concat9 = makeOP({Gather8, Transpose3}, {{"axis", -2}}); - auto Unsqueeze4 = makeOP({Concat9, 2}); - auto Broadcast4 = makeOP({Unsqueeze4, Concat7}, {{"mode", "bidirectional"}}); - auto Reshape4 = makeOP({Broadcast4, {0, 64, -1, 64}}, {{"special_zero", true}}); + auto Add6 = makeOP({MatMul3, Constant20}, {{"auto_broadcast", "numpy"}}); + auto Reshape3 = makeOP({Add6, {0, 0, 8, 64}}, {{"special_zero", true}}); + auto Transpose3 = makeOP({Reshape3, {0, 2, 1, 3}}); + auto Concat9 = makeOP({Gather8, Transpose3}, {{"axis", -2}}); + auto Unsqueeze4 = makeOP({Concat9, 2}); + auto Broadcast4 = makeOP({Unsqueeze4, Concat7}, {{"mode", "bidirectional"}}); + auto Reshape4 = makeOP({Broadcast4, {0, 64, -1, 64}}, {{"special_zero", true}}); auto Constant21 = makeConst(element::boolean, ov::Shape({}), {1}); auto Constant22 = makeConst(element::boolean, ov::Shape({}), {1}); - auto Gather9 = makeOP({ShapeOf2, 1, 0}, {{"batch_dims", 0}}); - auto Reshape5 = makeOP({Gather9, {1}}, {{"special_zero", false}}); - auto Squeeze0 = makeOP({Reshape5, 0}); - auto ShapeOf5 = makeOP({Gather4}, {{"output_type", "i64"}}); - auto Gather10 = makeOP({ShapeOf5, 2, 0}, {{"batch_dims", 0}}); - auto Add7 = makeOP({Squeeze0, Gather10}, {{"auto_broadcast", "numpy"}}); - auto Range0 = makeOP({0, Add7, 1}, {{"output_type", "i64"}}); - auto Unsqueeze5 = makeOP({Range0, 0}); - auto Unsqueeze6 = makeOP({Unsqueeze5, 1}); - auto Unsqueeze7 = makeOP({Unsqueeze6, 2}); - auto Convert16 = makeOP({Unsqueeze7}, {{"destination_type", "f32"}}); - auto Add8 = makeOP({Gather10, Gather9}, {{"auto_broadcast", "numpy"}}); - auto Range1 = makeOP({Gather10, Add8, 1}, {{"output_type", "f32"}}); - auto Unsqueeze8 = makeOP({Range1, 0}); - auto Unsqueeze9 = makeOP({Unsqueeze8, 1}); - auto Unsqueeze10 = makeOP({Unsqueeze9, 3}); + auto Gather9 = makeOP({ShapeOf2, 1, 0}, {{"batch_dims", 0}}); + auto Reshape5 = makeOP({Gather9, {1}}, {{"special_zero", false}}); + auto Squeeze0 = makeOP({Reshape5, 0}); + auto ShapeOf5 = makeOP({Gather4}, {{"output_type", "i64"}}); + auto Gather10 = makeOP({ShapeOf5, 2, 0}, {{"batch_dims", 0}}); + auto Add7 = makeOP({Squeeze0, Gather10}, {{"auto_broadcast", "numpy"}}); + auto Range0 = makeOP({0, Add7, 1}, {{"output_type", "i64"}}); + auto Unsqueeze5 = makeOP({Range0, 0}); + auto Unsqueeze6 = makeOP({Unsqueeze5, 1}); + auto Unsqueeze7 = makeOP({Unsqueeze6, 2}); + auto Convert16 = makeOP({Unsqueeze7}, {{"destination_type", "f32"}}); + auto Add8 = makeOP({Gather10, Gather9}, {{"auto_broadcast", "numpy"}}); + auto Range1 = makeOP({Gather10, Add8, 1}, {{"output_type", "f32"}}); + auto Unsqueeze8 = makeOP({Range1, 0}); + auto Unsqueeze9 = makeOP({Unsqueeze8, 1}); + auto Unsqueeze10 = makeOP({Unsqueeze9, 3}); auto Constant23 = makeConst(element::f32, ov::Shape({ 1, @@ -2320,39 +2319,39 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), {-128.000000f}); - auto Add9 = makeOP({Unsqueeze10, Constant23}, {{"auto_broadcast", "numpy"}}); - auto Greater2 = makeOP({Convert16, Add9}, {{"auto_broadcast", "numpy"}}); - auto BitwiseAnd0 = makeOP({Constant22, Greater2}, {{"auto_broadcast", "numpy"}}); - auto LessEqual0 = makeOP({Convert16, Unsqueeze10}, {{"auto_broadcast", "numpy"}}); - auto BitwiseAnd1 = makeOP({BitwiseAnd0, LessEqual0}, {{"auto_broadcast", "numpy"}}); - auto BitwiseAnd2 = makeOP({Constant21, BitwiseAnd1}, {{"auto_broadcast", "numpy"}}); - auto Convert17 = makeOP({attention_mask}, {{"destination_type", "boolean"}}); - auto ShapeOf6 = makeOP({Convert17}, {{"output_type", "i32"}}); - auto ReduceProd0 = makeOP({ShapeOf6, 0}, {{"keep_dims", true}}); - auto Concat10 = makeOP({ReduceProd0, {-1}}, {{"axis", 0}}); - auto Reshape6 = makeOP({Convert17, Concat10}, {{"special_zero", true}}); - auto Convert18 = makeOP({Unsqueeze7}, {{"destination_type", "i32"}}); - auto Squeeze1 = makeOP({Gather3}); - auto Range2 = makeOP({0, Squeeze1, 1}, {{"output_type", "i64"}}); - auto Unsqueeze11 = makeOP({Range2, 1}); - auto Unsqueeze12 = makeOP({Unsqueeze11, 2}); - auto Unsqueeze13 = makeOP({Unsqueeze12, 3}); - auto Convert19 = makeOP({Unsqueeze13}, {{"destination_type", "i32"}}); - auto Split0 = makeOP({ShapeOf6, 0}, {{"num_splits", 2}}); - auto Multiply16 = makeOP({Convert19, Split0->output(1)}, {{"auto_broadcast", "numpy"}}); - auto Add10 = makeOP({Convert18, Multiply16}, {{"auto_broadcast", "numpy"}}); - auto Gather11 = makeOP({Reshape6, Add10, 0}, {{"batch_dims", 0}}); - auto Reshape7 = makeOP({Gather11, {-1}}, {{"special_zero", false}}); - auto ShapeOf7 = makeOP({Add10}, {{"output_type", "i32"}}); - auto Reshape8 = makeOP({Reshape7, ShapeOf7}, {{"special_zero", false}}); - auto BitwiseAnd3 = makeOP({BitwiseAnd2, Reshape8}, {{"auto_broadcast", "numpy"}}); - auto Unsqueeze14 = makeOP({Add7, 0}); - auto Concat11 = makeOP({Gather3, {1l}, Reshape5, Unsqueeze14}, {{"axis", 0}}); - auto Broadcast5 = makeOP({BitwiseAnd3, Concat11}, {{"mode", "bidirectional"}}); - auto Select0 = makeOP({Broadcast5, 0.000000f, -65504.000000f}, {{"auto_broadcast", "numpy"}}); - auto Reshape9 = makeOP({Gather10, {1}}, {{"special_zero", false}}); - auto Add11 = makeOP({Reshape9, Reshape5}, {{"auto_broadcast", "numpy"}}); - auto Slice0 = makeOP({Select0, {0}, Add11, {1}, {3}}); + auto Add9 = makeOP({Unsqueeze10, Constant23}, {{"auto_broadcast", "numpy"}}); + auto Greater2 = makeOP({Convert16, Add9}, {{"auto_broadcast", "numpy"}}); + auto BitwiseAnd0 = makeOP({Constant22, Greater2}, {{"auto_broadcast", "numpy"}}); + auto LessEqual0 = makeOP({Convert16, Unsqueeze10}, {{"auto_broadcast", "numpy"}}); + auto BitwiseAnd1 = makeOP({BitwiseAnd0, LessEqual0}, {{"auto_broadcast", "numpy"}}); + auto BitwiseAnd2 = makeOP({Constant21, BitwiseAnd1}, {{"auto_broadcast", "numpy"}}); + auto Convert17 = makeOP({attention_mask}, {{"destination_type", "boolean"}}); + auto ShapeOf6 = makeOP({Convert17}, {{"output_type", "i32"}}); + auto ReduceProd0 = makeOP({ShapeOf6, 0}, {{"keep_dims", true}}); + auto Concat10 = makeOP({ReduceProd0, {-1}}, {{"axis", 0}}); + auto Reshape6 = makeOP({Convert17, Concat10}, {{"special_zero", true}}); + auto Convert18 = makeOP({Unsqueeze7}, {{"destination_type", "i32"}}); + auto Squeeze1 = makeOP({Gather3}); + auto Range2 = makeOP({0, Squeeze1, 1}, {{"output_type", "i64"}}); + auto Unsqueeze11 = makeOP({Range2, 1}); + auto Unsqueeze12 = makeOP({Unsqueeze11, 2}); + auto Unsqueeze13 = makeOP({Unsqueeze12, 3}); + auto Convert19 = makeOP({Unsqueeze13}, {{"destination_type", "i32"}}); + auto Split0 = makeOP({ShapeOf6, 0}, {{"num_splits", 2}}); + auto Multiply16 = makeOP({Convert19, Split0->output(1)}, {{"auto_broadcast", "numpy"}}); + auto Add10 = makeOP({Convert18, Multiply16}, {{"auto_broadcast", "numpy"}}); + auto Gather11 = makeOP({Reshape6, Add10, 0}, {{"batch_dims", 0}}); + auto Reshape7 = makeOP({Gather11, {-1}}, {{"special_zero", false}}); + auto ShapeOf7 = makeOP({Add10}, {{"output_type", "i32"}}); + auto Reshape8 = makeOP({Reshape7, ShapeOf7}, {{"special_zero", false}}); + auto BitwiseAnd3 = makeOP({BitwiseAnd2, Reshape8}, {{"auto_broadcast", "numpy"}}); + auto Unsqueeze14 = makeOP({Add7, 0}); + auto Concat11 = makeOP({Gather3, {1l}, Reshape5, Unsqueeze14}, {{"axis", 0}}); + auto Broadcast5 = makeOP({BitwiseAnd3, Concat11}, {{"mode", "bidirectional"}}); + auto Select0 = makeOP({Broadcast5, 0.000000f, -65504.000000f}, {{"auto_broadcast", "numpy"}}); + auto Reshape9 = makeOP({Gather10, {1}}, {{"special_zero", false}}); + auto Add11 = makeOP({Reshape9, Reshape5}, {{"auto_broadcast", "numpy"}}); + auto Slice0 = makeOP({Select0, {0}, Add11, {1}, {3}}); auto Constant24 = makeConst(element::f32, ov::Shape({ 1, @@ -2362,10 +2361,10 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { }), MOCK_VALUE); auto ScaledDotProductAttention = - makeOP({Concat2, Reshape2, Reshape4, Slice0, 0.125000f, Constant24}, + makeOP({Concat2, Reshape2, Reshape4, Slice0, 0.125000f, Constant24}, {{"causal", false}}); - auto res = make_shared(ScaledDotProductAttention); + auto res = make_shared(ScaledDotProductAttention); model = std::make_shared(OutputVector{res}, params); @@ -2414,26 +2413,26 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 2880, }), MOCK_VALUE); - auto Convert0 = makeOP({Constant1}, {{"destination_type", "f16"}}); + auto Convert0 = makeOP({Constant1}, {{"destination_type", "f16"}}); auto Constant2 = makeConst(element::u8, ov::Shape({ 201088, 1, }), MOCK_VALUE); - auto Convert1 = makeOP({Constant2}, {{"destination_type", "f16"}}); - auto Subtract0 = makeOP({Convert0, Convert1}, {{"auto_broadcast", "numpy"}}); + auto Convert1 = makeOP({Constant2}, {{"destination_type", "f16"}}); + auto Subtract0 = makeOP({Convert0, Convert1}, {{"auto_broadcast", "numpy"}}); auto Constant3 = makeConst(element::f16, ov::Shape({ 201088, 1, }), MOCK_VALUE); - auto Multiply0 = makeOP({Subtract0, Constant3}, {{"auto_broadcast", "numpy"}}); - auto Convert2 = makeOP({Multiply0}, {{"destination_type", "f32"}}); - auto Unsqueeze0 = makeOP({input_ids, 1}); - auto Convert3 = makeOP({Unsqueeze0}, {{"destination_type", "i32"}}); - auto Gather0 = makeOP({Convert2, Convert3, 0}, {{"batch_dims", 0}}); + auto Multiply0 = makeOP({Subtract0, Constant3}, {{"auto_broadcast", "numpy"}}); + auto Convert2 = makeOP({Multiply0}, {{"destination_type", "f32"}}); + auto Unsqueeze0 = makeOP({input_ids, 1}); + auto Convert3 = makeOP({Unsqueeze0}, {{"destination_type", "i32"}}); + auto Gather0 = makeOP({Convert2, Convert3, 0}, {{"batch_dims", 0}}); auto Constant4 = makeConst(element::f32, ov::Shape({ 1, @@ -2455,8 +2454,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), {2.000000f}); - auto Power0 = makeOP({Gather0, Constant6}, {{"auto_broadcast", "numpy"}}); - auto ReduceMean0 = makeOP({Power0, {-1}}, {{"keep_dims", true}}); + auto Power0 = makeOP({Gather0, Constant6}, {{"auto_broadcast", "numpy"}}); + auto ReduceMean0 = makeOP({Power0, {-1}}, {{"keep_dims", true}}); auto Constant7 = makeConst(element::f32, ov::Shape({ 1, @@ -2464,35 +2463,35 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), {0.000010f}); - auto Add0 = makeOP({ReduceMean0, Constant7}, {{"auto_broadcast", "numpy"}}); - auto Sqrt0 = makeOP({Add0}); - auto Divide0 = makeOP({Constant5, Sqrt0}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); - auto Multiply1 = makeOP({Gather0, Divide0}, {{"auto_broadcast", "numpy"}}); - auto Multiply2 = makeOP({Constant4, Multiply1}, {{"auto_broadcast", "numpy"}}); + auto Add0 = makeOP({ReduceMean0, Constant7}, {{"auto_broadcast", "numpy"}}); + auto Sqrt0 = makeOP({Add0}); + auto Divide0 = makeOP({Constant5, Sqrt0}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); + auto Multiply1 = makeOP({Gather0, Divide0}, {{"auto_broadcast", "numpy"}}); + auto Multiply2 = makeOP({Constant4, Multiply1}, {{"auto_broadcast", "numpy"}}); auto Constant8 = makeConst(element::u8, ov::Shape({ 4096, 2880, }), MOCK_VALUE); - auto Convert4 = makeOP({Constant8}, {{"destination_type", "f16"}}); + auto Convert4 = makeOP({Constant8}, {{"destination_type", "f16"}}); auto Constant9 = makeConst(element::u8, ov::Shape({ 4096, 1, }), MOCK_VALUE); - auto Convert5 = makeOP({Constant9}, {{"destination_type", "f16"}}); - auto Subtract1 = makeOP({Convert4, Convert5}, {{"auto_broadcast", "numpy"}}); + auto Convert5 = makeOP({Constant9}, {{"destination_type", "f16"}}); + auto Subtract1 = makeOP({Convert4, Convert5}, {{"auto_broadcast", "numpy"}}); auto Constant10 = makeConst(element::f16, ov::Shape({ 4096, 1, }), MOCK_VALUE); - auto Multiply3 = makeOP({Subtract1, Constant10}, {{"auto_broadcast", "numpy"}}); - auto Convert6 = makeOP({Multiply3}, {{"destination_type", "f32"}}); - auto MatMul0 = makeOP({Multiply2, Convert6}, {{"transpose_a", false}, {"transpose_b", true}}); + auto Multiply3 = makeOP({Subtract1, Constant10}, {{"auto_broadcast", "numpy"}}); + auto Convert6 = makeOP({Multiply3}, {{"destination_type", "f32"}}); + auto MatMul0 = makeOP({Multiply2, Convert6}, {{"transpose_a", false}, {"transpose_b", true}}); auto Constant11 = makeConst(element::f32, ov::Shape({ 1, @@ -2500,18 +2499,18 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 4096, }), MOCK_VALUE); - auto Add1 = makeOP({MatMul0, Constant11}, {{"auto_broadcast", "numpy"}}); - auto Reshape0 = makeOP({Add1, {0, 0, 64, 64}}, {{"special_zero", true}}); - auto Transpose0 = makeOP({Reshape0, {0, 2, 1, 3}}); - auto ShapeOf0 = makeOP({Transpose0}, {{"output_type", "i32"}}); - auto Gather1 = makeOP({ShapeOf0, -1, {0}}, {{"batch_dims", 0}}); - auto Divide1 = makeOP({Gather1, 2}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); - auto Mod0 = makeOP({Gather1, 2}, {{"auto_broadcast", "numpy"}}); - auto Greater0 = makeOP({Mod0, {0}}, {{"auto_broadcast", "numpy"}}); - auto Convert7 = makeOP({Greater0}, {{"destination_type", "i32"}}); - auto Add2 = makeOP({Divide1, Convert7}, {{"auto_broadcast", "numpy"}}); - auto Concat0 = makeOP({Add2, {-1}}, {{"axis", 0}}); - auto VariadicSplit0 = makeOP({Transpose0, -1, Concat0}); + auto Add1 = makeOP({MatMul0, Constant11}, {{"auto_broadcast", "numpy"}}); + auto Reshape0 = makeOP({Add1, {0, 0, 64, 64}}, {{"special_zero", true}}); + auto Transpose0 = makeOP({Reshape0, {0, 2, 1, 3}}); + auto ShapeOf0 = makeOP({Transpose0}, {{"output_type", "i32"}}); + auto Gather1 = makeOP({ShapeOf0, -1, {0}}, {{"batch_dims", 0}}); + auto Divide1 = makeOP({Gather1, 2}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); + auto Mod0 = makeOP({Gather1, 2}, {{"auto_broadcast", "numpy"}}); + auto Greater0 = makeOP({Mod0, {0}}, {{"auto_broadcast", "numpy"}}); + auto Convert7 = makeOP({Greater0}, {{"destination_type", "i32"}}); + auto Add2 = makeOP({Divide1, Convert7}, {{"auto_broadcast", "numpy"}}); + auto Concat0 = makeOP({Add2, {-1}}, {{"axis", 0}}); + auto VariadicSplit0 = makeOP({Transpose0, -1, Concat0}); auto Constant12 = makeConst(element::f32, ov::Shape({ 1, @@ -2519,16 +2518,16 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), MOCK_VALUE); - auto Unsqueeze1 = makeOP({position_ids, 1}); - auto ShapeOf1 = makeOP({Unsqueeze1}, {{"output_type", "i64"}}); - auto Gather2 = makeOP({ShapeOf1, {0}, 0}, {{"batch_dims", 0}}); - auto Concat1 = makeOP({Gather2, {1l}, {1l}}, {{"axis", 0}}); - auto Broadcast0 = makeOP({Constant12, Concat1}, {{"mode", "bidirectional"}}); - auto Unsqueeze2 = makeOP({Unsqueeze1, 1}); - auto Convert8 = makeOP({Unsqueeze2}, {{"destination_type", "f32"}}); - auto MatMul1 = makeOP({Broadcast0, Convert8}, {{"transpose_a", false}, {"transpose_b", false}}); - auto Transpose1 = makeOP({MatMul1, {0, 2, 1}}); - auto Cos0 = makeOP({Transpose1}); + auto Unsqueeze1 = makeOP({position_ids, 1}); + auto ShapeOf1 = makeOP({Unsqueeze1}, {{"output_type", "i64"}}); + auto Gather2 = makeOP({ShapeOf1, {0}, 0}, {{"batch_dims", 0}}); + auto Concat1 = makeOP({Gather2, {1l}, {1l}}, {{"axis", 0}}); + auto Broadcast0 = makeOP({Constant12, Concat1}, {{"mode", "bidirectional"}}); + auto Unsqueeze2 = makeOP({Unsqueeze1, 1}); + auto Convert8 = makeOP({Unsqueeze2}, {{"destination_type", "f32"}}); + auto MatMul1 = makeOP({Broadcast0, Convert8}, {{"transpose_a", false}, {"transpose_b", false}}); + auto Transpose1 = makeOP({MatMul1, {0, 2, 1}}); + auto Cos0 = makeOP({Transpose1}); auto Constant13 = makeConst(element::f32, ov::Shape({ 1, @@ -2536,10 +2535,10 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), {1.346574f}); - auto Multiply4 = makeOP({Cos0, Constant13}, {{"auto_broadcast", "numpy"}}); - auto Unsqueeze3 = makeOP({Multiply4, 1}); - auto Multiply5 = makeOP({VariadicSplit0->output(0), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); - auto Sin0 = makeOP({Transpose1}); + auto Multiply4 = makeOP({Cos0, Constant13}, {{"auto_broadcast", "numpy"}}); + auto Unsqueeze3 = makeOP({Multiply4, 1}); + auto Multiply5 = makeOP({VariadicSplit0->output(0), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); + auto Sin0 = makeOP({Transpose1}); auto Constant14 = makeConst(element::f32, ov::Shape({ 1, @@ -2547,84 +2546,84 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 1, }), {1.346574f}); - auto Multiply6 = makeOP({Sin0, Constant14}, {{"auto_broadcast", "numpy"}}); - auto Unsqueeze4 = makeOP({Multiply6, 1}); - auto Multiply7 = makeOP({VariadicSplit0->output(1), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); - auto Subtract2 = makeOP({Multiply5, Multiply7}, {{"auto_broadcast", "numpy"}}); - auto Multiply8 = makeOP({VariadicSplit0->output(1), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); - auto Multiply9 = makeOP({VariadicSplit0->output(0), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); - auto Add3 = makeOP({Multiply8, Multiply9}, {{"auto_broadcast", "numpy"}}); - auto Concat2 = makeOP({Subtract2, Add3}, {{"axis", -1}}); - auto Transpose2 = makeOP({Concat2, {0, 2, 1, 3}}); - auto Reshape1 = makeOP({Transpose2, {0, -1}}, {{"special_zero", true}}); + auto Multiply6 = makeOP({Sin0, Constant14}, {{"auto_broadcast", "numpy"}}); + auto Unsqueeze4 = makeOP({Multiply6, 1}); + auto Multiply7 = makeOP({VariadicSplit0->output(1), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); + auto Subtract2 = makeOP({Multiply5, Multiply7}, {{"auto_broadcast", "numpy"}}); + auto Multiply8 = makeOP({VariadicSplit0->output(1), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); + auto Multiply9 = makeOP({VariadicSplit0->output(0), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); + auto Add3 = makeOP({Multiply8, Multiply9}, {{"auto_broadcast", "numpy"}}); + auto Concat2 = makeOP({Subtract2, Add3}, {{"axis", -1}}); + auto Transpose2 = makeOP({Concat2, {0, 2, 1, 3}}); + auto Reshape1 = makeOP({Transpose2, {0, -1}}, {{"special_zero", true}}); auto Constant15 = makeConst(element::u8, ov::Shape({ 512, 2880, }), MOCK_VALUE); - auto Convert9 = makeOP({Constant15}, {{"destination_type", "f16"}}); + auto Convert9 = makeOP({Constant15}, {{"destination_type", "f16"}}); auto Constant16 = makeConst(element::u8, ov::Shape({ 512, 1, }), MOCK_VALUE); - auto Convert10 = makeOP({Constant16}, {{"destination_type", "f16"}}); - auto Subtract3 = makeOP({Convert9, Convert10}, {{"auto_broadcast", "numpy"}}); + auto Convert10 = makeOP({Constant16}, {{"destination_type", "f16"}}); + auto Subtract3 = makeOP({Convert9, Convert10}, {{"auto_broadcast", "numpy"}}); auto Constant17 = makeConst(element::f16, ov::Shape({ 512, 1, }), MOCK_VALUE); - auto Multiply10 = makeOP({Subtract3, Constant17}, {{"auto_broadcast", "numpy"}}); - auto Convert11 = makeOP({Multiply10}, {{"destination_type", "f32"}}); - auto MatMul2 = makeOP({Multiply2, Convert11}, {{"transpose_a", false}, {"transpose_b", true}}); - auto Reshape2 = makeOP({MatMul2, {0, 0, 8, 64}}, {{"special_zero", true}}); - auto Transpose3 = makeOP({Reshape2, {0, 2, 1, 3}}); - auto ShapeOf2 = makeOP({Transpose3}, {{"output_type", "i32"}}); - auto Gather3 = makeOP({ShapeOf2, -1, {0}}, {{"batch_dims", 0}}); - auto Divide2 = makeOP({Gather3, 2}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); - auto Mod1 = makeOP({Gather3, 2}, {{"auto_broadcast", "numpy"}}); - auto Greater1 = makeOP({Mod1, {0}}, {{"auto_broadcast", "numpy"}}); - auto Convert12 = makeOP({Greater1}, {{"destination_type", "i32"}}); - auto Add4 = makeOP({Divide2, Convert12}, {{"auto_broadcast", "numpy"}}); - auto Concat3 = makeOP({Add4, {-1}}, {{"axis", 0}}); - auto VariadicSplit1 = makeOP({Transpose3, -1, Concat3}); - auto Multiply11 = makeOP({VariadicSplit1->output(0), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); - auto Multiply12 = makeOP({VariadicSplit1->output(1), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); - auto Subtract4 = makeOP({Multiply11, Multiply12}, {{"auto_broadcast", "numpy"}}); - auto Multiply13 = makeOP({VariadicSplit1->output(1), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); - auto Multiply14 = makeOP({VariadicSplit1->output(0), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); - auto Add5 = makeOP({Multiply13, Multiply14}, {{"auto_broadcast", "numpy"}}); - auto Concat4 = makeOP({Subtract4, Add5}, {{"axis", -1}}); - auto Transpose4 = makeOP({Concat4, {0, 2, 1, 3}}); - auto Reshape3 = makeOP({Transpose4, {0, -1}}, {{"special_zero", true}}); + auto Multiply10 = makeOP({Subtract3, Constant17}, {{"auto_broadcast", "numpy"}}); + auto Convert11 = makeOP({Multiply10}, {{"destination_type", "f32"}}); + auto MatMul2 = makeOP({Multiply2, Convert11}, {{"transpose_a", false}, {"transpose_b", true}}); + auto Reshape2 = makeOP({MatMul2, {0, 0, 8, 64}}, {{"special_zero", true}}); + auto Transpose3 = makeOP({Reshape2, {0, 2, 1, 3}}); + auto ShapeOf2 = makeOP({Transpose3}, {{"output_type", "i32"}}); + auto Gather3 = makeOP({ShapeOf2, -1, {0}}, {{"batch_dims", 0}}); + auto Divide2 = makeOP({Gather3, 2}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); + auto Mod1 = makeOP({Gather3, 2}, {{"auto_broadcast", "numpy"}}); + auto Greater1 = makeOP({Mod1, {0}}, {{"auto_broadcast", "numpy"}}); + auto Convert12 = makeOP({Greater1}, {{"destination_type", "i32"}}); + auto Add4 = makeOP({Divide2, Convert12}, {{"auto_broadcast", "numpy"}}); + auto Concat3 = makeOP({Add4, {-1}}, {{"axis", 0}}); + auto VariadicSplit1 = makeOP({Transpose3, -1, Concat3}); + auto Multiply11 = makeOP({VariadicSplit1->output(0), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); + auto Multiply12 = makeOP({VariadicSplit1->output(1), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); + auto Subtract4 = makeOP({Multiply11, Multiply12}, {{"auto_broadcast", "numpy"}}); + auto Multiply13 = makeOP({VariadicSplit1->output(1), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); + auto Multiply14 = makeOP({VariadicSplit1->output(0), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); + auto Add5 = makeOP({Multiply13, Multiply14}, {{"auto_broadcast", "numpy"}}); + auto Concat4 = makeOP({Subtract4, Add5}, {{"axis", -1}}); + auto Transpose4 = makeOP({Concat4, {0, 2, 1, 3}}); + auto Reshape3 = makeOP({Transpose4, {0, -1}}, {{"special_zero", true}}); auto Constant18 = makeConst(element::u8, ov::Shape({ 512, 2880, }), MOCK_VALUE); - auto Convert13 = makeOP({Constant18}, {{"destination_type", "f16"}}); + auto Convert13 = makeOP({Constant18}, {{"destination_type", "f16"}}); auto Constant19 = makeConst(element::u8, ov::Shape({ 512, 1, }), MOCK_VALUE); - auto Convert14 = makeOP({Constant19}, {{"destination_type", "f16"}}); - auto Subtract5 = makeOP({Convert13, Convert14}, {{"auto_broadcast", "numpy"}}); + auto Convert14 = makeOP({Constant19}, {{"destination_type", "f16"}}); + auto Subtract5 = makeOP({Convert13, Convert14}, {{"auto_broadcast", "numpy"}}); auto Constant20 = makeConst(element::f16, ov::Shape({ 512, 1, }), MOCK_VALUE); - auto Multiply15 = makeOP({Subtract5, Constant20}, {{"auto_broadcast", "numpy"}}); - auto Convert15 = makeOP({Multiply15}, {{"destination_type", "f32"}}); - auto MatMul3 = makeOP({Multiply2, Convert15}, {{"transpose_a", false}, {"transpose_b", true}}); + auto Multiply15 = makeOP({Subtract5, Constant20}, {{"auto_broadcast", "numpy"}}); + auto Convert15 = makeOP({Multiply15}, {{"destination_type", "f32"}}); + auto MatMul3 = makeOP({Multiply2, Convert15}, {{"transpose_a", false}, {"transpose_b", true}}); auto Constant21 = makeConst(element::f32, ov::Shape({ 1, @@ -2632,11 +2631,11 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { 512, }), MOCK_VALUE); - auto Add6 = makeOP({MatMul3, Constant21}, {{"auto_broadcast", "numpy"}}); - auto Reshape4 = makeOP({Add6, {0, 0, 8, 64}}, {{"special_zero", true}}); - auto Transpose5 = makeOP({Reshape4, {0, 2, 1, 3}}); - auto Transpose6 = makeOP({Transpose5, {0, 2, 1, 3}}); - auto Reshape5 = makeOP({Transpose6, {0, -1}}, {{"special_zero", true}}); + auto Add6 = makeOP({MatMul3, Constant21}, {{"auto_broadcast", "numpy"}}); + auto Reshape4 = makeOP({Add6, {0, 0, 8, 64}}, {{"special_zero", true}}); + auto Transpose5 = makeOP({Reshape4, {0, 2, 1, 3}}); + auto Transpose6 = makeOP({Transpose5, {0, 2, 1, 3}}); + auto Reshape5 = makeOP({Transpose6, {0, -1}}, {{"special_zero", true}}); auto Constant22 = makeConst(element::f32, ov::Shape({ 1, @@ -2647,11 +2646,11 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { MOCK_VALUE); auto sliding_window_neg = makeConst(element::f32, ov::Shape({1, 1, 1, 1}), {-128.0f}); - auto Squeeze2 = makeOP({sliding_window_neg}, {{"allow_axis_skip", false}}); - auto Convert16 = makeOP({Squeeze2}, {{"destination_type", "i32"}}); - auto sliding_window = makeOP({Convert16, -1}, {{"auto_broadcast", "numpy"}}); - auto scale = v0::Constant::create(element::f32, {}, {0.1250f}); - auto alibi_slopes_stub = v0::Constant::create(element::f32, Shape{0}, {}); + auto Squeeze2 = makeOP({sliding_window_neg}, {{"allow_axis_skip", false}}); + auto Convert16 = makeOP({Squeeze2}, {{"destination_type", "i32"}}); + auto sliding_window = makeOP({Convert16, -1}, {{"auto_broadcast", "numpy"}}); + auto scale = ov::op::v0::Constant::create(element::f32, {}, {0.1250f}); + auto alibi_slopes_stub = ov::op::v0::Constant::create(element::f32, Shape{0}, {}); auto PagedAttentionExtension = std::make_shared(OutputVector{Reshape1, Reshape3, @@ -2674,14 +2673,14 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { xattention_block_size, xattention_stride, Constant22}); - auto ShapeOf3 = makeOP({Transpose6}, {{"output_type", "i64"}}); - auto Gather4 = makeOP({ShapeOf3, -1, 0}, {{"batch_dims", 0}}); - auto Unsqueeze5 = makeOP({Gather4, 0}); - auto Concat5 = makeOP({{0l}, {1l}, {-1l}, Unsqueeze5}, {{"axis", 0}}); - auto Reshape6 = makeOP({PagedAttentionExtension->output(0), Concat5}, {{"special_zero", true}}); - auto Transpose7 = makeOP({Reshape6, {0, 2, 1, 3}}); - - auto res = makeOP({Transpose7}); + auto ShapeOf3 = makeOP({Transpose6}, {{"output_type", "i64"}}); + auto Gather4 = makeOP({ShapeOf3, -1, 0}, {{"batch_dims", 0}}); + auto Unsqueeze5 = makeOP({Gather4, 0}); + auto Concat5 = makeOP({{0l}, {1l}, {-1l}, Unsqueeze5}, {{"axis", 0}}); + auto Reshape6 = makeOP({PagedAttentionExtension->output(0), Concat5}, {{"special_zero", true}}); + auto Transpose7 = makeOP({Reshape6, {0, 2, 1, 3}}); + + auto res = makeOP({Transpose7}); model_ref = std::make_shared(res, params); diff --git a/src/common/transformations/tests/symbolic_transformations/chained_maximum.cpp b/src/common/transformations/tests/symbolic_transformations/chained_maximum.cpp index c2d19a30828a96..7882f8d3a63f28 100644 --- a/src/common/transformations/tests/symbolic_transformations/chained_maximum.cpp +++ b/src/common/transformations/tests/symbolic_transformations/chained_maximum.cpp @@ -15,24 +15,23 @@ #include "transformations/symbolic_transformations/symbolic_optimizations.hpp" using namespace ov; -using namespace ov::op; using namespace std; TEST_F(TransformationTestsF, ChainedMaximumAC) { // A == C // Maximum(Maximum(A, B), C) -> Maximum(B, C) { - auto input = make_shared(element::f32, PartialShape::dynamic(4)); + auto input = make_shared(element::f32, PartialShape::dynamic(4)); - auto A = make_shared(input); - auto B = v0::Constant::create(element::i64, {}, {1}); - auto C = make_shared(input); + auto A = make_shared(input); + auto B = ov::op::v0::Constant::create(element::i64, {}, {1}); + auto C = make_shared(input); - auto maximum_0 = make_shared(A, B); - auto maximum_1 = make_shared(maximum_0, C); + auto maximum_0 = make_shared(A, B); + auto maximum_1 = make_shared(maximum_0, C); - auto data = make_shared(element::f32, PartialShape::dynamic()); - auto broadcast = make_shared(data, maximum_1); + auto data = make_shared(element::f32, PartialShape::dynamic()); + auto broadcast = make_shared(data, maximum_1); model = make_shared(OutputVector{broadcast}, ParameterVector{input, data}); manager.set_per_pass_validation(false); @@ -40,15 +39,15 @@ TEST_F(TransformationTestsF, ChainedMaximumAC) { manager.register_pass(); } { - auto input = make_shared(element::f32, PartialShape::dynamic(4)); + auto input = make_shared(element::f32, PartialShape::dynamic(4)); - auto B = v0::Constant::create(element::i64, {}, {1}); - auto C = make_shared(input); + auto B = ov::op::v0::Constant::create(element::i64, {}, {1}); + auto C = make_shared(input); - auto maximum = make_shared(B, C); + auto maximum = make_shared(B, C); - auto data = make_shared(element::f32, PartialShape::dynamic()); - auto broadcast = make_shared(data, maximum); + auto data = make_shared(element::f32, PartialShape::dynamic()); + auto broadcast = make_shared(data, maximum); model_ref = make_shared(OutputVector{broadcast}, ParameterVector{input, data}); } @@ -58,16 +57,16 @@ TEST_F(TransformationTestsF, ChainedMaximumBC) { // B == C // Maximum(Maximum(A, B), C) -> Maximum(A, C) { - auto input = make_shared(element::f32, PartialShape::dynamic(4)); + auto input = make_shared(element::f32, PartialShape::dynamic(4)); - auto A = v0::Constant::create(element::i64, {}, {1}); - auto B = make_shared(input); - auto C = make_shared(input); + auto A = ov::op::v0::Constant::create(element::i64, {}, {1}); + auto B = make_shared(input); + auto C = make_shared(input); - auto maximum_0 = make_shared(A, B); - auto maximum_1 = make_shared(maximum_0, C); - auto data = make_shared(element::f32, PartialShape::dynamic()); - auto broadcast = make_shared(data, maximum_1); + auto maximum_0 = make_shared(A, B); + auto maximum_1 = make_shared(maximum_0, C); + auto data = make_shared(element::f32, PartialShape::dynamic()); + auto broadcast = make_shared(data, maximum_1); model = make_shared(OutputVector{broadcast}, ParameterVector{input, data}); manager.set_per_pass_validation(false); @@ -75,15 +74,15 @@ TEST_F(TransformationTestsF, ChainedMaximumBC) { manager.register_pass(); } { - auto input = make_shared(element::f32, PartialShape::dynamic(4)); + auto input = make_shared(element::f32, PartialShape::dynamic(4)); - auto A = v0::Constant::create(element::i64, {}, {1}); - auto C = make_shared(input); + auto A = ov::op::v0::Constant::create(element::i64, {}, {1}); + auto C = make_shared(input); - auto maximum = make_shared(A, C); + auto maximum = make_shared(A, C); - auto data = make_shared(element::f32, PartialShape::dynamic()); - auto broadcast = make_shared(data, maximum); + auto data = make_shared(element::f32, PartialShape::dynamic()); + auto broadcast = make_shared(data, maximum); model_ref = make_shared(OutputVector{broadcast}, ParameterVector{input, data}); } @@ -92,17 +91,17 @@ TEST_F(TransformationTestsF, ChainedMaximumBC) { TEST_F(TransformationTestsF, ChainedMaximumNegativeNoLabels) { { auto shape = PartialShape::dynamic(4); - auto input = make_shared(element::f32, shape); + auto input = make_shared(element::f32, shape); - auto A = v0::Constant::create(element::i64, {}, {1}); - auto B = make_shared(input); - auto C = make_shared(input); + auto A = ov::op::v0::Constant::create(element::i64, {}, {1}); + auto B = make_shared(input); + auto C = make_shared(input); - auto maximum_0 = make_shared(A, B); - auto maximum_1 = make_shared(maximum_0, C); + auto maximum_0 = make_shared(A, B); + auto maximum_1 = make_shared(maximum_0, C); - auto data = make_shared(element::f32, PartialShape::dynamic()); - auto broadcast = make_shared(data, maximum_1); + auto data = make_shared(element::f32, PartialShape::dynamic()); + auto broadcast = make_shared(data, maximum_1); model = make_shared(OutputVector{broadcast}, ParameterVector{input, data}); manager.register_pass(); @@ -111,18 +110,18 @@ TEST_F(TransformationTestsF, ChainedMaximumNegativeNoLabels) { TEST_F(TransformationTestsF, ChainedMaximumNegativeDifferentLabels) { { - auto input_0 = make_shared(element::f32, PartialShape::dynamic(4)); - auto input_1 = make_shared(element::f32, PartialShape::dynamic(4)); + auto input_0 = make_shared(element::f32, PartialShape::dynamic(4)); + auto input_1 = make_shared(element::f32, PartialShape::dynamic(4)); - auto A = v0::Constant::create(element::i64, {}, {1}); - auto B = make_shared(input_0); - auto C = make_shared(input_1); + auto A = ov::op::v0::Constant::create(element::i64, {}, {1}); + auto B = make_shared(input_0); + auto C = make_shared(input_1); - auto maximum_0 = make_shared(A, B); - auto maximum_1 = make_shared(maximum_0, C); + auto maximum_0 = make_shared(A, B); + auto maximum_1 = make_shared(maximum_0, C); - auto data = make_shared(element::f32, PartialShape::dynamic()); - auto broadcast = make_shared(data, maximum_1); + auto data = make_shared(element::f32, PartialShape::dynamic()); + auto broadcast = make_shared(data, maximum_1); model = make_shared(OutputVector{broadcast}, ParameterVector{input_0, input_1, data}); manager.set_per_pass_validation(false); diff --git a/src/common/transformations/tests/symbolic_transformations/dereshape_fullyconnected.cpp b/src/common/transformations/tests/symbolic_transformations/dereshape_fullyconnected.cpp index a5460af89fd3f9..31c77c2c9d1baf 100644 --- a/src/common/transformations/tests/symbolic_transformations/dereshape_fullyconnected.cpp +++ b/src/common/transformations/tests/symbolic_transformations/dereshape_fullyconnected.cpp @@ -16,7 +16,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::op; using namespace std; TEST_F(TransformationTestsF, DeReshapeFC) { @@ -24,24 +23,24 @@ TEST_F(TransformationTestsF, DeReshapeFC) { set_shape_symbols(shape); // we label shape with consecutive labels: A, B, C { - auto data = make_shared(element::f32, shape); - auto in_reshape = make_shared(data, v0::Constant::create(element::i64, {2}, {-1, 40}), true); - auto second_input = make_shared(element::f32, Shape{40, 80}); + auto data = make_shared(element::f32, shape); + auto in_reshape = make_shared(data, ov::op::v0::Constant::create(element::i64, {2}, {-1, 40}), true); + auto second_input = make_shared(element::f32, Shape{40, 80}); - auto matmul = make_shared(in_reshape, second_input); + auto matmul = make_shared(in_reshape, second_input); auto batch_dims = ov::op::util::node_to_get_shape_value_of_indices_from_shape_source(data, {0, 1}); auto pattern = - make_shared(OutputVector{batch_dims, v0::Constant::create(element::i64, {1}, {80})}, 0); - auto out_reshape = make_shared(matmul, pattern, false); + make_shared(OutputVector{batch_dims, ov::op::v0::Constant::create(element::i64, {1}, {80})}, 0); + auto out_reshape = make_shared(matmul, pattern, false); model = make_shared(OutputVector{out_reshape}, ParameterVector{data, second_input}); manager.register_pass(); } { - auto data = make_shared(element::f32, shape); - auto second_input = make_shared(element::f32, Shape{40, 80}); - auto matmul = make_shared(data, second_input); + auto data = make_shared(element::f32, shape); + auto second_input = make_shared(element::f32, Shape{40, 80}); + auto matmul = make_shared(data, second_input); model_ref = make_shared(OutputVector{matmul}, ParameterVector{data, second_input}); } @@ -51,26 +50,26 @@ TEST_F(TransformationTestsF, DeReshapeFCWithConvert) { auto shape = PartialShape{-1, -1, 40}; set_shape_symbols(shape); // we label shape with consecutive labels: A, B, C { - auto data = make_shared(element::f16, shape); - auto in_reshape = make_shared(data, v0::Constant::create(element::i64, {2}, {-1, 40}), true); - auto convert = make_shared(in_reshape, element::f32); - auto second_input = make_shared(element::f32, Shape{40, 80}); + auto data = make_shared(element::f16, shape); + auto in_reshape = make_shared(data, ov::op::v0::Constant::create(element::i64, {2}, {-1, 40}), true); + auto convert = make_shared(in_reshape, element::f32); + auto second_input = make_shared(element::f32, Shape{40, 80}); - auto matmul = make_shared(convert, second_input); + auto matmul = make_shared(convert, second_input); auto batch_dims = ov::op::util::node_to_get_shape_value_of_indices_from_shape_source(data, {0, 1}); auto pattern = - make_shared(OutputVector{batch_dims, v0::Constant::create(element::i64, {1}, {80})}, 0); - auto out_reshape = make_shared(matmul, pattern, false); + make_shared(OutputVector{batch_dims, ov::op::v0::Constant::create(element::i64, {1}, {80})}, 0); + auto out_reshape = make_shared(matmul, pattern, false); model = make_shared(OutputVector{out_reshape}, ParameterVector{data, second_input}); manager.register_pass(); } { - auto data = make_shared(element::f16, shape); - auto convert = make_shared(data, element::f32); - auto second_input = make_shared(element::f32, Shape{40, 80}); - auto matmul = make_shared(convert, second_input); + auto data = make_shared(element::f16, shape); + auto convert = make_shared(data, element::f32); + auto second_input = make_shared(element::f32, Shape{40, 80}); + auto matmul = make_shared(convert, second_input); model_ref = make_shared(OutputVector{matmul}, ParameterVector{data, second_input}); } @@ -80,15 +79,15 @@ TEST_F(TransformationTestsF, DeReshapeFCNegative) { auto shape = PartialShape{-1, -1, 40}; set_shape_symbols(shape); // we label shape with consecutive labels: A, B, C { - auto data = make_shared(element::f16, shape); - auto in_reshape = make_shared(data, v0::Constant::create(element::i64, {2}, {-1, 40}), true); - auto convert = make_shared(in_reshape, element::f32); - auto second_input = make_shared(element::f32, Shape{40, 80}); + auto data = make_shared(element::f16, shape); + auto in_reshape = make_shared(data, ov::op::v0::Constant::create(element::i64, {2}, {-1, 40}), true); + auto convert = make_shared(in_reshape, element::f32); + auto second_input = make_shared(element::f32, Shape{40, 80}); - auto matmul = make_shared(convert, second_input); + auto matmul = make_shared(convert, second_input); - auto pattern = v0::Constant::create(element::i64, {3}, {4, -1, 80}); - auto out_reshape = make_shared(matmul, pattern, false); + auto pattern = ov::op::v0::Constant::create(element::i64, {3}, {4, -1, 80}); + auto out_reshape = make_shared(matmul, pattern, false); model = make_shared(OutputVector{out_reshape}, ParameterVector{data, second_input}); manager.register_pass(); diff --git a/src/common/transformations/tests/symbolic_transformations/dereshape_matmul.cpp b/src/common/transformations/tests/symbolic_transformations/dereshape_matmul.cpp index be7b1007449877..5d633a6d06dd93 100644 --- a/src/common/transformations/tests/symbolic_transformations/dereshape_matmul.cpp +++ b/src/common/transformations/tests/symbolic_transformations/dereshape_matmul.cpp @@ -21,7 +21,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::op; using namespace std; namespace { @@ -42,7 +41,7 @@ class DimensionTestHelper { explicit DimensionTestHelper(const size_t& num_dims) { auto dimensions = PartialShape::dynamic(Rank(num_dims)); set_shape_symbols(dimensions); - parameter = make_shared(element::f32, dimensions); + parameter = make_shared(element::f32, dimensions); for (size_t i = 0; i < num_dims; ++i) m_map[i] = {dimensions[i], op::util::node_to_get_shape_value_of_indices_from_shape_source(parameter, {i})}; } @@ -62,16 +61,16 @@ class DimensionTestHelper { OutputVector sources(dims_indices.size()); for (size_t i = 0; i < dims_indices.size(); ++i) sources[i] = m_map.at(dims_indices[i]).source; - auto concat = make_shared(sources, 0); - return make_shared(source, concat, false); + auto concat = make_shared(sources, 0); + return make_shared(source, concat, false); } - std::shared_ptr get_parameter() const { + std::shared_ptr get_parameter() const { return parameter; } private: - std::shared_ptr parameter; + std::shared_ptr parameter; std::map m_map; }; @@ -88,8 +87,8 @@ shared_ptr reshape(const Output& source, OutputVector sources(dims_indices.size()); for (size_t i = 0; i < dims_indices.size(); ++i) sources[i] = helper[dims_indices[i]].source; - auto concat = make_shared(sources, 0); - return make_shared(source, concat, false); + auto concat = make_shared(sources, 0); + return make_shared(source, concat, false); } void get_dims(const ov::Output& source, const size_t& from, const size_t& to, ov::NodeVector& dims) { @@ -243,17 +242,17 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar OutputVector outputs; // LHS input of MatMul - auto lhs_input = make_shared(element::f32, lhs_original_pshape); + auto lhs_input = make_shared(element::f32, lhs_original_pshape); auto lhs_output = dims.make_reshape(lhs_input, lhs_reshape_idx); if (set{10, 11, 300, 301, 310, 311}.count(concat_mode)) { const auto& another_pshape = make_concat_input_pshape(dims, lhs_reshape_idx); - const auto& another_input = make_shared(element::f32, another_pshape); + const auto& another_input = make_shared(element::f32, another_pshape); if (set{10, 300, 301}.count(concat_mode)) { // reshape on 0 port - lhs_output = make_shared(OutputVector{lhs_output, another_input}, -1); + lhs_output = make_shared(OutputVector{lhs_output, another_input}, -1); } else if (set{11, 310, 311}.count(concat_mode)) { // reshape on 1 port - lhs_output = make_shared(OutputVector{another_input, lhs_output}, -1); + lhs_output = make_shared(OutputVector{another_input, lhs_output}, -1); } else { ASSERT_TRUE(false) << "Unknown mode of concat: " << concat_mode; } @@ -262,19 +261,19 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar } if (bea_scalar_mode == 1 || bea_scalar_mode == 3) - lhs_output = make_shared(lhs_output, v0::Constant::create(element::f32, {}, {0.125})); + lhs_output = make_shared(lhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); // RHS input of MatMul - auto rhs_input = make_shared(element::f32, rhs_original_pshape); + auto rhs_input = make_shared(element::f32, rhs_original_pshape); auto rhs_output = dims.make_reshape(rhs_input, rhs_reshape_idx); if (set{20, 21, 300, 301, 310, 311}.count(concat_mode)) { const auto& another_pshape = make_concat_input_pshape(dims, rhs_reshape_idx); - const auto& another_input = make_shared(element::f32, another_pshape); + const auto& another_input = make_shared(element::f32, another_pshape); if (set{20, 300, 310}.count(concat_mode)) { // reshape on 0 port - rhs_output = make_shared(OutputVector{rhs_output, another_input}, -1); + rhs_output = make_shared(OutputVector{rhs_output, another_input}, -1); } else if (set{21, 301, 311}.count(concat_mode)) { // reshape on 1 port - rhs_output = make_shared(OutputVector{another_input, rhs_output}, -1); + rhs_output = make_shared(OutputVector{another_input, rhs_output}, -1); } else { ASSERT_TRUE(false) << "Unknown mode of concat: " << concat_mode; } @@ -283,16 +282,16 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar } if (bea_scalar_mode == 2 || bea_scalar_mode == 3) - rhs_output = make_shared(rhs_output, v0::Constant::create(element::f32, {}, {0.125})); + rhs_output = make_shared(rhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); - Output matmul = make_shared(lhs_output, rhs_output); + Output matmul = make_shared(lhs_output, rhs_output); if (final_add_mode == 1) // 1 - add has matmul on lhs matmul = - make_shared(matmul, v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1})); + make_shared(matmul, ov::op::v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1})); else if (final_add_mode == 2) // 2 - add has matmul on rhs matmul = - make_shared(v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1}), matmul); + make_shared(ov::op::v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1}), matmul); auto output_reshape = reshape(matmul, out_reshape_idx, dims); @@ -302,8 +301,8 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar outputs.emplace_back(output_reshape); for (auto& output : outputs) - output = std::make_shared(output, v0::Constant::create(element::i32, {1}, {-1}), false); - auto output = make_shared(outputs, 0); + output = std::make_shared(output, ov::op::v0::Constant::create(element::i32, {1}, {-1}), false); + auto output = make_shared(outputs, 0); model = make_shared(output, inputs, "Tested model"); } @@ -319,66 +318,66 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar OutputVector outputs; // LHS input of MatMul - auto lhs_input = make_shared(element::f32, lhs_original_pshape); + auto lhs_input = make_shared(element::f32, lhs_original_pshape); auto lhs_output = lhs_input->output(0); if (set{10, 11, 300, 301, 310, 311}.count(concat_mode)) { const auto& another_pshape = make_concat_input_pshape(dims, lhs_reshape_idx); - const auto& another_input = make_shared(element::f32, another_pshape); + const auto& another_input = make_shared(element::f32, another_pshape); auto target_shape_of_input = get_target_shape_from_sources(lhs_output, another_input); - auto input_reshape = make_shared(another_input, target_shape_of_input, false); + auto input_reshape = make_shared(another_input, target_shape_of_input, false); if (set{10, 300, 301}.count(concat_mode)) { // reshape on 0 port - lhs_output = make_shared(OutputVector{lhs_output, input_reshape}, -1); + lhs_output = make_shared(OutputVector{lhs_output, input_reshape}, -1); } else if (set{11, 310, 311}.count(concat_mode)) { // reshape on 1 port - lhs_output = make_shared(OutputVector{input_reshape, lhs_output}, -1); + lhs_output = make_shared(OutputVector{input_reshape, lhs_output}, -1); } else { ASSERT_TRUE(false) << "Unknown mode of concat: " << concat_mode; } auto target_shape_of_output = get_target_shape_from_sources(input_reshape->input_value(0), lhs_output); - auto output_reshape = make_shared(lhs_output, target_shape_of_output, false); + auto output_reshape = make_shared(lhs_output, target_shape_of_output, false); inputs.push_back(another_input); outputs.emplace_back(output_reshape); } if (bea_scalar_mode == 1 || bea_scalar_mode == 3) - lhs_output = make_shared(lhs_output, v0::Constant::create(element::f32, {}, {0.125})); + lhs_output = make_shared(lhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); // RHS input of MatMul - auto rhs_input = make_shared(element::f32, rhs_original_pshape); + auto rhs_input = make_shared(element::f32, rhs_original_pshape); auto rhs_output = rhs_input->output(0); if (set{20, 21, 300, 301, 310, 311}.count(concat_mode)) { const auto& another_pshape = make_concat_input_pshape(dims, rhs_reshape_idx); - const auto& another_input = make_shared(element::f32, another_pshape); + const auto& another_input = make_shared(element::f32, another_pshape); auto target_shape_of_input = get_target_shape_from_sources(rhs_output, another_input); - auto input_reshape = make_shared(another_input, target_shape_of_input, false); + auto input_reshape = make_shared(another_input, target_shape_of_input, false); if (set{20, 300, 310}.count(concat_mode)) { // reshape on 0 port - rhs_output = make_shared(OutputVector{rhs_output, input_reshape}, -1); + rhs_output = make_shared(OutputVector{rhs_output, input_reshape}, -1); } else if (set{21, 301, 311}.count(concat_mode)) { // reshape on 1 port - rhs_output = make_shared(OutputVector{input_reshape, rhs_output}, -1); + rhs_output = make_shared(OutputVector{input_reshape, rhs_output}, -1); } else { ASSERT_TRUE(false) << "Unknown mode of concat: " << concat_mode; } auto target_shape_of_output = get_target_shape_from_sources(input_reshape->input_value(0), rhs_output); - auto output_reshape = make_shared(rhs_output, target_shape_of_output, false); + auto output_reshape = make_shared(rhs_output, target_shape_of_output, false); inputs.push_back(another_input); outputs.emplace_back(output_reshape); } if (bea_scalar_mode == 2 || bea_scalar_mode == 3) - rhs_output = make_shared(rhs_output, v0::Constant::create(element::f32, {}, {0.125})); + rhs_output = make_shared(rhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); - Output matmul = make_shared(lhs_output, rhs_output); + Output matmul = make_shared(lhs_output, rhs_output); if (final_add_mode > 0) { - const auto original_add_in = v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1}); + const auto original_add_in = ov::op::v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1}); auto divisor = ov::op::util::node_to_get_shape_value_of_indices_from_shape_source(lhs_input, {1}); auto first_batch_dim = std::make_shared(ov::op::v0::Constant::create(element::i64, {1}, {1}), @@ -391,9 +390,9 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar auto other_input_reshape = op::util::make_try_fold(original_add_in, pattern, true); if (final_add_mode == 1) { // 1 - add has matmul on lhs - matmul = make_shared(matmul, other_input_reshape); + matmul = make_shared(matmul, other_input_reshape); } else if (final_add_mode == 2) { // 2 - add has matmul on rhs - matmul = make_shared(other_input_reshape, matmul); + matmul = make_shared(other_input_reshape, matmul); } } inputs.push_back(dims.get_parameter()); @@ -402,8 +401,8 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar outputs.emplace_back(matmul); for (auto& output : outputs) - output = std::make_shared(output, v0::Constant::create(element::i32, {1}, {-1}), false); - auto output = make_shared(outputs, 0); + output = std::make_shared(output, ov::op::v0::Constant::create(element::i32, {1}, {-1}), false); + auto output = make_shared(outputs, 0); model_ref = make_shared(output, inputs, "Reference model"); } diff --git a/src/common/transformations/tests/symbolic_transformations/nop_broadcast.cpp b/src/common/transformations/tests/symbolic_transformations/nop_broadcast.cpp index dafcab67973860..a41503ed054a19 100644 --- a/src/common/transformations/tests/symbolic_transformations/nop_broadcast.cpp +++ b/src/common/transformations/tests/symbolic_transformations/nop_broadcast.cpp @@ -16,7 +16,6 @@ #include "openvino/op/shape_of.hpp" using namespace ov; -using namespace ov::op; using namespace std; TEST_F(TransformationTestsF, NopBroadcastOpset1) { @@ -24,24 +23,24 @@ TEST_F(TransformationTestsF, NopBroadcastOpset1) { set_shape_symbols(shape); // we set unique symbols to the shape: A, B, C, D { - auto data = make_shared(element::f32, shape); + auto data = make_shared(element::f32, shape); - auto symbol_input = make_shared(element::f32, shape); - auto shape_of = make_shared(symbol_input); + auto symbol_input = make_shared(element::f32, shape); + auto shape_of = make_shared(symbol_input); auto ones = ov::op::v0::Constant::create(element::i64, {}, {1}); - auto maximum = make_shared(shape_of, ones); + auto maximum = make_shared(shape_of, ones); - auto broadcast = make_shared(data, maximum); - auto relu = make_shared(broadcast); + auto broadcast = make_shared(data, maximum); + auto relu = make_shared(broadcast); model = make_shared(OutputVector{relu}, ParameterVector{data, symbol_input}); manager.register_pass(); } { - auto data = make_shared(element::f32, shape); - auto relu = make_shared(data); + auto data = make_shared(element::f32, shape); + auto relu = make_shared(data); - auto symbol_input = make_shared(element::f32, shape); + auto symbol_input = make_shared(element::f32, shape); model_ref = make_shared(OutputVector{relu}, ParameterVector{data, symbol_input}); } @@ -52,24 +51,24 @@ TEST_F(TransformationTestsF, NopBroadcastOpset3) { set_shape_symbols(shape); // we set unique symbols to the shape: A, B, C, D { - auto data = make_shared(element::f32, shape); + auto data = make_shared(element::f32, shape); - auto symbol_input = make_shared(element::f32, shape); - auto shape_of = make_shared(symbol_input); + auto symbol_input = make_shared(element::f32, shape); + auto shape_of = make_shared(symbol_input); auto ones = ov::op::v0::Constant::create(element::i64, {4}, {1, 1, 1, 1}); - auto maximum = make_shared(shape_of, ones); + auto maximum = make_shared(shape_of, ones); - auto broadcast = make_shared(data, maximum); - auto relu = make_shared(broadcast); + auto broadcast = make_shared(data, maximum); + auto relu = make_shared(broadcast); model = make_shared(OutputVector{relu}, ParameterVector{data, symbol_input}); manager.register_pass(); } { - auto data = make_shared(element::f32, shape); - auto relu = make_shared(data); + auto data = make_shared(element::f32, shape); + auto relu = make_shared(data); - auto symbol_input = make_shared(element::f32, shape); + auto symbol_input = make_shared(element::f32, shape); model_ref = make_shared(OutputVector{relu}, ParameterVector{data, symbol_input}); } @@ -80,15 +79,15 @@ TEST_F(TransformationTestsF, NopBroadcastNegative) { auto shape = PartialShape::dynamic(1); shape[0].set_symbol(std::make_shared()); - auto data = make_shared(element::f32, shape); + auto data = make_shared(element::f32, shape); - auto symbol_input = make_shared(element::f32, shape); - auto shape_of = make_shared(symbol_input); + auto symbol_input = make_shared(element::f32, shape); + auto shape_of = make_shared(symbol_input); auto ones = ov::op::v0::Constant::create(element::i64, {2}, {1, 1}); - auto maximum = make_shared(shape_of, ones); + auto maximum = make_shared(shape_of, ones); - auto broadcast = make_shared(data, maximum); - auto relu = make_shared(broadcast); + auto broadcast = make_shared(data, maximum); + auto relu = make_shared(broadcast); model = make_shared(OutputVector{relu}, ParameterVector{data, symbol_input}); manager.register_pass(); diff --git a/src/common/transformations/tests/symbolic_transformations/reshape_optimizations.cpp b/src/common/transformations/tests/symbolic_transformations/reshape_optimizations.cpp index db4e0d0ce4a956..54df366bf11adf 100644 --- a/src/common/transformations/tests/symbolic_transformations/reshape_optimizations.cpp +++ b/src/common/transformations/tests/symbolic_transformations/reshape_optimizations.cpp @@ -18,7 +18,6 @@ #include "openvino/op/shape_of.hpp" using namespace ov; -using namespace ov::op; using namespace std; TEST_F(TransformationTestsF, FlattenOptimization) { @@ -28,30 +27,30 @@ TEST_F(TransformationTestsF, FlattenOptimization) { set_shape_symbols(shape); // we set unique symbols to the shape: A, B, C, D { - auto data = make_shared(element::f32, shape); + auto data = make_shared(element::f32, shape); - auto shape_of = make_shared(data); + auto shape_of = make_shared(data); auto indices = ov::op::v0::Constant::create(element::i64, {2}, {0, 1}); auto axis = ov::op::v0::Constant::create(element::i64, {}, {0}); - auto as_is_dims = make_shared(shape_of, indices, axis); + auto as_is_dims = make_shared(shape_of, indices, axis); - auto merged_dim = make_shared( - make_shared(shape_of, ov::op::v0::Constant::create(element::i64, {1}, {2}), axis), - make_shared(shape_of, ov::op::v0::Constant::create(element::i64, {1}, {3}), axis)); + auto merged_dim = make_shared( + make_shared(shape_of, ov::op::v0::Constant::create(element::i64, {1}, {2}), axis), + make_shared(shape_of, ov::op::v0::Constant::create(element::i64, {1}, {3}), axis)); - auto pattern = make_shared(OutputVector{as_is_dims, merged_dim}, 0); + auto pattern = make_shared(OutputVector{as_is_dims, merged_dim}, 0); - auto reshape = make_shared(data, pattern, false); + auto reshape = make_shared(data, pattern, false); model = make_shared(OutputVector{reshape}, ParameterVector{data}); manager.register_pass(); } { - auto data = make_shared(element::f32, shape); + auto data = make_shared(element::f32, shape); auto pattern = ov::op::v0::Constant::create(element::i64, {3}, {0, 0, -1}); - auto reshape = make_shared(data, pattern, true); + auto reshape = make_shared(data, pattern, true); model_ref = make_shared(OutputVector{reshape}, ParameterVector{data}); } @@ -64,27 +63,27 @@ TEST_F(TransformationTestsF, LastDimSplitStaticLast) { set_shape_symbols(shape); // we set unique symbols to the shape: A, B, C, D { - auto data = make_shared(element::f32, shape); + auto data = make_shared(element::f32, shape); - auto shape_of = make_shared(data); + auto shape_of = make_shared(data); auto indices = ov::op::v0::Constant::create(element::i64, {3}, {0, 1, 2}); auto axis = ov::op::v0::Constant::create(element::i64, {}, {0}); - auto as_is_dims = make_shared(shape_of, indices, axis); + auto as_is_dims = make_shared(shape_of, indices, axis); auto splited_dim = ov::op::v0::Constant::create(element::i64, {2}, {-1, 8}); - auto pattern = make_shared(OutputVector{as_is_dims, splited_dim}, 0); + auto pattern = make_shared(OutputVector{as_is_dims, splited_dim}, 0); - auto reshape = make_shared(data, pattern, false); + auto reshape = make_shared(data, pattern, false); model = make_shared(OutputVector{reshape}, ParameterVector{data}); manager.register_pass(); } { - auto data = make_shared(element::f32, shape); + auto data = make_shared(element::f32, shape); auto pattern = ov::op::v0::Constant::create(element::i64, {5}, {0, 0, 0, -1, 8}); - auto reshape = make_shared(data, pattern, true); + auto reshape = make_shared(data, pattern, true); model_ref = make_shared(OutputVector{reshape}, ParameterVector{data}); } @@ -97,27 +96,27 @@ TEST_F(TransformationTestsF, LastDimSplitDymanicLast) { set_shape_symbols(shape); // we set unique symbols to the shape: A, B, C, D { - auto data = make_shared(element::f32, shape); + auto data = make_shared(element::f32, shape); - auto shape_of = make_shared(data); + auto shape_of = make_shared(data); auto indices = ov::op::v0::Constant::create(element::i64, {3}, {0, 1, 2}); auto axis = ov::op::v0::Constant::create(element::i64, {}, {0}); - auto as_is_dims = make_shared(shape_of, indices, axis); + auto as_is_dims = make_shared(shape_of, indices, axis); auto splited_dim = ov::op::v0::Constant::create(element::i64, {2}, {8, -1}); - auto pattern = make_shared(OutputVector{as_is_dims, splited_dim}, 0); + auto pattern = make_shared(OutputVector{as_is_dims, splited_dim}, 0); - auto reshape = make_shared(data, pattern, false); + auto reshape = make_shared(data, pattern, false); model = make_shared(OutputVector{reshape}, ParameterVector{data}); manager.register_pass(); } { - auto data = make_shared(element::f32, shape); + auto data = make_shared(element::f32, shape); auto pattern = ov::op::v0::Constant::create(element::i64, {5}, {0, 0, 0, 8, -1}); - auto reshape = make_shared(data, pattern, true); + auto reshape = make_shared(data, pattern, true); model_ref = make_shared(OutputVector{reshape}, ParameterVector{data}); } @@ -129,21 +128,21 @@ TEST_F(TransformationTestsF, NegativeTest) { set_shape_symbols(shape); // we set unique symbols to the shape: A, B, C, D { - auto data = make_shared(element::f32, shape); + auto data = make_shared(element::f32, shape); - auto shape_of = make_shared(data); + auto shape_of = make_shared(data); auto indices = ov::op::v0::Constant::create(element::i64, {3}, {0, 1, 2}); auto axis = ov::op::v0::Constant::create(element::i64, {}, {0}); - auto as_is_dims = make_shared(shape_of, indices, axis); + auto as_is_dims = make_shared(shape_of, indices, axis); - auto D = make_shared(shape_of, ov::op::v0::Constant::create(element::i64, {1}, {3}), axis); - auto D_2 = make_shared(D, ov::op::v0::Constant::create(element::i64, {}, {2})); - auto D_3 = make_shared(D, ov::op::v0::Constant::create(element::i64, {}, {3})); + auto D = make_shared(shape_of, ov::op::v0::Constant::create(element::i64, {1}, {3}), axis); + auto D_2 = make_shared(D, ov::op::v0::Constant::create(element::i64, {}, {2})); + auto D_3 = make_shared(D, ov::op::v0::Constant::create(element::i64, {}, {3})); auto six = ov::op::v0::Constant::create(element::i64, {1}, {6}); - auto pattern = make_shared(OutputVector{as_is_dims, D_2, D_3, six}, 0); + auto pattern = make_shared(OutputVector{as_is_dims, D_2, D_3, six}, 0); - auto reshape = make_shared(data, pattern, false); + auto reshape = make_shared(data, pattern, false); model = make_shared(OutputVector{reshape}, ParameterVector{data}); manager.register_pass(); @@ -154,19 +153,19 @@ TEST_F(TransformationTestsF, ZeroDimsInOutputShape) { // [A, B] auto shape = PartialShape{0, 0}; { - auto data = make_shared(element::f32, shape); - auto b = make_shared(element::f32, PartialShape{-1}); + auto data = make_shared(element::f32, shape); + auto b = make_shared(element::f32, PartialShape{-1}); auto a = ov::op::v0::Constant::create(element::i64, Shape{1}, {0}); - auto shape_of = make_shared(b); + auto shape_of = make_shared(b); auto indices = ov::op::v0::Constant::create(element::i64, {1}, {0}); auto axis = ov::op::v0::Constant::create(element::i64, {}, {0}); - auto b_dim = make_shared(shape_of, indices, axis); + auto b_dim = make_shared(shape_of, indices, axis); - auto pattern = make_shared(OutputVector{a, b_dim}, 0); + auto pattern = make_shared(OutputVector{a, b_dim}, 0); - auto reshape = make_shared(data, pattern, false); + auto reshape = make_shared(data, pattern, false); model = make_shared(OutputVector{reshape}, ParameterVector{data, b}); manager.register_pass(); diff --git a/src/common/transformations/tests/symbolic_transformations/symbol_optimization.cpp b/src/common/transformations/tests/symbolic_transformations/symbol_optimization.cpp index 240bbeebab286e..df5a22bd62cb8e 100644 --- a/src/common/transformations/tests/symbolic_transformations/symbol_optimization.cpp +++ b/src/common/transformations/tests/symbolic_transformations/symbol_optimization.cpp @@ -22,13 +22,12 @@ #include "transformations/symbolic_transformations/utils.hpp" using namespace ov; -using namespace ov::op; using namespace std; TEST(TransformationTests, ApplySymbolEquivalence_Concat) { - auto input_1 = make_shared(element::f32, PartialShape::dynamic(4)); - auto input_2 = make_shared(element::f32, PartialShape::dynamic(4)); - auto concat = make_shared(OutputVector{input_1, input_2}, -1); + auto input_1 = make_shared(element::f32, PartialShape::dynamic(4)); + auto input_2 = make_shared(element::f32, PartialShape::dynamic(4)); + auto concat = make_shared(OutputVector{input_1, input_2}, -1); // shape inference notes that all the non-axis dimensions are equal to each other auto model = make_shared(OutputVector{concat}, ParameterVector{input_2, input_1}); @@ -54,18 +53,18 @@ TEST(TransformationTests, ApplySymbolEquivalence_Concat) { TEST_F(TransformationTestsF, ApplySymbolEquivalence_Concat_Values) { { - auto input_1 = make_shared(element::f32, PartialShape::dynamic(4)); - auto input_2 = make_shared(element::f32, PartialShape::dynamic(4)); - auto concat = make_shared(OutputVector{input_1, input_2}, -1); + auto input_1 = make_shared(element::f32, PartialShape::dynamic(4)); + auto input_2 = make_shared(element::f32, PartialShape::dynamic(4)); + auto concat = make_shared(OutputVector{input_1, input_2}, -1); - auto shape = make_shared(concat); - auto gather = make_shared(shape, - v0::Constant::create(element::i64, {1}, {-1}), - v0::Constant::create(element::i64, {}, {0})); + auto shape = make_shared(concat); + auto gather = make_shared(shape, + ov::op::v0::Constant::create(element::i64, {1}, {-1}), + ov::op::v0::Constant::create(element::i64, {}, {0})); - auto reshape = make_shared( + auto reshape = make_shared( concat, - make_shared(OutputVector{gather, v0::Constant::create(element::i64, {1}, {-1})}, 0), + make_shared(OutputVector{gather, ov::op::v0::Constant::create(element::i64, {1}, {-1})}, 0), false); model = make_shared(OutputVector{reshape}, ParameterVector{input_2, input_1}); @@ -76,67 +75,67 @@ TEST_F(TransformationTestsF, ApplySymbolEquivalence_Concat_Values) { manager.register_pass(); } { - auto input_1 = make_shared(element::f32, PartialShape::dynamic(4)); - auto input_2 = make_shared(element::f32, PartialShape::dynamic(4)); - auto concat = make_shared(OutputVector{input_1, input_2}, -1); + auto input_1 = make_shared(element::f32, PartialShape::dynamic(4)); + auto input_2 = make_shared(element::f32, PartialShape::dynamic(4)); + auto concat = make_shared(OutputVector{input_1, input_2}, -1); - auto shape_1 = make_shared(input_1); - auto gather_1 = make_shared(shape_1, - v0::Constant::create(element::i64, {1}, {3}), - v0::Constant::create(element::i64, {}, {0})); + auto shape_1 = make_shared(input_1); + auto gather_1 = make_shared(shape_1, + ov::op::v0::Constant::create(element::i64, {1}, {3}), + ov::op::v0::Constant::create(element::i64, {}, {0})); - auto shape_2 = make_shared(input_2); - auto gather_2 = make_shared(shape_2, - v0::Constant::create(element::i64, {1}, {3}), - v0::Constant::create(element::i64, {}, {0})); + auto shape_2 = make_shared(input_2); + auto gather_2 = make_shared(shape_2, + ov::op::v0::Constant::create(element::i64, {1}, {3}), + ov::op::v0::Constant::create(element::i64, {}, {0})); - auto sum = make_shared(gather_1, gather_2); + auto sum = make_shared(gather_1, gather_2); - auto reshape = make_shared( + auto reshape = make_shared( concat, - make_shared(OutputVector{sum, v0::Constant::create(element::i64, {1}, {-1})}, 0), + make_shared(OutputVector{sum, ov::op::v0::Constant::create(element::i64, {1}, {-1})}, 0), false); model_ref = make_shared(OutputVector{reshape}, ParameterVector{input_2, input_1}); } } Output get_dim_by_idx(const Output& source, const int64_t& idx, element::Type type = element::i64) { - auto shape = make_shared(source, type); - auto gather = make_shared(shape, - v0::Constant::create(element::i64, {}, {idx}), - v0::Constant::create(element::i64, {}, {0})); + auto shape = make_shared(source, type); + auto gather = make_shared(shape, + ov::op::v0::Constant::create(element::i64, {}, {idx}), + ov::op::v0::Constant::create(element::i64, {}, {0})); return gather->output(0); } Output get_dim_by_idx(const Output& source, initializer_list idx, element::Type type = element::i64) { - auto shape = make_shared(source, type); - auto gather = make_shared(shape, - v0::Constant::create(element::i64, {idx.size()}, idx), - v0::Constant::create(element::i64, {}, {0})); + auto shape = make_shared(source, type); + auto gather = make_shared(shape, + ov::op::v0::Constant::create(element::i64, {idx.size()}, idx), + ov::op::v0::Constant::create(element::i64, {}, {0})); return gather->output(0); } TEST_F(TransformationTestsF, ValueOptimizationSingleValue) { { - auto input = make_shared(element::f32, PartialShape::dynamic(4)); + auto input = make_shared(element::f32, PartialShape::dynamic(4)); auto dim_0 = get_dim_by_idx(input, {-1}, element::i64); auto dim_1 = get_dim_by_idx(input, {3}, element::i32); auto dim_2 = get_dim_by_idx(input, -1, element::i32); - auto reshape_0 = make_shared( + auto reshape_0 = make_shared( input, - make_shared(OutputVector{v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), false); - auto reshape_1 = make_shared( + auto reshape_1 = make_shared( input, - make_shared(OutputVector{v0::Constant::create(element::i32, {1}, {0}), dim_1}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_1}, 0), false); - auto range = make_shared(v0::Constant::create(element::i32, {}, {0}), + auto range = make_shared(ov::op::v0::Constant::create(element::i32, {}, {0}), dim_2, - v0::Constant::create(element::i32, {}, {1}), + ov::op::v0::Constant::create(element::i32, {}, {1}), element::i32); model = make_shared(OutputVector{reshape_0, reshape_1, range}, ParameterVector{input}); @@ -147,21 +146,21 @@ TEST_F(TransformationTestsF, ValueOptimizationSingleValue) { manager.register_pass(); } { - auto input = make_shared(element::f32, PartialShape::dynamic(4)); + auto input = make_shared(element::f32, PartialShape::dynamic(4)); auto dim_1 = get_dim_by_idx(input, {3}, element::i32); - auto dim_0 = std::make_shared(dim_1, element::i64); - auto dim_2 = std::make_shared(dim_1); - auto reshape_0 = make_shared( + auto dim_0 = std::make_shared(dim_1, element::i64); + auto dim_2 = std::make_shared(dim_1); + auto reshape_0 = make_shared( input, - make_shared(OutputVector{v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), false); - auto reshape_1 = make_shared( + auto reshape_1 = make_shared( input, - make_shared(OutputVector{v0::Constant::create(element::i32, {1}, {0}), dim_1}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_1}, 0), false); - auto range = make_shared(v0::Constant::create(element::i32, {}, {0}), + auto range = make_shared(ov::op::v0::Constant::create(element::i32, {}, {0}), dim_2, - v0::Constant::create(element::i32, {}, {1}), + ov::op::v0::Constant::create(element::i32, {}, {1}), element::i32); model_ref = make_shared(OutputVector{reshape_0, reshape_1, range}, ParameterVector{input}); @@ -171,18 +170,18 @@ TEST_F(TransformationTestsF, ValueOptimizationSingleValue) { TEST_F(TransformationTestsF, ValueOptimizationDoubleValue) { { - auto input = make_shared(element::f32, PartialShape::dynamic(4)); + auto input = make_shared(element::f32, PartialShape::dynamic(4)); auto dim_0 = get_dim_by_idx(input, {-1, -2}, element::i64); auto dim_1 = get_dim_by_idx(input, {3, 2}, element::i32); - auto reshape_0 = make_shared( + auto reshape_0 = make_shared( input, - make_shared(OutputVector{v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), false); - auto reshape_1 = make_shared( + auto reshape_1 = make_shared( input, - make_shared(OutputVector{v0::Constant::create(element::i32, {1}, {0}), dim_1}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_1}, 0), false); model = make_shared(OutputVector{reshape_0, reshape_1}, ParameterVector{input}); @@ -193,17 +192,17 @@ TEST_F(TransformationTestsF, ValueOptimizationDoubleValue) { manager.register_pass(); } { - auto input = make_shared(element::f32, PartialShape::dynamic(4)); + auto input = make_shared(element::f32, PartialShape::dynamic(4)); auto dim_0 = get_dim_by_idx(input, {3, 2}, element::i32); - auto dim_1 = std::make_shared(dim_0, element::i64); + auto dim_1 = std::make_shared(dim_0, element::i64); - auto reshape_0 = make_shared( + auto reshape_0 = make_shared( input, - make_shared(OutputVector{v0::Constant::create(element::i64, {1}, {-1}), dim_1}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_1}, 0), false); - auto reshape_1 = make_shared( + auto reshape_1 = make_shared( input, - make_shared(OutputVector{v0::Constant::create(element::i32, {1}, {0}), dim_0}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_0}, 0), false); model_ref = make_shared(OutputVector{reshape_0, reshape_1}, ParameterVector{input}); @@ -213,18 +212,18 @@ TEST_F(TransformationTestsF, ValueOptimizationDoubleValue) { TEST_F(TransformationTestsF, ValueOptimizationSymbolAndValue) { { - auto input = make_shared(element::f32, PartialShape({-1, -1, 4, -1})); + auto input = make_shared(element::f32, PartialShape({-1, -1, 4, -1})); auto dim_0 = get_dim_by_idx(input, {-1, -2}, element::i64); auto dim_1 = get_dim_by_idx(input, {3, 2}, element::i32); - auto reshape_0 = make_shared( + auto reshape_0 = make_shared( input, - make_shared(OutputVector{v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), false); - auto reshape_1 = make_shared( + auto reshape_1 = make_shared( input, - make_shared(OutputVector{v0::Constant::create(element::i32, {1}, {-1}), dim_1}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {-1}), dim_1}, 0), false); model = make_shared(OutputVector{reshape_0, reshape_1}, ParameterVector{input}); @@ -235,14 +234,14 @@ TEST_F(TransformationTestsF, ValueOptimizationSymbolAndValue) { manager.register_pass(); } { - auto input = make_shared(element::f32, PartialShape({-1, -1, 4, -1})); - auto dim_0 = make_shared( - OutputVector{v0::Constant::create(element::i32, {1}, {-1}), get_dim_by_idx(input, {3, 2}, element::i32)}, + auto input = make_shared(element::f32, PartialShape({-1, -1, 4, -1})); + auto dim_0 = make_shared( + OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {-1}), get_dim_by_idx(input, {3, 2}, element::i32)}, 0); - auto dim_1 = std::make_shared(dim_0, element::i64); + auto dim_1 = std::make_shared(dim_0, element::i64); - auto reshape_0 = make_shared(input, dim_1, false); - auto reshape_1 = make_shared(input, dim_0, false); + auto reshape_0 = make_shared(input, dim_1, false); + auto reshape_1 = make_shared(input, dim_0, false); model_ref = make_shared(OutputVector{reshape_0, reshape_1}, ParameterVector{input}); } From 5937621917aa8d1377024be1ac6946be72943bae Mon Sep 17 00:00:00 2001 From: Evgeny Kotov Date: Fri, 5 Dec 2025 10:56:26 +0100 Subject: [PATCH 2/3] clang fix --- .../activations_scaling.cpp | 12 +- .../adaptive_pool_to_reduce.cpp | 3 +- .../add_fake_quantize_fusion.cpp | 4 +- .../align_eltwise_input_ranks.cpp | 8 +- .../augru_cell_fusion.cpp | 12 +- .../batch_to_space_fusion.cpp | 27 +- .../common_optimizations/binarize_weights.cpp | 26 +- .../broadcast_elementwise_fusion.cpp | 3 +- .../broadcast_transition.cpp | 10 +- .../compress_float_constants.cpp | 19 +- .../concat_reduce_fusion.cpp | 4 +- .../common_optimizations/conv_mul_fusion.cpp | 23 +- .../convert_nms_gather_path_to_unsigned.cpp | 26 +- .../convert_pagedattn_inputs.cpp | 40 +- .../convert_quantize_dequantize.cpp | 14 +- ...onvert_u4_weights_zero_point_to_scalar.cpp | 15 +- .../depth_to_space_fusion.cpp | 4 +- .../dilated_convolution_converter.cpp | 6 +- .../disable_shapeof_constant_folding.cpp | 13 +- .../eliminate_unsqueeze_gather.cpp | 22 +- .../common_optimizations/fq_mul_fusion.cpp | 4 +- .../fq_reshape_fusion.cpp | 17 +- .../common_optimizations/fuse_moe_experts.cpp | 31 +- .../fuse_rotary_positional_embeddings.cpp | 426 +++++++++++------- .../common_optimizations/gelu_fusion.cpp | 2 +- .../common_optimizations/glu_fusion.cpp | 5 +- .../group_normalization_fusion.cpp | 45 +- .../common_optimizations/gru_cell_fusion.cpp | 15 +- .../common_optimizations/hswish_fusion.cpp | 3 +- .../leaky_relu_fusion.cpp | 4 +- .../lin_op_sequence_fusion.cpp | 6 +- .../lora_subgraph_fusion.cpp | 29 +- .../common_optimizations/lstm_cell_fusion.cpp | 15 +- ..._rope_input_to_keep_in_mixed_precision.cpp | 5 +- .../matmul_experts_fusion.cpp | 91 ++-- .../matmul_multiply_fusion.cpp | 4 +- .../moe_transpose_weights.cpp | 54 ++- .../mul_fake_quantize_fusion.cpp | 4 +- .../common_optimizations/nop_elimination.cpp | 47 +- .../optimize_strided_slice.cpp | 20 +- .../common_optimizations/pad_fusion.cpp | 3 +- .../pull_through_reduce.cpp | 8 +- .../pull_transpose_through_fq.cpp | 16 +- .../common_optimizations/reduce_merge.cpp | 16 +- .../reduce_reshape_fusion.cpp | 4 +- .../relu_fake_quantize_fusion.cpp | 3 +- .../reshape_sequence_fusion.cpp | 4 +- .../common_optimizations/ric_fusion.cpp | 39 +- .../common_optimizations/rms_fusion.cpp | 2 +- .../common_optimizations/sdpa_fusion.cpp | 138 ++++-- .../sdpa_scale_fusion.cpp | 18 +- .../simplify_shape_of_sub_graph.cpp | 41 +- .../common_optimizations/softplus_fusion.cpp | 4 +- .../space_to_batch_fusion.cpp | 24 +- .../strides_optimization.cpp | 4 +- .../transpose_sinking.cpp | 59 +-- .../transpose_to_reshape.cpp | 3 +- .../weights_dequantize_to_fake_quantize.cpp | 6 +- .../mark_floatpoint_range.cpp | 18 +- ...k_subgraphs_to_keep_in_mixed_precision.cpp | 92 ++-- .../mark_dequantization_subgraph.cpp | 42 +- .../batch_norm_decomposition.cpp | 22 +- .../convert_bitwise_to_logical_bool.cpp | 22 +- .../convert_convertpromotetypes.cpp | 3 +- .../op_conversions/convert_depth_to_space.cpp | 4 +- .../convert_fc_to_compressed.cpp | 8 +- .../convert_fc_to_quantized_legacy.cpp | 5 +- .../convert_gather_to_compressed.cpp | 14 +- .../convert_reduce_to_pooling.cpp | 9 +- .../convert_reduce_to_reshape.cpp | 21 +- .../op_conversions/convert_space_to_depth.cpp | 4 +- .../op_conversions/convert_subtract.cpp | 4 +- .../convert_ti_to_sequences.cpp | 153 ++++--- .../op_conversions/eye_decomposition.cpp | 4 +- .../group_query_attention_decomposition.cpp | 59 ++- ...ed_dot_product_attention_decomposition.cpp | 16 +- .../compressed_weights_block.cpp | 3 +- .../position_ids_replacer.cpp | 53 ++- .../prev_sequence_length_pattern.cpp | 13 +- .../state_management_pattern.cpp | 264 +++++++---- .../total_sequence_length_pattern.cpp | 30 +- .../proposal_scales_stridedslice.cpp | 8 +- .../smart_reshape/strided_slice_squeeze.cpp | 6 +- .../dereshape_matmul.cpp | 54 ++- .../reshape_optimizations.cpp | 6 +- .../symbolic_optimizations.cpp | 6 +- .../transpose_sinking/ts_binary.cpp | 10 +- .../transpose_sinking/ts_concat.cpp | 3 +- .../transpose_sinking/ts_cumsum.cpp | 3 +- .../transpose_sinking/ts_data_movement.cpp | 7 +- .../transpose_sinking/ts_fuse.cpp | 10 +- .../transpose_sinking/ts_gather.cpp | 16 +- .../transpose_sinking/ts_interpolate.cpp | 10 +- .../transpose_sinking/ts_reduction.cpp | 16 +- .../transpose_sinking/ts_slice.cpp | 3 +- .../transpose_sinking/ts_split.cpp | 4 +- .../transpose_sinking/ts_squeeze.cpp | 18 +- .../transpose_sinking/ts_tile.cpp | 3 +- .../transpose_sinking/ts_unary.cpp | 34 +- .../transpose_sinking/ts_unsqueeze.cpp | 15 +- .../src/transformations/utils/utils.cpp | 35 +- .../convert_pagedattn_inputs.cpp | 12 +- .../eliminate_unsqueeze_gather.cpp | 17 +- ...bgraph_to_keep_in_mixed_precision_test.cpp | 12 +- .../moc_transformations.cpp | 6 +- .../common_optimizations/sdpa_fusion_test.cpp | 28 +- .../shared_ops_optimization.cpp | 170 ++++--- .../sdpa_to_paged_attention_test.cpp | 126 ++++-- .../dereshape_fullyconnected.cpp | 19 +- .../dereshape_matmul.cpp | 33 +- .../symbol_optimization.cpp | 74 +-- 111 files changed, 1873 insertions(+), 1264 deletions(-) diff --git a/src/common/transformations/src/transformations/common_optimizations/activations_scaling.cpp b/src/common/transformations/src/transformations/common_optimizations/activations_scaling.cpp index 96bd6d1a43a70e..cba831f39eb22e 100644 --- a/src/common/transformations/src/transformations/common_optimizations/activations_scaling.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/activations_scaling.cpp @@ -185,7 +185,8 @@ ov::pass::activations_scaling::EliminateScalarMul::EliminateScalarMul() { auto mul_m = ov::pass::pattern::wrap_type({convert_m, scale_const_m}); auto mvn_m = ov::pass::pattern::wrap_type({mul_m, ov::pass::pattern::any_input()}); auto rms_m = ov::pass::pattern::wrap_type({mul_m, ov::pass::pattern::any_input()}); - auto group_norm_m = ov::pass::pattern::wrap_type({mul_m, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto group_norm_m = ov::pass::pattern::wrap_type( + {mul_m, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto shape_of_m = ov::pass::pattern::wrap_type({mul_m}); auto norm_m = std::make_shared(OutputVector{mvn_m, rms_m, group_norm_m, shape_of_m}); @@ -239,9 +240,12 @@ ov::pass::activations_scaling::EliminateScalarMul::EliminateScalarMul() { ov::pass::activations_scaling::MulShareTransformation::MulShareTransformation() { MATCHER_SCOPE(MulShareTransformation); - auto mvn_m = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - auto rms_m = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - auto group_norm_m = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto mvn_m = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto rms_m = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto group_norm_m = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto shape_of_m = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); auto norm_m = std::make_shared(OutputVector{mvn_m, rms_m, group_norm_m, shape_of_m}); diff --git a/src/common/transformations/src/transformations/common_optimizations/adaptive_pool_to_reduce.cpp b/src/common/transformations/src/transformations/common_optimizations/adaptive_pool_to_reduce.cpp index 4e9bd93b13275f..909317853ed2f2 100644 --- a/src/common/transformations/src/transformations/common_optimizations/adaptive_pool_to_reduce.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/adaptive_pool_to_reduce.cpp @@ -20,7 +20,8 @@ ov::pass::AdaptivePoolToReduce::AdaptivePoolToReduce() { MATCHER_SCOPE(AdaptivePoolToReduce); auto data_pattern = ov::pass::pattern::any_input(); auto out_spatial_shape = ov::pass::pattern::wrap_type(); - auto a_pool = ov::pass::pattern::wrap_type({data_pattern, out_spatial_shape}); + auto a_pool = ov::pass::pattern::wrap_type( + {data_pattern, out_spatial_shape}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/add_fake_quantize_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/add_fake_quantize_fusion.cpp index 90043d7a5d27d1..c05ae2b18bc233 100644 --- a/src/common/transformations/src/transformations/common_optimizations/add_fake_quantize_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/add_fake_quantize_fusion.cpp @@ -27,8 +27,8 @@ ov::pass::AddFakeQuantizeFusion::AddFakeQuantizeFusion() { MATCHER_SCOPE(AddFakeQuantizeFusion); auto input_pattern = ov::pass::pattern::any_input(); auto const_pattern = ov::pass::pattern::wrap_type(); - auto add_pattern = - ov::pass::pattern::wrap_type({input_pattern, const_pattern}, ov::pass::pattern::consumers_count(1)); + auto add_pattern = ov::pass::pattern::wrap_type({input_pattern, const_pattern}, + ov::pass::pattern::consumers_count(1)); auto fq_pattern = ov::pass::pattern::wrap_type({add_pattern, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), diff --git a/src/common/transformations/src/transformations/common_optimizations/align_eltwise_input_ranks.cpp b/src/common/transformations/src/transformations/common_optimizations/align_eltwise_input_ranks.cpp index c0445f8079d6ef..90bb1e43c81f55 100644 --- a/src/common/transformations/src/transformations/common_optimizations/align_eltwise_input_ranks.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/align_eltwise_input_ranks.cpp @@ -16,10 +16,10 @@ ov::pass::AlignEltwiseInputRanks::AlignEltwiseInputRanks() { auto eltwise_pattern = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_rank()); + ov::op::util::BinaryElementwiseComparison, + ov::op::util::BinaryElementwiseLogical, + ov::op::util::BinaryElementwiseArithmetic, + ov::op::v0::FakeQuantize>(ov::pass::pattern::has_static_rank()); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); diff --git a/src/common/transformations/src/transformations/common_optimizations/augru_cell_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/augru_cell_fusion.cpp index 4aa2e593ee2fc2..190bec7a6d53c9 100644 --- a/src/common/transformations/src/transformations/common_optimizations/augru_cell_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/augru_cell_fusion.cpp @@ -73,8 +73,10 @@ ov::pass::AUGRUCellFusion::AUGRUCellFusion() { return !(p_shape.rank().is_dynamic() || p_shape[1].is_dynamic()); }; - auto concat_1 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(is_first_dim_static), ov::pass::pattern::any_input(is_first_dim_static)}); - auto matmul_1 = ov::pass::pattern::wrap_type({concat_1, ov::pass::pattern::any_input(is_first_dim_static)}); + auto concat_1 = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(is_first_dim_static), ov::pass::pattern::any_input(is_first_dim_static)}); + auto matmul_1 = + ov::pass::pattern::wrap_type({concat_1, ov::pass::pattern::any_input(is_first_dim_static)}); auto add_1 = ov::pass::pattern::wrap_type({matmul_1, ov::pass::pattern::any_input()}); // only Sigmoid is supported in the current version of AUGRUCell auto sigmoid = ov::pass::pattern::wrap_type({add_1}); @@ -82,12 +84,14 @@ ov::pass::AUGRUCellFusion::AUGRUCellFusion() { auto multiply = ov::pass::pattern::wrap_type({split, ov::pass::pattern::any_input()}); auto concat_2 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), multiply}); - auto matmul_2 = ov::pass::pattern::wrap_type({concat_2, ov::pass::pattern::any_input(is_first_dim_static)}); + auto matmul_2 = + ov::pass::pattern::wrap_type({concat_2, ov::pass::pattern::any_input(is_first_dim_static)}); auto add_2 = ov::pass::pattern::wrap_type({matmul_2, ov::pass::pattern::any_input()}); // only Tanh is supported in the current version of AUGRUCell auto tanh = ov::pass::pattern::wrap_type({add_2}); - auto subtract_1 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto subtract_1 = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto multiply_2 = ov::pass::pattern::wrap_type({subtract_1, split}); auto subtract_2 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), multiply_2}); auto multiply_3 = ov::pass::pattern::wrap_type({subtract_2, tanh}); diff --git a/src/common/transformations/src/transformations/common_optimizations/batch_to_space_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/batch_to_space_fusion.cpp index 845229ba864bee..58e808e1139372 100644 --- a/src/common/transformations/src/transformations/common_optimizations/batch_to_space_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/batch_to_space_fusion.cpp @@ -23,25 +23,26 @@ ov::pass::BatchToSpaceFusion::BatchToSpaceFusion() { MATCHER_SCOPE(BatchToSpaceFusion); auto data_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); - auto reshape_before_pattern = - ov::pass::pattern::wrap_type({data_pattern, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(4)); - auto trans_before_pattern = - ov::pass::pattern::wrap_type({data_pattern, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(4)); + auto reshape_before_pattern = ov::pass::pattern::wrap_type( + {data_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); + auto trans_before_pattern = ov::pass::pattern::wrap_type( + {data_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto reshape_or_transpose_before_pattern = std::make_shared(OutputVector{reshape_before_pattern, trans_before_pattern}); - auto depth_to_space_pattern = ov::pass::pattern::wrap_type({reshape_or_transpose_before_pattern}); + auto depth_to_space_pattern = + ov::pass::pattern::wrap_type({reshape_or_transpose_before_pattern}); auto starts_pattern = ov::pass::pattern::wrap_type(); auto ends_pattern = ov::pass::pattern::wrap_type(); auto slice_pattern = ov::pass::pattern::wrap_type( {depth_to_space_pattern, starts_pattern, ends_pattern, ov::pass::pattern::wrap_type()}); - auto reshape_after_pattern = - ov::pass::pattern::wrap_type({slice_pattern, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(4)); - auto trans_after_pattern = - ov::pass::pattern::wrap_type({slice_pattern, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(4)); + auto reshape_after_pattern = ov::pass::pattern::wrap_type( + {slice_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); + auto trans_after_pattern = ov::pass::pattern::wrap_type( + {slice_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto reshape_or_transpose_after_pattern = std::make_shared(OutputVector{reshape_after_pattern, trans_after_pattern}); diff --git a/src/common/transformations/src/transformations/common_optimizations/binarize_weights.cpp b/src/common/transformations/src/transformations/common_optimizations/binarize_weights.cpp index a7eff727f1177f..3ab44298312a58 100644 --- a/src/common/transformations/src/transformations/common_optimizations/binarize_weights.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/binarize_weights.cpp @@ -61,18 +61,20 @@ pass::BinarizeWeights::BinarizeWeights() { MATCHER_SCOPE(BinarizeWeights); auto activations_fq_pattern = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), - ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type()}, - ov::pass::pattern::consumers_count(1)); - auto weights_fq_pattern = ov::pass::pattern::wrap_type({ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type()}, - ov::pass::pattern::consumers_count(1)); - auto conv_pattern = ov::pass::pattern::wrap_type({activations_fq_pattern, weights_fq_pattern}); + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); + auto weights_fq_pattern = + ov::pass::pattern::wrap_type({ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); + auto conv_pattern = + ov::pass::pattern::wrap_type({activations_fq_pattern, weights_fq_pattern}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto conv = ov::as_type_ptr(m.get_match_root()); diff --git a/src/common/transformations/src/transformations/common_optimizations/broadcast_elementwise_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/broadcast_elementwise_fusion.cpp index 480e1c98484b1b..249c942417fe72 100644 --- a/src/common/transformations/src/transformations/common_optimizations/broadcast_elementwise_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/broadcast_elementwise_fusion.cpp @@ -73,7 +73,8 @@ ov::pass::BroadcastElementwiseFusion::BroadcastElementwiseFusion() { MATCHER_SCOPE(BroadcastElementwiseFusion); auto broadcast_input = ov::pass::pattern::any_input(); auto broadcast = - ov::pass::pattern::wrap_type({broadcast_input, ov::pass::pattern::any_input()}, ov::pass::pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({broadcast_input, ov::pass::pattern::any_input()}, + ov::pass::pattern::consumers_count(1)); auto eltwise_input = ov::pass::pattern::any_input(); auto eltwise = ov::pass::pattern::wrap_type({eltwise_input, broadcast}); diff --git a/src/common/transformations/src/transformations/common_optimizations/broadcast_transition.cpp b/src/common/transformations/src/transformations/common_optimizations/broadcast_transition.cpp index ffab0e9aabd6d3..8ccc9c229793ec 100644 --- a/src/common/transformations/src/transformations/common_optimizations/broadcast_transition.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/broadcast_transition.cpp @@ -21,11 +21,13 @@ ov::pass::BroadcastTransition::BroadcastTransition() { MATCHER_SCOPE(BroadcastTransition); - auto bcast_m = - ov::pass::pattern::wrap_type(ov::pass::pattern::consumers_count(1)); + auto bcast_m = ov::pass::pattern::wrap_type( + ov::pass::pattern::consumers_count(1)); auto eltwise_input_m = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); - auto eltwise_1 = ov::pass::pattern::wrap_type({eltwise_input_m, bcast_m}); - auto eltwise_2 = ov::pass::pattern::wrap_type({bcast_m, eltwise_input_m}); + auto eltwise_1 = + ov::pass::pattern::wrap_type({eltwise_input_m, bcast_m}); + auto eltwise_2 = + ov::pass::pattern::wrap_type({bcast_m, eltwise_input_m}); auto eltwise_m = std::make_shared(OutputVector{eltwise_1, eltwise_2}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/compress_float_constants.cpp b/src/common/transformations/src/transformations/common_optimizations/compress_float_constants.cpp index 93aa23e472e410..84702e75532137 100644 --- a/src/common/transformations/src/transformations/common_optimizations/compress_float_constants.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/compress_float_constants.cpp @@ -92,20 +92,21 @@ class DetectFakeQuantizeOrFakeConvert : public MatcherPass { class DetectCompressedWeights : public MatcherPass { public: DetectCompressedWeights() { - auto weights = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any({ov::element::i4, - ov::element::u4, - ov::element::i8, - ov::element::u8, - ov::element::nf4, - ov::element::f8e4m3, - ov::element::f8e5m2})); + auto weights = ov::pass::pattern::wrap_type( + ov::pass::pattern::type_matches_any({ov::element::i4, + ov::element::u4, + ov::element::i8, + ov::element::u8, + ov::element::nf4, + ov::element::f8e4m3, + ov::element::f8e5m2})); auto convert = ov::pass::pattern::wrap_type({weights}); auto zero_point_const = ov::pass::pattern::wrap_type(); auto zero_point = ov::pass::pattern::optional(zero_point_const); auto subtract = ov::pass::pattern::wrap_type({convert, zero_point}); auto subtract_or_convert = std::make_shared(ov::OutputVector{convert, subtract}); - auto multiply = - ov::pass::pattern::wrap_type({subtract_or_convert, ov::pass::pattern::wrap_type()}); + auto multiply = ov::pass::pattern::wrap_type( + {subtract_or_convert, ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { return true; diff --git a/src/common/transformations/src/transformations/common_optimizations/concat_reduce_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/concat_reduce_fusion.cpp index 8c323886c7fbd7..38e4b189f67ce8 100644 --- a/src/common/transformations/src/transformations/common_optimizations/concat_reduce_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/concat_reduce_fusion.cpp @@ -86,8 +86,8 @@ ov::pass::PullSqueezeThroughEltwise::PullSqueezeThroughEltwise() { ov::pass::ReplaceConcatReduceByMinOrMax::ReplaceConcatReduceByMinOrMax() { MATCHER_SCOPE(ReplaceConcatReduceByMinOrMax); - auto concat_pattern = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto concat_pattern = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto reduce_axes_pattern = ov::pass::pattern::wrap_type(); auto reduce_pattern = ov::pass::pattern::wrap_type( {concat_pattern, reduce_axes_pattern}); diff --git a/src/common/transformations/src/transformations/common_optimizations/conv_mul_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/conv_mul_fusion.cpp index 7ccba179737a03..76b94b397a2516 100644 --- a/src/common/transformations/src/transformations/common_optimizations/conv_mul_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/conv_mul_fusion.cpp @@ -20,7 +20,8 @@ ov::pass::ConvolutionMultiplyFusion::ConvolutionMultiplyFusion() { MATCHER_SCOPE(ConvolutionMultiplyFusion); auto input = ov::pass::pattern::any_input(); auto weights = ov::pass::pattern::any_input(ov::pass::pattern::has_static_dim(0) /* has OIYX layout */); - auto conv = ov::pass::pattern::wrap_type({input, weights}, ov::pass::pattern::consumers_count(1)); + auto conv = + ov::pass::pattern::wrap_type({input, weights}, ov::pass::pattern::consumers_count(1)); auto mul_const = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_shape()); auto mul = ov::pass::pattern::wrap_type({conv, mul_const}); @@ -83,7 +84,8 @@ ov::pass::GroupConvolutionMultiplyFusion::GroupConvolutionMultiplyFusion() { MATCHER_SCOPE(GroupConvolutionMultiplyFusion); auto input = ov::pass::pattern::any_input(); auto weights = ov::pass::pattern::any_input(ov::pass::pattern::has_static_dims({0, 1}) /* has GOIYX layout */); - auto conv = ov::pass::pattern::wrap_type({input, weights}, ov::pass::pattern::consumers_count(1)); + auto conv = ov::pass::pattern::wrap_type({input, weights}, + ov::pass::pattern::consumers_count(1)); auto mul_const = ov::pass::pattern::wrap_type(); // ov::pass::pattern::has_static_shape()); auto mul = ov::pass::pattern::wrap_type({conv, mul_const}); @@ -170,9 +172,11 @@ ov::pass::ConvolutionBackpropDataMultiplyFusion::ConvolutionBackpropDataMultiply auto input = ov::pass::pattern::any_input(); auto weights = ov::pass::pattern::any_input(ov::pass::pattern::has_static_dim(1) /* has IOYX layout */); auto conv_2_inputs = - ov::pass::pattern::wrap_type({input, weights}, ov::pass::pattern::consumers_count(1)); - auto conv_3_inputs = ov::pass::pattern::wrap_type({input, weights, ov::pass::pattern::any_input()}, - ov::pass::pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({input, weights}, + ov::pass::pattern::consumers_count(1)); + auto conv_3_inputs = ov::pass::pattern::wrap_type( + {input, weights, ov::pass::pattern::any_input()}, + ov::pass::pattern::consumers_count(1)); auto conv = std::make_shared(OutputVector{conv_2_inputs, conv_3_inputs}); auto mul_const = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_shape()); auto mul = ov::pass::pattern::wrap_type({conv, mul_const}); @@ -245,10 +249,11 @@ ov::pass::GroupConvolutionBackpropDataMultiplyFusion::GroupConvolutionBackpropDa auto input = ov::pass::pattern::any_input(); auto weights = ov::pass::pattern::any_input(ov::pass::pattern::has_static_dims({0, 2}) /* has GIOYX layout */); auto conv_2_inputs = - ov::pass::pattern::wrap_type({input, weights}, ov::pass::pattern::consumers_count(1)); - auto conv_3_inputs = - ov::pass::pattern::wrap_type({input, weights, ov::pass::pattern::any_input()}, - ov::pass::pattern::consumers_count(1)); + ov::pass::pattern::wrap_type({input, weights}, + ov::pass::pattern::consumers_count(1)); + auto conv_3_inputs = ov::pass::pattern::wrap_type( + {input, weights, ov::pass::pattern::any_input()}, + ov::pass::pattern::consumers_count(1)); auto conv = std::make_shared(OutputVector{conv_2_inputs, conv_3_inputs}); auto mul_const = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_shape()); auto mul = ov::pass::pattern::wrap_type({conv, mul_const}); diff --git a/src/common/transformations/src/transformations/common_optimizations/convert_nms_gather_path_to_unsigned.cpp b/src/common/transformations/src/transformations/common_optimizations/convert_nms_gather_path_to_unsigned.cpp index 81220a7d42075c..f1569f0c6b068f 100644 --- a/src/common/transformations/src/transformations/common_optimizations/convert_nms_gather_path_to_unsigned.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/convert_nms_gather_path_to_unsigned.cpp @@ -35,9 +35,9 @@ class InitNMSPath : public pass::MatcherPass { InitNMSPath() { MATCHER_SCOPE(InitNMSPath); auto nms_pattern = ov::pass::pattern::wrap_type(); + ov::op::v3::NonMaxSuppression, + ov::op::v5::NonMaxSuppression, + ov::op::v9::NonMaxSuppression>(); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& out_nodes = m.get_match_root()->output(0).get_target_inputs(); for (const auto& out_node : out_nodes) { @@ -55,16 +55,16 @@ class PropagateNMSPath : public pass::MatcherPass { PropagateNMSPath() { MATCHER_SCOPE(PropagateNMSPath); auto node_pattern = ov::pass::pattern::wrap_type(); + ov::op::v0::Unsqueeze, + ov::op::v1::Reshape, + ov::op::util::BroadcastBase, + ov::op::v1::StridedSlice, + ov::op::v8::Slice, + ov::op::v1::VariadicSplit, + ov::op::util::GatherBase, + ov::op::v0::Concat, + ov::op::v0::Convert, + ov::op::v8::If>(); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto propagate_path = [](const ov::OutputVector& input_nodes, ov::Node* target_node) { if (any_of(input_nodes.begin(), input_nodes.end(), [](const Output& output) { diff --git a/src/common/transformations/src/transformations/common_optimizations/convert_pagedattn_inputs.cpp b/src/common/transformations/src/transformations/common_optimizations/convert_pagedattn_inputs.cpp index 1e402a84679ce7..91d7583e001d9d 100644 --- a/src/common/transformations/src/transformations/common_optimizations/convert_pagedattn_inputs.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/convert_pagedattn_inputs.cpp @@ -45,26 +45,26 @@ ov::pass::ConvertPagedAttnInputs::ConvertPagedAttnInputs(const KVCacheConfig& co auto sinks = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); auto result = ov::pass::pattern::wrap_type({Q, - K, - V, - key_cache_0, - value_cache_0, - past_lens, - subsequence_begins, - block_indices, - block_indices_begins, - scale, - sliding_window, - alibi_slopes, - max_context_len, - score_aggregation_window, - rotated_block_indices, - rotation_deltas, - rotation_trig_lut, - xattention_threshold, - xattention_block_size, - xattention_stride, - sinks}); + K, + V, + key_cache_0, + value_cache_0, + past_lens, + subsequence_begins, + block_indices, + block_indices_begins, + scale, + sliding_window, + alibi_slopes, + max_context_len, + score_aggregation_window, + rotated_block_indices, + rotation_deltas, + rotation_trig_lut, + xattention_threshold, + xattention_block_size, + xattention_stride, + sinks}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto pa_op = m.get_match_root(); auto key_cache = ov::as_type_ptr(pa_op->get_input_node_shared_ptr(3)); diff --git a/src/common/transformations/src/transformations/common_optimizations/convert_quantize_dequantize.cpp b/src/common/transformations/src/transformations/common_optimizations/convert_quantize_dequantize.cpp index 2286a10cf5d693..cc116e56452d3c 100644 --- a/src/common/transformations/src/transformations/common_optimizations/convert_quantize_dequantize.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/convert_quantize_dequantize.cpp @@ -68,7 +68,8 @@ ov::pass::ConvertQuantizeDequantize::ConvertQuantizeDequantize( const ov::element::TypeVector& supported_original_precisions, const bool ignore_consumers_count_check) { MATCHER_SCOPE(ConvertQuantizeDequantize); -auto data_pattern = ov::pass::pattern::any_input(ov::pass::pattern::type_matches_any(supported_original_precisions)); + auto data_pattern = + ov::pass::pattern::any_input(ov::pass::pattern::type_matches_any(supported_original_precisions)); auto input_low_pattern = ov::pass::pattern::any_input(); auto input_high_pattern = ov::pass::pattern::any_input(); auto output_low_pattern = ov::pass::pattern::wrap_type(); @@ -76,18 +77,21 @@ auto data_pattern = ov::pass::pattern::any_input(ov::pass::pattern::type_matches auto fq_pattern = ov::pass::pattern::wrap_type( {data_pattern, input_low_pattern, input_high_pattern, output_low_pattern, output_high_pattern}); ov::pass::pattern::op::Predicate convert1_predicate = - ignore_consumers_count_check ? ov::pass::pattern::type_matches_any(supported_low_precisions) - : ov::pass::pattern::type_matches_any(supported_low_precisions) && ov::pass::pattern::consumers_count(1); + ignore_consumers_count_check + ? ov::pass::pattern::type_matches_any(supported_low_precisions) + : ov::pass::pattern::type_matches_any(supported_low_precisions) && ov::pass::pattern::consumers_count(1); auto convert1_pattern = ov::pass::pattern::wrap_type({fq_pattern}, convert1_predicate); ov::pass::pattern::op::Predicate convert2_predicate = ignore_consumers_count_check ? ov::pass::pattern::type_matches_any(supported_original_precisions) - : ov::pass::pattern::type_matches_any(supported_original_precisions) && ov::pass::pattern::consumers_count(1); + : ov::pass::pattern::type_matches_any(supported_original_precisions) && + ov::pass::pattern::consumers_count(1); auto convert2_pattern = ov::pass::pattern::wrap_type({convert1_pattern}, convert2_predicate); auto zero_point_pattern = ov::pass::pattern::any_input(); ov::pass::pattern::op::Predicate sub_predicate = ignore_consumers_count_check ? ov::pass::pattern::op::Predicate() : ov::pass::pattern::consumers_count(1); - auto sub_pattern = ov::pass::pattern::optional({convert2_pattern, zero_point_pattern}, sub_predicate); + auto sub_pattern = + ov::pass::pattern::optional({convert2_pattern, zero_point_pattern}, sub_predicate); auto scale_pattern = ov::pass::pattern::any_input(); auto mul_pattern = ov::pass::pattern::wrap_type({sub_pattern, scale_pattern}); diff --git a/src/common/transformations/src/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.cpp b/src/common/transformations/src/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.cpp index d8de2271a7c08d..0130e16df3cf1c 100644 --- a/src/common/transformations/src/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/convert_u4_weights_zero_point_to_scalar.cpp @@ -16,8 +16,10 @@ ov::pass::ConvertU4WeightsZeroPointToScalar::ConvertU4WeightsZeroPointToScalar() { MATCHER_SCOPE(ConvertU4WeightsZeroPointToScalar); - auto weights_m = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(ov::element::u4)); - auto convert_m = ov::pass::pattern::wrap_type({weights_m}, ov::pass::pattern::consumers_count(1)); + auto weights_m = + ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(ov::element::u4)); + auto convert_m = + ov::pass::pattern::wrap_type({weights_m}, ov::pass::pattern::consumers_count(1)); auto float_zp_predicate = [](ov::Output output) -> bool { return ov::pass::pattern::type_matches_any({ov::element::f32, ov::element::f16})(output) && @@ -26,12 +28,15 @@ ov::pass::ConvertU4WeightsZeroPointToScalar::ConvertU4WeightsZeroPointToScalar() auto float_zero_point_m = ov::pass::pattern::wrap_type(float_zp_predicate); auto u4_zp_predicate = [](ov::Output output) -> bool { - return ov::pass::pattern::type_matches(ov::element::u4)(output) && ov::pass::pattern::consumers_count(1)(output); + return ov::pass::pattern::type_matches(ov::element::u4)(output) && + ov::pass::pattern::consumers_count(1)(output); }; auto u4_zero_point_m = ov::pass::pattern::wrap_type(u4_zp_predicate); - auto zero_point_convert_m = ov::pass::pattern::wrap_type({u4_zero_point_m}, float_zp_predicate); + auto zero_point_convert_m = + ov::pass::pattern::wrap_type({u4_zero_point_m}, float_zp_predicate); - auto zero_point_m = std::make_shared(OutputVector{float_zero_point_m, zero_point_convert_m}); + auto zero_point_m = + std::make_shared(OutputVector{float_zero_point_m, zero_point_convert_m}); auto subtract_m = ov::pass::pattern::wrap_type({convert_m, zero_point_m}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/depth_to_space_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/depth_to_space_fusion.cpp index 4aa0e1b1b8acbc..ed3e8aaf69b176 100644 --- a/src/common/transformations/src/transformations/common_optimizations/depth_to_space_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/depth_to_space_fusion.cpp @@ -127,8 +127,8 @@ ov::pass::DepthToSpaceFusion::DepthToSpaceFusion() { auto input3 = ov::pass::pattern::any_input(); auto reshape_before = ov::pass::pattern::wrap_type({input0, input1}, ov::pass::pattern::consumers_count(1)); - auto permute = - ov::pass::pattern::wrap_type({reshape_before, input2}, ov::pass::pattern::consumers_count(1)); + auto permute = ov::pass::pattern::wrap_type({reshape_before, input2}, + ov::pass::pattern::consumers_count(1)); auto reshape_after = ov::pass::pattern::wrap_type({permute, input3}); ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/dilated_convolution_converter.cpp b/src/common/transformations/src/transformations/common_optimizations/dilated_convolution_converter.cpp index 2b91911746822f..d0ce4e1256c02e 100644 --- a/src/common/transformations/src/transformations/common_optimizations/dilated_convolution_converter.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/dilated_convolution_converter.cpp @@ -29,8 +29,10 @@ ov::pass::DilatedConvolutionConverter::DilatedConvolutionConverter() { auto pads_end_pattern = ov::pass::pattern::wrap_type(); auto space_to_batch_pattern = ov::pass::pattern::wrap_type( {data_pattern, block_shape_pattern, pads_begin_pattern, pads_end_pattern}); - auto conv_p = ov::pass::pattern::wrap_type({space_to_batch_pattern, ov::pass::pattern::any_input()}); - auto gconv_p = ov::pass::pattern::wrap_type({space_to_batch_pattern, ov::pass::pattern::any_input()}); + auto conv_p = + ov::pass::pattern::wrap_type({space_to_batch_pattern, ov::pass::pattern::any_input()}); + auto gconv_p = ov::pass::pattern::wrap_type( + {space_to_batch_pattern, ov::pass::pattern::any_input()}); auto conv_pattern = std::make_shared(OutputVector{conv_p, gconv_p}); auto crops_begin_pattern = ov::pass::pattern::wrap_type(); auto crops_end_pattern = ov::pass::pattern::wrap_type(); diff --git a/src/common/transformations/src/transformations/common_optimizations/disable_shapeof_constant_folding.cpp b/src/common/transformations/src/transformations/common_optimizations/disable_shapeof_constant_folding.cpp index 64ebeb26c87cf7..f9f37048729f12 100644 --- a/src/common/transformations/src/transformations/common_optimizations/disable_shapeof_constant_folding.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/disable_shapeof_constant_folding.cpp @@ -11,12 +11,13 @@ #include "transformations/rt_info/disable_constant_folding.hpp" ov::pass::DisableShapeOfConstantFolding::DisableShapeOfConstantFolding(bool check_shape) { - auto shape_of = ov::pass::pattern::wrap_type([=](const Output& output) { - const auto& shape = output.get_partial_shape(); - if (!check_shape) - return true; - return shape.is_dynamic() || shape_size(shape.get_shape()) != 1; - }); + auto shape_of = + ov::pass::pattern::wrap_type([=](const Output& output) { + const auto& shape = output.get_partial_shape(); + if (!check_shape) + return true; + return shape.is_dynamic() || shape_size(shape.get_shape()) != 1; + }); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { disable_constant_folding(m.get_match_root()); diff --git a/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp b/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp index c0bac13e7a9260..c6de78e448fca2 100644 --- a/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp @@ -26,7 +26,8 @@ ov::pass::EliminateUnsqueezeGather::EliminateUnsqueezeGather() { // Remove Unsqueeze + Gather pair, if Gather gathers data by `1` dimension that was previously added by Unsqueeze const auto unsqueezeAxis = ov::pass::pattern::any_input(); const auto unsqueezeInput = ov::pass::pattern::any_input(); - const auto unsqueeze = ov::pass::pattern::wrap_type({unsqueezeInput, unsqueezeAxis}, ov::pass::pattern::consumers_count(1)); + const auto unsqueeze = ov::pass::pattern::wrap_type({unsqueezeInput, unsqueezeAxis}, + ov::pass::pattern::consumers_count(1)); const auto gatherIndices = ov::op::v0::Constant::create(element::i64, Shape{}, {0}); const auto gatherAxis = ov::pass::pattern::any_input(); const auto gather = ov::pass::pattern::wrap_type({unsqueeze, gatherIndices, gatherAxis}); @@ -75,19 +76,24 @@ ov::pass::EliminateGatherUnsqueeze::EliminateGatherUnsqueeze() { MATCHER_SCOPE(EliminateGatherUnsqueeze); const auto gather_label = ov::pass::pattern::wrap_type(scalar_with_one_consumer); - const auto be_label = ov::pass::pattern::wrap_type( - {gather_label, ov::pass::pattern::any_input()}, - scalar_with_one_consumer); + const auto be_label = + ov::pass::pattern::wrap_type({gather_label, ov::pass::pattern::any_input()}, + scalar_with_one_consumer); const auto or_label = std::make_shared(OutputVector{gather_label, be_label}); - const auto unsqueeze_label = ov::pass::pattern::wrap_type({or_label, ov::pass::pattern::any_input()}, ov::pass::pattern::rank_equals(1)); + const auto unsqueeze_label = ov::pass::pattern::wrap_type( + {or_label, ov::pass::pattern::any_input()}, + ov::pass::pattern::rank_equals(1)); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto pattern_nodes = m.get_pattern_map(); auto& gather = pattern_nodes.at(gather_label); auto& unsqueeze = pattern_nodes.at(unsqueeze_label); - const auto& indices = ov::op::util::make_try_fold(gather->input_value(1), - ov::op::v0::Constant::create(element::i32, {1}, {1}), - false); + const auto& indices = + ov::op::util::make_try_fold(gather->input_value(1), + ov::op::v0::Constant::create(element::i32, {1}, {1}), + false); register_new_node(indices); gather->input(1).replace_source_output(indices->output(0)); copy_runtime_info({unsqueeze, gather}, {indices, gather}); diff --git a/src/common/transformations/src/transformations/common_optimizations/fq_mul_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/fq_mul_fusion.cpp index 19c4fbde9c6d4b..344b49df54d63d 100644 --- a/src/common/transformations/src/transformations/common_optimizations/fq_mul_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/fq_mul_fusion.cpp @@ -52,8 +52,8 @@ ov::pass::FakeQuantizeMulFusion::FakeQuantizeMulFusion() { ov::pass::pattern::consumers_count(1)); const auto mul_constant_p = ov::pass::pattern::wrap_type(); - const auto mul_node_p = - ov::pass::pattern::wrap_type({fq_node_p, mul_constant_p}, ov::pass::pattern::consumers_count(1)); + const auto mul_node_p = ov::pass::pattern::wrap_type({fq_node_p, mul_constant_p}, + ov::pass::pattern::consumers_count(1)); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/fq_reshape_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/fq_reshape_fusion.cpp index c6b9f615672bc0..f41ecff33d9d48 100644 --- a/src/common/transformations/src/transformations/common_optimizations/fq_reshape_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/fq_reshape_fusion.cpp @@ -23,14 +23,15 @@ ov::pass::FakeQuantizeReshapeFusion::FakeQuantizeReshapeFusion() { MATCHER_SCOPE(FakeQuantizeReshapeFusion); // for weights only const auto data_p = ov::pass::pattern::wrap_type(ov::pass::pattern::has_static_shape()); - const auto convert_p = ov::pass::pattern::optional(data_p, ov::pass::pattern::consumers_count(1)); - const auto fq_node_p = - ov::pass::pattern::wrap_type({convert_p, - ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}, - ov::pass::pattern::consumers_count(1)); + const auto convert_p = + ov::pass::pattern::optional(data_p, ov::pass::pattern::consumers_count(1)); + const auto fq_node_p = ov::pass::pattern::wrap_type( + {convert_p, + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}, + ov::pass::pattern::consumers_count(1)); const auto reshape_node_p = ov::pass::pattern::wrap_type( {fq_node_p, ov::pass::pattern::wrap_type()}, [](const Output& output) { diff --git a/src/common/transformations/src/transformations/common_optimizations/fuse_moe_experts.cpp b/src/common/transformations/src/transformations/common_optimizations/fuse_moe_experts.cpp index 9e70c0dbb54d58..c3d328e7de94cb 100644 --- a/src/common/transformations/src/transformations/common_optimizations/fuse_moe_experts.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/fuse_moe_experts.cpp @@ -101,8 +101,8 @@ std::shared_ptr mlp3_no_bias_swiglu_block( auto select_Gather_1 = wrap_type( {permute_Transpose, expert_id, wrap_type(ov::pass::pattern::value_matches("0"))}, {{"batch_dims", 0}}); - auto squeeze_Squeeze_1 = - wrap_type({select_Gather_1, wrap_type(ov::pass::pattern::value_matches("0"))}); + auto squeeze_Squeeze_1 = wrap_type( + {select_Gather_1, wrap_type(ov::pass::pattern::value_matches("0"))}); // NonZero output_type relaxed to accept both i32 and i64 auto ListUnpack_NonZero_1 = wrap_type({squeeze_Squeeze_1}); auto ListUnpack_Split_1 = wrap_type( @@ -126,11 +126,13 @@ std::shared_ptr mlp3_no_bias_swiglu_block( auto index_add__Broadcast_16 = wrap_type({index_add__Reshape_1, index_add__ShapeOf_14}, {{"mode", "bidirectional"}}); auto unsqueeze_Unsqueeze_reshape = - wrap_type({unsqueeze_Unsqueeze, ov::pass::pattern::any_input()}, {{"special_zero", false}}); - auto index_Gather_2 = wrap_type({unsqueeze_Unsqueeze_reshape, - index_add__Convert_1, - wrap_type(ov::pass::pattern::value_matches("0"))}, - {{"batch_dims", 0}}); + wrap_type({unsqueeze_Unsqueeze, ov::pass::pattern::any_input()}, + {{"special_zero", false}}); + auto index_Gather_2 = + wrap_type({unsqueeze_Unsqueeze_reshape, + index_add__Convert_1, + wrap_type(ov::pass::pattern::value_matches("0"))}, + {{"batch_dims", 0}}); auto reshape_Reshape_1_0 = wrap_type({index_Gather_2, ov::pass::pattern::any_input()}, {{"special_zero", true}}); auto reshape_Reshape_1_1 = @@ -168,12 +170,12 @@ std::shared_ptr mlp3_no_bias_swiglu_block( wrap_type({linear_MatMul_down, index_Reshape_8_1}, {{"auto_broadcast", "numpy"}}); auto index_add__Broadcast_17 = wrap_type({mul_Multiply_2, index_add__ShapeOf_14}, {{"mode", "bidirectional"}}); - auto index_add__ScatterElementsUpdate_5 = - wrap_type({index_add__ScatterElementsUpdate_2, - index_add__Broadcast_16, - index_add__Broadcast_17, - wrap_type(ov::pass::pattern::value_matches("0"))}, - {{"reduction", "sum"}, {"use_init_val", true}}); + auto index_add__ScatterElementsUpdate_5 = wrap_type( + {index_add__ScatterElementsUpdate_2, + index_add__Broadcast_16, + index_add__Broadcast_17, + wrap_type(ov::pass::pattern::value_matches("0"))}, + {{"reduction", "sum"}, {"use_init_val", true}}); auto block = std::make_shared( ov::OutputVector{permute_Transpose, unsqueeze_Unsqueeze, index_Split_out_1, index_Reshape}, ov::OutputVector{index_add__ScatterElementsUpdate_5}, @@ -257,7 +259,8 @@ std::tuple, std::shared_ptr> create_routing_weights_ auto shape_of = wrap_type({unsqueeze}, {{"output_type", "i32"}}); auto split = wrap_type({shape_of, axes.axis0}, {{"num_splits", 3}}); split->set_output_size(3); - auto reshape = wrap_type({unsqueeze, ov::pass::pattern::any_input()}, {{"special_zero", true}}); + auto reshape = + wrap_type({unsqueeze, ov::pass::pattern::any_input()}, {{"special_zero", true}}); return {split, reshape}; } diff --git a/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp b/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp index d0b6622d5944b0..a2f4f69355e5cd 100644 --- a/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp @@ -94,12 +94,14 @@ ov::pass::RoPEFusionFlux::RoPEFusionFlux() { // y1 = x * t_cos // y2 = x3 * t_sin // y = y1 + y2 - auto x = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4) && ov::pass::pattern::shape_matches("[PRESERVED_DIMS..., head_size]")); + auto x = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4) && + ov::pass::pattern::shape_matches("[PRESERVED_DIMS..., head_size]")); auto t_cos = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto t_sin = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); - auto x1 = ov::pass::pattern::wrap_type({x, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[PRESERVED_DIMS..., ?, 2]")); + auto x1 = + ov::pass::pattern::wrap_type({x, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[PRESERVED_DIMS..., ?, 2]")); auto split = ov::pass::pattern::wrap_type({x1, -1}, {{"num_splits", 2}}); split->set_output_size(2); @@ -110,8 +112,9 @@ ov::pass::RoPEFusionFlux::RoPEFusionFlux() { auto opt_unsqueeze = ov::pass::pattern::optional({opt_squeeze_1, -1}); auto x2 = ov::pass::pattern::wrap_type({opt_unsqueeze, split->output(0)}, {{"axis", -1}}); - auto x3 = ov::pass::pattern::wrap_type({x2, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[PRESERVED_DIMS..., head_size]")); + auto x3 = ov::pass::pattern::wrap_type( + {x2, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[PRESERVED_DIMS..., head_size]")); auto y1 = ov::pass::pattern::wrap_type({x, t_cos}, {{"auto_broadcast", "numpy"}}); auto y2 = ov::pass::pattern::wrap_type({x3, t_sin}, {{"auto_broadcast", "numpy"}}); @@ -188,12 +191,16 @@ ov::pass::RoPEFusionGPTNEOX::RoPEFusionGPTNEOX(int rank) { auto int32_max = std::numeric_limits::max(); auto x2 = NewGenSlice(x, "half_ndims", int32_max, 1, rank - 1); - auto x2neg = ov::pass::pattern::wrap_type({x2 | varsplit->output(1), -1.0f}, {{"auto_broadcast", "numpy"}}); + auto x2neg = ov::pass::pattern::wrap_type({x2 | varsplit->output(1), -1.0f}, + {{"auto_broadcast", "numpy"}}); auto x1 = NewGenSlice(x, 0, "half_ndims", 1, rank - 1); - auto x_rotate_half = ov::pass::pattern::wrap_type({x2neg, x1 | varsplit->output(0)}, {{"axis", -1}}); + auto x_rotate_half = + ov::pass::pattern::wrap_type({x2neg, x1 | varsplit->output(0)}, {{"axis", -1}}); - auto mul_cos = ov::pass::pattern::wrap_type({x_or_cos1, x_or_cos2}, {{"auto_broadcast", "numpy"}}); - auto mul_sin = ov::pass::pattern::wrap_type({x_rotate_half, t_sin}, {{"auto_broadcast", "numpy"}}); + auto mul_cos = + ov::pass::pattern::wrap_type({x_or_cos1, x_or_cos2}, {{"auto_broadcast", "numpy"}}); + auto mul_sin = + ov::pass::pattern::wrap_type({x_rotate_half, t_sin}, {{"auto_broadcast", "numpy"}}); auto result = ov::pass::pattern::wrap_type({mul_cos, mul_sin}, {{"auto_broadcast", "numpy"}}); @@ -258,36 +265,45 @@ ov::pass::RoPEFusionCosSinPreprocess::RoPEFusionCosSinPreprocess() { auto cos_const = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::f32)); auto sin_const = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::f32)); - auto node_batch_size = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::shape_matches("[1]")); - auto tile_batch = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::shape_matches("[1]")); - auto gather_positions = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::rank_equals(4)); + auto node_batch_size = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && + ov::pass::pattern::shape_matches("[1]")); + auto tile_batch = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && + ov::pass::pattern::shape_matches("[1]")); + auto gather_positions = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && + ov::pass::pattern::rank_equals(4)); auto prepare_cos_sin_gptneox = [&](std::shared_ptr const_tab) { auto slice = ov::pass::pattern::wrap_type({const_tab, {0}, node_batch_size, {1}, {0}}); auto strided_slice = NewGenStridedSlice(const_tab, {0}, node_batch_size, {1}, 0); - return ov::pass::pattern::wrap_type({strided_slice | slice, gather_positions}, {{"axis", 2}}); + return ov::pass::pattern::wrap_type({strided_slice | slice, gather_positions}, + {{"axis", 2}}); }; - auto seq_len = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::shape_matches("[1]")); - auto gather_positions_2d = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::rank_equals(2)); + auto seq_len = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && + ov::pass::pattern::shape_matches("[1]")); + auto gather_positions_2d = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && + ov::pass::pattern::rank_equals(2)); auto prepare_cos_sin_llama = [&](std::shared_ptr const_tab) { auto ScatterUpdate = ov::pass::pattern::wrap_type({{0, 0, 0}, 2, seq_len, 0}); auto slice_Slice = ov::pass::pattern::wrap_type({const_tab, {0}, seq_len, {1}, {2}}); auto slice_StridedSlice = NewGenStridedSlice(const_tab, {0, 0, 0}, ScatterUpdate, {1, 1, 1}, 2); - auto squeeze = ov::pass::pattern::wrap_type({slice_StridedSlice | slice_Slice, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, head_dims]")); - auto index_Gather = ov::pass::pattern::wrap_type({squeeze, gather_positions_2d, 0}, {{"batch_dims", 0}}); + auto squeeze = ov::pass::pattern::wrap_type( + {slice_StridedSlice | slice_Slice, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, head_dims]")); + auto index_Gather = + ov::pass::pattern::wrap_type({squeeze, gather_positions_2d, 0}, {{"batch_dims", 0}}); // another simplified pattern for gathering at position_ids auto slice_Slice2 = ov::pass::pattern::wrap_type({const_tab, {0}, seq_len, {1}, {0}}); auto slice_StridedSlice2 = NewGenStridedSlice(const_tab, {0}, seq_len, {1}, 0); - auto index_Gather2 = - ov::pass::pattern::wrap_type({slice_Slice2 | slice_StridedSlice2, gather_positions_2d, 0}, - {{"batch_dims", 0}}); + auto index_Gather2 = ov::pass::pattern::wrap_type( + {slice_Slice2 | slice_StridedSlice2, gather_positions_2d, 0}, + {{"batch_dims", 0}}); - auto unsqueeze = ov::pass::pattern::wrap_type({index_Gather | index_Gather2, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[1, 1, ?, head_dims]")); + auto unsqueeze = ov::pass::pattern::wrap_type( + {index_Gather | index_Gather2, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[1, 1, ?, head_dims]")); auto unsqueeze2 = ov::pass::pattern::wrap_type({index_Gather2, 1}); return unsqueeze2 | unsqueeze; @@ -345,8 +361,10 @@ ov::pass::RoPEFusionIOSlicing::RoPEFusionIOSlicing() { auto y = NewGenSlice(data, "ndims", int32_max, 1, 3); auto x_emb = ov::pass::pattern::wrap_type( {x | varsplit->output(0), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}) | - ov::pass::pattern::wrap_type( - {x | varsplit->output(0), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + ov::pass::pattern::wrap_type({x | varsplit->output(0), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto result = ov::pass::pattern::wrap_type({x_emb, y | varsplit->output(1)}, {{"axis", -1}}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { @@ -397,9 +415,11 @@ ov::pass::RoPEFusionPreprocess::RoPEFusionPreprocess() { auto x = ov::pass::pattern::wrap_type({input_slice | input_to_trans, {0, 2, 1, 3}}); // RoPE node: supports both 3 and 4 inputs - auto result = ov::pass::pattern::wrap_type({x, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}) | - ov::pass::pattern::wrap_type( - {x, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto result = + ov::pass::pattern::wrap_type( + {x, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}) | + ov::pass::pattern::wrap_type( + {x, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -446,11 +466,12 @@ auto const_idx_predicate = [](ov::pass::pattern::PatternSymbolMap&, const ov::Ou }; static std::shared_ptr repeat_interleave_pattern(const ov::Output& var_split_output) { - auto unsqueeze = ov::pass::pattern::wrap_type({var_split_output, {"dim0", "dim1", "1", "32"}}) | - ov::pass::pattern::wrap_type({var_split_output, 2}); + auto unsqueeze = + ov::pass::pattern::wrap_type({var_split_output, {"dim0", "dim1", "1", "32"}}) | + ov::pass::pattern::wrap_type({var_split_output, 2}); // repeate cos/sin table - auto const_idx = - ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(ov::element::i32) && const_idx_predicate); + auto const_idx = ov::pass::pattern::wrap_type( + ov::pass::pattern::type_matches(ov::element::i32) && const_idx_predicate); return ov::pass::pattern::wrap_type({unsqueeze, const_idx, 3}, {{"batch_dims", 0}}); } @@ -467,7 +488,8 @@ ov::pass::RoPEFusionGPTJ::RoPEFusionGPTJ() { auto view_Reshape = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto slice_Slice_965 = NewGenSlice(view_Reshape, 0, "ndims", 1, 3); // view_Reshape : B,L,H,S - auto varsplit_view_Reshape = ov::pass::pattern::wrap_type({view_Reshape, 3, {"ndims", "end"}}); + auto varsplit_view_Reshape = + ov::pass::pattern::wrap_type({view_Reshape, 3, {"ndims", "end"}}); varsplit_view_Reshape->set_output_size(2); // x interleave (-x[:,:,:, 1::2], x[:,:,:, 0::2]) auto slice_Slice_1174 = NewGenSlice(slice_Slice_965 | varsplit_view_Reshape->output(0), 1, INT_MAX, 2, 3); @@ -475,16 +497,18 @@ ov::pass::RoPEFusionGPTJ::RoPEFusionGPTJ() { auto neg_Multiply_1177 = ov::pass::pattern::wrap_type({slice_Slice_1174, -1.0f}, {{"auto_broadcast", "numpy"}}); auto Unsqueeze_65524 = ov::pass::pattern::wrap_type({neg_Multiply_1177, -1}); - auto Unsqueeze_28998 = ov::pass::pattern::wrap_type({neg_Multiply_1177, {"-1", "1", "head_num", "32", "1"}}, - {{"special_zero", false}}); + auto Unsqueeze_28998 = + ov::pass::pattern::wrap_type({neg_Multiply_1177, {"-1", "1", "head_num", "32", "1"}}, + {{"special_zero", false}}); auto slice_Slice_1168 = NewGenSlice(slice_Slice_965 | varsplit_view_Reshape->output(0), 0, INT_MAX, 2, 3); auto Unsqueeze_65525 = ov::pass::pattern::wrap_type({slice_Slice_1168, -1}); - auto Unsqueeze_28999 = ov::pass::pattern::wrap_type({slice_Slice_1168, {"-1", "1", "head_num", "32", "1"}}, - {{"special_zero", false}}); - auto stack_1182 = - ov::pass::pattern::wrap_type({Unsqueeze_65524 | Unsqueeze_28998, Unsqueeze_65525 | Unsqueeze_28999}, - {{"axis", -1}}); + auto Unsqueeze_28999 = + ov::pass::pattern::wrap_type({slice_Slice_1168, {"-1", "1", "head_num", "32", "1"}}, + {{"special_zero", false}}); + auto stack_1182 = ov::pass::pattern::wrap_type( + {Unsqueeze_65524 | Unsqueeze_28998, Unsqueeze_65525 | Unsqueeze_28999}, + {{"axis", -1}}); auto ShapeOf_169068 = ov::pass::pattern::wrap_type({stack_1182}); auto flatten_Slice_1194 = NewGenSlice(ShapeOf_169068, 0, 3, 1, 0); @@ -492,21 +516,23 @@ ov::pass::RoPEFusionGPTJ::RoPEFusionGPTJ() { // If with special zero, no need to use shapeof to get full shape auto flatten_Reshape_1198 = ov::pass::pattern::wrap_type({stack_1182, flatten_Concat_1197}); auto flatten_Reshape_Zero = - ov::pass::pattern::wrap_type({stack_1182, ov::pass::pattern::any_input()}, {{"special_zero", true}}); + ov::pass::pattern::wrap_type({stack_1182, ov::pass::pattern::any_input()}, + {{"special_zero", true}}); // x*cos [B,L,H,ndims] auto mul_cos = ov::pass::pattern::wrap_type( {slice_Slice_965 | varsplit_view_Reshape->output(0), repeat_interleave_cos}, {{"auto_broadcast", "numpy"}}); - auto mul_sin = - ov::pass::pattern::wrap_type({flatten_Reshape_1198 | flatten_Reshape_Zero, repeat_interleave_sin}, - {{"auto_broadcast", "numpy"}}); + auto mul_sin = ov::pass::pattern::wrap_type( + {flatten_Reshape_1198 | flatten_Reshape_Zero, repeat_interleave_sin}, + {{"auto_broadcast", "numpy"}}); // *cos + *sin auto rotary_emb = ov::pass::pattern::wrap_type({mul_cos, mul_sin}, {{"auto_broadcast", "numpy"}}); auto slice_Slice_971 = NewGenSlice(view_Reshape, "ndims", INT_MAX, 1, 3); - auto result = ov::pass::pattern::wrap_type({rotary_emb, slice_Slice_971 | varsplit_view_Reshape->output(1)}, + auto result = + ov::pass::pattern::wrap_type({rotary_emb, slice_Slice_971 | varsplit_view_Reshape->output(1)}, {{"axis", -1}}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { @@ -582,16 +608,19 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { // [seq_length, batch_size, input_size(will be cropped to match hidden state size)] // [batch_size, seq_length, input_size] support_2d_rope auto qkv_linear = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(3)); - auto seq_length = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && ov::pass::pattern::shape_matches("[1]")); + auto seq_length = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::i32) && + ov::pass::pattern::shape_matches("[1]")); // [max_pos_embeddings, batch_size, half_rotary_dims, 2] // [batch_size, max_pos_embeddings, half_rotary_dims, 2] support_2d_rope auto cos_sin_cache = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); - auto qkv_proj = - ov::pass::pattern::wrap_type({qkv_linear, -1, {"total_size_q", "total_size_k", "total_size_v"}}); + auto qkv_proj = ov::pass::pattern::wrap_type( + {qkv_linear, -1, {"total_size_q", "total_size_k", "total_size_v"}}); qkv_proj->set_output_size(3); - auto reshape_pattern_const = ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("0, 0, head_cnt, head_size")); - auto cur_key = ov::pass::pattern::wrap_type({qkv_proj, reshape_pattern_const}, {{"special_zero", true}}); + auto reshape_pattern_const = ov::pass::pattern::wrap_type( + ov::pass::pattern::value_matches("0, 0, head_cnt, head_size")); + auto cur_key = + ov::pass::pattern::wrap_type({qkv_proj, reshape_pattern_const}, {{"special_zero", true}}); std::shared_ptr input_key = nullptr; // Extended the RoPE to a two-dimensional form to accommodate the 2D positional encoding in GLM. // Calculate positional embedding independent of batch and each head @@ -600,8 +629,9 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { // For Models, where SDPA to PagedAttention transformation was applied, // all sequences have the size == 1, we move sequences to the batch, this is the PagedAttention specific, // so seq_length dim will be always 1, this means that Transpose is unnecessary and Reshape op can be used. - auto transposed_cur_key = ov::pass::pattern::wrap_type({qkv_proj, {"-1", "head_cnt", "1", "head_size"}}, - {{"special_zero", false}}); + auto transposed_cur_key = + ov::pass::pattern::wrap_type({qkv_proj, {"-1", "head_cnt", "1", "head_size"}}, + {{"special_zero", false}}); // Transpose for SDPA version: input_key = ov::pass::pattern::wrap_type({cur_key, {0, 2, 1, 3}}) | transposed_cur_key; } else { @@ -616,17 +646,19 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { // rotate half std::shared_ptr reshape0 = nullptr; if (support_2d_rope) { - auto const_target_shape0 = - ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("0, head_cnt, 0, ndims/2, 2")); - reshape0 = ov::pass::pattern::wrap_type({slice0 | var_split0->output(0), const_target_shape0}, - {{"special_zero", true}}); + auto const_target_shape0 = ov::pass::pattern::wrap_type( + ov::pass::pattern::value_matches("0, head_cnt, 0, ndims/2, 2")); + reshape0 = + ov::pass::pattern::wrap_type({slice0 | var_split0->output(0), const_target_shape0}, + {{"special_zero", true}}); } else { auto concat0 = - ov::pass::pattern::wrap_type({seq_length, {-1}, {"head_cnt"}, {"ndims/2"}, {2}}, {{"axis", 0}}); - auto const_target_shape1 = - ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("0, 0, head_cnt, ndims/2, 2")); - auto const_target_shape2 = - ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("seq_len, batch, head_cnt, ndims/2, 2")); + ov::pass::pattern::wrap_type({seq_length, {-1}, {"head_cnt"}, {"ndims/2"}, {2}}, + {{"axis", 0}}); + auto const_target_shape1 = ov::pass::pattern::wrap_type( + ov::pass::pattern::value_matches("0, 0, head_cnt, ndims/2, 2")); + auto const_target_shape2 = ov::pass::pattern::wrap_type( + ov::pass::pattern::value_matches("seq_len, batch, head_cnt, ndims/2, 2")); reshape0 = ov::pass::pattern::wrap_type( {slice0 | var_split0->output(0), concat0 | const_target_shape1 | const_target_shape2}); } @@ -640,24 +672,29 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { std::shared_ptr reshape1 = nullptr; if (support_2d_rope) { // Slice cos_sin_cache to support 2-dimentional RoPE - auto scatter_update0 = ov::pass::pattern::wrap_type({{0, 0}, {1}, seq_length, {0}}, {}); + auto scatter_update0 = + ov::pass::pattern::wrap_type({{0, 0}, {1}, seq_length, {0}}, {}); auto slice1 = ov::pass::pattern::wrap_type({cos_sin_cache, {0}, seq_length, {1}, {1}}); - auto slice2 = ov::pass::pattern::wrap_type({cos_sin_cache, {0, 0}, scatter_update0, {1, 1}, {0}}); + auto slice2 = + ov::pass::pattern::wrap_type({cos_sin_cache, {0, 0}, scatter_update0, {1, 1}, {0}}); auto ss_stop = ov::pass::pattern::wrap_type(); auto strided_slice0 = NewGenStridedSlice(cos_sin_cache, {0, 0}, ss_stop | scatter_update0, {1, 1}, 1); - auto concat1 = ov::pass::pattern::wrap_type({{-1}, {1}, seq_length, {"ndims/2"}, {2}}, {{"axis", 0}}); - auto const_target_shape3 = - ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("batch, 1, seq_len, ndims/2, 2")); + auto concat1 = + ov::pass::pattern::wrap_type({{-1}, {1}, seq_length, {"ndims/2"}, {2}}, {{"axis", 0}}); + auto const_target_shape3 = ov::pass::pattern::wrap_type( + ov::pass::pattern::value_matches("batch, 1, seq_len, ndims/2, 2")); // [batch, 1, seq_length, half_rotary_dims, 2] reshape1 = ov::pass::pattern::wrap_type( {strided_slice0 | slice1 | slice2 | var_split1->output(0), concat1 | const_target_shape3}); } else { - auto concat2 = ov::pass::pattern::wrap_type({seq_length, {-1}, {1}, {"ndims/2"}, {2}}, {{"axis", 0}}); - auto const_target_shape4 = ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("1, -1, 1, ndims/2, 2")); - auto const_target_shape5 = - ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("seq_len, batch, 1, ndims/2, 2")); + auto concat2 = + ov::pass::pattern::wrap_type({seq_length, {-1}, {1}, {"ndims/2"}, {2}}, {{"axis", 0}}); + auto const_target_shape4 = ov::pass::pattern::wrap_type( + ov::pass::pattern::value_matches("1, -1, 1, ndims/2, 2")); + auto const_target_shape5 = ov::pass::pattern::wrap_type( + ov::pass::pattern::value_matches("seq_len, batch, 1, ndims/2, 2")); auto slice3 = ov::pass::pattern::wrap_type({cos_sin_cache, {0}, seq_length, {1}, {0}}); auto strided_slice1 = NewGenStridedSlice(cos_sin_cache, {0}, seq_length, {1}, 0); @@ -668,19 +705,27 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { } auto cos_tab = ov::pass::pattern::wrap_type({reshape1, 0, -1}, {{"batch_dims", 0}}); - auto x_even_cos = ov::pass::pattern::wrap_type({x_even, cos_tab}, {{"auto_broadcast", "numpy"}}); + auto x_even_cos = + ov::pass::pattern::wrap_type({x_even, cos_tab}, {{"auto_broadcast", "numpy"}}); auto sin_tab = ov::pass::pattern::wrap_type({reshape1, 1, -1}, {{"batch_dims", 0}}); - auto x_odd_sin = ov::pass::pattern::wrap_type({x_odd, sin_tab}, {{"auto_broadcast", "numpy"}}); - auto neg_x_odd_sin = ov::pass::pattern::wrap_type({x_odd_sin, -1.000000f}, {{"auto_broadcast", "numpy"}}); - auto add0 = ov::pass::pattern::wrap_type({x_even_cos, neg_x_odd_sin}, {{"auto_broadcast", "numpy"}}); - auto y_even = ov::pass::pattern::wrap_type({add0, -1}) | - ov::pass::pattern::wrap_type({add0, gen_chatglm_const()}, {{"special_zero", false}}); - auto x_odd_cos = ov::pass::pattern::wrap_type({x_odd, cos_tab}, {{"auto_broadcast", "numpy"}}); - auto x_even_sin = ov::pass::pattern::wrap_type({x_even, sin_tab}, {{"auto_broadcast", "numpy"}}); + auto x_odd_sin = + ov::pass::pattern::wrap_type({x_odd, sin_tab}, {{"auto_broadcast", "numpy"}}); + auto neg_x_odd_sin = + ov::pass::pattern::wrap_type({x_odd_sin, -1.000000f}, {{"auto_broadcast", "numpy"}}); + auto add0 = + ov::pass::pattern::wrap_type({x_even_cos, neg_x_odd_sin}, {{"auto_broadcast", "numpy"}}); + auto y_even = + ov::pass::pattern::wrap_type({add0, -1}) | + ov::pass::pattern::wrap_type({add0, gen_chatglm_const()}, {{"special_zero", false}}); + auto x_odd_cos = + ov::pass::pattern::wrap_type({x_odd, cos_tab}, {{"auto_broadcast", "numpy"}}); + auto x_even_sin = + ov::pass::pattern::wrap_type({x_even, sin_tab}, {{"auto_broadcast", "numpy"}}); auto add1 = ov::pass::pattern::wrap_type({x_odd_cos, x_even_sin}, {{"auto_broadcast", "numpy"}}); - auto y_odd = ov::pass::pattern::wrap_type({add1, -1}) | - ov::pass::pattern::wrap_type({add1, gen_chatglm_const()}, {{"special_zero", false}}); + auto y_odd = + ov::pass::pattern::wrap_type({add1, -1}) | + ov::pass::pattern::wrap_type({add1, gen_chatglm_const()}, {{"special_zero", false}}); auto concat2 = ov::pass::pattern::wrap_type({y_even, y_odd}, {{"axis", -1}}); @@ -692,21 +737,25 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { std::shared_ptr reshape2 = nullptr; if (support_2d_rope) { // [batch, head_cnt, length, half_rotary_dims, 2] - const_target_shape6 = - ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("batch, head_cnt, seq_len, ndims") || - ov::pass::pattern::value_matches("0, head_cnt, 0, ndims")); - reshape2 = ov::pass::pattern::wrap_type({concat2, concat3 | const_target_shape6}, {{"special_zero", true}}); + const_target_shape6 = ov::pass::pattern::wrap_type( + ov::pass::pattern::value_matches("batch, head_cnt, seq_len, ndims") || + ov::pass::pattern::value_matches("0, head_cnt, 0, ndims")); + reshape2 = ov::pass::pattern::wrap_type({concat2, concat3 | const_target_shape6}, + {{"special_zero", true}}); } else { // [length, batch, head_cnt, half_rotary_dims, 2] - auto const_target_shape7 = ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("0, 0, head_cnt, ndims")); - const_target_shape6 = - ov::pass::pattern::wrap_type(ov::pass::pattern::value_matches("seq_len, batch, head_cnt, ndims")); - reshape2 = ov::pass::pattern::wrap_type({concat2, concat3 | const_target_shape6 | const_target_shape7}, - {{"special_zero", true}}); + auto const_target_shape7 = ov::pass::pattern::wrap_type( + ov::pass::pattern::value_matches("0, 0, head_cnt, ndims")); + const_target_shape6 = ov::pass::pattern::wrap_type( + ov::pass::pattern::value_matches("seq_len, batch, head_cnt, ndims")); + reshape2 = ov::pass::pattern::wrap_type( + {concat2, concat3 | const_target_shape6 | const_target_shape7}, + {{"special_zero", true}}); } auto slice5 = NewGenSlice(input_key, "ndims", INT_MAX, 1, 3); - auto concat4 = ov::pass::pattern::wrap_type({reshape2, slice5 | var_split0->output(1)}, {{"axis", -1}}); + auto concat4 = + ov::pass::pattern::wrap_type({reshape2, slice5 | var_split0->output(1)}, {{"axis", -1}}); auto result = concat4 | reshape2; matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { @@ -779,9 +828,10 @@ ov::pass::RoPEFusionChatGLMHF::RoPEFusionChatGLMHF() { auto cos = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, 1, 1, ?]")); auto sin = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, 1, 1, ?]")); - auto reshape = ov::pass::pattern::wrap_type({qk_linear, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, head_cnt, 1, head_size]"), - {{"special_zero", false}}); + auto reshape = ov::pass::pattern::wrap_type( + {qk_linear, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, head_cnt, 1, head_size]"), + {{"special_zero", false}}); auto vsplit_out0 = ov::pass::pattern::wrap_type( {reshape, 3, ov::pass::pattern::any_input()}, @@ -791,26 +841,33 @@ ov::pass::RoPEFusionChatGLMHF::RoPEFusionChatGLMHF() { ov::pass::pattern::output_index_matches(1) && ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims]")); auto slice_1 = NewGenSlice(reshape, 0, "ndims", 1, 3) | vsplit_out0; - auto const_idx = - ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(ov::element::i32) && const_idx_predicate); - auto repeat_interleave_cos = ov::pass::pattern::wrap_type({cos, const_idx, -1}, {{"batch_dims", 0}}); - auto repeat_interleave_sin = ov::pass::pattern::wrap_type({sin, const_idx, -1}, {{"batch_dims", 0}}); + auto const_idx = ov::pass::pattern::wrap_type( + ov::pass::pattern::type_matches(ov::element::i32) && const_idx_predicate); + auto repeat_interleave_cos = + ov::pass::pattern::wrap_type({cos, const_idx, -1}, {{"batch_dims", 0}}); + auto repeat_interleave_sin = + ov::pass::pattern::wrap_type({sin, const_idx, -1}, {{"batch_dims", 0}}); - auto multiply = ov::pass::pattern::wrap_type({slice_1, repeat_interleave_cos}, {{"auto_broadcast", "numpy"}}); + auto multiply = ov::pass::pattern::wrap_type({slice_1, repeat_interleave_cos}, + {{"auto_broadcast", "numpy"}}); auto slice_2 = NewGenSlice(slice_1, 1, INT_MAX, 2, 3); auto neg = ov::pass::pattern::wrap_type({slice_2, -1}, {{"auto_broadcast", "numpy"}}); - auto unsqueeze_1 = ov::pass::pattern::wrap_type({neg, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims/2, 1]"), - {{"special_zero", false}}); + auto unsqueeze_1 = ov::pass::pattern::wrap_type( + {neg, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims/2, 1]"), + {{"special_zero", false}}); auto slice_3 = NewGenSlice(slice_1, 0, INT_MAX, 2, 3); - auto unsqueeze_2 = ov::pass::pattern::wrap_type({slice_3, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims/2, 1]"), - {{"special_zero", false}}); + auto unsqueeze_2 = ov::pass::pattern::wrap_type( + {slice_3, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims/2, 1]"), + {{"special_zero", false}}); auto stack = ov::pass::pattern::wrap_type({unsqueeze_1, unsqueeze_2}, {{"axis", -1}}); - auto flatten = ov::pass::pattern::wrap_type({stack, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims]"), - {{"special_zero", true}}); - auto multiply_1 = ov::pass::pattern::wrap_type({flatten, repeat_interleave_sin}, {{"auto_broadcast", "numpy"}}); + auto flatten = + ov::pass::pattern::wrap_type({stack, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims]"), + {{"special_zero", true}}); + auto multiply_1 = ov::pass::pattern::wrap_type({flatten, repeat_interleave_sin}, + {{"auto_broadcast", "numpy"}}); auto add = ov::pass::pattern::wrap_type({multiply, multiply_1}, {{"auto_broadcast", "numpy"}}); auto slice_5 = NewGenSlice(reshape, "ndims", INT_MAX, 1, 3) | vsplit_out1; @@ -859,35 +916,44 @@ ov::pass::RoPEFusionQwen::RoPEFusionQwen() { MATCHER_SCOPE(RoPEFusionQwen); // rotary_emb_cos & rotary_emb_sin are sliced by present kv-length (past-kv-length + cur_len) - auto rotary_emb_cos = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[1, ?, 1, ?]")); // [1,..4096,1,128] - auto rotary_emb_sin = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[1, ?, 1, ?]")); // [1,..4096,1,128] - auto qkv_proj = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, ?, ?]")); // [?,?,12288] + auto rotary_emb_cos = + ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[1, ?, 1, ?]")); // [1,..4096,1,128] + auto rotary_emb_sin = + ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[1, ?, 1, ?]")); // [1,..4096,1,128] + auto qkv_proj = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, ?, ?]")); // [?,?,12288] auto position_ids = ov::pass::pattern::any_input(); - auto ListUnpack_410_VariadicSplit = - ov::pass::pattern::wrap_type({qkv_proj, 2, {"head_cnt*head_size", "head_cnt*head_size", "?"}}); + auto ListUnpack_410_VariadicSplit = ov::pass::pattern::wrap_type( + {qkv_proj, 2, {"head_cnt*head_size", "head_cnt*head_size", "?"}}); ListUnpack_410_VariadicSplit->set_output_size(3); // B,L,H,S - auto view_Reshape_424 = ov::pass::pattern::wrap_type({ListUnpack_410_VariadicSplit, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, ?, head_cnt, head_size]"), - {{"special_zero", true}}); + auto view_Reshape_424 = ov::pass::pattern::wrap_type( + {ListUnpack_410_VariadicSplit, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, ?, head_cnt, head_size]"), + {{"special_zero", true}}); auto slice_Slice_543 = NewGenSlice(view_Reshape_424, 0, "head_size", 1, 3); auto ShapeOf_485735 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}, {}); - auto Multiply_567524 = ov::pass::pattern::wrap_type({ShapeOf_485735, -1}, {{"auto_broadcast", "numpy"}}); + auto Multiply_567524 = + ov::pass::pattern::wrap_type({ShapeOf_485735, -1}, {{"auto_broadcast", "numpy"}}); auto Gather_377635 = ov::pass::pattern::wrap_type({Multiply_567524, 1, 0}, {{"batch_dims", 0}}); auto ShapeOf_409241 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}, {}); auto Gather_311651 = ov::pass::pattern::wrap_type({ShapeOf_409241, 1, 0}, {{"batch_dims", 0}}); - auto neg_Multiply = ov::pass::pattern::wrap_type({Gather_311651, -1}, {{"auto_broadcast", "numpy"}}); + auto neg_Multiply = + ov::pass::pattern::wrap_type({Gather_311651, -1}, {{"auto_broadcast", "numpy"}}); - auto ScatterUpdate_463814 = ov::pass::pattern::wrap_type({{0, 0}, 1, Gather_377635 | neg_Multiply, 0}); - auto slice_Slice_446 = ov::pass::pattern::wrap_type({rotary_emb_cos, Gather_377635 | neg_Multiply, INT_MAX, 1, 1}); + auto ScatterUpdate_463814 = + ov::pass::pattern::wrap_type({{0, 0}, 1, Gather_377635 | neg_Multiply, 0}); + auto slice_Slice_446 = + ov::pass::pattern::wrap_type({rotary_emb_cos, Gather_377635 | neg_Multiply, INT_MAX, 1, 1}); - auto gather_cos_by_pos_ids = ov::pass::pattern::wrap_type({rotary_emb_cos, position_ids, 1}, {{"batch_dims", 0}}); - auto reshape_cos_to_expected_layout = ov::pass::pattern::wrap_type({gather_cos_by_pos_ids, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, 1, 1, 128]"), - {{"special_zero", false}}); + auto gather_cos_by_pos_ids = + ov::pass::pattern::wrap_type({rotary_emb_cos, position_ids, 1}, {{"batch_dims", 0}}); + auto reshape_cos_to_expected_layout = + ov::pass::pattern::wrap_type({gather_cos_by_pos_ids, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, 1, 1, 128]"), + {{"special_zero", false}}); auto slice_StridedSlice_446 = NewGenStridedSlice(rotary_emb_cos, ScatterUpdate_463814, {0, INT_MAX}, {1, 1}, 1); auto mul_Multiply_552 = ov::pass::pattern::wrap_type( @@ -896,18 +962,23 @@ ov::pass::RoPEFusionQwen::RoPEFusionQwen() { auto reshape_opt1 = [&](std::shared_ptr input_BLHS) { auto ShapeOf_485814 = ov::pass::pattern::wrap_type({input_BLHS}, {}); - auto Gather_377647 = ov::pass::pattern::wrap_type({ShapeOf_485814, 1, 0}, {{"batch_dims", 0}}); + auto Gather_377647 = + ov::pass::pattern::wrap_type({ShapeOf_485814, 1, 0}, {{"batch_dims", 0}}); // batch-size, we don't care - auto Gather_377641 = - ov::pass::pattern::any_input(ov::pass::pattern::type_matches(ov::element::i32) && ov::pass::pattern::shape_matches("[1]")); - auto ListConstruct_581_Concat = - ov::pass::pattern::wrap_type({Gather_377641, Gather_377647, "head_cnt", 2, "head_size/2"}, {{"axis", 0}}); - auto Gather_391791 = ov::pass::pattern::wrap_type({ShapeOf_485814, {0, 1}, 0}, {{"batch_dims", 0}}); - auto ListConstruct_522_Concat = ov::pass::pattern::wrap_type({Gather_391791, 32, 2, 64}, {{"axis", 0}}); - - auto reshape_Reshape_577 = ov::pass::pattern::wrap_type({input_BLHS, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, 2, head_size/2]"), - {{"special_zero", true}}); + auto Gather_377641 = ov::pass::pattern::any_input(ov::pass::pattern::type_matches(ov::element::i32) && + ov::pass::pattern::shape_matches("[1]")); + auto ListConstruct_581_Concat = ov::pass::pattern::wrap_type( + {Gather_377641, Gather_377647, "head_cnt", 2, "head_size/2"}, + {{"axis", 0}}); + auto Gather_391791 = + ov::pass::pattern::wrap_type({ShapeOf_485814, {0, 1}, 0}, {{"batch_dims", 0}}); + auto ListConstruct_522_Concat = + ov::pass::pattern::wrap_type({Gather_391791, 32, 2, 64}, {{"axis", 0}}); + + auto reshape_Reshape_577 = + ov::pass::pattern::wrap_type({input_BLHS, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, 2, head_size/2]"), + {{"special_zero", true}}); return ov::pass::pattern::wrap_type( {reshape_Reshape_577, ListConstruct_581_Concat | ListConstruct_522_Concat}, {{"special_zero", false}}); @@ -915,37 +986,46 @@ ov::pass::RoPEFusionQwen::RoPEFusionQwen() { auto reshape_special = ov::pass::pattern::wrap_type( {slice_Slice_543, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[..., 0, 2, head_size/2]") || ov::pass::pattern::shape_matches("[..., head_cnt, 2, head_size/2]"), + ov::pass::pattern::shape_matches("[..., 0, 2, head_size/2]") || + ov::pass::pattern::shape_matches("[..., head_cnt, 2, head_size/2]"), {{"special_zero", true}}); auto ListUnpack_586_Split = - ov::pass::pattern::wrap_type({reshape_opt1(slice_Slice_543) | reshape_special, -2}, {{"num_splits", 2}}); + ov::pass::pattern::wrap_type({reshape_opt1(slice_Slice_543) | reshape_special, -2}, + {{"num_splits", 2}}); ListUnpack_586_Split->set_output_size(2); - auto Multiply_567527 = - ov::pass::pattern::wrap_type({ListUnpack_586_Split->output(1), -1.0f}, {{"auto_broadcast", "numpy"}}); + auto Multiply_567527 = ov::pass::pattern::wrap_type({ListUnpack_586_Split->output(1), -1.0f}, + {{"auto_broadcast", "numpy"}}); auto ListUnpack_586_Squeeze_0 = ov::pass::pattern::wrap_type({Multiply_567527, -2}); - auto ListUnpack_586_Squeeze = ov::pass::pattern::wrap_type({ListUnpack_586_Split->output(0), -2}); - - auto ListUnpack_Squeeze_0_1 = ov::pass::pattern::wrap_type({Multiply_567527, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, 1, 32, 64]"), - {{"special_zero", false}}); - auto ListUnpack_Squeeze_1 = ov::pass::pattern::wrap_type({ListUnpack_586_Split->output(0), ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, 1, 32, 64]"), - {{"special_zero", false}}); + auto ListUnpack_586_Squeeze = + ov::pass::pattern::wrap_type({ListUnpack_586_Split->output(0), -2}); + + auto ListUnpack_Squeeze_0_1 = + ov::pass::pattern::wrap_type({Multiply_567527, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, 1, 32, 64]"), + {{"special_zero", false}}); + auto ListUnpack_Squeeze_1 = ov::pass::pattern::wrap_type( + {ListUnpack_586_Split->output(0), ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, 1, 32, 64]"), + {{"special_zero", false}}); auto cat_Concat_593 = ov::pass::pattern::wrap_type( {ListUnpack_586_Squeeze_0 | ListUnpack_Squeeze_0_1, ListUnpack_586_Squeeze | ListUnpack_Squeeze_1}, {{"axis", -1}}); auto slice_StridedSlice_470 = NewGenStridedSlice(rotary_emb_sin, ScatterUpdate_463814, {0, INT_MAX}, {1, 1}, 1); - auto slice_Slice_470 = ov::pass::pattern::wrap_type({rotary_emb_sin, Gather_377635 | neg_Multiply, INT_MAX, 1, 1}); - auto gather_sin_by_pos_ids = ov::pass::pattern::wrap_type({rotary_emb_sin, position_ids, 1}, {{"batch_dims", 0}}); - auto reshape_sin_to_expected_layout = ov::pass::pattern::wrap_type({gather_sin_by_pos_ids, ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("[?, 1, 1, 128]"), - {{"special_zero", false}}); + auto slice_Slice_470 = + ov::pass::pattern::wrap_type({rotary_emb_sin, Gather_377635 | neg_Multiply, INT_MAX, 1, 1}); + auto gather_sin_by_pos_ids = + ov::pass::pattern::wrap_type({rotary_emb_sin, position_ids, 1}, {{"batch_dims", 0}}); + auto reshape_sin_to_expected_layout = + ov::pass::pattern::wrap_type({gather_sin_by_pos_ids, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("[?, 1, 1, 128]"), + {{"special_zero", false}}); auto mul_Multiply_594 = ov::pass::pattern::wrap_type( {cat_Concat_593, slice_StridedSlice_470 | slice_Slice_470 | reshape_sin_to_expected_layout}, {{"auto_broadcast", "numpy"}}); - auto result = ov::pass::pattern::wrap_type({mul_Multiply_552, mul_Multiply_594}, {{"auto_broadcast", "numpy"}}); + auto result = ov::pass::pattern::wrap_type({mul_Multiply_552, mul_Multiply_594}, + {{"auto_broadcast", "numpy"}}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -1024,19 +1104,21 @@ ov::pass::RoPEShareCosSin::RoPEShareCosSin() { std::vector> inputs = {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}; // Broadcast pattern - auto const_broadcast_axes = - ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::u8) && ov::pass::pattern::value_matches("{0}")); - auto broadcast = ov::pass::pattern::wrap_type({"{1.000000f}", inputs[0], const_broadcast_axes}, - {{"mode", "numpy"}}); + auto const_broadcast_axes = ov::pass::pattern::wrap_type( + ov::pass::pattern::type_matches(element::u8) && ov::pass::pattern::value_matches("{0}")); + auto broadcast = + ov::pass::pattern::wrap_type({"{1.000000f}", inputs[0], const_broadcast_axes}, + {{"mode", "numpy"}}); // Multiply pattern (expand broadcast) - auto const_inv_freq = ov::pass::pattern::wrap_type(); // Pattern for the constant inverse frequency + auto const_inv_freq = + ov::pass::pattern::wrap_type(); // Pattern for the constant inverse frequency auto multiply = ov::pass::pattern::wrap_type({const_inv_freq, broadcast}, {{"auto_broadcast", "numpy"}}); // MatMul pattern - auto matmul = - ov::pass::pattern::wrap_type({multiply, inputs[1]}, {{"transpose_a", false}, {"transpose_b", false}}); + auto matmul = ov::pass::pattern::wrap_type({multiply, inputs[1]}, + {{"transpose_a", false}, {"transpose_b", false}}); // Transpose pattern auto transpose = ov::pass::pattern::wrap_type({matmul, {0, 2, 1}}); @@ -1138,15 +1220,21 @@ ov::pass::RoPEFusionGPTOSS::RoPEFusionGPTOSS() { auto vsplit_out1 = ov::pass::pattern::wrap_type( {x, -1, {"half_ndims", "?"}}, ov::pass::pattern::output_index_matches(1) && ov::pass::pattern::shape_matches("[?, ?, ?, half_ndims]")); - auto first_half_mul_cos = ov::pass::pattern::wrap_type({vsplit_out0, t_cos}, {{"auto_broadcast", "numpy"}}); - auto second_half_mul_sin = ov::pass::pattern::wrap_type({vsplit_out1, t_sin}, {{"auto_broadcast", "numpy"}}); - auto neg = ov::pass::pattern::wrap_type({second_half_mul_sin, -1.0f}, {{"auto_broadcast", "numpy"}}); - auto sub_Subtract = ov::pass::pattern::wrap_type({first_half_mul_cos, neg}, {{"auto_broadcast", "numpy"}}); - - auto second_half_mul_cos = ov::pass::pattern::wrap_type({vsplit_out1, t_cos}, {{"auto_broadcast", "numpy"}}); - auto first_half_mul_sin = ov::pass::pattern::wrap_type({vsplit_out0, t_sin}, {{"auto_broadcast", "numpy"}}); - auto add_Add = - ov::pass::pattern::wrap_type({second_half_mul_cos, first_half_mul_sin}, {{"auto_broadcast", "numpy"}}); + auto first_half_mul_cos = + ov::pass::pattern::wrap_type({vsplit_out0, t_cos}, {{"auto_broadcast", "numpy"}}); + auto second_half_mul_sin = + ov::pass::pattern::wrap_type({vsplit_out1, t_sin}, {{"auto_broadcast", "numpy"}}); + auto neg = + ov::pass::pattern::wrap_type({second_half_mul_sin, -1.0f}, {{"auto_broadcast", "numpy"}}); + auto sub_Subtract = + ov::pass::pattern::wrap_type({first_half_mul_cos, neg}, {{"auto_broadcast", "numpy"}}); + + auto second_half_mul_cos = + ov::pass::pattern::wrap_type({vsplit_out1, t_cos}, {{"auto_broadcast", "numpy"}}); + auto first_half_mul_sin = + ov::pass::pattern::wrap_type({vsplit_out0, t_sin}, {{"auto_broadcast", "numpy"}}); + auto add_Add = ov::pass::pattern::wrap_type({second_half_mul_cos, first_half_mul_sin}, + {{"auto_broadcast", "numpy"}}); auto concat_result = ov::pass::pattern::wrap_type({sub_Subtract, add_Add}, {{"axis", -1}}); auto result = concat_result; diff --git a/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp index 37b9bf1eb8849f..dab6da3c316744 100644 --- a/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp @@ -154,7 +154,7 @@ ov::pass::GeluFusionWithErfThree::GeluFusionWithErfThree() { ov::pass::GeluFusionWithErfFour::GeluFusionWithErfFour() { MATCHER_SCOPE(GeluFusionWithErfFour); using namespace ov; -auto input = ov::pass::pattern::any_input(); + auto input = ov::pass::pattern::any_input(); auto mul1_constant = ov::pass::pattern::wrap_type(check_value(SQRT1_2, 0.001f)); auto mul1 = ov::pass::pattern::wrap_type({input, mul1_constant}); auto erf = ov::pass::pattern::wrap_type({mul1}); diff --git a/src/common/transformations/src/transformations/common_optimizations/glu_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/glu_fusion.cpp index 95147e9d77a937..a45440619aef0d 100644 --- a/src/common/transformations/src/transformations/common_optimizations/glu_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/glu_fusion.cpp @@ -21,7 +21,7 @@ namespace ov { namespace pass { GLUFusion::GLUFusion() { -using ov::pass::pattern::op::Or; + using ov::pass::pattern::op::Or; auto last_dim_static = [](const ov::Output& output) { auto out_ps = output.get_node()->get_output_partial_shape(0); @@ -35,7 +35,8 @@ using ov::pass::pattern::op::Or; // VariadicSplit(X, axis, split_lengths) = Xw, Xv auto axis_const_m = ov::pass::pattern::wrap_type(); auto split_lengths_const_m = ov::pass::pattern::wrap_type(); - auto variadic_split_m = ov::pass::pattern::wrap_type({data_m, axis_const_m, split_lengths_const_m}); + auto variadic_split_m = + ov::pass::pattern::wrap_type({data_m, axis_const_m, split_lengths_const_m}); variadic_split_m->set_output_size(2); // Swish(Xw) = Xw * (1.0 + exp(-beta * Xw)) diff --git a/src/common/transformations/src/transformations/common_optimizations/group_normalization_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/group_normalization_fusion.cpp index 960bc3f5dd81cc..7c739666c0bb12 100644 --- a/src/common/transformations/src/transformations/common_optimizations/group_normalization_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/group_normalization_fusion.cpp @@ -31,34 +31,45 @@ ov::pass::GroupNormalizationFusion::GroupNormalizationFusion() { return (output_ps.rank().is_static()) && (output_ps.rank().get_length() >= 2); }; - auto input_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({has_real_not_quantized_type, has_at_least_2d_shape, ov::pass::pattern::has_static_dim(1)})); - - auto pre_mvn_shape_const_m = ov::pass::pattern::wrap_type(ov::pass::pattern::all_of({ov::pass::pattern::rank_equals(1), ov::pass::pattern::has_static_dim(0)})); - auto pre_mvn_reshape_m = - ov::pass::pattern::wrap_type({input_m, pre_mvn_shape_const_m}, - ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::rank_equals(3), ov::pass::pattern::has_static_dim(1)})); - - auto mvn_reduction_axes_const_m = ov::pass::pattern::wrap_type(ov::pass::pattern::all_of({ov::pass::pattern::rank_equals(1), ov::pass::pattern::has_static_dim(0)})); + auto input_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of( + {has_real_not_quantized_type, has_at_least_2d_shape, ov::pass::pattern::has_static_dim(1)})); + + auto pre_mvn_shape_const_m = ov::pass::pattern::wrap_type( + ov::pass::pattern::all_of({ov::pass::pattern::rank_equals(1), ov::pass::pattern::has_static_dim(0)})); + auto pre_mvn_reshape_m = ov::pass::pattern::wrap_type( + {input_m, pre_mvn_shape_const_m}, + ov::pass::pattern::all_of( + {has_real_not_quantized_type, ov::pass::pattern::rank_equals(3), ov::pass::pattern::has_static_dim(1)})); + + auto mvn_reduction_axes_const_m = ov::pass::pattern::wrap_type( + ov::pass::pattern::all_of({ov::pass::pattern::rank_equals(1), ov::pass::pattern::has_static_dim(0)})); auto mvn_m = ov::pass::pattern::wrap_type({pre_mvn_reshape_m, mvn_reduction_axes_const_m}); - auto instance_norm_gamma_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); + auto instance_norm_gamma_m = ov::pass::pattern::any_input( + ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); auto instance_norm_opt_gamma_m = ov::pass::pattern::optional({mvn_m, instance_norm_gamma_m}); - auto instance_norm_beta_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); + auto instance_norm_beta_m = ov::pass::pattern::any_input( + ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); auto instance_norm_opt_gamma_opt_beta_m = ov::pass::pattern::optional({instance_norm_opt_gamma_m, instance_norm_beta_m}); - auto post_instance_norm_shape_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({ov::pass::pattern::rank_equals(1), ov::pass::pattern::has_static_dim(0)})); - auto post_instance_norm_reshape_m = - ov::pass::pattern::wrap_type({instance_norm_opt_gamma_opt_beta_m, post_instance_norm_shape_m}, - ov::pass::pattern::all_of({has_real_not_quantized_type, has_at_least_2d_shape, ov::pass::pattern::has_static_dim(1)})); + auto post_instance_norm_shape_m = ov::pass::pattern::any_input( + ov::pass::pattern::all_of({ov::pass::pattern::rank_equals(1), ov::pass::pattern::has_static_dim(0)})); + auto post_instance_norm_reshape_m = ov::pass::pattern::wrap_type( + {instance_norm_opt_gamma_opt_beta_m, post_instance_norm_shape_m}, + ov::pass::pattern::all_of( + {has_real_not_quantized_type, has_at_least_2d_shape, ov::pass::pattern::has_static_dim(1)})); - auto group_norm_gamma_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); + auto group_norm_gamma_m = ov::pass::pattern::any_input( + ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); auto group_norm_gamma_multiply_m = ov::pass::pattern::wrap_type({post_instance_norm_reshape_m, group_norm_gamma_m}); - auto group_norm_beta_m = ov::pass::pattern::any_input(ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); - auto group_norm_beta_add_m = ov::pass::pattern::wrap_type({group_norm_gamma_multiply_m, group_norm_beta_m}); + auto group_norm_beta_m = ov::pass::pattern::any_input( + ov::pass::pattern::all_of({has_real_not_quantized_type, ov::pass::pattern::has_static_shape()})); + auto group_norm_beta_add_m = + ov::pass::pattern::wrap_type({group_norm_gamma_multiply_m, group_norm_beta_m}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/gru_cell_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/gru_cell_fusion.cpp index e3e25073bb52a8..2feb6f8a2c4d76 100644 --- a/src/common/transformations/src/transformations/common_optimizations/gru_cell_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/gru_cell_fusion.cpp @@ -86,19 +86,24 @@ ov::pass::GRUCellFusion::GRUCellFusion() { return !(p_shape.rank().is_dynamic() || p_shape[1].is_dynamic()); }; - auto concat_1 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(is_first_dim_static), ov::pass::pattern::any_input(is_first_dim_static)}); - auto matmul_1 = ov::pass::pattern::wrap_type({concat_1, ov::pass::pattern::any_input(is_first_dim_static)}); + auto concat_1 = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(is_first_dim_static), ov::pass::pattern::any_input(is_first_dim_static)}); + auto matmul_1 = + ov::pass::pattern::wrap_type({concat_1, ov::pass::pattern::any_input(is_first_dim_static)}); auto add_1 = ov::pass::pattern::wrap_type({matmul_1, ov::pass::pattern::any_input()}); auto optional_bias_add_1 = make_shared(OutputVector{matmul_1, add_1}); - auto activation_1 = ov::pass::pattern::wrap_type({optional_bias_add_1}); + auto activation_1 = + ov::pass::pattern::wrap_type({optional_bias_add_1}); auto split = ov::pass::pattern::wrap_type({activation_1, ov::pass::pattern::any_input()}); auto multiply_1 = ov::pass::pattern::wrap_type({split, ov::pass::pattern::any_input()}); auto concat_2 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), multiply_1}); - auto matmul_2 = ov::pass::pattern::wrap_type({concat_2, ov::pass::pattern::any_input(is_first_dim_static)}); + auto matmul_2 = + ov::pass::pattern::wrap_type({concat_2, ov::pass::pattern::any_input(is_first_dim_static)}); auto add_2 = ov::pass::pattern::wrap_type({matmul_2, ov::pass::pattern::any_input()}); auto optional_bias_add_2 = make_shared(OutputVector{matmul_2, add_2}); - auto activation_2 = ov::pass::pattern::wrap_type({optional_bias_add_2}); + auto activation_2 = + ov::pass::pattern::wrap_type({optional_bias_add_2}); auto subtract = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), split}); auto multiply_2 = ov::pass::pattern::wrap_type({subtract, activation_2}); diff --git a/src/common/transformations/src/transformations/common_optimizations/hswish_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/hswish_fusion.cpp index c36d8991b650b8..0f0e25afd4db07 100644 --- a/src/common/transformations/src/transformations/common_optimizations/hswish_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/hswish_fusion.cpp @@ -132,7 +132,8 @@ ov::pass::HSwishFusionWithHSigmoid::HSwishFusionWithHSigmoid() { MATCHER_SCOPE(HSwishFusionWithHSigmoid); // Replaces a sub-graph x * HSigmoid(x) with a HSwish op. auto input = ov::pass::pattern::any_input(); - auto hsigmoid_pattern = ov::pass::pattern::wrap_type({input}, ov::pass::pattern::consumers_count(1)); + auto hsigmoid_pattern = + ov::pass::pattern::wrap_type({input}, ov::pass::pattern::consumers_count(1)); auto mul_pattern = ov::pass::pattern::wrap_type({input, hsigmoid_pattern}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/leaky_relu_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/leaky_relu_fusion.cpp index 84c0c8d73463ee..c9f7ac3ded73dc 100644 --- a/src/common/transformations/src/transformations/common_optimizations/leaky_relu_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/leaky_relu_fusion.cpp @@ -20,8 +20,8 @@ ov::pass::LeakyReluFusion::LeakyReluFusion() { MATCHER_SCOPE(LeakyReluFusion); auto data_pattern = ov::pass::pattern::any_input(); auto alpha_pattern = ov::pass::pattern::wrap_type(); - auto multiply_pattern = - ov::pass::pattern::wrap_type({data_pattern, alpha_pattern}, ov::pass::pattern::consumers_count(1)); + auto multiply_pattern = ov::pass::pattern::wrap_type({data_pattern, alpha_pattern}, + ov::pass::pattern::consumers_count(1)); auto max_pattern = ov::pass::pattern::wrap_type({data_pattern, multiply_pattern}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/lin_op_sequence_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/lin_op_sequence_fusion.cpp index cdceecf22550ba..238ab05a748301 100644 --- a/src/common/transformations/src/transformations/common_optimizations/lin_op_sequence_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/lin_op_sequence_fusion.cpp @@ -30,7 +30,8 @@ ov::pass::AddMultiplyFusion::AddMultiplyFusion() { // Create Add->Multiply pattern where Add has exactly one consumer auto m_data = ov::pass::pattern::any_input(); auto m_add_constant = ov::pass::pattern::wrap_type(); - auto m_add = ov::pass::pattern::wrap_type({m_data, m_add_constant}, ov::pass::pattern::consumers_count(1)); + auto m_add = + ov::pass::pattern::wrap_type({m_data, m_add_constant}, ov::pass::pattern::consumers_count(1)); auto m_mul_constant = ov::pass::pattern::wrap_type(); auto m_mul = ov::pass::pattern::wrap_type({m_add, m_mul_constant}); @@ -77,7 +78,8 @@ ov::pass::AddAddFusion::AddAddFusion() { // Create Add->Add pattern where first Add has exactly one consumer auto m_data = ov::pass::pattern::any_input(); auto m_add1_constant = ov::pass::pattern::wrap_type(); - auto m_add1 = ov::pass::pattern::wrap_type({m_data, m_add1_constant}, ov::pass::pattern::consumers_count(1)); + auto m_add1 = + ov::pass::pattern::wrap_type({m_data, m_add1_constant}, ov::pass::pattern::consumers_count(1)); auto m_add2_constant = ov::pass::pattern::wrap_type(); auto m_add2 = ov::pass::pattern::wrap_type({m_add1, m_add2_constant}); diff --git a/src/common/transformations/src/transformations/common_optimizations/lora_subgraph_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/lora_subgraph_fusion.cpp index bc68f81890471d..56ecd6639f8206 100644 --- a/src/common/transformations/src/transformations/common_optimizations/lora_subgraph_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/lora_subgraph_fusion.cpp @@ -23,25 +23,34 @@ ov::pass::LoraSubgraphFusion::LoraSubgraphFusion() { MATCHER_SCOPE(LoraSubgraphFusion); -auto lora_input_m = ov::pass::pattern::any_input(); + auto lora_input_m = ov::pass::pattern::any_input(); auto transpose_const1_m = ov::pass::pattern::wrap_type(ov::pass::pattern::consumers_count(1)); - auto transpose1_m = ov::pass::pattern::optional({lora_input_m, transpose_const1_m}, ov::pass::pattern::consumers_count(1)); + auto transpose1_m = ov::pass::pattern::optional({lora_input_m, transpose_const1_m}, + ov::pass::pattern::consumers_count(1)); auto read_value1_m = ov::pass::pattern::wrap_type(); - auto convert1_m = ov::pass::pattern::optional(read_value1_m, ov::pass::pattern::consumers_count(1)); - auto matmul1_m = ov::pass::pattern::wrap_type({transpose1_m, convert1_m}, ov::pass::pattern::consumers_count(1)); + auto convert1_m = + ov::pass::pattern::optional(read_value1_m, ov::pass::pattern::consumers_count(1)); + auto matmul1_m = ov::pass::pattern::wrap_type({transpose1_m, convert1_m}, + ov::pass::pattern::consumers_count(1)); auto read_value2_m = ov::pass::pattern::wrap_type(); - auto convert2_m = ov::pass::pattern::optional(read_value2_m, ov::pass::pattern::consumers_count(1)); - auto multiply_m = ov::pass::pattern::wrap_type({matmul1_m, convert2_m}, ov::pass::pattern::consumers_count(1)); + auto convert2_m = + ov::pass::pattern::optional(read_value2_m, ov::pass::pattern::consumers_count(1)); + auto multiply_m = ov::pass::pattern::wrap_type({matmul1_m, convert2_m}, + ov::pass::pattern::consumers_count(1)); auto read_value3_m = ov::pass::pattern::wrap_type(); - auto convert3_m = ov::pass::pattern::optional(read_value3_m, ov::pass::pattern::consumers_count(1)); - auto matmul2_m = ov::pass::pattern::wrap_type({multiply_m, convert3_m}, ov::pass::pattern::consumers_count(1)); + auto convert3_m = + ov::pass::pattern::optional(read_value3_m, ov::pass::pattern::consumers_count(1)); + auto matmul2_m = ov::pass::pattern::wrap_type({multiply_m, convert3_m}, + ov::pass::pattern::consumers_count(1)); auto transpose_const2_m = ov::pass::pattern::wrap_type(ov::pass::pattern::consumers_count(1)); - auto transpose2_m = ov::pass::pattern::optional({matmul2_m, transpose_const2_m}, ov::pass::pattern::consumers_count(1)); - auto main_flow_m = ov::pass::pattern::wrap_type({lora_input_m, ov::pass::pattern::any_input()}); + auto transpose2_m = ov::pass::pattern::optional({matmul2_m, transpose_const2_m}, + ov::pass::pattern::consumers_count(1)); + auto main_flow_m = ov::pass::pattern::wrap_type( + {lora_input_m, ov::pass::pattern::any_input()}); auto add_m = ov::pass::pattern::wrap_type({transpose2_m, main_flow_m}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/lstm_cell_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/lstm_cell_fusion.cpp index d752ce353962cd..bdbd075f0b4b53 100644 --- a/src/common/transformations/src/transformations/common_optimizations/lstm_cell_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/lstm_cell_fusion.cpp @@ -222,17 +222,21 @@ ov::pass::LSTMCellFusionWithJointWeights::LSTMCellFusionWithJointWeights() { auto bias_add_label = ov::pass::pattern::wrap_type({matmul_label, bias_label}); auto axis_label = ov::pass::pattern::wrap_type(); auto split_label = ov::pass::pattern::wrap_type({bias_add_label, axis_label}); - auto it_label = ov::pass::pattern::wrap_type({split_label}); - auto ct_label = ov::pass::pattern::wrap_type({split_label}); + auto it_label = + ov::pass::pattern::wrap_type({split_label}); + auto ct_label = + ov::pass::pattern::wrap_type({split_label}); auto ft_additional_bias_label = ov::pass::pattern::wrap_type(); auto add_label = ov::pass::pattern::wrap_type({split_label, ft_additional_bias_label}); auto ft_label = ov::pass::pattern::wrap_type({add_label}); - auto ot_label = ov::pass::pattern::wrap_type({split_label}); + auto ot_label = + ov::pass::pattern::wrap_type({split_label}); auto mul_label = ov::pass::pattern::wrap_type({it_label, ct_label}); auto c_label = ov::pass::pattern::any_input(); auto mul1_label = ov::pass::pattern::wrap_type({ft_label, c_label}); auto Co_label = ov::pass::pattern::wrap_type({mul_label, mul1_label}); - auto Co_activation_label = ov::pass::pattern::wrap_type({Co_label}); + auto Co_activation_label = + ov::pass::pattern::wrap_type({Co_label}); auto Ho_label = ov::pass::pattern::wrap_type({Co_activation_label, ot_label}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { @@ -551,7 +555,8 @@ ov::pass::LSTMCellFusionWithSplitWeights::LSTMCellFusionWithSplitWeights() { auto ft_mul_c_label = ov::pass::pattern::wrap_type({ft_label, c_label}); auto ct_label = ov::pass::pattern::wrap_type({ft_mul_c_label, it_mul_c1t_label}); - auto ct_activated_label = ov::pass::pattern::wrap_type({ct_label}); + auto ct_activated_label = + ov::pass::pattern::wrap_type({ct_label}); auto ht_label = ov::pass::pattern::wrap_type({ct_activated_label, ot_label}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/mark_rope_input_to_keep_in_mixed_precision.cpp b/src/common/transformations/src/transformations/common_optimizations/mark_rope_input_to_keep_in_mixed_precision.cpp index 219899ba279122..8e575d4e481dc9 100644 --- a/src/common/transformations/src/transformations/common_optimizations/mark_rope_input_to_keep_in_mixed_precision.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/mark_rope_input_to_keep_in_mixed_precision.cpp @@ -17,9 +17,10 @@ ov::pass::MarkRopeInputsToKeepInMixedPrecision::MarkRopeInputsToKeepInMixedPrecision() { MATCHER_SCOPE(MarkRopeInputsToKeepInMixedPrecision); -auto cos_tab = ov::pass::pattern::any_input(); + auto cos_tab = ov::pass::pattern::any_input(); auto sin_tab = ov::pass::pattern::any_input(); - auto rope = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), cos_tab, sin_tab}); + auto rope = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), cos_tab, sin_tab}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/matmul_experts_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/matmul_experts_fusion.cpp index c7ad459122f596..39f8a292deed0b 100644 --- a/src/common/transformations/src/transformations/common_optimizations/matmul_experts_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/matmul_experts_fusion.cpp @@ -30,22 +30,30 @@ using namespace ov::pass; ov::pass::FuseVectorizedMOE2GEMM::FuseVectorizedMOE2GEMM() { MATCHER_SCOPE(FuseVectorizedMOE2GEMM); - auto experts_input = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto experts_input = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto tile = ov::pass::pattern::wrap_type({experts_input, ov::pass::pattern::any_input()}); auto after_tile_reshape = ov::pass::pattern::wrap_type({tile, ov::pass::pattern::any_input()}); - auto gate_up_matmul = ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, - {{"transpose_a", false}, {"transpose_b", true}}); + auto gate_up_matmul = + ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, + {{"transpose_a", false}, {"transpose_b", true}}); auto gate_up_add = ov::pass::pattern::wrap_type({gate_up_matmul, ov::pass::pattern::any_input()}); // Branch 1: Slice_1 -> Clamp -> Add_1 - auto slice1 = ov::pass::pattern::wrap_type( - {gate_up_add, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto slice1 = ov::pass::pattern::wrap_type({gate_up_add, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto clamp = ov::pass::pattern::wrap_type({slice1}); auto add1 = ov::pass::pattern::wrap_type({clamp, ov::pass::pattern::wrap_const()}); // Branch 2: Slice_2 -> Minimum_1 -> Swish - auto slice2 = ov::pass::pattern::wrap_type( - {gate_up_add, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto slice2 = ov::pass::pattern::wrap_type({gate_up_add, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto minimum1 = ov::pass::pattern::wrap_type({slice2, ov::pass::pattern::wrap_const()}); auto swish_beta = ov::pass::pattern::wrap_const(); auto swish = ov::pass::pattern::wrap_type({minimum1, swish_beta}); @@ -54,22 +62,32 @@ ov::pass::FuseVectorizedMOE2GEMM::FuseVectorizedMOE2GEMM() { auto multiply2 = ov::pass::pattern::wrap_type({add1, swish}); // Down projection - auto down_proj_matmul = ov::pass::pattern::wrap_type({multiply2, ov::pass::pattern::any_input()}, - {{"transpose_a", false}, {"transpose_b", true}}); - auto down_proj_add = ov::pass::pattern::wrap_type({down_proj_matmul, ov::pass::pattern::wrap_const()}); - auto end_reshape = ov::pass::pattern::wrap_type({down_proj_add, ov::pass::pattern::any_input()}); + auto down_proj_matmul = + ov::pass::pattern::wrap_type({multiply2, ov::pass::pattern::any_input()}, + {{"transpose_a", false}, {"transpose_b", true}}); + auto down_proj_add = + ov::pass::pattern::wrap_type({down_proj_matmul, ov::pass::pattern::wrap_const()}); + auto end_reshape = + ov::pass::pattern::wrap_type({down_proj_add, ov::pass::pattern::any_input()}); // Routing weights/mask auto router_topk_indices = ov::pass::pattern::any_input(); - auto scatter_elements_update = ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(), router_topk_indices, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - - auto router_transpose = ov::pass::pattern::wrap_type({scatter_elements_update, ov::pass::pattern::any_input()}); - auto router_reshape = ov::pass::pattern::wrap_type({router_transpose, ov::pass::pattern::any_input()}); - auto unsqueeze_routing_weights = ov::pass::pattern::wrap_type({router_reshape, ov::pass::pattern::any_input()}); + auto scatter_elements_update = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), + router_topk_indices, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); + + auto router_transpose = + ov::pass::pattern::wrap_type({scatter_elements_update, ov::pass::pattern::any_input()}); + auto router_reshape = + ov::pass::pattern::wrap_type({router_transpose, ov::pass::pattern::any_input()}); + auto unsqueeze_routing_weights = + ov::pass::pattern::wrap_type({router_reshape, ov::pass::pattern::any_input()}); auto mul3 = ov::pass::pattern::wrap_type({end_reshape, unsqueeze_routing_weights}); - auto reduce_sum = ov::pass::pattern::wrap_type({mul3, ov::pass::pattern::any_input()}, {{"keep_dims", false}}); + auto reduce_sum = ov::pass::pattern::wrap_type({mul3, ov::pass::pattern::any_input()}, + {{"keep_dims", false}}); auto moe_pattern = reduce_sum; matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { @@ -127,35 +145,46 @@ ov::pass::FuseVectorizedMOE2GEMM::FuseVectorizedMOE2GEMM() { ov::pass::FuseVectorizedMOE3GEMM::FuseVectorizedMOE3GEMM() { MATCHER_SCOPE(FuseVectorizedMOE3GEMM); - auto experts_input = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto experts_input = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto tile = ov::pass::pattern::wrap_type({experts_input, ov::pass::pattern::any_input()}); auto after_tile_reshape = ov::pass::pattern::wrap_type({tile, ov::pass::pattern::any_input()}); // First GEMM (activation gate) - auto gate_matmul = ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, - {{"transpose_a", false}, {"transpose_b", true}}); + auto gate_matmul = + ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, + {{"transpose_a", false}, {"transpose_b", true}}); auto swish = ov::pass::pattern::wrap_type({gate_matmul}); // Second GEMM (up_projection) - auto up_matmul = ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, - {{"transpose_a", false}, {"transpose_b", true}}); + auto up_matmul = + ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, + {{"transpose_a", false}, {"transpose_b", true}}); // Join: Multiply (SwiGLU) auto swiglu = ov::pass::pattern::wrap_type({swish, up_matmul}); // Third GEMM (down_projection) - auto down_matmul = ov::pass::pattern::wrap_type({swiglu, ov::pass::pattern::any_input()}, - {{"transpose_a", false}, {"transpose_b", true}}); + auto down_matmul = + ov::pass::pattern::wrap_type({swiglu, ov::pass::pattern::any_input()}, + {{"transpose_a", false}, {"transpose_b", true}}); auto end_reshape = ov::pass::pattern::wrap_type({down_matmul, ov::pass::pattern::any_input()}); // Routing weights/mask auto router_topk_indices = ov::pass::pattern::any_input(); - auto scatter_elements_update = ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(), router_topk_indices, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - auto router_transpose = ov::pass::pattern::wrap_type({scatter_elements_update, ov::pass::pattern::any_input()}); - auto router_reshape = ov::pass::pattern::wrap_type({router_transpose, ov::pass::pattern::any_input()}); - auto unsqueeze_routing_weights = ov::pass::pattern::wrap_type({router_reshape, ov::pass::pattern::any_input()}); + auto scatter_elements_update = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), + router_topk_indices, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); + auto router_transpose = + ov::pass::pattern::wrap_type({scatter_elements_update, ov::pass::pattern::any_input()}); + auto router_reshape = + ov::pass::pattern::wrap_type({router_transpose, ov::pass::pattern::any_input()}); + auto unsqueeze_routing_weights = + ov::pass::pattern::wrap_type({router_reshape, ov::pass::pattern::any_input()}); auto mul3 = ov::pass::pattern::wrap_type({end_reshape, unsqueeze_routing_weights}); - auto reduce_sum = ov::pass::pattern::wrap_type({mul3, ov::pass::pattern::any_input()}, {{"keep_dims", false}}); + auto reduce_sum = ov::pass::pattern::wrap_type({mul3, ov::pass::pattern::any_input()}, + {{"keep_dims", false}}); auto moe_pattern = reduce_sum; matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/matmul_multiply_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/matmul_multiply_fusion.cpp index 488546ad345698..6063d104c84693 100644 --- a/src/common/transformations/src/transformations/common_optimizations/matmul_multiply_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/matmul_multiply_fusion.cpp @@ -152,8 +152,8 @@ pass::MatMulMultiplyFusion::MatMulMultiplyFusion() { auto input_pattern = ov::pass::pattern::any_input(); auto weights_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); auto mul_const_pattern = ov::pass::pattern::wrap_type(); - auto matmul_pattern = - ov::pass::pattern::wrap_type({input_pattern, weights_pattern}, ov::pass::pattern::consumers_count(1)); + auto matmul_pattern = ov::pass::pattern::wrap_type({input_pattern, weights_pattern}, + ov::pass::pattern::consumers_count(1)); auto mul_pattern = ov::pass::pattern::wrap_type({matmul_pattern, mul_const_pattern}); matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/moe_transpose_weights.cpp b/src/common/transformations/src/transformations/common_optimizations/moe_transpose_weights.cpp index 0fdb544deda81b..dac3516ebd517a 100644 --- a/src/common/transformations/src/transformations/common_optimizations/moe_transpose_weights.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/moe_transpose_weights.cpp @@ -34,41 +34,59 @@ using namespace ov::pass; ov::pass::VectorizedMOE2GEMMTransposeWeights::VectorizedMOE2GEMMTransposeWeights() { MATCHER_SCOPE(VectorizedMOE2GEMMTransposeWeights); - auto experts_input = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto experts_input = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto tile = ov::pass::pattern::wrap_type({experts_input, ov::pass::pattern::any_input()}); auto after_tile_reshape = ov::pass::pattern::wrap_type({tile, ov::pass::pattern::any_input()}); - auto gate_up_matmul = ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, - {{"transpose_a", false}, {"transpose_b", false}}); + auto gate_up_matmul = + ov::pass::pattern::wrap_type({after_tile_reshape, ov::pass::pattern::any_input()}, + {{"transpose_a", false}, {"transpose_b", false}}); auto gate_up_add = ov::pass::pattern::wrap_type({gate_up_matmul, ov::pass::pattern::any_input()}); - auto slice1 = ov::pass::pattern::wrap_type( - {gate_up_add, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto slice1 = ov::pass::pattern::wrap_type({gate_up_add, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto clamp = ov::pass::pattern::wrap_type({slice1}); auto add1 = ov::pass::pattern::wrap_type({clamp, ov::pass::pattern::wrap_const()}); - auto slice2 = ov::pass::pattern::wrap_type( - {gate_up_add, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto slice2 = ov::pass::pattern::wrap_type({gate_up_add, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto minimum1 = ov::pass::pattern::wrap_type({slice2, ov::pass::pattern::wrap_const()}); auto swish_beta = ov::pass::pattern::wrap_const(); auto swish = ov::pass::pattern::wrap_type({minimum1, swish_beta}); auto multiply2 = ov::pass::pattern::wrap_type({add1, swish}); - auto down_proj_matmul = ov::pass::pattern::wrap_type({multiply2, ov::pass::pattern::any_input()}, - {{"transpose_a", false}, {"transpose_b", false}}); - auto down_proj_add = ov::pass::pattern::wrap_type({down_proj_matmul, ov::pass::pattern::wrap_const()}); - auto end_reshape = ov::pass::pattern::wrap_type({down_proj_add, ov::pass::pattern::any_input()}); + auto down_proj_matmul = + ov::pass::pattern::wrap_type({multiply2, ov::pass::pattern::any_input()}, + {{"transpose_a", false}, {"transpose_b", false}}); + auto down_proj_add = + ov::pass::pattern::wrap_type({down_proj_matmul, ov::pass::pattern::wrap_const()}); + auto end_reshape = + ov::pass::pattern::wrap_type({down_proj_add, ov::pass::pattern::any_input()}); auto router_topk_indices = ov::pass::pattern::any_input(); - auto scatter_elements_update = ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(), router_topk_indices, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - - auto router_transpose = ov::pass::pattern::wrap_type({scatter_elements_update, ov::pass::pattern::any_input()}); - auto router_reshape = ov::pass::pattern::wrap_type({router_transpose, ov::pass::pattern::any_input()}); - auto unsqueeze_routing_weights = ov::pass::pattern::wrap_type({router_reshape, ov::pass::pattern::any_input()}); + auto scatter_elements_update = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), + router_topk_indices, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); + + auto router_transpose = + ov::pass::pattern::wrap_type({scatter_elements_update, ov::pass::pattern::any_input()}); + auto router_reshape = + ov::pass::pattern::wrap_type({router_transpose, ov::pass::pattern::any_input()}); + auto unsqueeze_routing_weights = + ov::pass::pattern::wrap_type({router_reshape, ov::pass::pattern::any_input()}); auto mul3 = ov::pass::pattern::wrap_type({end_reshape, unsqueeze_routing_weights}); - auto reduce_sum = ov::pass::pattern::wrap_type({mul3, ov::pass::pattern::any_input()}, {{"keep_dims", false}}); + auto reduce_sum = ov::pass::pattern::wrap_type({mul3, ov::pass::pattern::any_input()}, + {{"keep_dims", false}}); auto moe_pattern = reduce_sum; matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/mul_fake_quantize_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/mul_fake_quantize_fusion.cpp index 0ad70c126499db..577971ae9add43 100644 --- a/src/common/transformations/src/transformations/common_optimizations/mul_fake_quantize_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/mul_fake_quantize_fusion.cpp @@ -24,8 +24,8 @@ ov::pass::MulFakeQuantizeFusion::MulFakeQuantizeFusion() { MATCHER_SCOPE(MulFakeQuantizeFusion); auto input_pattern = ov::pass::pattern::any_input(); auto const_pattern = ov::pass::pattern::wrap_type(); - auto mul_pattern = - ov::pass::pattern::wrap_type({input_pattern, const_pattern}, ov::pass::pattern::consumers_count(1)); + auto mul_pattern = ov::pass::pattern::wrap_type({input_pattern, const_pattern}, + ov::pass::pattern::consumers_count(1)); auto fq_pattern = ov::pass::pattern::wrap_type({mul_pattern, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), diff --git a/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp b/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp index df444c8bb8bf75..525eed51e24940 100644 --- a/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp @@ -375,11 +375,12 @@ SIMPLE_MATCHER_PASS_DEFINITION(EliminateGather, pass::EliminateReduceReshape::EliminateReduceReshape() { MATCHER_SCOPE(EliminateReduceReshape); -auto axes = ov::pass::pattern::wrap_type(); - auto reduce_pattern = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), axes}); + auto axes = ov::pass::pattern::wrap_type(); + auto reduce_pattern = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), axes}); auto requested_shape_pattern = ov::pass::pattern::wrap_type(); - auto reshape_pattern = - ov::pass::pattern::wrap_type({reduce_pattern, requested_shape_pattern}, ov::pass::pattern::consumers_count(1)); + auto reshape_pattern = ov::pass::pattern::wrap_type({reduce_pattern, requested_shape_pattern}, + ov::pass::pattern::consumers_count(1)); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_map(); @@ -1050,7 +1051,8 @@ ov::pass::EliminateSplitConcat::EliminateSplitConcat() { pass::EliminateTranspose::EliminateTranspose() { MATCHER_SCOPE(EliminateTranspose); auto order = ov::pass::pattern::wrap_type(); - auto transpose_pattern = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), order}); + auto transpose_pattern = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), order}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_map(); @@ -1085,8 +1087,8 @@ pass::EliminateEltwise::EliminateEltwise() { auto eltwise_pattern = ov::pass::pattern::wrap_type( {input, constant_pattern}); - auto subtract_pattern = - ov::pass::pattern::wrap_type({input, ov::pass::pattern::wrap_type({constant_pattern})}); + auto subtract_pattern = ov::pass::pattern::wrap_type( + {input, ov::pass::pattern::wrap_type({constant_pattern})}); auto root = make_shared(OutputVector{eltwise_pattern, subtract_pattern}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { @@ -1108,9 +1110,9 @@ pass::EliminateEltwise::EliminateEltwise() { pass::EliminateScatterUpdate::EliminateScatterUpdate() { MATCHER_SCOPE(EliminateScatterUpdate); auto scatter_pattern = ov::pass::pattern::wrap_type(); + ov::op::v3::ScatterNDUpdate, + ov::op::v15::ScatterNDUpdate, + ov::op::v3::ScatterElementsUpdate>(); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto scatter = m.get_match_root(); @@ -1211,7 +1213,8 @@ ov::pass::EliminateStridedSlice::EliminateStridedSlice() { auto begin_const = ov::pass::pattern::wrap_type(); auto end_const = ov::pass::pattern::wrap_type(); auto optional_stride_const = ov::pass::pattern::wrap_type(); - auto pattern = ov::pass::pattern::wrap_type({input, begin_const, end_const, optional_stride_const}); + auto pattern = + ov::pass::pattern::wrap_type({input, begin_const, end_const, optional_stride_const}); ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { auto strided_slice_node = ov::as_type_ptr(m.get_match_root()); @@ -1299,7 +1302,8 @@ ov::pass::EliminateStridedSliceByShape::EliminateStridedSliceByShape() { auto begin = ov::pass::pattern::any_input(); auto end = ov::pass::pattern::any_input(); auto optional_stride_const = ov::pass::pattern::wrap_type(); - auto strided_slice = ov::pass::pattern::wrap_type({input, begin, end, optional_stride_const}); + auto strided_slice = + ov::pass::pattern::wrap_type({input, begin, end, optional_stride_const}); auto axes = ov::pass::pattern::any_input(); auto slice = ov::pass::pattern::wrap_type({input, begin, end, optional_stride_const, axes}); @@ -1350,17 +1354,18 @@ ov::pass::EliminateStridedSliceByShape::EliminateStridedSliceByShape() { ov::pass::PrepareShapeOpsForEliminationAroundBE::PrepareShapeOpsForEliminationAroundBE() { MATCHER_SCOPE(PrepareShapeOpsForEliminationAroundBE); - auto first_label = - ov::pass::pattern::wrap_type( + auto first_label = ov::pass::pattern:: + wrap_type( ov::pass::pattern::rank_equals(0)); auto other_input_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(0)); - auto binary_op_label = ov::pass::pattern::wrap_type({first_label, other_input_label}, - ov::pass::pattern::consumers_count(1)); - auto second_label = - ov::pass::pattern::wrap_type({binary_op_label, ov::pass::pattern::any_input()}, - ov::pass::pattern::rank_equals(1)); + auto binary_op_label = + ov::pass::pattern::wrap_type({first_label, other_input_label}, + ov::pass::pattern::consumers_count(1)); + auto second_label = ov::pass::pattern::wrap_type( + {binary_op_label, ov::pass::pattern::any_input()}, + ov::pass::pattern::rank_equals(1)); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_node = m.get_pattern_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp b/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp index 3c1787083a750f..adeff53d35c8db 100644 --- a/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp @@ -395,14 +395,20 @@ bool ov::pass::GroupedSliceToVSplitOptimization::run_on_model(const std::shared_ ov::pass::SliceSequenceToSingleSlice::SliceSequenceToSingleSlice() { MATCHER_SCOPE(SliceSequenceToSingleSlice); -using namespace ov::op::util; -auto const_axes_1_pattern = ov::pass::pattern::wrap_type(); + using namespace ov::op::util; + auto const_axes_1_pattern = ov::pass::pattern::wrap_type(); auto const_axes_2_pattern = ov::pass::pattern::wrap_type(); - auto slice_1_pattern = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), const_axes_1_pattern}, - ov::pass::pattern::consumers_count(1)); - auto slice_2_pattern = - ov::pass::pattern::wrap_type({slice_1_pattern, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), const_axes_2_pattern}); + auto slice_1_pattern = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + const_axes_1_pattern}, + ov::pass::pattern::consumers_count(1)); + auto slice_2_pattern = ov::pass::pattern::wrap_type({slice_1_pattern, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + const_axes_2_pattern}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/pad_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/pad_fusion.cpp index 8a1ced75d54285..def8963217414e 100644 --- a/src/common/transformations/src/transformations/common_optimizations/pad_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/pad_fusion.cpp @@ -245,7 +245,8 @@ pass::PadFusionConvolutionBackpropData::PadFusionConvolutionBackpropData() { auto pad_node_pattern = ov::pass::pattern::wrap_type( {data_pattern, pads_begin_pattern, pads_end_pattern, pad_value_pattern}, ov::pass::pattern::consumers_count(1)); - auto conv_pattern = ov::pass::pattern::wrap_type({pad_node_pattern, filter_pattern}); + auto conv_pattern = + ov::pass::pattern::wrap_type({pad_node_pattern, filter_pattern}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/pull_through_reduce.cpp b/src/common/transformations/src/transformations/common_optimizations/pull_through_reduce.cpp index 128de306c35115..adb62883ffde49 100644 --- a/src/common/transformations/src/transformations/common_optimizations/pull_through_reduce.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/pull_through_reduce.cpp @@ -112,8 +112,8 @@ ov::pass::PullUnsqueezeThroughReduce::PullUnsqueezeThroughReduce() { const auto input = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); const auto unsqueeze_axes = ov::pass::pattern::wrap_type(); - const auto unsqueeze = - ov::pass::pattern::wrap_type({input, unsqueeze_axes}, ov::pass::pattern::consumers_count(1)); + const auto unsqueeze = ov::pass::pattern::wrap_type({input, unsqueeze_axes}, + ov::pass::pattern::consumers_count(1)); const auto reduce_axes = ov::pass::pattern::wrap_type(); const auto reduce = ov::pass::pattern::wrap_type( @@ -186,8 +186,8 @@ ov::pass::PullReshapeThroughReduce::PullReshapeThroughReduce() { const auto input = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()); const auto reshape_target_shape = ov::pass::pattern::wrap_type(); - const auto reshape = - ov::pass::pattern::wrap_type({input, reshape_target_shape}, ov::pass::pattern::consumers_count(1)); + const auto reshape = ov::pass::pattern::wrap_type({input, reshape_target_shape}, + ov::pass::pattern::consumers_count(1)); const auto reduce_axes = ov::pass::pattern::wrap_type(); const auto reduce = ov::pass::pattern::wrap_type( diff --git a/src/common/transformations/src/transformations/common_optimizations/pull_transpose_through_fq.cpp b/src/common/transformations/src/transformations/common_optimizations/pull_transpose_through_fq.cpp index e8b79218e9b17d..633b3dcc7abe96 100644 --- a/src/common/transformations/src/transformations/common_optimizations/pull_transpose_through_fq.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/pull_transpose_through_fq.cpp @@ -22,13 +22,15 @@ ov::pass::PullTransposeThroughFQUp::PullTransposeThroughFQUp() { MATCHER_SCOPE(PullTransposeThroughFQUp); const auto weights = ov::pass::pattern::wrap_type(); - const auto convert_p = ov::pass::pattern::optional(weights, ov::pass::pattern::consumers_count(1)); - auto m_fq = ov::pass::pattern::wrap_type({convert_p, - ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}, - ov::pass::pattern::consumers_count(1)); + const auto convert_p = + ov::pass::pattern::optional(weights, ov::pass::pattern::consumers_count(1)); + auto m_fq = ov::pass::pattern::wrap_type( + {convert_p, + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}, + ov::pass::pattern::consumers_count(1)); auto m_transpose_perm = ov::pass::pattern::wrap_type(); auto m_transpose = ov::pass::pattern::wrap_type({m_fq, m_transpose_perm}); diff --git a/src/common/transformations/src/transformations/common_optimizations/reduce_merge.cpp b/src/common/transformations/src/transformations/common_optimizations/reduce_merge.cpp index 592c5da8265bca..6e54e39ab5435b 100644 --- a/src/common/transformations/src/transformations/common_optimizations/reduce_merge.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/reduce_merge.cpp @@ -116,14 +116,14 @@ pass::ReduceMerge::ReduceMerge() { auto reduce_sum_pattern = create_pattern(); auto pattern = std::make_shared(OutputVector{reducel1_pattern, - reducel2_pattern, - reduce_log_and_pattern, - reduce_log_or_pattern, - reduce_max_pattern, - reduce_mean_pattern, - reduce_min_pattern, - reduce_prod_pattern, - reduce_sum_pattern}); + reducel2_pattern, + reduce_log_and_pattern, + reduce_log_or_pattern, + reduce_max_pattern, + reduce_mean_pattern, + reduce_min_pattern, + reduce_prod_pattern, + reduce_sum_pattern}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto node = m.get_match_root(); diff --git a/src/common/transformations/src/transformations/common_optimizations/reduce_reshape_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/reduce_reshape_fusion.cpp index cb156c47ee8aeb..155c1d36aac829 100644 --- a/src/common/transformations/src/transformations/common_optimizations/reduce_reshape_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/reduce_reshape_fusion.cpp @@ -27,8 +27,8 @@ ov::pass::ReduceReshapeFusion::ReduceReshapeFusion() { ov::pass::pattern::wrap_type( {ov::pass::pattern::any_input(), reduce_axes}, ov::pass::pattern::consumers_count(1)); - const auto reshape = - ov::pass::pattern::wrap_type({reduce, ov::pass::pattern::any_input()}, ov::pass::pattern::has_static_shape()); + const auto reshape = ov::pass::pattern::wrap_type({reduce, ov::pass::pattern::any_input()}, + ov::pass::pattern::has_static_shape()); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/relu_fake_quantize_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/relu_fake_quantize_fusion.cpp index 5c9090f65ac7fe..3df557eb9b9e55 100644 --- a/src/common/transformations/src/transformations/common_optimizations/relu_fake_quantize_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/relu_fake_quantize_fusion.cpp @@ -19,7 +19,8 @@ ov::pass::ReluFakeQuantizeFusion::ReluFakeQuantizeFusion() { MATCHER_SCOPE(ReluFakeQuantizeFusion); auto data_pattern = ov::pass::pattern::any_input(); - auto relu_pattern = ov::pass::pattern::wrap_type({data_pattern}, ov::pass::pattern::consumers_count(1)); + auto relu_pattern = + ov::pass::pattern::wrap_type({data_pattern}, ov::pass::pattern::consumers_count(1)); auto input_low_pattern = ov::pass::pattern::wrap_type(); auto fq_pattern = ov::pass::pattern::wrap_type({relu_pattern, input_low_pattern, diff --git a/src/common/transformations/src/transformations/common_optimizations/reshape_sequence_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/reshape_sequence_fusion.cpp index 11a166a387abc8..ed0bd2bddd3b19 100644 --- a/src/common/transformations/src/transformations/common_optimizations/reshape_sequence_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/reshape_sequence_fusion.cpp @@ -64,8 +64,8 @@ ov::pass::ReshapeSequenceFusion::ReshapeSequenceFusion(bool use_shape_for_elimin MATCHER_SCOPE(ReshapeSequenceFusion); auto reshape_input = ov::pass::pattern::any_input(); auto reshape_a_pattern = ov::pass::pattern::wrap_type(); - auto reshape_a = - ov::pass::pattern::wrap_type({reshape_input, reshape_a_pattern}, ov::pass::pattern::consumers_count(1)); + auto reshape_a = ov::pass::pattern::wrap_type({reshape_input, reshape_a_pattern}, + ov::pass::pattern::consumers_count(1)); auto reshape_b_pattern = ov::pass::pattern::any_input(); auto reshape_b = ov::pass::pattern::wrap_type({reshape_a, reshape_b_pattern}); diff --git a/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp index c36f4f48557616..fd6efa50226e20 100644 --- a/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp @@ -346,7 +346,8 @@ class Binary : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::prop::Binary"); Binary() { MATCHER_SCOPE(Binary); - auto pattern_root = ov::pass::pattern::wrap_type(); + auto pattern_root = + ov::pass::pattern::wrap_type(); auto callback = [=](ov::pass::pattern::Matcher& m) { const auto& root = m.get_match_root(); @@ -530,9 +531,9 @@ class PassThrough : public ov::pass::MatcherPass { PassThrough() { MATCHER_SCOPE(PassThrough); auto pattern_root = ov::pass::pattern::wrap_type(); + ov::op::v0::Convert, + ov::op::util::PadBase, + ov::op::v0::PRelu>(); auto callback = [=](ov::pass::pattern::Matcher& m) { auto root = m.get_match_root(); @@ -643,7 +644,8 @@ class EraseSplitConcat : public ov::pass::MatcherPass { MATCHER_SCOPE(EraseSplitConcat); auto input_p = ov::pass::pattern::any_input(); auto split_p = ov::pass::pattern::wrap_type({input_p, ov::pass::pattern::any_input()}); - auto pattern_root = ov::pass::pattern::wrap_type({split_p, split_p, split_p}, need_to_erase_ric); + auto pattern_root = + ov::pass::pattern::wrap_type({split_p, split_p, split_p}, need_to_erase_ric); auto callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -664,9 +666,9 @@ class EraseGather : public ov::pass::MatcherPass { EraseGather() { MATCHER_SCOPE(EraseGather); auto input_p = ov::pass::pattern::any_input(); - auto pattern_root = - ov::pass::pattern::wrap_type({input_p, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, - need_to_erase_ric); + auto pattern_root = ov::pass::pattern::wrap_type( + {input_p, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, + need_to_erase_ric); auto callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); auto output = pattern_map.at(pattern_root); @@ -687,19 +689,20 @@ class Binary : public ov::pass::MatcherPass { OPENVINO_MATCHER_PASS_RTTI("pass::back_prop::Binary"); Binary() { MATCHER_SCOPE(Binary); - auto fake_quantize_pattern = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())}, - ov::pass::pattern::has_static_rank()); + auto fake_quantize_pattern = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())}, + ov::pass::pattern::has_static_rank()); auto binary_elementwise_pattern = ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())}, ov::pass::pattern::has_static_rank()); - auto pattern_root = - std::make_shared(OutputVector{fake_quantize_pattern, binary_elementwise_pattern}); + auto pattern_root = std::make_shared( + OutputVector{fake_quantize_pattern, binary_elementwise_pattern}); auto callback = [=](ov::pass::pattern::Matcher& m) { const auto& root = m.get_match_root(); diff --git a/src/common/transformations/src/transformations/common_optimizations/rms_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/rms_fusion.cpp index ca5ccee79f45ab..d4d70421ed3d43 100644 --- a/src/common/transformations/src/transformations/common_optimizations/rms_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/rms_fusion.cpp @@ -38,7 +38,7 @@ static std::function)> constant_value(const float targ } RMSFusion::RMSFusion(bool force_tail_convert, bool enable_div_x) { -// Detect RMS decomposition pattern + // Detect RMS decomposition pattern // x * 1/Sqrt(ReduceMean(x^2,axes)+eps) * gamma auto x = ov::pass::pattern::any_input(); diff --git a/src/common/transformations/src/transformations/common_optimizations/sdpa_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/sdpa_fusion.cpp index 90396627d1702a..6e65400c0c21ab 100644 --- a/src/common/transformations/src/transformations/common_optimizations/sdpa_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/sdpa_fusion.cpp @@ -101,26 +101,37 @@ bool SDPAFusion::run_on_model(const std::shared_ptr& model) { SDPAReshapeFusion::SDPAReshapeFusion() { MATCHER_SCOPE(SDPAReshapeFusion); -auto q = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("Batches..., S_q, D")); - auto k = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("AnyLayout...") && ov::pass::pattern::rank_more_than(2)); - auto v = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("Batches..., S_kv, D") && check_layout("AnyLayout")); + auto q = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("Batches..., S_q, D")); + auto k = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("AnyLayout...") && + ov::pass::pattern::rank_more_than(2)); + auto v = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("Batches..., S_kv, D") && + check_layout("AnyLayout")); auto mask = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); // these Reshape/Unsqueeze may already exist in the graph - auto unsq_q = ov::pass::pattern::wrap_type({q, ov::pass::pattern::any_input()}); - auto unsq_k = ov::pass::pattern::wrap_type({k, ov::pass::pattern::any_input()}); - auto unsq_v = ov::pass::pattern::wrap_type({v, ov::pass::pattern::any_input()}); + auto unsq_q = + ov::pass::pattern::wrap_type({q, ov::pass::pattern::any_input()}); + auto unsq_k = + ov::pass::pattern::wrap_type({k, ov::pass::pattern::any_input()}); + auto unsq_v = + ov::pass::pattern::wrap_type({v, ov::pass::pattern::any_input()}); // this Transpose may already exist in the graph - auto opt_original_transpose_k = ov::pass::pattern::optional({unsq_k, ov::pass::pattern::any_input()}); + auto opt_original_transpose_k = + ov::pass::pattern::optional({unsq_k, ov::pass::pattern::any_input()}); // these Reshape/Unsqueeze may be inserted by SDPAFusionMatcher - auto opt_unsq_q = ov::pass::pattern::optional({unsq_q, ov::pass::pattern::any_input()}); - auto opt_unsq_k = ov::pass::pattern::optional({opt_original_transpose_k, ov::pass::pattern::any_input()}); - auto opt_unsq_v = ov::pass::pattern::optional({unsq_v, ov::pass::pattern::any_input()}); + auto opt_unsq_q = ov::pass::pattern::optional( + {unsq_q, ov::pass::pattern::any_input()}); + auto opt_unsq_k = ov::pass::pattern::optional( + {opt_original_transpose_k, ov::pass::pattern::any_input()}); + auto opt_unsq_v = ov::pass::pattern::optional( + {unsq_v, ov::pass::pattern::any_input()}); // this Transpose may be inserted by SDPAFusionMatcher - auto opt_transpose_k = ov::pass::pattern::optional({opt_unsq_k, ov::pass::pattern::any_input()}, ov::pass::pattern::shape_matches("..., S_kv, D")); + auto opt_transpose_k = + ov::pass::pattern::optional({opt_unsq_k, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("..., S_kv, D")); auto sdpa_pattern = ov::pass::pattern::wrap_type({ opt_unsq_q, @@ -130,9 +141,11 @@ auto q = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("Batches. ov::pass::pattern::any_input(), }); - auto opt_sdpa_reshape = ov::pass::pattern::optional({sdpa_pattern, ov::pass::pattern::any_input()}); - auto post_sdpa = - ov::pass::pattern::wrap_type({opt_sdpa_reshape, ov::pass::pattern::any_input()}, ov::pass::pattern::shape_matches("Batches..., S_q, D")); + auto opt_sdpa_reshape = ov::pass::pattern::optional( + {sdpa_pattern, ov::pass::pattern::any_input()}); + auto post_sdpa = ov::pass::pattern::wrap_type( + {opt_sdpa_reshape, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("Batches..., S_q, D")); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pm = m.get_pattern_value_map(); @@ -222,9 +235,10 @@ static std::shared_ptr get_scale(std::shared_ptr scale_patte return nullptr; } else { if (rank.get_length() > 1) { - scale_node = ov::op::util::make_try_fold(scale_node, - ov::op::v0::Constant::create(ov::element::i64, {1}, {1}), - false); + scale_node = ov::op::util::make_try_fold( + scale_node, + ov::op::v0::Constant::create(ov::element::i64, {1}, {1}), + false); } return scale_node.get_node_shared_ptr(); } @@ -334,7 +348,7 @@ static ov::OutputVector get_qkv(ov::OutputVector qkv, SDPAFusionMatcher::SDPAFusionMatcher() { MATCHER_SCOPE(SDPAFusionMatcher); -/* + /* * Corner Case: Dynamic Mask and Attention Scores * When the mask and the attention scores (after MatMul) have [..., -1, -1] shapes, * we cannot automatically determine symbols and propogate them. @@ -357,20 +371,30 @@ SDPAFusionMatcher::SDPAFusionMatcher() { return true; }; - auto q = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, S_q, E") || ov::pass::pattern::shape_matches("S_q, E")); - auto k = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, S_kv, E") || ov::pass::pattern::shape_matches("S_kv, E")); - auto kT = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, E, S_kv") || ov::pass::pattern::shape_matches("E, S_kv")); - auto v = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, S_kv, Ev") || ov::pass::pattern::shape_matches("S_kv, Ev")); + auto q = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, S_q, E") || + ov::pass::pattern::shape_matches("S_q, E")); + auto k = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, S_kv, E") || + ov::pass::pattern::shape_matches("S_kv, E")); + auto kT = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, E, S_kv") || + ov::pass::pattern::shape_matches("E, S_kv")); + auto v = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("..., H, S_kv, Ev") || + ov::pass::pattern::shape_matches("S_kv, Ev")); auto attn_scale = ov::pass::pattern::any_input(); auto opt_k_scale = ov::pass::pattern::optional({k, attn_scale}); auto opt_kT_scale = ov::pass::pattern::optional({kT, attn_scale}); - auto qk_pred = (ov::pass::pattern::shape_matches("..., H, S_q, S_kv") || ov::pass::pattern::shape_matches("S_q, S_kv")) && ov::pass::pattern::consumers_count(1); - auto qk = ov::pass::pattern::wrap_type({q, opt_kT_scale}, qk_pred, {{"transpose_a", false}, {"transpose_b", false}}); + auto qk_pred = + (ov::pass::pattern::shape_matches("..., H, S_q, S_kv") || ov::pass::pattern::shape_matches("S_q, S_kv")) && + ov::pass::pattern::consumers_count(1); + auto qk = ov::pass::pattern::wrap_type({q, opt_kT_scale}, + qk_pred, + {{"transpose_a", false}, {"transpose_b", false}}); auto qk_transpose_b = - ov::pass::pattern::wrap_type({q, opt_k_scale}, qk_pred, {{"transpose_a", false}, {"transpose_b", true}}); + ov::pass::pattern::wrap_type({q, opt_k_scale}, + qk_pred, + {{"transpose_a", false}, {"transpose_b", true}}); auto qk_alternatives = qk | qk_transpose_b; // Optional unsqueeze that is converted to Reshape @@ -386,11 +410,14 @@ SDPAFusionMatcher::SDPAFusionMatcher() { // 3. Mask add // 4. Reshape after adding mask auto mask = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); - auto qk_opt_scaled_pre_mask_opt_reshaped = ov::pass::pattern::optional({qk_opt_scaled, ov::pass::pattern::any_input()}); + auto qk_opt_scaled_pre_mask_opt_reshaped = + ov::pass::pattern::optional({qk_opt_scaled, ov::pass::pattern::any_input()}); auto add_pred = ov::pass::pattern::consumers_count(1) && corner_case_check; - auto qk_opt_scaled_opt_mask_added = ov::pass::pattern::optional({qk_opt_scaled_pre_mask_opt_reshaped, mask}, add_pred); - auto qk_post_mask_opt_reshaped = ov::pass::pattern::optional({qk_opt_scaled_opt_mask_added, ov::pass::pattern::any_input()}); + auto qk_opt_scaled_opt_mask_added = + ov::pass::pattern::optional({qk_opt_scaled_pre_mask_opt_reshaped, mask}, add_pred); + auto qk_post_mask_opt_reshaped = ov::pass::pattern::optional( + {qk_opt_scaled_opt_mask_added, ov::pass::pattern::any_input()}); // Softmax axis can be: // Pattern 1: axis = -1 (last axis) @@ -406,13 +433,16 @@ SDPAFusionMatcher::SDPAFusionMatcher() { return static_cast(input_rank.get_length() - 1) == axis; }); auto softmax_pred = - ov::pass::pattern::consumers_count(1) && axis_predicate && (ov::pass::pattern::shape_matches("..., H, S_q, S_kv") || ov::pass::pattern::shape_matches("S_q, S_kv")); + ov::pass::pattern::consumers_count(1) && axis_predicate && + (ov::pass::pattern::shape_matches("..., H, S_q, S_kv") || ov::pass::pattern::shape_matches("S_q, S_kv")); auto softmax = ov::pass::pattern::wrap_type({qk_post_mask_opt_reshaped}, softmax_pred); - auto softmax_opt_reshaped = ov::pass::pattern::optional({softmax, ov::pass::pattern::any_input()}); + auto softmax_opt_reshaped = + ov::pass::pattern::optional({softmax, ov::pass::pattern::any_input()}); auto qkv_shape = ov::pass::pattern::shape_matches("..., H, S_q, Ev") || ov::pass::pattern::shape_matches("S_q, Ev"); - auto qkv = - ov::pass::pattern::wrap_type({softmax_opt_reshaped, v}, qkv_shape, {{"transpose_a", false}, {"transpose_b", false}}); + auto qkv = ov::pass::pattern::wrap_type({softmax_opt_reshaped, v}, + qkv_shape, + {{"transpose_a", false}, {"transpose_b", false}}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pm = m.get_pattern_value_map(); @@ -447,8 +477,12 @@ SDPAFusionMatcher::SDPAFusionMatcher() { if (qkv.size() == 0) return false; - std::shared_ptr sdpa = - std::make_shared(qkv[0], qkv[1], qkv[2], mask_input, scale_node, false); + std::shared_ptr sdpa = std::make_shared(qkv[0], + qkv[1], + qkv[2], + mask_input, + scale_node, + false); sdpa->set_friendly_name(m.get_match_root()->get_friendly_name()); ov::copy_runtime_info(m.get_matched_nodes(), sdpa); ov::replace_node(m.get_match_root(), sdpa); @@ -461,12 +495,14 @@ SDPAFusionMatcher::SDPAFusionMatcher() { SDPAFusionMatcherSinks::SDPAFusionMatcherSinks() { MATCHER_SCOPE(SDPAFusionMatcherSinks); -auto v = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto v = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto k = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto q = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto qk_transpose_b = - ov::pass::pattern::wrap_type({q, k}, ov::pass::pattern::consumers_count(1), {{"transpose_a", false}, {"transpose_b", true}}); + ov::pass::pattern::wrap_type({q, k}, + ov::pass::pattern::consumers_count(1), + {{"transpose_a", false}, {"transpose_b", true}}); auto attn_scale = ov::pass::pattern::any_input(); auto opt_qk_scaled = ov::pass::pattern::optional({qk_transpose_b, attn_scale}); @@ -497,8 +533,14 @@ auto v = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto softmax_pred = ov::pass::pattern::consumers_count(1) && axis_predicate; auto softmax = ov::pass::pattern::wrap_type({sinks_sub}, softmax_pred); - auto sinks_slice = ov::pass::pattern::wrap_type({softmax, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}) | - ov::pass::pattern::wrap_type({softmax, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto sinks_slice = + ov::pass::pattern::wrap_type( + {softmax, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}) | + ov::pass::pattern::wrap_type({softmax, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto qkv = ov::pass::pattern::wrap_type({sinks_slice, v}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { @@ -534,15 +576,19 @@ auto v = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); if (sinks_present) { const auto& sinks_node = pm.at(sinks); sdpa = std::make_shared(qkv[0], - qkv[1], - qkv[2], - mask_input, - scale_node, - sinks_node, - false); + qkv[1], + qkv[2], + mask_input, + scale_node, + sinks_node, + false); } else { - sdpa = - std::make_shared(qkv[0], qkv[1], qkv[2], mask_input, scale_node, false); + sdpa = std::make_shared(qkv[0], + qkv[1], + qkv[2], + mask_input, + scale_node, + false); } sdpa->set_friendly_name(m.get_match_root()->get_friendly_name()); ov::copy_runtime_info(m.get_matched_nodes(), sdpa); diff --git a/src/common/transformations/src/transformations/common_optimizations/sdpa_scale_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/sdpa_scale_fusion.cpp index e40a0a5bad8622..830fb5deaca405 100644 --- a/src/common/transformations/src/transformations/common_optimizations/sdpa_scale_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/sdpa_scale_fusion.cpp @@ -35,21 +35,25 @@ bool SDPAScaleFusion::run_on_model(const std::shared_ptr& model) { } SDPAScaleFusionPass::SDPAScaleFusionPass() { -auto q = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); + auto q = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto k = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto v = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto mask = ov::pass::pattern::any_input(); auto sdpa_scale = ov::pass::pattern::wrap_const(); - auto scale_q = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[]") || ov::pass::pattern::shape_matches("[1]")); - auto scale_k = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[]") || ov::pass::pattern::shape_matches("[1]")); + auto scale_q = + ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[]") || ov::pass::pattern::shape_matches("[1]")); + auto scale_k = + ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[]") || ov::pass::pattern::shape_matches("[1]")); auto scaled_q = ov::pass::pattern::optional({q, scale_q}); auto scaled_k = ov::pass::pattern::optional({k, scale_k}); - auto sdpa_mask_scale = ov::pass::pattern::wrap_type({scaled_q, scaled_k, v, mask, sdpa_scale}, + auto sdpa_mask_scale = + ov::pass::pattern::wrap_type({scaled_q, scaled_k, v, mask, sdpa_scale}, {{"causal", false}}); - auto sdpa_mask = - ov::pass::pattern::wrap_type({scaled_q, scaled_k, v, mask}, {{"causal", false}}); - auto sdpa_simple = ov::pass::pattern::wrap_type({scaled_q, scaled_k, v}, {{"causal", false}}); + auto sdpa_mask = ov::pass::pattern::wrap_type({scaled_q, scaled_k, v, mask}, + {{"causal", false}}); + auto sdpa_simple = ov::pass::pattern::wrap_type({scaled_q, scaled_k, v}, + {{"causal", false}}); auto sdpa = sdpa_simple | sdpa_mask | sdpa_mask_scale; ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/common_optimizations/simplify_shape_of_sub_graph.cpp b/src/common/transformations/src/transformations/common_optimizations/simplify_shape_of_sub_graph.cpp index d668a2d2bafafe..ae3f98c31d7e85 100644 --- a/src/common/transformations/src/transformations/common_optimizations/simplify_shape_of_sub_graph.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/simplify_shape_of_sub_graph.cpp @@ -42,7 +42,8 @@ pass::GroupedGatherElimination::GroupedGatherElimination() { while (inputs.size() > i + 1) { auto curr = inputs[i].get_node_shared_ptr(), next = inputs[i + 1].get_node_shared_ptr(); if (curr->get_type_info() != next->get_type_info() || - (!is_type(curr) && !is_type(curr) && !is_type(curr)) || + (!is_type(curr) && !is_type(curr) && + !is_type(curr)) || (curr->input_value(0) != next->input_value(0))) { ++i; continue; @@ -76,21 +77,24 @@ pass::GroupedGatherElimination::GroupedGatherElimination() { } // curr and next are the same type of gather which takes data from the same source - auto joint_indices = - new_ops.add(ov::op::util::make_try_fold(OutputVector{curr_indices, next_indices}, 0)); + auto joint_indices = new_ops.add( + ov::op::util::make_try_fold(OutputVector{curr_indices, next_indices}, 0)); std::shared_ptr new_gather; if (is_type(curr)) { - new_gather = register_new_node(curr->input_value(0), - joint_indices->output(0), - ov::op::v0::Constant::create(element::i64, {}, {0})->output(0)); + new_gather = register_new_node( + curr->input_value(0), + joint_indices->output(0), + ov::op::v0::Constant::create(element::i64, {}, {0})->output(0)); } else if (is_type(curr)) { - new_gather = register_new_node(curr->input_value(0), - joint_indices->output(0), - ov::op::v0::Constant::create(element::i64, {}, {0})->output(0)); + new_gather = register_new_node( + curr->input_value(0), + joint_indices->output(0), + ov::op::v0::Constant::create(element::i64, {}, {0})->output(0)); } else if (is_type(curr)) { - new_gather = register_new_node(curr->input_value(0), - joint_indices->output(0), - ov::op::v0::Constant::create(element::i64, {}, {0})->output(0)); + new_gather = register_new_node( + curr->input_value(0), + joint_indices->output(0), + ov::op::v0::Constant::create(element::i64, {}, {0})->output(0)); } else { OPENVINO_THROW("Unexpected Gather version"); } @@ -119,7 +123,9 @@ pass::GroupedGatherElimination::GroupedGatherElimination() { pass::GatherNopElimination::GatherNopElimination() { MATCHER_SCOPE(GatherNopElimination); const auto gather_label = ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}); + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}); matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto gather = m.get_match_root(); @@ -186,8 +192,10 @@ pass::SimplifyGatherShapeOf::SimplifyGatherShapeOf() { const auto data_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); const auto indices_pattern = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); const auto axis_pattern = ov::pass::pattern::wrap_type(); - const auto gather_pattern = ov::pass::pattern::wrap_type({data_pattern, indices_pattern, axis_pattern}); - const auto shape_of_pattern = ov::pass::pattern::wrap_type({gather_pattern}); + const auto gather_pattern = + ov::pass::pattern::wrap_type({data_pattern, indices_pattern, axis_pattern}); + const auto shape_of_pattern = + ov::pass::pattern::wrap_type({gather_pattern}); matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); @@ -201,7 +209,8 @@ pass::SimplifyGatherShapeOf::SimplifyGatherShapeOf() { auto zero_axis = ov::op::v0::Constant::create(element::i64, Shape{}, {0}); NodeVector new_ops; - auto new_shapeof = std::make_shared(gather->input_value(0), node->get_output_element_type(0)); + auto new_shapeof = + std::make_shared(gather->input_value(0), node->get_output_element_type(0)); new_ops.push_back(new_shapeof); std::shared_ptr replace_op; if (indices_rank.get_length() == 0) { diff --git a/src/common/transformations/src/transformations/common_optimizations/softplus_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/softplus_fusion.cpp index eaeabfaa7f5942..d516fced2eb884 100644 --- a/src/common/transformations/src/transformations/common_optimizations/softplus_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/softplus_fusion.cpp @@ -22,8 +22,8 @@ ov::pass::SoftPlusFusion::SoftPlusFusion() { // fuses ln(exp(x) + 1.0) operations into SoftPlus(x) auto input = ov::pass::pattern::any_input(); auto exp = std::make_shared(input); - auto add_constant = - ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any({element::f32, element::f16})); + auto add_constant = ov::pass::pattern::wrap_type( + ov::pass::pattern::type_matches_any({element::f32, element::f16})); auto add = std::make_shared(exp, add_constant); auto log = std::make_shared(add); diff --git a/src/common/transformations/src/transformations/common_optimizations/space_to_batch_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/space_to_batch_fusion.cpp index 2db5cdc0ed21e2..cdf33eeb7bb397 100644 --- a/src/common/transformations/src/transformations/common_optimizations/space_to_batch_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/space_to_batch_fusion.cpp @@ -23,12 +23,12 @@ ov::pass::SpaceToBatchFusion::SpaceToBatchFusion() { MATCHER_SCOPE(SpaceToBatchFusion); auto data_pattern = ov::pass::pattern::any_input(); - auto reshape_before_pattern = - ov::pass::pattern::wrap_type({data_pattern, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(4)); - auto trans_before_pattern = - ov::pass::pattern::wrap_type({data_pattern, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(4)); + auto reshape_before_pattern = ov::pass::pattern::wrap_type( + {data_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); + auto trans_before_pattern = ov::pass::pattern::wrap_type( + {data_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto reshape_or_transpose_before_pattern = std::make_shared(OutputVector{reshape_before_pattern, trans_before_pattern}); auto pads_begin_pattern = ov::pass::pattern::wrap_type(); @@ -38,12 +38,12 @@ ov::pass::SpaceToBatchFusion::SpaceToBatchFusion() { {reshape_or_transpose_before_pattern, pads_begin_pattern, pads_end_pattern, pad_value}); auto space_to_depth_pattern = ov::pass::pattern::wrap_type({pad_pattern}, ov::pass::pattern::has_static_shape()); - auto reshape_after_pattern = - ov::pass::pattern::wrap_type({space_to_depth_pattern, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(4)); - auto trans_after_pattern = - ov::pass::pattern::wrap_type({space_to_depth_pattern, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(4)); + auto reshape_after_pattern = ov::pass::pattern::wrap_type( + {space_to_depth_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); + auto trans_after_pattern = ov::pass::pattern::wrap_type( + {space_to_depth_pattern, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(4)); auto reshape_or_transpose_after_pattern = std::make_shared(OutputVector{reshape_after_pattern, trans_after_pattern}); diff --git a/src/common/transformations/src/transformations/common_optimizations/strides_optimization.cpp b/src/common/transformations/src/transformations/common_optimizations/strides_optimization.cpp index c3b47556046cbf..4c9c5924ead3eb 100644 --- a/src/common/transformations/src/transformations/common_optimizations/strides_optimization.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/strides_optimization.cpp @@ -171,8 +171,8 @@ ov::pass::ConvStridesPropagation::ConvStridesPropagation() { ov::pass::SupportedNodesStridesPropagation::SupportedNodesStridesPropagation() { MATCHER_SCOPE(SupportedNodesStridesPropagation); - auto root = - ov::pass::pattern::wrap_type(); + auto root = ov::pass::pattern::wrap_type(); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); diff --git a/src/common/transformations/src/transformations/common_optimizations/transpose_sinking.cpp b/src/common/transformations/src/transformations/common_optimizations/transpose_sinking.cpp index 5459846648e090..10a85a80ac14f1 100644 --- a/src/common/transformations/src/transformations/common_optimizations/transpose_sinking.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/transpose_sinking.cpp @@ -82,9 +82,9 @@ ov::pass::TransposeEltwise::TransposeEltwise() { [](const Output& output) { return ov::is_preprocesing_node(output.get_node_shared_ptr()); }); - auto transpose_p = - ov::pass::pattern::wrap_type({eltwise_p, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::consumers_count(1)); + auto transpose_p = ov::pass::pattern::wrap_type( + {eltwise_p, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); auto callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); @@ -125,9 +125,9 @@ ov::pass::TransposeEltwise::TransposeEltwise() { ov::pass::TransposeConvert::TransposeConvert() { MATCHER_SCOPE(TransposeConvert); - auto transpose_label = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, - ov::pass::pattern::consumers_count(1)); + auto transpose_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); auto convert_label = ov::pass::pattern::wrap_type({transpose_label}); matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { @@ -152,13 +152,13 @@ ov::pass::TransposeConvert::TransposeConvert() { ov::pass::TransposeReduction::TransposeReduction() { MATCHER_SCOPE(TransposeReduction); - auto transpose_label = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, - ov::pass::pattern::consumers_count(1)); - auto reduce_or_squeeze_label = - ov::pass::pattern::wrap_type({transpose_label, ov::pass::pattern::wrap_type()}); + auto transpose_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); + auto reduce_or_squeeze_label = ov::pass::pattern::wrap_type( + {transpose_label, ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); @@ -223,17 +223,18 @@ ov::pass::TransposeReduction::TransposeReduction() { ov::pass::TransposeFQReduction::TransposeFQReduction() { MATCHER_SCOPE(TransposeFQReduction); - auto transpose_label = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); - auto fq_label = ov::pass::pattern::wrap_type({transpose_label, - ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())}); - auto reduce_or_squeeze_label = - ov::pass::pattern::wrap_type({fq_label, ov::pass::pattern::wrap_type()}); + auto transpose_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); + auto fq_label = ov::pass::pattern::wrap_type( + {transpose_label, + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())}); + auto reduce_or_squeeze_label = ov::pass::pattern::wrap_type( + {fq_label, ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto& pattern_to_output = m.get_pattern_value_map(); @@ -293,11 +294,11 @@ ov::pass::TransposeFQReduction::TransposeFQReduction() { ov::pass::TransposeFuse::TransposeFuse() { MATCHER_SCOPE(TransposeFuse); - auto transpose_1 = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, - ov::pass::pattern::consumers_count(1)); - auto transpose_2 = - ov::pass::pattern::wrap_type({transpose_1, ov::pass::pattern::wrap_type()}); + auto transpose_1 = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + ov::pass::pattern::consumers_count(1)); + auto transpose_2 = ov::pass::pattern::wrap_type( + {transpose_1, ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/common_optimizations/transpose_to_reshape.cpp b/src/common/transformations/src/transformations/common_optimizations/transpose_to_reshape.cpp index 7be837620f5e3b..9df267bc5398d0 100644 --- a/src/common/transformations/src/transformations/common_optimizations/transpose_to_reshape.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/transpose_to_reshape.cpp @@ -25,7 +25,8 @@ ov::pass::TransposeToReshape::TransposeToReshape() { MATCHER_SCOPE(TransposeToReshape); auto transpose_label = ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), ov::pass::pattern::wrap_type()}); + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { auto transpose = m.get_match_root(); auto data = transpose->input_value(0); diff --git a/src/common/transformations/src/transformations/common_optimizations/weights_dequantize_to_fake_quantize.cpp b/src/common/transformations/src/transformations/common_optimizations/weights_dequantize_to_fake_quantize.cpp index fc0437ed587fa4..81eb00eb28b18f 100644 --- a/src/common/transformations/src/transformations/common_optimizations/weights_dequantize_to_fake_quantize.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/weights_dequantize_to_fake_quantize.cpp @@ -19,9 +19,11 @@ ov::pass::WeightsDequantizeToFakeQuantize::WeightsDequantizeToFakeQuantize() { MATCHER_SCOPE(WeightsDequantizeToFakeQuantize); - const auto weights = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::i8)); + const auto weights = + ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::i8)); const auto convert = ov::pass::pattern::wrap_type({weights}); - const auto sub_c_integer = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::i8)); + const auto sub_c_integer = + ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::i8)); const auto convert_sub_c_integer = ov::pass::pattern::wrap_type({sub_c_integer}); const auto sub_integer = ov::pass::pattern::wrap_type({convert, convert_sub_c_integer}); const auto sub_c = ov::pass::pattern::wrap_type(); diff --git a/src/common/transformations/src/transformations/fp16_compression/mark_floatpoint_range.cpp b/src/common/transformations/src/transformations/fp16_compression/mark_floatpoint_range.cpp index ab5f1a9f3cd1cc..cc6263a480929c 100644 --- a/src/common/transformations/src/transformations/fp16_compression/mark_floatpoint_range.cpp +++ b/src/common/transformations/src/transformations/fp16_compression/mark_floatpoint_range.cpp @@ -33,16 +33,16 @@ void ov::pass::erase_range_path(const std::shared_ptr& node) { ov::pass::MarkFloatingPointRange::MarkFloatingPointRange() { MATCHER_SCOPE(MarkFloatingPointRange); -// through these nodes + // through these nodes const auto range_propagating_nodes = ov::pass::pattern::wrap_type(); + ov::op::v1::Greater, + ov::op::v1::GreaterEqual, + ov::op::v1::Less, + ov::op::v1::LessEqual, + ov::op::v1::Reshape, + ov::op::v4::Range, + ov::op::v0::Squeeze, + ov::op::v0::Unsqueeze>(); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); diff --git a/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp b/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp index fdf65ab389398e..4b525a753141f0 100644 --- a/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp +++ b/src/common/transformations/src/transformations/fp16_compression/mark_subgraphs_to_keep_in_mixed_precision.cpp @@ -88,25 +88,25 @@ void erase_fq_path(const std::shared_ptr& node) { // Marking continues to propagate through these ops. const std::shared_ptr propagate_through_ops = ov::pass::pattern::wrap_type(); + ov::op::v0::Unsqueeze, + ov::op::v1::Reshape, + op::util::BroadcastBase, + op::util::BinaryElementwiseArithmetic, + op::util::UnaryElementwiseArithmetic, + ov::op::v6::MVN, + ov::op::v0::MVN, + ov::op::v0::NormalizeL2, + ov::op::v0::Sqrt, + ov::op::v1::StridedSlice, + ov::op::v1::ReduceSum, + ov::op::v1::ReduceMean, + ov::op::v8::Slice, + ov::op::v1::VariadicSplit, + ov::op::v1::Split, + ov::op::v0::Concat, + ov::op::v0::Convert, // through Convert can go only to Constants + ov::op::v0::Constant, + ov::op::v0::Tile>(); } // namespace @@ -338,8 +338,8 @@ class MarkDivWithEps : public MatcherPass { auto eps_const_pattern = ov::pass::pattern::wrap_type(); auto optional_eps_convert = ov::pass::pattern::optional(eps_const_pattern); - auto max_or_add = - ov::pass::pattern::wrap_type(OutputVector{input_2, optional_eps_convert}); + auto max_or_add = ov::pass::pattern::wrap_type( + OutputVector{input_2, optional_eps_convert}); auto optional_sqrt = ov::pass::pattern::optional(max_or_add); // whether is divided directly or after sqrt (e.g. in L2Norm after sqrt, in MVN is divided directly) @@ -350,7 +350,8 @@ class MarkDivWithEps : public MatcherPass { auto pow_pattern = std::make_shared(max_or_add, optional_pow_convert); auto mul_pattern = std::make_shared(input_1, pow_pattern); - auto div_or_mul_to_negative_pow = std::make_shared(OutputVector{divide, mul_pattern}); + auto div_or_mul_to_negative_pow = + std::make_shared(OutputVector{divide, mul_pattern}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); @@ -404,29 +405,30 @@ class PropagateDownDisableSensitivityForQuantized : public pass::MatcherPass { MATCHER_SCOPE(PropagateDownDisableSensitivityForQuantized); // through this nodes - const std::shared_ptr quantization_propagating_nodes = ov::pass::pattern::wrap_type(); + const std::shared_ptr quantization_propagating_nodes = + ov::pass::pattern::wrap_type(); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& node = m.get_match_root(); diff --git a/src/common/transformations/src/transformations/low_precision/mark_dequantization_subgraph.cpp b/src/common/transformations/src/transformations/low_precision/mark_dequantization_subgraph.cpp index e51e5f4d4b5114..2743b9d58b688f 100644 --- a/src/common/transformations/src/transformations/low_precision/mark_dequantization_subgraph.cpp +++ b/src/common/transformations/src/transformations/low_precision/mark_dequantization_subgraph.cpp @@ -211,19 +211,23 @@ ov::pass::MarkDequantization::MarkDequantization(const element::TypeVector& prec // data input: auto input_pattern = ov::pass::pattern::any_input(check_precision(precisions)); - auto convert_pattern = ov::pass::pattern::wrap_type({input_pattern}, ov::pass::pattern::consumers_count(1)); + auto convert_pattern = + ov::pass::pattern::wrap_type({input_pattern}, ov::pass::pattern::consumers_count(1)); // zero points: auto zp_pattern = ov::pass::pattern::any_input(); auto zp_convert_pattern = ov::pass::pattern::optional(zp_pattern); - auto zp_reshape_pattern = ov::pass::pattern::optional({zp_convert_pattern, ov::pass::pattern::any_input()}); + auto zp_reshape_pattern = ov::pass::pattern::optional( + {zp_convert_pattern, ov::pass::pattern::any_input()}); auto subtract_pattern = ov::pass::pattern::optional({convert_pattern, zp_reshape_pattern}); // scale: auto scale_pattern = ov::pass::pattern::any_input(); auto scale_convert_pattern = ov::pass::pattern::optional(scale_pattern); - auto scale_reshape_pattern = ov::pass::pattern::optional({scale_convert_pattern, ov::pass::pattern::any_input()}); - auto multiply_pattern = ov::pass::pattern::wrap_type({subtract_pattern, scale_reshape_pattern}); + auto scale_reshape_pattern = ov::pass::pattern::optional( + {scale_convert_pattern, ov::pass::pattern::any_input()}); + auto multiply_pattern = + ov::pass::pattern::wrap_type({subtract_pattern, scale_reshape_pattern}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) -> bool { const auto& pt_map = m.get_pattern_value_map(); @@ -275,19 +279,23 @@ ov::pass::KeepConstPrecision::KeepConstPrecision(const element::TypeVector& prec // data input: auto input_pattern = ov::pass::pattern::any_input(); - auto convert_pattern = ov::pass::pattern::wrap_type({input_pattern}, ov::pass::pattern::consumers_count(1)); + auto convert_pattern = + ov::pass::pattern::wrap_type({input_pattern}, ov::pass::pattern::consumers_count(1)); // zero points: auto zp_pattern = ov::pass::pattern::any_input(); auto zp_convert_pattern = ov::pass::pattern::optional(zp_pattern); - auto zp_reshape_pattern = ov::pass::pattern::optional({zp_convert_pattern, ov::pass::pattern::any_input()}); + auto zp_reshape_pattern = ov::pass::pattern::optional( + {zp_convert_pattern, ov::pass::pattern::any_input()}); auto subtract_pattern = ov::pass::pattern::optional({convert_pattern, zp_reshape_pattern}); // scale: auto scale_pattern = ov::pass::pattern::any_input(); auto scale_convert_pattern = ov::pass::pattern::optional(scale_pattern); - auto scale_reshape_pattern = ov::pass::pattern::optional({scale_convert_pattern, ov::pass::pattern::any_input()}); - auto multiply_pattern = ov::pass::pattern::wrap_type({subtract_pattern, scale_reshape_pattern}); + auto scale_reshape_pattern = ov::pass::pattern::optional( + {scale_convert_pattern, ov::pass::pattern::any_input()}); + auto multiply_pattern = + ov::pass::pattern::wrap_type({subtract_pattern, scale_reshape_pattern}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) -> bool { const auto& pt_map = m.get_pattern_value_map(); @@ -324,20 +332,25 @@ ov::pass::KeepDequantizationPrecision::KeepDequantizationPrecision(const element bool add_precision_sensitive_convert) { MATCHER_SCOPE(KeepDequantizationPrecision); - auto input_pattern = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any(precisions)); - auto convert_pattern = ov::pass::pattern::wrap_type({input_pattern}, ov::pass::pattern::consumers_count(1)); + auto input_pattern = + ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any(precisions)); + auto convert_pattern = + ov::pass::pattern::wrap_type({input_pattern}, ov::pass::pattern::consumers_count(1)); // zero points: auto zp_pattern = ov::pass::pattern::wrap_type(); auto zp_convert_pattern = ov::pass::pattern::optional(zp_pattern); - auto zp_reshape_pattern = ov::pass::pattern::optional({zp_convert_pattern, ov::pass::pattern::any_input()}); + auto zp_reshape_pattern = ov::pass::pattern::optional( + {zp_convert_pattern, ov::pass::pattern::any_input()}); auto subtract_pattern = ov::pass::pattern::optional({convert_pattern, zp_reshape_pattern}); // scale: auto scale_pattern = ov::pass::pattern::wrap_type(); auto scale_convert_pattern = ov::pass::pattern::optional(scale_pattern); - auto scale_reshape_pattern = ov::pass::pattern::optional({scale_convert_pattern, ov::pass::pattern::any_input()}); - auto multiply_pattern = ov::pass::pattern::wrap_type({subtract_pattern, scale_reshape_pattern}); + auto scale_reshape_pattern = ov::pass::pattern::optional( + {scale_convert_pattern, ov::pass::pattern::any_input()}); + auto multiply_pattern = + ov::pass::pattern::wrap_type({subtract_pattern, scale_reshape_pattern}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pt_map = m.get_pattern_value_map(); @@ -391,7 +404,8 @@ ov::pass::MarkGatherSubgraph::MarkGatherSubgraph(const element::TypeVector& tabl auto data_convert = ov::pass::pattern::optional({data_input}); // 2. Indices input → (optional Convert) → (input to Gather[1]) - auto indices_input = ov::pass::pattern::wrap_type(check_precision(indices_precisions)); + auto indices_input = + ov::pass::pattern::wrap_type(check_precision(indices_precisions)); auto indices_convert = ov::pass::pattern::optional({indices_input}); // Gather (fp, integral, any) diff --git a/src/common/transformations/src/transformations/op_conversions/batch_norm_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/batch_norm_decomposition.cpp index fc758b7fe83240..f5547803df2cdc 100644 --- a/src/common/transformations/src/transformations/op_conversions/batch_norm_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/batch_norm_decomposition.cpp @@ -29,16 +29,18 @@ using namespace ov; ov::pass::BatchNormDecomposition::BatchNormDecomposition() { MATCHER_SCOPE(BatchNormDecomposition); - auto bn_1 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input()}); - auto bn_5 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input()}); + auto bn_1 = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); + auto bn_5 = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto bn = std::make_shared(OutputVector{bn_1, bn_5}); matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/op_conversions/convert_bitwise_to_logical_bool.cpp b/src/common/transformations/src/transformations/op_conversions/convert_bitwise_to_logical_bool.cpp index faa21b240189ed..1f5097a9297b65 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_bitwise_to_logical_bool.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_bitwise_to_logical_bool.cpp @@ -20,9 +20,9 @@ ov::pass::ConvertBitwiseAndToLogicalAnd::ConvertBitwiseAndToLogicalAnd() { MATCHER_SCOPE(ConvertBitwiseAndToLogicalAnd); - auto pattern = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean)), - ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); + auto pattern = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean)), + ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto bitwise = ov::as_type_ptr(m.get_match_root()); @@ -45,8 +45,8 @@ ov::pass::ConvertBitwiseAndToLogicalAnd::ConvertBitwiseAndToLogicalAnd() { } ov::pass::ConvertBitwiseNotToLogicalNot::ConvertBitwiseNotToLogicalNot() { MATCHER_SCOPE(ConvertBitwiseNotToLogicalNot); - auto pattern = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); + auto pattern = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto bitwise = ov::as_type_ptr(m.get_match_root()); @@ -68,9 +68,9 @@ ov::pass::ConvertBitwiseNotToLogicalNot::ConvertBitwiseNotToLogicalNot() { ov::pass::ConvertBitwiseOrToLogicalOr::ConvertBitwiseOrToLogicalOr() { MATCHER_SCOPE(ConvertBitwiseOrToLogicalOr); - auto pattern = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean)), - ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); + auto pattern = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean)), + ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto bitwise = ov::as_type_ptr(m.get_match_root()); @@ -94,9 +94,9 @@ ov::pass::ConvertBitwiseOrToLogicalOr::ConvertBitwiseOrToLogicalOr() { ov::pass::ConvertBitwiseXorToLogicalXor::ConvertBitwiseXorToLogicalXor() { MATCHER_SCOPE(ConvertBitwiseXorToLogicalXor); - auto pattern = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean)), - ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); + auto pattern = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean)), + ov::pass::pattern::any_input(ov::pass::pattern::type_matches(element::boolean))}); const matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto bitwise = ov::as_type_ptr(m.get_match_root()); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_convertpromotetypes.cpp b/src/common/transformations/src/transformations/op_conversions/convert_convertpromotetypes.cpp index 78da3bf7a1d3db..1eb17f2f90fb85 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_convertpromotetypes.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_convertpromotetypes.cpp @@ -17,7 +17,8 @@ ov::pass::ConvertConvertPromoteTypes::ConvertConvertPromoteTypes() { auto has_static_defined_type = [](const Output& output) -> bool { return !ov::pass::pattern::type_matches_any({element::dynamic})(output); }; - auto convert_promote_types = ov::pass::pattern::wrap_type(has_static_defined_type); + auto convert_promote_types = + ov::pass::pattern::wrap_type(has_static_defined_type); matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) { auto convert_promote_types = ov::as_type_ptr(m.get_match_root()); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_depth_to_space.cpp b/src/common/transformations/src/transformations/op_conversions/convert_depth_to_space.cpp index dec8f57ff6e384..beba87c226394a 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_depth_to_space.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_depth_to_space.cpp @@ -18,8 +18,8 @@ ov::pass::ConvertDepthToSpace::ConvertDepthToSpace() { MATCHER_SCOPE(ConvertDepthToSpace); - auto dts_node = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}); + auto dts_node = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}); matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto dts_node = ov::as_type_ptr(m.get_match_root()); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_fc_to_compressed.cpp b/src/common/transformations/src/transformations/op_conversions/convert_fc_to_compressed.cpp index 51c37d5afb1854..8cc7fe11188ac3 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_fc_to_compressed.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_fc_to_compressed.cpp @@ -129,11 +129,12 @@ ov::pass::ConvertFullyConnectedToFullyConnectedCompressed::ConvertFullyConnected const std::vector& supported_weights_types, SupportsPredicate supports_config, bool convert_u4zp_to_u8) { -auto weights_block = + auto weights_block = std::make_shared(supported_weights_types, std::set{2}); auto activation = ov::pass::pattern::any_input(ov::pass::pattern::type_matches_any(supported_activation_types)); auto bias = ov::pass::pattern::any_input(); - auto fully_connected = ov::pass::pattern::wrap_type({activation, weights_block, bias}); + auto fully_connected = + ov::pass::pattern::wrap_type({activation, weights_block, bias}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -179,6 +180,7 @@ auto weights_block = return true; }; - auto m = std::make_shared(fully_connected, "ConvertFullyConnectedToFullyConnectedCompressed"); + auto m = std::make_shared(fully_connected, + "ConvertFullyConnectedToFullyConnectedCompressed"); this->register_matcher(m, callback); } \ No newline at end of file diff --git a/src/common/transformations/src/transformations/op_conversions/convert_fc_to_quantized_legacy.cpp b/src/common/transformations/src/transformations/op_conversions/convert_fc_to_quantized_legacy.cpp index 530644b58c4579..e6894509a53caf 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_fc_to_quantized_legacy.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_fc_to_quantized_legacy.cpp @@ -19,14 +19,15 @@ #include "transformations/utils/utils.hpp" ov::pass::ConvertFCToFCQuantizedLegacy::ConvertFCToFCQuantizedLegacy() { -std::vector activation_types{ov::element::u8, ov::element::i8}; + std::vector activation_types{ov::element::u8, ov::element::i8}; std::vector weights_types{ov::element::i8}; auto activations_m = ov::pass::pattern::any_input(ov::pass::pattern::type_matches_any(activation_types)); auto weights_m = ov::pass::pattern::any_input(); auto bias_m = ov::pass::pattern::any_input(); - auto fully_connected_m = ov::pass::pattern::wrap_type({activations_m, weights_m, bias_m}); + auto fully_connected_m = + ov::pass::pattern::wrap_type({activations_m, weights_m, bias_m}); auto dequantization_scales_m = ov::pass::pattern::wrap_type(); auto multiply_m = ov::pass::pattern::wrap_type({fully_connected_m, dequantization_scales_m}); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp b/src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp index f35fb7f7fc7c42..d2179e698e2a25 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp @@ -21,7 +21,7 @@ #include "transformations/utils/utils.hpp" ov::pass::ConvertGatherToGatherCompressed::ConvertGatherToGatherCompressed() { -auto compressed_constant = [](const ov::Output& output) { + auto compressed_constant = [](const ov::Output& output) { return (output.get_element_type() == ov::element::u8 || output.get_element_type() == ov::element::i8 || output.get_element_type() == ov::element::u4 || output.get_element_type() == ov::element::i4) && (output.get_shape().size() == 2 || output.get_shape().size() == 3); @@ -52,7 +52,8 @@ auto compressed_constant = [](const ov::Output& output) { auto dicts_input_m = std::make_shared(ov::OutputVector{reshape_m, last_convert_m, mul_m}); - auto gather_m = ov::pass::pattern::wrap_type({dicts_input_m, ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); + auto gather_m = ov::pass::pattern::wrap_type( + {dicts_input_m, ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -148,12 +149,15 @@ auto compressed_constant = [](const ov::Output& output) { } ov::pass::MoveDecompressionAfterGather::MoveDecompressionAfterGather() { -auto dicts = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any({element::f16, element::bf16})); + auto dicts = ov::pass::pattern::wrap_type( + ov::pass::pattern::type_matches_any({element::f16, element::bf16})); auto convert_predicate = [](ov::Output output) -> bool { - return ov::pass::pattern::consumers_count(1)(output) && ov::pass::pattern::type_matches(ov::element::f32)(output); + return ov::pass::pattern::consumers_count(1)(output) && + ov::pass::pattern::type_matches(ov::element::f32)(output); }; auto convert = ov::pass::pattern::wrap_type({dicts}, convert_predicate); - auto gather = ov::pass::pattern::wrap_type({convert, ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); + auto gather = ov::pass::pattern::wrap_type( + {convert, ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_pooling.cpp b/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_pooling.cpp index 13edc967aee070..4d6886a4bdab1a 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_pooling.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_pooling.cpp @@ -11,7 +11,8 @@ ov::pass::ConvertReduceMeanToPooling::ConvertReduceMeanToPooling() { MATCHER_SCOPE(ConvertReduceMeanToPooling); auto m = std::make_shared( ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type()}, ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_pooling()); @@ -20,7 +21,8 @@ ov::pass::ConvertReduceMaxToPooling::ConvertReduceMaxToPooling() { MATCHER_SCOPE(ConvertReduceMaxToPooling); auto m = std::make_shared( ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type()}, ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_pooling()); @@ -29,7 +31,8 @@ ov::pass::ConvertReduceSumToPooling::ConvertReduceSumToPooling() { MATCHER_SCOPE(ConvertReduceSumToPooling); auto m = std::make_shared( ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type()}, ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_pooling()); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_reshape.cpp b/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_reshape.cpp index dfd9446d1e43b5..eb9fdbb0d722c2 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_reshape.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_reduce_to_reshape.cpp @@ -25,7 +25,8 @@ ov::pass::ConvertReduceMeanToReshape::ConvertReduceMeanToReshape() { MATCHER_SCOPE(ConvertReduceMeanToReshape); auto m = std::make_shared( ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type()}, ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); @@ -35,7 +36,8 @@ ov::pass::ConvertReduceSumToReshape::ConvertReduceSumToReshape() { MATCHER_SCOPE(ConvertReduceSumToReshape); auto m = std::make_shared( ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type()}, ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); @@ -45,7 +47,8 @@ ov::pass::ConvertReduceProdToReshape::ConvertReduceProdToReshape() { MATCHER_SCOPE(ConvertReduceProdToReshape); auto m = std::make_shared( ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type()}, ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); @@ -55,7 +58,8 @@ ov::pass::ConvertReduceMaxToReshape::ConvertReduceMaxToReshape() { MATCHER_SCOPE(ConvertReduceMaxToReshape); auto m = std::make_shared( ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type()}, ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); @@ -65,7 +69,8 @@ ov::pass::ConvertReduceMinToReshape::ConvertReduceMinToReshape() { MATCHER_SCOPE(ConvertReduceMinToReshape); auto m = std::make_shared( ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type()}, ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); @@ -75,7 +80,8 @@ ov::pass::ConvertReduceLogicalAndToReshape::ConvertReduceLogicalAndToReshape() { MATCHER_SCOPE(ConvertReduceLogicalAndToReshape); auto m = std::make_shared( ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type()}, ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); @@ -85,7 +91,8 @@ ov::pass::ConvertReduceLogicalOrToReshape::ConvertReduceLogicalOrToReshape() { MATCHER_SCOPE(ConvertReduceLogicalOrToReshape); auto m = std::make_shared( ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), ov::pass::pattern::wrap_type()}, + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()), + ov::pass::pattern::wrap_type()}, ov::pass::pattern::has_static_shape()), matcher_name); register_matcher(m, convert_reduce_to_reshape()); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_space_to_depth.cpp b/src/common/transformations/src/transformations/op_conversions/convert_space_to_depth.cpp index 8325dc5aee5f37..17a4beabc8e4f2 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_space_to_depth.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_space_to_depth.cpp @@ -18,8 +18,8 @@ ov::pass::ConvertSpaceToDepth::ConvertSpaceToDepth() { MATCHER_SCOPE(ConvertSpaceToDepth); - auto dts = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}); + auto dts = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape())}); matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) { auto std_node = ov::as_type_ptr(m.get_match_root()); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_subtract.cpp b/src/common/transformations/src/transformations/op_conversions/convert_subtract.cpp index 61c03c45742f67..12e41390fee608 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_subtract.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_subtract.cpp @@ -66,8 +66,8 @@ pass::ConvertSubtract::ConvertSubtract() { pass::ConvertSubtractWithConstant::ConvertSubtractWithConstant() { MATCHER_SCOPE(ConvertSubtractWithConstant); - auto sub = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); + auto sub = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto node = m.get_match_root(); diff --git a/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp b/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp index 8ec46184e01e34..4de110f32a7b62 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp @@ -427,12 +427,14 @@ bool check_lstm_cell_pattern( create_mul_by_one_pattern(h_param, h_broadcast_value, h_mul, false); auto xi_common_label = std::make_shared(OutputVector{xi_reshape_label, x_mul}); - auto hidden_common_label = std::make_shared(OutputVector{init_hidden_state_i_label, h_mul}); + auto hidden_common_label = + std::make_shared(OutputVector{init_hidden_state_i_label, h_mul}); auto lstm_cell_label = ov::pass::pattern::wrap_type( {xi_common_label, hidden_common_label, init_cell_state_i_label, W_label, R_label, B_label}); auto unsqueeze_axis_label = ov::pass::pattern::wrap_type(); - auto unsqueeze_hidden_state_label = ov::pass::pattern::wrap_type({lstm_cell_label, unsqueeze_axis_label}); + auto unsqueeze_hidden_state_label = + ov::pass::pattern::wrap_type({lstm_cell_label, unsqueeze_axis_label}); auto result_hidden_state_label = ov::pass::pattern::wrap_type({unsqueeze_hidden_state_label}); // check that body-graph contains a pattern corresponding LSTMCell @@ -784,23 +786,25 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda auto input_transpose_const_label = ov::pass::pattern::wrap_type(); auto input_transpose_label = ov::pass::pattern::wrap_type({input_label, input_transpose_const_label}, - ov::pass::pattern::rank_equals(3)); + ov::pass::pattern::rank_equals(3)); auto scatter_indexes_label = ov::pass::pattern::wrap_type(); - auto scatter_update_label = std::make_shared(OutputVector{input_transpose_label, input_label}); + auto scatter_update_label = + std::make_shared(OutputVector{input_transpose_label, input_label}); auto scatter_label = ov::pass::pattern::wrap_type( {ov::pass::pattern::any_input(), scatter_indexes_label, scatter_update_label}); auto trip_count_label = ov::pass::pattern::wrap_type(); auto cond_label = ov::pass::pattern::wrap_type(); auto loop_label = ov::pass::pattern::wrap_type({trip_count_label, - cond_label, - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - scatter_label}); + cond_label, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + scatter_label}); auto output_transpose_const_label = ov::pass::pattern::wrap_type(); - auto output_transpose_label = ov::pass::pattern::wrap_type({loop_label, output_transpose_const_label}); + auto output_transpose_label = + ov::pass::pattern::wrap_type({loop_label, output_transpose_const_label}); // Loop body pattern: auto sequence_index_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(0)); @@ -809,8 +813,8 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda auto iteration_counter_incremented_label = ov::pass::pattern::wrap_type({iteration_counter_label, iteration_counter_step_label}); auto iteration_counter_limit_label = ov::pass::pattern::wrap_type(); - auto iteration_counter_less_than_limit_label = - ov::pass::pattern::wrap_type({iteration_counter_incremented_label, iteration_counter_limit_label}); + auto iteration_counter_less_than_limit_label = ov::pass::pattern::wrap_type( + {iteration_counter_incremented_label, iteration_counter_limit_label}); auto sequence_index_step_label = ov::pass::pattern::wrap_type(); auto sequence_index_incremented_label = ov::pass::pattern::wrap_type({sequence_index_label, sequence_index_step_label}); @@ -832,7 +836,7 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda std::make_shared(OutputVector{sequence_index_label, sequence_index_reshaped_label}); auto gather_body_label = ov::pass::pattern::wrap_type({X_body_label, sequence_index_or_label, gather_axis_label}, - ov::pass::pattern::rank_equals(2)); + ov::pass::pattern::rank_equals(2)); auto W_label = ov::pass::pattern::any_input(); auto R_label = ov::pass::pattern::any_input(); auto B_label = ov::pass::pattern::wrap_type(); @@ -1325,14 +1329,20 @@ class EliminateGatherWithRange : public ov::pass::MatcherPass { auto data_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(3)); auto shapeof_label = ov::pass::pattern::wrap_type({data_label}); - auto shapeof_gather_label = ov::pass::pattern::wrap_type( - {shapeof_label, ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}); - auto shapeof_gather2_label = ov::pass::pattern::wrap_type( - {shapeof_gather_label, ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}); - auto reshape_label = - ov::pass::pattern::wrap_type({shapeof_gather2_label, ov::pass::pattern::wrap_type()}); - auto range_label = ov::pass::pattern::wrap_type( - {ov::pass::pattern::wrap_type(), reshape_label, ov::pass::pattern::wrap_type()}); + auto shapeof_gather_label = + ov::pass::pattern::wrap_type({shapeof_label, + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}); + auto shapeof_gather2_label = + ov::pass::pattern::wrap_type({shapeof_gather_label, + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}); + auto reshape_label = ov::pass::pattern::wrap_type( + {shapeof_gather2_label, ov::pass::pattern::wrap_type()}); + auto range_label = + ov::pass::pattern::wrap_type({ov::pass::pattern::wrap_type(), + reshape_label, + ov::pass::pattern::wrap_type()}); auto match_node = ov::pass::pattern::wrap_type( {data_label, range_label, ov::pass::pattern::wrap_type()}); @@ -1389,24 +1399,25 @@ ov::pass::FuseReverseLSTMSequence::FuseReverseLSTMSequence() { MATCHER_SCOPE(FuseReverseLSTMSequence); auto data_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(3)); - auto first_transpose_label = - ov::pass::pattern::wrap_type({data_label, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(3)); + auto first_transpose_label = ov::pass::pattern::wrap_type( + {data_label, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(3)); auto input_to_first_reverse_sequence_label = std::make_shared(OutputVector{first_transpose_label, data_label}); - auto first_reverse_sequence_label = - ov::pass::pattern::wrap_type({input_to_first_reverse_sequence_label, ov::pass::pattern::any_input()}); - auto second_transpose_label = - ov::pass::pattern::wrap_type({first_reverse_sequence_label, ov::pass::pattern::wrap_type()}); + auto first_reverse_sequence_label = ov::pass::pattern::wrap_type( + {input_to_first_reverse_sequence_label, ov::pass::pattern::any_input()}); + auto second_transpose_label = ov::pass::pattern::wrap_type( + {first_reverse_sequence_label, ov::pass::pattern::wrap_type()}); auto lstm_label = ov::pass::pattern::wrap_type({second_transpose_label, - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input()}, - ov::pass::pattern::consumers_count(1)); - auto squeeze_label = ov::pass::pattern::wrap_type({lstm_label, ov::pass::pattern::wrap_type()}); + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}, + ov::pass::pattern::consumers_count(1)); + auto squeeze_label = + ov::pass::pattern::wrap_type({lstm_label, ov::pass::pattern::wrap_type()}); auto second_reverse_sequence_label = ov::pass::pattern::wrap_type({squeeze_label, ov::pass::pattern::any_input()}); @@ -1534,52 +1545,58 @@ ov::pass::FuseLSTMSequencesToBidirectionalLSTMSequence::FuseLSTMSequencesToBidir ov::pass::pattern::wrap_type({data_label, ov::pass::pattern::wrap_type()}); auto lstm_sequence_forward_first_input_label = std::make_shared(OutputVector{transpose_forward_label, data_label}); - auto shapeof_forward_label = ov::pass::pattern::wrap_type({lstm_sequence_forward_first_input_label}); - auto gather_forward_label = ov::pass::pattern::wrap_type( - {shapeof_forward_label, ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}); + auto shapeof_forward_label = + ov::pass::pattern::wrap_type({lstm_sequence_forward_first_input_label}); + auto gather_forward_label = + ov::pass::pattern::wrap_type({shapeof_forward_label, + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}); auto max_sequence_len_forward_label = ov::pass::pattern::wrap_type(); auto broadcast_forward_label = ov::pass::pattern::wrap_type({max_sequence_len_forward_label, gather_forward_label}); auto const_sequence_lengths_forward_label = ov::pass::pattern::wrap_type(); - auto sequence_lengths_forward_label = - std::make_shared(OutputVector{broadcast_forward_label, const_sequence_lengths_forward_label}); + auto sequence_lengths_forward_label = std::make_shared( + OutputVector{broadcast_forward_label, const_sequence_lengths_forward_label}); auto lstm_sequence_forward_label = ov::pass::pattern::wrap_type({lstm_sequence_forward_first_input_label, - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - sequence_lengths_forward_label, - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input()}); - auto squeeze_forward_label = - ov::pass::pattern::wrap_type({lstm_sequence_forward_label, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(3)); + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + sequence_lengths_forward_label, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); + auto squeeze_forward_label = ov::pass::pattern::wrap_type( + {lstm_sequence_forward_label, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(3)); // backward pattern - auto transpose_reverse_label = - ov::pass::pattern::wrap_type({data_label, ov::pass::pattern::wrap_type()}); + auto transpose_reverse_label = ov::pass::pattern::wrap_type( + {data_label, ov::pass::pattern::wrap_type()}); auto lstm_sequence_reverse_first_input_label = std::make_shared(OutputVector{transpose_reverse_label, data_label}); - auto shapeof_reverse_label = ov::pass::pattern::wrap_type({lstm_sequence_reverse_first_input_label}); - auto gather_reverse_label = ov::pass::pattern::wrap_type( - {shapeof_reverse_label, ov::pass::pattern::wrap_type(), ov::pass::pattern::wrap_type()}); + auto shapeof_reverse_label = + ov::pass::pattern::wrap_type({lstm_sequence_reverse_first_input_label}); + auto gather_reverse_label = + ov::pass::pattern::wrap_type({shapeof_reverse_label, + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}); auto max_sequence_len_reverse_label = ov::pass::pattern::wrap_type(); auto broadcast_reverse_label = ov::pass::pattern::wrap_type({max_sequence_len_reverse_label, gather_reverse_label}); auto const_sequence_lengths_reverse_label = ov::pass::pattern::wrap_type(); - auto sequence_lengths_reverse_label = - std::make_shared(OutputVector{broadcast_reverse_label, const_sequence_lengths_reverse_label}); + auto sequence_lengths_reverse_label = std::make_shared( + OutputVector{broadcast_reverse_label, const_sequence_lengths_reverse_label}); auto lstm_sequence_reverse_label = ov::pass::pattern::wrap_type({lstm_sequence_reverse_first_input_label, - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - sequence_lengths_reverse_label, - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input(), - ov::pass::pattern::any_input()}); - auto squeeze_reverse_label = - ov::pass::pattern::wrap_type({lstm_sequence_reverse_label, ov::pass::pattern::wrap_type()}, - ov::pass::pattern::rank_equals(3)); + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + sequence_lengths_reverse_label, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); + auto squeeze_reverse_label = ov::pass::pattern::wrap_type( + {lstm_sequence_reverse_label, ov::pass::pattern::wrap_type()}, + ov::pass::pattern::rank_equals(3)); auto concat_label = ov::pass::pattern::wrap_type({squeeze_forward_label, squeeze_reverse_label}); diff --git a/src/common/transformations/src/transformations/op_conversions/eye_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/eye_decomposition.cpp index 5641a7044b31cb..1f1bd6c9cb2d88 100644 --- a/src/common/transformations/src/transformations/op_conversions/eye_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/eye_decomposition.cpp @@ -33,8 +33,8 @@ namespace { /** \brief Check if output is rank one and data type can be i32 or i64. */ const auto is_rank_one_int_shape = [](const Output& output) -> bool { - return ov::pass::pattern::type_matches_any({element::i32, element::i64})(output) && ov::pass::pattern::has_static_shape()(output) && - ov::pass::pattern::rank_equals(1)(output); + return ov::pass::pattern::type_matches_any({element::i32, element::i64})(output) && + ov::pass::pattern::has_static_shape()(output) && ov::pass::pattern::rank_equals(1)(output); }; /** \brief Predicate to check eye k node is valid. */ diff --git a/src/common/transformations/src/transformations/op_conversions/group_query_attention_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/group_query_attention_decomposition.cpp index b00e2b61612128..18beee23a0b8ee 100644 --- a/src/common/transformations/src/transformations/op_conversions/group_query_attention_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/group_query_attention_decomposition.cpp @@ -55,7 +55,7 @@ ov::pass::GroupQueryAttentionDecomposition::GroupQueryAttentionDecomposition() { ov::OutputVector ov::pass::GroupQueryAttentionDecomposition::decompose( std::shared_ptr node) { -const auto num_heads = node->get_num_heads(); + const auto num_heads = node->get_num_heads(); const auto kv_num_heads = node->get_kv_num_heads(); const auto scale = node->get_scale(); const auto do_rotary = node->get_do_rotary(); @@ -93,8 +93,10 @@ const auto num_heads = node->get_num_heads(); const auto curr_seqlen_scalar = register_new_node(current_seqlen); if (do_rotary) { - ov::Output position_ids = - register_new_node(zero_without_shape, curr_seqlen_scalar, one_without_shape, ov::element::i64); + ov::Output position_ids = register_new_node(zero_without_shape, + curr_seqlen_scalar, + one_without_shape, + ov::element::i64); position_ids = register_new_node(position_ids, past_seqlen); const auto cos = register_new_node(cos_cache, position_ids, zero); @@ -115,10 +117,13 @@ const auto num_heads = node->get_num_heads(); // M = current_seqlen, which is always 1 for the KV cache model. const auto current_kv_len_const = register_new_node( ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {K.get_partial_shape()[2].get_length()})); - const auto past_kv_len_const = register_new_node( - ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {past_key.get_partial_shape()[2].get_length()})); + const auto past_kv_len_const = + register_new_node(ov::op::v0::Constant::create(ov::element::i64, + ov::Shape{1}, + {past_key.get_partial_shape()[2].get_length()})); past_key = register_new_node(past_key, current_kv_len_const, past_kv_len_const, one, two); - past_value = register_new_node(past_value, current_kv_len_const, past_kv_len_const, one, two); + past_value = + register_new_node(past_value, current_kv_len_const, past_kv_len_const, one, two); } K = construct_kv_cache(past_key, K); V = construct_kv_cache(past_value, V); @@ -135,14 +140,16 @@ const auto num_heads = node->get_num_heads(); const auto kv_shape = register_new_node(K); const auto kv_shape_prev_2 = get_dimensions(kv_shape, {0, 1}); const auto kv_shape_last_2 = get_dimensions(kv_shape, {2, 3}); - auto new_kv_shape = register_new_node(ov::NodeVector{kv_shape_prev_2, one, kv_shape_last_2}, 0); + auto new_kv_shape = + register_new_node(ov::NodeVector{kv_shape_prev_2, one, kv_shape_last_2}, 0); K = register_new_node(K, new_kv_shape, false); V = register_new_node(V, new_kv_shape, false); K = register_new_node(ov::OutputVector(kv_num_heads_factor, K), 2); V = register_new_node(ov::OutputVector(kv_num_heads_factor, V), 2); const auto q_shape = register_new_node(Q); const auto q_shape_prev_2 = get_dimensions(q_shape, {0, 1}); - auto extended_kv_shape = register_new_node(ov::NodeVector{q_shape_prev_2, kv_shape_last_2}, 0); + auto extended_kv_shape = + register_new_node(ov::NodeVector{q_shape_prev_2, kv_shape_last_2}, 0); K = register_new_node(K, extended_kv_shape, false); V = register_new_node(V, extended_kv_shape, false); } @@ -150,12 +157,16 @@ const auto num_heads = node->get_num_heads(); // Make attention mask std::shared_ptr mask; - std::shared_ptr hori_range = - register_new_node(zero_without_shape, concat_kv_len_scalar, one_without_shape, ov::element::i64); + std::shared_ptr hori_range = register_new_node(zero_without_shape, + concat_kv_len_scalar, + one_without_shape, + ov::element::i64); hori_range = register_new_node(hori_range, zero); - std::shared_ptr vert_range = - register_new_node(zero_without_shape, curr_seqlen_scalar, one_without_shape, ov::element::i64); + std::shared_ptr vert_range = register_new_node(zero_without_shape, + curr_seqlen_scalar, + one_without_shape, + ov::element::i64); vert_range = register_new_node(vert_range, one); const auto past_k_node_len = get_dimensions(past_key.get_node_shared_ptr(), {2}); vert_range = register_new_node(vert_range, past_k_node_len); @@ -165,15 +176,17 @@ const auto num_heads = node->get_num_heads(); // cf. make_attention_mask@src\plugins\intel_gpu\tests\common\subgraphs_builders.hpp std::shared_ptr minus_inf = nullptr; if (T == ov::element::f32) - minus_inf = register_new_node(ov::op::v0::Constant::create(T, ov::Shape{}, {-std::numeric_limits::infinity()})); - else if (T == ov::element::f16) minus_inf = - register_new_node(ov::op::v0::Constant::create(T, ov::Shape{}, {std::numeric_limits::lowest()})); + register_new_node(ov::op::v0::Constant::create(T, ov::Shape{}, {-std::numeric_limits::infinity()})); + else if (T == ov::element::f16) + minus_inf = register_new_node( + ov::op::v0::Constant::create(T, ov::Shape{}, {std::numeric_limits::lowest()})); mask = register_new_node(triu, minus_inf, typed_zero); if (is_static_input) { const auto padding_len = register_new_node(concat_kv_len, seqlens_1d); - const auto padding_mask_vert_shape = register_new_node(ov::NodeVector{current_seqlen, one}, 0); + const auto padding_mask_vert_shape = + register_new_node(ov::NodeVector{current_seqlen, one}, 0); const auto padding_mask_vert = register_new_node(padding_len, padding_mask_vert_shape); const auto padding_mask = register_new_node(hori_range, padding_mask_vert); mask = register_new_node(padding_mask, mask, minus_inf); @@ -201,7 +214,7 @@ const auto num_heads = node->get_num_heads(); ov::OutputVector ov::pass::GroupQueryAttentionDecomposition::make_split(const ov::Output& value, int64_t num_splits, int64_t axis) { -const auto axis_node = register_new_node(ov::op::v0::Constant::create(ov::element::i64, ov::Shape{}, {axis})); + const auto axis_node = register_new_node(ov::op::v0::Constant::create(ov::element::i64, ov::Shape{}, {axis})); const auto split = register_new_node(value, axis_node, num_splits); return split->outputs(); @@ -210,7 +223,7 @@ const auto axis_node = register_new_node(ov::op::v0::Constant::create(ov::elemen std::shared_ptr ov::pass::GroupQueryAttentionDecomposition::get_dimensions( const std::shared_ptr& shape, const std::vector& dims) { -const auto zero = ov::op::v0::Constant::create(ov::element::i32, ov::Shape{}, {0}); + const auto zero = ov::op::v0::Constant::create(ov::element::i32, ov::Shape{}, {0}); const auto dims_const = ov::op::v0::Constant::create(ov::element::i32, ov::Shape{dims.size()}, dims); return register_new_node(shape, dims_const, zero); } @@ -225,7 +238,7 @@ std::shared_ptr ov::pass::GroupQueryAttentionDecomposition::rotaryEmbe ov::Output cos, ov::Output sin, bool interleaved) { -auto zero = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {0}); + auto zero = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {0}); auto one = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {1}); if (interleaved) { @@ -244,9 +257,9 @@ auto zero = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {0}); auto in_split_1 = register_new_node(in_split[1], split_input_shape, false); auto res_0 = register_new_node(register_new_node(in_split_0, cos), - register_new_node(in_split_1, sin)); + register_new_node(in_split_1, sin)); auto res_1 = register_new_node(register_new_node(in_split_0, sin), - register_new_node(in_split_1, cos)); + register_new_node(in_split_1, cos)); split_input_shape = register_new_node(ov::NodeVector{dim_bns, cos_last_dim, one}, 0); auto res_0_5d = register_new_node(res_0, split_input_shape, false); @@ -257,9 +270,9 @@ auto zero = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {0}); } else { auto in_split = make_split(input, 2, -1); auto res_0 = register_new_node(register_new_node(in_split[0], cos), - register_new_node(in_split[1], sin)); + register_new_node(in_split[1], sin)); auto res_1 = register_new_node(register_new_node(in_split[0], sin), - register_new_node(in_split[1], cos)); + register_new_node(in_split[1], cos)); return register_new_node(ov::NodeVector{res_0, res_1}, -1); } diff --git a/src/common/transformations/src/transformations/op_conversions/scaled_dot_product_attention_decomposition.cpp b/src/common/transformations/src/transformations/op_conversions/scaled_dot_product_attention_decomposition.cpp index d6f6d494a4b762..8815c66467aa06 100644 --- a/src/common/transformations/src/transformations/op_conversions/scaled_dot_product_attention_decomposition.cpp +++ b/src/common/transformations/src/transformations/op_conversions/scaled_dot_product_attention_decomposition.cpp @@ -89,7 +89,7 @@ ov::pass::ScaledDotProductAttentionDecomposition::ScaledDotProductAttentionDecom std::shared_ptr ov::pass::ScaledDotProductAttentionDecomposition::decompose( std::shared_ptr node) { -auto query = node->input_value(0); + auto query = node->input_value(0); auto key = node->input_value(1); auto value = node->input_value(2); auto q_shape = register_new_node(query, element::i32); @@ -135,9 +135,9 @@ auto query = node->input_value(0); auto k_last_dim = register_new_node(k_rank, minus_one); auto k_next_dim = register_new_node(k_rank, minus_two)->output(0); k_rank = register_new_node(k_rank, zero_i); - auto minus_inf = - register_new_node(ov::op::v0::Constant::create(element::f32, Shape{}, {-std::numeric_limits::infinity()})) - ->output(0); + auto minus_inf = register_new_node( + ov::op::v0::Constant::create(element::f32, Shape{}, {-std::numeric_limits::infinity()})) + ->output(0); auto keep_dim_last = register_new_node(k_next_dim, zero_i); auto k_dims_before_transpose = register_new_node(zero_i, keep_dim_last, one_i, element::i32); @@ -177,7 +177,8 @@ auto query = node->input_value(0); auto tsl = register_new_node(target_s_len, zero_i); auto mask_shape = register_new_node(OutputVector{tsl, ssl}, 0); mask = register_new_node(minus_inf, mask_shape); - auto horizontal_range = register_new_node(zero_i, source_s_len, one_i, element::i32)->output(0); + auto horizontal_range = + register_new_node(zero_i, source_s_len, one_i, element::i32)->output(0); horizontal_range = register_new_node(horizontal_range, zero_i); auto stop = register_new_node(target_s_len, one_i); auto vertical_range = register_new_node(one_i, stop, one_i, element::i32)->output(0); @@ -194,8 +195,9 @@ auto query = node->input_value(0); auto zero_i = register_new_node(ov::op::v0::Constant::create(element::i32, Shape{1}, {0})); auto one_i = register_new_node(ov::op::v0::Constant::create(element::i32, Shape{1}, {1})); - auto q_last_but_one_dim = register_new_node(register_new_node(q_shape), - ov::op::v0::Constant::create(element::i64, Shape{}, {1})); + auto q_last_but_one_dim = + register_new_node(register_new_node(q_shape), + ov::op::v0::Constant::create(element::i64, Shape{}, {1})); auto sink_target_shape_1 = register_new_node(q_shape, zero_i, q_last_but_one_dim, one_i); auto sink_target_shape = register_new_node(OutputVector{sink_target_shape_1, one_i}, 0); auto sink_broadcast = register_new_node(sink, sink_target_shape); diff --git a/src/common/transformations/src/transformations/pattern_blocks/compressed_weights_block.cpp b/src/common/transformations/src/transformations/pattern_blocks/compressed_weights_block.cpp index a3ba9def440f28..47ea4c90f6570a 100644 --- a/src/common/transformations/src/transformations/pattern_blocks/compressed_weights_block.cpp +++ b/src/common/transformations/src/transformations/pattern_blocks/compressed_weights_block.cpp @@ -27,7 +27,8 @@ ov::pass::pattern::op::CompressedWeightsBlock::CompressedWeightsBlock( const std::vector& supported_weights_types, const std::set& supported_weights_ranks) : Block({}, {}, "CompressedWeightsBlock") { - auto weights = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches_any(supported_weights_types)); + auto weights = ov::pass::pattern::wrap_type( + ov::pass::pattern::type_matches_any(supported_weights_types)); auto convert = ov::pass::pattern::wrap_type({weights}); auto sub_const = ov::pass::pattern::wrap_type(); diff --git a/src/common/transformations/src/transformations/sdpa_to_paged_attention/position_ids_replacer.cpp b/src/common/transformations/src/transformations/sdpa_to_paged_attention/position_ids_replacer.cpp index 36fdab5629e6c7..4af244620f6ef0 100644 --- a/src/common/transformations/src/transformations/sdpa_to_paged_attention/position_ids_replacer.cpp +++ b/src/common/transformations/src/transformations/sdpa_to_paged_attention/position_ids_replacer.cpp @@ -32,13 +32,15 @@ ov::pass::PositionIDsReplacer::PositionIDsReplacer(const Output& position_ MATCHER_SCOPE(PositionIDsReplacer); auto input_ids = ov::pass::pattern::any_input(); - auto input_embed = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), input_ids, ov::pass::pattern::any_input()}); + auto input_embed = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), input_ids, ov::pass::pattern::any_input()}); auto position_ids_pattern = ov::pass::pattern::any_input(); auto offset = ov::pass::pattern::wrap_type(); auto add_offset = ov::pass::pattern::wrap_type({position_ids_pattern, offset}); auto convert = ov::pass::pattern::wrap_type({add_offset}); - auto position_embed = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), convert, ov::pass::pattern::any_input()}); + auto position_embed = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), convert, ov::pass::pattern::any_input()}); auto mul = ov::pass::pattern::optional({input_embed, ov::pass::pattern::any_input()}); @@ -60,7 +62,8 @@ ov::pass::PositionIDsReplacerQwen::PositionIDsReplacerQwen(const Output& p // total seq len: auto p_max_context_len = ov::pass::pattern::wrap_type(); auto p_opt_convert = ov::pass::pattern::optional(p_max_context_len); - auto p_opt_reshape = ov::pass::pattern::optional({p_opt_convert, ov::pass::pattern::any_input()}); + auto p_opt_reshape = + ov::pass::pattern::optional({p_opt_convert, ov::pass::pattern::any_input()}); // current seq len: // it might be present in 2 different ways: @@ -69,11 +72,13 @@ ov::pass::PositionIDsReplacerQwen::PositionIDsReplacerQwen(const Output& p // Probably we can use the symbols to re-use one of these ways. // Currently, "any_input" is used to detect the both places. auto p_shape_of = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); - auto p_current_len = ov::pass::pattern::wrap_type({p_shape_of, ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const()}); + auto p_current_len = ov::pass::pattern::wrap_type( + {p_shape_of, ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const()}); auto p_neg_const = ov::pass::pattern::wrap_type(); auto p_neg_const_convert = ov::pass::pattern::optional(p_neg_const); - auto p_neg_const_reshape = ov::pass::pattern::optional({p_neg_const_convert, ov::pass::pattern::any_input()}); + auto p_neg_const_reshape = + ov::pass::pattern::optional({p_neg_const_convert, ov::pass::pattern::any_input()}); auto p_neg_mul = ov::pass::pattern::wrap_type({p_current_len, p_neg_const_reshape}); // For now, it has always been a constant, but this may change in the future. @@ -84,9 +89,16 @@ ov::pass::PositionIDsReplacerQwen::PositionIDsReplacerQwen(const Output& p // dequantizing subgraph, so it's going to be any_input() here. auto p_rotary_emb_sincos = ov::pass::pattern::any_input(); // the rotary_emb_cos/rotary_emb_sin are sliced by the total length [1,..4096,1,128] - auto p_slice_1 = - ov::pass::pattern::wrap_type({p_rotary_emb_sincos, ov::pass::pattern::wrap_const(), p_opt_reshape, ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const()}); - auto p_slice_2 = ov::pass::pattern::wrap_type({p_slice_1, p_neg_mul, ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const()}); + auto p_slice_1 = ov::pass::pattern::wrap_type({p_rotary_emb_sincos, + ov::pass::pattern::wrap_const(), + p_opt_reshape, + ov::pass::pattern::wrap_const(), + ov::pass::pattern::wrap_const()}); + auto p_slice_2 = ov::pass::pattern::wrap_type({p_slice_1, + p_neg_mul, + ov::pass::pattern::wrap_const(), + ov::pass::pattern::wrap_const(), + ov::pass::pattern::wrap_const()}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); @@ -115,7 +127,8 @@ ov::pass::PositionIDsReplacerQwen::PositionIDsReplacerQwen(const Output& p // so here we need to reshape the output tensor to move the seq dim (num tokens) to the batch // num_kv_heads * head_size are already handled in the StateManagementPattern transformation auto head_size = static_cast(pshape[3].get_length()); - auto new_shape = ov::op::v0::Constant::create(element::i64, Shape{4}, std::vector{-1, 1, 1, head_size}); + auto new_shape = + ov::op::v0::Constant::create(element::i64, Shape{4}, std::vector{-1, 1, 1, head_size}); auto reshape = std::make_shared(gather, new_shape, false); replace_node(slice_2, reshape); return true; @@ -125,7 +138,8 @@ ov::pass::PositionIDsReplacerQwen::PositionIDsReplacerQwen(const Output& p register_matcher(m, callback); } -ov::pass::PositionIDsReplacerCodeGen2::PositionIDsReplacerCodeGen2(const std::shared_ptr& position_ids) { +ov::pass::PositionIDsReplacerCodeGen2::PositionIDsReplacerCodeGen2( + const std::shared_ptr& position_ids) { MATCHER_SCOPE(PositionIDsReplacerCodeGen2); auto p_range = ov::pass::pattern::wrap_type(); @@ -135,11 +149,15 @@ ov::pass::PositionIDsReplacerCodeGen2::PositionIDsReplacerCodeGen2(const std::sh auto p_reshape = ov::pass::pattern::wrap_type({p_sin_cos, ov::pass::pattern::any_input()}); auto p_tile = ov::pass::pattern::wrap_type({p_reshape, ov::pass::pattern::any_input()}); auto p_opt_reshape = ov::pass::pattern::optional({p_tile, ov::pass::pattern::any_input()}); - auto p_opt_unsq = ov::pass::pattern::optional({p_opt_reshape, ov::pass::pattern::any_input()}); + auto p_opt_unsq = + ov::pass::pattern::optional({p_opt_reshape, ov::pass::pattern::any_input()}); - auto p_reshape_1in = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - auto p_add_2in = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - auto p_slice = ov::pass::pattern::wrap_type({p_opt_unsq, p_reshape_1in, p_add_2in, ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const()}); + auto p_reshape_1in = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto p_add_2in = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto p_slice = ov::pass::pattern::wrap_type( + {p_opt_unsq, p_reshape_1in, p_add_2in, ov::pass::pattern::wrap_const(), ov::pass::pattern::wrap_const()}); auto p_add = ov::pass::pattern::wrap_type(); matcher_pass_callback callback = [=, &position_ids](ov::pass::pattern::Matcher& m) { @@ -147,14 +165,15 @@ ov::pass::PositionIDsReplacerCodeGen2::PositionIDsReplacerCodeGen2(const std::sh auto slice = pvm.at(p_slice).get_node_shared_ptr(); auto gather = std::make_shared(slice->input_value(0), - position_ids, - ov::op::v0::Constant::create(element::i64, Shape{}, {1})); + position_ids, + ov::op::v0::Constant::create(element::i64, Shape{}, {1})); if (gather->output(0).get_partial_shape().rank() != 3) { return false; } auto transpose = - std::make_shared(gather, ov::op::v0::Constant::create(element::i64, Shape{3}, {1, 0, 2})); + std::make_shared(gather, + ov::op::v0::Constant::create(element::i64, Shape{3}, {1, 0, 2})); replace_node(slice, transpose); return true; diff --git a/src/common/transformations/src/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.cpp b/src/common/transformations/src/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.cpp index 874bbf20aaccf7..a9ba3364bcc69d 100644 --- a/src/common/transformations/src/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.cpp +++ b/src/common/transformations/src/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.cpp @@ -20,9 +20,11 @@ ov::pass::PrevSequenceLengthPattern::PrevSequenceLengthPattern(const std::shared // kv-cache state In first case it should replace it by prev_max_seq_len. For the second case, connect to batch_dim. auto kv_past = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); - auto kv_gather = ov::pass::pattern::wrap_type({kv_past, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto kv_gather = ov::pass::pattern::wrap_type( + {kv_past, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto kv_shape = ov::pass::pattern::wrap_type({kv_gather}); - auto seq = ov::pass::pattern::wrap_type({kv_shape, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto seq = ov::pass::pattern::wrap_type( + {kv_shape, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { // TODO: Check that seq has axis that really takes sequence len but not any other dimension -- use symbolics or @@ -39,9 +41,10 @@ ov::pass::PrevSequenceLengthPattern::PrevSequenceLengthPattern(const std::shared auto target_type = gather->get_output_element_type(0); std::shared_ptr replacement; if (kv_init_shape[axis].is_static() && kv_init_shape[axis].get_length() == 0) { - auto cur_seq_len = std::make_shared(std::make_shared(unsqueezed_input_ids), - ov::op::v0::Constant::create(element::i64, Shape{}, {1}), - ov::op::v0::Constant::create(element::i64, Shape{}, {0})); + auto cur_seq_len = + std::make_shared(std::make_shared(unsqueezed_input_ids), + ov::op::v0::Constant::create(element::i64, Shape{}, {1}), + ov::op::v0::Constant::create(element::i64, Shape{}, {0})); auto cur_seq_len_i32 = std::make_shared(cur_seq_len, element::i32); auto prev_max_seq_len = std::make_shared(max_context_len, cur_seq_len_i32); replacement = prev_max_seq_len; diff --git a/src/common/transformations/src/transformations/sdpa_to_paged_attention/state_management_pattern.cpp b/src/common/transformations/src/transformations/sdpa_to_paged_attention/state_management_pattern.cpp index 766e462db31ccf..47b055834cbf2f 100644 --- a/src/common/transformations/src/transformations/sdpa_to_paged_attention/state_management_pattern.cpp +++ b/src/common/transformations/src/transformations/sdpa_to_paged_attention/state_management_pattern.cpp @@ -49,21 +49,27 @@ using ov::OutputVector; static std::tuple, std::shared_ptr> general_alibi_pattern() { // Optional pattern to capture alibi slopes (based on pattern from bloom) auto general_alibi = ov::pass::pattern::any_input(); - auto general_sdpa_mask = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), general_alibi}); // apply input position_ids - general_sdpa_mask = ov::pass::pattern::wrap_type({general_sdpa_mask, ov::pass::pattern::any_input()}); - general_sdpa_mask = ov::pass::pattern::wrap_type({general_sdpa_mask, ov::pass::pattern::any_input()}); - general_sdpa_mask = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), general_sdpa_mask}); + auto general_sdpa_mask = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), general_alibi}); // apply input position_ids + general_sdpa_mask = + ov::pass::pattern::wrap_type({general_sdpa_mask, ov::pass::pattern::any_input()}); + general_sdpa_mask = + ov::pass::pattern::wrap_type({general_sdpa_mask, ov::pass::pattern::any_input()}); + general_sdpa_mask = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), general_sdpa_mask}); return {general_alibi, general_sdpa_mask}; } static std::tuple, std::shared_ptr> jais_13b_alibi_pattern() { auto jais_13b_alibi = ov::pass::pattern::any_input(); auto mirroring_abs = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); - auto unsqueeze = ov::pass::pattern::wrap_type({mirroring_abs, ov::pass::pattern::any_input()}); + auto unsqueeze = + ov::pass::pattern::wrap_type({mirroring_abs, ov::pass::pattern::any_input()}); auto jais_alibi_mask = ov::pass::pattern::wrap_type({jais_13b_alibi, unsqueeze}); - jais_alibi_mask = ov::pass::pattern::wrap_type({jais_alibi_mask, ov::pass::pattern::any_input()}); - jais_alibi_mask = ov::pass::pattern::wrap_type({jais_alibi_mask, ov::pass::pattern::any_input()}); + jais_alibi_mask = + ov::pass::pattern::wrap_type({jais_alibi_mask, ov::pass::pattern::any_input()}); + jais_alibi_mask = + ov::pass::pattern::wrap_type({jais_alibi_mask, ov::pass::pattern::any_input()}); jais_alibi_mask = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), jais_alibi_mask}); return {jais_13b_alibi, jais_alibi_mask}; } @@ -71,29 +77,40 @@ static std::tuple, std::shared_ptr> jais_13b static std::tuple, std::shared_ptr> baichuan2_13b_alibi_pattern() { auto baichuan2_alibi = ov::pass::pattern::any_input(); // this slice expected to be replaced with Slice(alibi_const, start {1, 1}, stop {2, 2}, step {1, 1}, axes{1, 2}); - auto alibi_slice_to_replace = ov::pass::pattern::wrap_type( - {baichuan2_alibi, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto alibi_slice_to_replace = ov::pass::pattern::wrap_type({baichuan2_alibi, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); auto alibi_path = ov::pass::pattern::wrap_type({alibi_slice_to_replace}); - alibi_path = ov::pass::pattern::wrap_type({alibi_path, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - alibi_path = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), alibi_path}); + alibi_path = ov::pass::pattern::wrap_type( + {alibi_path, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + alibi_path = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), alibi_path}); alibi_path = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), alibi_path}); alibi_path = ov::pass::pattern::wrap_type({alibi_path}); alibi_path = ov::pass::pattern::wrap_type({alibi_path, ov::pass::pattern::any_input()}); alibi_path = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), alibi_path}); - alibi_path = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), alibi_path}); - auto alibi_unsqueeze = ov::pass::pattern::wrap_type({alibi_slice_to_replace, ov::pass::pattern::any_input()}); + alibi_path = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), alibi_path}); + auto alibi_unsqueeze = + ov::pass::pattern::wrap_type({alibi_slice_to_replace, ov::pass::pattern::any_input()}); alibi_path = ov::pass::pattern::wrap_type({alibi_path, alibi_unsqueeze}); - auto mul = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - alibi_path = ov::pass::pattern::wrap_type( - {alibi_path, mul, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto mul = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + alibi_path = ov::pass::pattern::wrap_type({alibi_path, + mul, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); return {baichuan2_alibi, alibi_path}; } static std::shared_ptr handle_general_alibi(const std::shared_ptr& matched_general_alibi_slopes) { std::shared_ptr res_alibi_slopes = std::make_shared(matched_general_alibi_slopes, - ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}), - false); + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}), + false); if (res_alibi_slopes->get_element_type() != ov::element::f32) { res_alibi_slopes = std::make_shared(res_alibi_slopes, ov::element::f32); } @@ -119,14 +136,14 @@ static std::shared_ptr handle_jais_13b_alibi(const std::shared_ptr(res_alibi_slopes, - ov::op::v0::Constant::create(res_alibi_slopes->get_element_type(), {}, {-1})); + res_alibi_slopes = std::make_shared( + res_alibi_slopes, + ov::op::v0::Constant::create(res_alibi_slopes->get_element_type(), {}, {-1})); } } else { - res_alibi_slopes = - std::make_shared(res_alibi_slopes, - ov::op::v0::Constant::create(res_alibi_slopes->get_element_type(), {}, {-1})); + res_alibi_slopes = std::make_shared( + res_alibi_slopes, + ov::op::v0::Constant::create(res_alibi_slopes->get_element_type(), {}, {-1})); } return res_alibi_slopes; @@ -173,9 +190,10 @@ static std::shared_ptr handle_baichuan2_13b_alibi( auto axes = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {1, 2}); // the Slice to extract the correct values res_alibi_slopes = std::make_shared(res_alibi_slopes, start, stop, step, axes); - res_alibi_slopes = std::make_shared(res_alibi_slopes, - ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}), - false); + res_alibi_slopes = + std::make_shared(res_alibi_slopes, + ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}), + false); if (res_alibi_slopes->get_element_type() != ov::element::f32) { res_alibi_slopes = std::make_shared(res_alibi_slopes, ov::element::f32); } @@ -184,26 +202,34 @@ static std::shared_ptr handle_baichuan2_13b_alibi( } static std::tuple, std::shared_ptr> phi3_sliding_window_pattern() { -auto offset = ov::pass::pattern::wrap_type(); + auto offset = ov::pass::pattern::wrap_type(); auto t196 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), offset}); auto t197 = ov::pass::pattern::optional(t196); - auto t200 = ov::pass::pattern::wrap_type({t197, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto t200 = ov::pass::pattern::wrap_type( + {t197, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto t201 = ov::pass::pattern::wrap_type({t200, ov::pass::pattern::any_input()}); auto t202 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), t201}); - auto t208 = ov::pass::pattern::wrap_type({t202, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto t208 = ov::pass::pattern::wrap_type( + {t202, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto t209 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), t208}); auto t210 = ov::pass::pattern::optional(t209); - auto t211 = ov::pass::pattern::wrap_type({t210, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto t211 = ov::pass::pattern::wrap_type( + {t210, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto t213 = ov::pass::pattern::wrap_type({t211, ov::pass::pattern::any_input()}); auto t214 = ov::pass::pattern::wrap_type({t213, ov::pass::pattern::any_input()}); auto t218 = ov::pass::pattern::wrap_type({t214, ov::pass::pattern::any_input()}); - auto t219 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), t218}); - auto mask = ov::pass::pattern::wrap_type({t219, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto t219 = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), t218}); + auto mask = ov::pass::pattern::wrap_type({t219, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); return {mask, offset}; } static std::tuple, std::shared_ptr> gpt_oss_sliding_window_pattern() { -auto q_idx = ov::pass::pattern::any_input(); + auto q_idx = ov::pass::pattern::any_input(); auto kv_idx = ov::pass::pattern::any_input(); auto kv_idx_opt_conv = ov::pass::pattern::optional(kv_idx); @@ -213,18 +239,28 @@ auto q_idx = ov::pass::pattern::any_input(); auto add = ov::pass::pattern::wrap_type({q_idx, offset}); auto greater = ov::pass::pattern::wrap_type({kv_idx_opt_conv, add}); auto bitwise_and = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), greater}); - auto bitwise_and_1 = ov::pass::pattern::wrap_type({bitwise_and, ov::pass::pattern::any_input()}); - auto bitwise_and_2 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), bitwise_and_1}); - auto bitwise_and_3 = ov::pass::pattern::wrap_type({bitwise_and_2, ov::pass::pattern::any_input()}); - auto broadcast = ov::pass::pattern::wrap_type({bitwise_and_3, ov::pass::pattern::any_input()}); - auto select = ov::pass::pattern::wrap_type({broadcast, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); - auto mask = ov::pass::pattern::wrap_type({select, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto bitwise_and_1 = + ov::pass::pattern::wrap_type({bitwise_and, ov::pass::pattern::any_input()}); + auto bitwise_and_2 = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), bitwise_and_1}); + auto bitwise_and_3 = + ov::pass::pattern::wrap_type({bitwise_and_2, ov::pass::pattern::any_input()}); + auto broadcast = + ov::pass::pattern::wrap_type({bitwise_and_3, ov::pass::pattern::any_input()}); + auto select = ov::pass::pattern::wrap_type( + {broadcast, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto mask = ov::pass::pattern::wrap_type({select, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); return {mask, offset}; } // Exactly copied the function from another file. Maybe should be moved to some general file -static std::shared_ptr setName(std::shared_ptr node, const std::string& name) { +static std::shared_ptr setName(std::shared_ptr node, + const std::string& name) { // Set name for both node and output tensor (should be only one tensor, and any other names will be overriden by a // given single name) node->set_friendly_name(name); @@ -241,15 +277,17 @@ static node_tuple kv_read_and_concat(ov::Output kv_current) { auto kv_past_var = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); auto kv_past_par = ov::pass::pattern::wrap_type(); auto kv_past = std::make_shared( - OutputVector{ov::pass::pattern::wrap_type({kv_past_var, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}), + OutputVector{ov::pass::pattern::wrap_type( + {kv_past_var, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}), kv_past_par}); kv_past = std::make_shared( OutputVector{kv_past, ov::pass::pattern::wrap_type( - {kv_past, ov::pass::pattern::any_input()})}); // Transpose is used when kv-cache is stored in a not - // usual layout, example: bloom + {kv_past, ov::pass::pattern::any_input()})}); // Transpose is used when kv-cache is stored in + // a not usual layout, example: bloom auto kv_current2 = ov::pass::pattern::any_input(); - auto kv_current_reshaped = ov::pass::pattern::wrap_type({kv_current2, ov::pass::pattern::any_input()}); + auto kv_current_reshaped = + ov::pass::pattern::wrap_type({kv_current2, ov::pass::pattern::any_input()}); auto kv_concat = ov::pass::pattern::wrap_type( {kv_past, std::make_shared(OutputVector{kv_current_reshaped, kv_current})}); return node_tuple(kv_past_par, kv_current2, kv_current_reshaped, kv_concat); @@ -325,14 +363,14 @@ ov::pass::StateManagementPattern::StateManagementPattern( // TODO: Consider not specifying VariadicSplit as an input for Concat, it is not really used in the pattern, but // just sets more strict requirement for the graph. The risk with not specifying VariadicSplit is that it can be // ambiguous which part the matcher should take: KV merged part or where K and V are separate, requires experiments. - auto qkv_current_split_node = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto qkv_current_split_node = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); qkv_current_split_node->set_output_size(2); auto kv_current = qkv_current_split_node->output(1); std::shared_ptr kv_past_par, kv_current2, kv_concat, kv_current_reshaped; std::tie(kv_past_par, kv_current2, kv_current_reshaped, kv_concat) = kv_read_and_concat(kv_current); - auto kv_concat_split = - ov::pass::pattern::wrap_type({kv_concat, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto kv_concat_split = ov::pass::pattern::wrap_type( + {kv_concat, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); kv_concat_split->set_output_size(2); k_concat = std::make_shared(OutputVector{kv_concat_split->output(0), k_concat}); @@ -341,18 +379,24 @@ ov::pass::StateManagementPattern::StateManagementPattern( auto kv_shaping = [=](const std::shared_ptr& kv_concat, std::shared_ptr& unsqueeze) { // Return unsqeeze (return param) to deduce number of kv heads in // the place where they are being broadcases in case of GQA and MQ - auto interim = ov::pass::pattern::wrap_type( - {kv_concat, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto interim = ov::pass::pattern::wrap_type({kv_concat, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); interim = ov::pass::pattern::wrap_type( {interim, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); unsqueeze = ov::pass::pattern::wrap_type( - {std::make_shared(OutputVector{kv_concat, interim}), ov::pass::pattern::any_input()}); - interim = ov::pass::pattern::wrap_type( - {unsqueeze, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + {std::make_shared(OutputVector{kv_concat, interim}), + ov::pass::pattern::any_input()}); + interim = ov::pass::pattern::wrap_type({unsqueeze, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); interim = ov::pass::pattern::wrap_type( {interim, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); interim = ov::pass::pattern::wrap_type( - {std::make_shared(OutputVector{unsqueeze, interim}), ov::pass::pattern::any_input()}); + {std::make_shared(OutputVector{unsqueeze, interim}), + ov::pass::pattern::any_input()}); interim = std::make_shared( OutputVector{ov::pass::pattern::wrap_type({interim, ov::pass::pattern::any_input()}), interim}); // Reshape is missing sometimes in MQA case @@ -364,8 +408,10 @@ ov::pass::StateManagementPattern::StateManagementPattern( auto k_shaped = kv_shaping(k_concat, k_heads_unsqueeze); auto v_shaped = kv_shaping(v_concat, v_heads_unsqueeze); - auto k_simply_shaped = ov::pass::pattern::wrap_type({k_concat, ov::pass::pattern::any_input()}); - auto v_simply_shaped = ov::pass::pattern::wrap_type({v_concat, ov::pass::pattern::any_input()}); + auto k_simply_shaped = + ov::pass::pattern::wrap_type({k_concat, ov::pass::pattern::any_input()}); + auto v_simply_shaped = + ov::pass::pattern::wrap_type({v_concat, ov::pass::pattern::any_input()}); auto k_order = ov::pass::pattern::any_input(); auto v_order = ov::pass::pattern::any_input(); @@ -404,29 +450,30 @@ ov::pass::StateManagementPattern::StateManagementPattern( auto q = ov::pass::pattern::any_input(); auto scale_input = ov::pass::pattern::any_input(scale_predicate); - auto sinks = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape() && ov::pass::pattern::rank_equals(4)); + auto sinks = + ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape() && ov::pass::pattern::rank_equals(4)); - auto k_to_sdpa = - std::make_shared(OutputVector{k_concat, k_shaped, k_shaped_transposed, k_simply_shaped}); - auto v_to_sdpa = - std::make_shared(OutputVector{v_concat, v_shaped, v_shaped_transposed, v_simply_shaped}); + auto k_to_sdpa = std::make_shared( + OutputVector{k_concat, k_shaped, k_shaped_transposed, k_simply_shaped}); + auto v_to_sdpa = std::make_shared( + OutputVector{v_concat, v_shaped, v_shaped_transposed, v_simply_shaped}); auto mask_to_sdpa = std::make_shared(OutputVector{phi3_mask, - general_alibi_mask, - jais_alibi_mask, - baichuan2_13b_alibi_mask, - gpt_oss_mask, - ov::pass::pattern::any_input()}); + general_alibi_mask, + jais_alibi_mask, + baichuan2_13b_alibi_mask, + gpt_oss_mask, + ov::pass::pattern::any_input()}); auto sdpa_with_4_inputs = ov::pass::pattern::wrap_type({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa}); - auto sdpa_with_5_inputs = - ov::pass::pattern::wrap_type({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa, scale_input}); - auto sdpa_with_6_inputs = - ov::pass::pattern::wrap_type({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa, scale_input, sinks}); + auto sdpa_with_5_inputs = ov::pass::pattern::wrap_type( + {q, k_to_sdpa, v_to_sdpa, mask_to_sdpa, scale_input}); + auto sdpa_with_6_inputs = ov::pass::pattern::wrap_type( + {q, k_to_sdpa, v_to_sdpa, mask_to_sdpa, scale_input, sinks}); - auto sdpa_variants = - std::make_shared(OutputVector{sdpa_with_4_inputs, sdpa_with_5_inputs, sdpa_with_6_inputs}); + auto sdpa_variants = std::make_shared( + OutputVector{sdpa_with_4_inputs, sdpa_with_5_inputs, sdpa_with_6_inputs}); ov::matcher_pass_callback callback = [=, &kv_parameters, @@ -467,10 +514,12 @@ ov::pass::StateManagementPattern::StateManagementPattern( auto num_v_heads = num_v_heads_dim.get_length(); std::string layer_index_str = std::to_string(layer_index); - auto k_parameter = setName(std::make_shared(element::dynamic, ov::PartialShape::dynamic(4)), - "key_cache." + layer_index_str); - auto v_parameter = setName(std::make_shared(element::dynamic, ov::PartialShape::dynamic(4)), - "value_cache." + layer_index_str); + auto k_parameter = + setName(std::make_shared(element::dynamic, ov::PartialShape::dynamic(4)), + "key_cache." + layer_index_str); + auto v_parameter = + setName(std::make_shared(element::dynamic, ov::PartialShape::dynamic(4)), + "value_cache." + layer_index_str); layer_index += 1; kv_parameters.push_back(k_parameter); @@ -479,7 +528,9 @@ ov::pass::StateManagementPattern::StateManagementPattern( auto q_transpose = std::make_shared(real_q, kv_transpose_order); auto q_reshape = - std::make_shared(q_transpose, ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -1}), true); + std::make_shared(q_transpose, + ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -1}), + true); ov::Output k_target_layout, v_target_layout; if (pattern_map.count(qkv_current_split_node)) { @@ -523,26 +574,32 @@ ov::pass::StateManagementPattern::StateManagementPattern( if (pattern_map.find(k_order) != pattern_map .end()) { // reapply transpose found in the graph by manipulating of indices of our Transpose - k_transpose_order = std::make_shared(pattern_map.at(k_order), - kv_transpose_order, - ov::op::v0::Constant::create(element::i64, Shape{}, {0})); + k_transpose_order = + std::make_shared(pattern_map.at(k_order), + kv_transpose_order, + ov::op::v0::Constant::create(element::i64, Shape{}, {0})); } k_target_layout = std::make_shared(real_k, k_transpose_order); std::shared_ptr v_transpose_order = kv_transpose_order; if (pattern_map.find(v_order) != pattern_map .end()) { // reapply transpose found in the graph by manipulating of indices of our Transpose - v_transpose_order = std::make_shared(pattern_map.at(v_order), - kv_transpose_order, - ov::op::v0::Constant::create(element::i64, Shape{}, {0})); + v_transpose_order = + std::make_shared(pattern_map.at(v_order), + kv_transpose_order, + ov::op::v0::Constant::create(element::i64, Shape{}, {0})); } v_target_layout = std::make_shared(real_v, v_transpose_order); } auto k_reshape = - std::make_shared(k_target_layout, ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -1}), true); + std::make_shared(k_target_layout, + ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -1}), + true); auto v_reshape = - std::make_shared(v_target_layout, ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -1}), true); + std::make_shared(v_target_layout, + ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -1}), + true); std::shared_ptr scale; if (pattern_map.count(scale_input)) { @@ -562,12 +619,14 @@ ov::pass::StateManagementPattern::StateManagementPattern( // propagation may not always derive it as a constant. That's why a sub-graph computing `scale` is built // instead of just a constant node representing one of the dimensions. auto hidden_shape = std::make_shared(real_q); - auto hidden_dim = std::make_shared(hidden_shape, - ov::op::v0::Constant::create(element::i64, Shape{}, {-1}), - ov::op::v0::Constant::create(element::i64, Shape{}, {0})); + auto hidden_dim = + std::make_shared(hidden_shape, + ov::op::v0::Constant::create(element::i64, Shape{}, {-1}), + ov::op::v0::Constant::create(element::i64, Shape{}, {0})); scale = std::make_shared( ov::op::v0::Constant::create(element::f32, Shape{}, {1}), - std::make_shared(std::make_shared(hidden_dim, element::f32))); + std::make_shared( + std::make_shared(hidden_dim, element::f32))); } } @@ -591,7 +650,9 @@ ov::pass::StateManagementPattern::StateManagementPattern( if (offset->get_element_type() != element::i32) { offset = std::make_shared(offset, element::i32); } - sliding_window = std::make_shared(ov::op::v0::Constant::create(element::i32, Shape{}, {2}), offset); + sliding_window = + std::make_shared(ov::op::v0::Constant::create(element::i32, Shape{}, {2}), + offset); } else if (pattern_map.count(gpt_oss_offset)) { auto offset = pattern_map.at(gpt_oss_offset).get_node_shared_ptr(); if (pattern_map.at(gpt_oss_offset).get_partial_shape().rank() != 0) { @@ -600,7 +661,9 @@ ov::pass::StateManagementPattern::StateManagementPattern( if (offset->get_element_type() != element::i32) { offset = std::make_shared(offset, element::i32); } - sliding_window = std::make_shared(offset, ov::op::v0::Constant::create(element::i32, Shape{}, {-1})); + sliding_window = + std::make_shared(offset, + ov::op::v0::Constant::create(element::i32, Shape{}, {-1})); } else { sliding_window = ov::op::v0::Constant::create(element::i32, Shape{}, {0}); } @@ -634,8 +697,9 @@ ov::pass::StateManagementPattern::StateManagementPattern( optional_model_wide_params.find("model_rotation_trig_lut") != optional_model_wide_params.end(), "No model_rotation_trig_lut input found. For using cache rotation, the model have to contain " "an additional input (Parameter) called model_rotation_trig_lut."); - auto rotated_block_indices = setName(std::make_shared(element::i32, PartialShape{-1}), - "rotated_block_indices." + std::to_string(layer_index - 1)); + auto rotated_block_indices = + setName(std::make_shared(element::i32, PartialShape{-1}), + "rotated_block_indices." + std::to_string(layer_index - 1)); auto rotation_deltas = setName(std::make_shared(element::i32, PartialShape{-1, -1}), "rotation_deltas." + std::to_string(layer_index - 1)); @@ -700,16 +764,18 @@ ov::pass::StateManagementPattern::StateManagementPattern( // The output shape of PagedAttention will be converted to [batch, 1, head_num, head_size_v], the head_size_v // may be different from head_size_q/head_size_k. The head_size_v could be got from the shape of value input - auto hidden_dim_v = std::make_shared(std::make_shared(v_target_layout), - ov::op::v0::Constant::create(element::i64, Shape{}, {-1}), - ov::op::v0::Constant::create(element::i64, Shape{}, {0})); + auto hidden_dim_v = + std::make_shared(std::make_shared(v_target_layout), + ov::op::v0::Constant::create(element::i64, Shape{}, {-1}), + ov::op::v0::Constant::create(element::i64, Shape{}, {0})); auto pa_shape = std::make_shared( OutputVector{ ov::op::v0::Constant::create(element::i64, Shape{1}, {0}), ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), ov::op::v0::Constant::create(element::i64, Shape{1}, {-1}), - std::make_shared(hidden_dim_v, ov::op::v0::Constant::create(element::i64, Shape{}, {0})), + std::make_shared(hidden_dim_v, + ov::op::v0::Constant::create(element::i64, Shape{}, {0})), }, 0); auto pa_reshape = std::make_shared(paged_attention->output(0), pa_shape, true); diff --git a/src/common/transformations/src/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.cpp b/src/common/transformations/src/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.cpp index 1f53ac65b13212..c72d3daaa52382 100644 --- a/src/common/transformations/src/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.cpp +++ b/src/common/transformations/src/transformations/sdpa_to_paged_attention/total_sequence_length_pattern.cpp @@ -39,12 +39,14 @@ ov::pass::TotalSequenceLengthPattern::TotalSequenceLengthPattern( MATCHER_SCOPE(TotalSequenceLengthPattern); auto kv_past = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}); - auto kv_gather = ov::pass::pattern::wrap_type({kv_past, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto kv_gather = ov::pass::pattern::wrap_type( + {kv_past, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto kv_current = ov::pass::pattern::any_input(); auto kv_concat = ov::pass::pattern::wrap_type({kv_gather, kv_current}); auto kv_shape = ov::pass::pattern::wrap_type({kv_concat}); auto gather_idx_label = ov::pass::pattern::wrap_type(); - auto seq = ov::pass::pattern::wrap_type({kv_shape, gather_idx_label, ov::pass::pattern::any_input()}); + auto seq = + ov::pass::pattern::wrap_type({kv_shape, gather_idx_label, ov::pass::pattern::any_input()}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { // TODO: Check that seq has axis that really takes sequence len but not any other dimension -- @@ -115,17 +117,22 @@ ov::pass::TotalSequenceLengthPatternQwen::TotalSequenceLengthPatternQwen( MATCHER_SCOPE(TotalSequenceLengthPatternQwen); auto p_input_ids = ov::pass::pattern::wrap_type(); - auto p_unsqueeze = ov::pass::pattern::wrap_type({p_input_ids, ov::pass::pattern::any_input()}); - auto p_opt_reshape_1 = ov::pass::pattern::optional({p_unsqueeze, ov::pass::pattern::any_input()}); + auto p_unsqueeze = + ov::pass::pattern::wrap_type({p_input_ids, ov::pass::pattern::any_input()}); + auto p_opt_reshape_1 = + ov::pass::pattern::optional({p_unsqueeze, ov::pass::pattern::any_input()}); auto p_opt_convert_1 = ov::pass::pattern::optional(p_opt_reshape_1); auto p_kv_shape_current = ov::pass::pattern::wrap_type({p_opt_convert_1}); - auto p_seq_current = ov::pass::pattern::wrap_type({p_kv_shape_current, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto p_seq_current = ov::pass::pattern::wrap_type( + {p_kv_shape_current, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto p_opt_convert_2 = ov::pass::pattern::optional(p_seq_current); auto p_max_context_len = ov::pass::pattern::wrap_type(); - auto p_prev_max_seq_len = ov::pass::pattern::wrap_type({p_max_context_len, ov::pass::pattern::any_input()}); + auto p_prev_max_seq_len = + ov::pass::pattern::wrap_type({p_max_context_len, ov::pass::pattern::any_input()}); auto p_opt_convert_3 = ov::pass::pattern::optional(p_prev_max_seq_len); - auto p_opt_reshape_2 = ov::pass::pattern::optional({p_opt_convert_3, ov::pass::pattern::any_input()}); + auto p_opt_reshape_2 = + ov::pass::pattern::optional({p_opt_convert_3, ov::pass::pattern::any_input()}); auto p_total_seq = ov::pass::pattern::wrap_type({p_opt_convert_2, p_opt_reshape_2}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { @@ -150,12 +157,15 @@ ov::pass::TotalSequenceLengthPatternCodeGen2::TotalSequenceLengthPatternCodeGen2 MATCHER_SCOPE(TotalSequenceLengthPatternCodeGen2); auto p_max_context_len = ov::pass::pattern::wrap_type(); - auto p_sub = ov::pass::pattern::wrap_type({p_max_context_len, ov::pass::pattern::any_input()}); + auto p_sub = + ov::pass::pattern::wrap_type({p_max_context_len, ov::pass::pattern::any_input()}); auto p_conv = ov::pass::pattern::wrap_type({p_sub}); - auto p_var_split = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto p_var_split = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto p_kv_shape_current = ov::pass::pattern::wrap_type({p_var_split}); - auto p_gather = ov::pass::pattern::wrap_type({p_kv_shape_current, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto p_gather = ov::pass::pattern::wrap_type( + {p_kv_shape_current, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); auto p_total_seq = ov::pass::pattern::wrap_type({p_gather, p_conv}); matcher_pass_callback callback = [=, &max_context_len](ov::pass::pattern::Matcher& m) { diff --git a/src/common/transformations/src/transformations/smart_reshape/proposal_scales_stridedslice.cpp b/src/common/transformations/src/transformations/smart_reshape/proposal_scales_stridedslice.cpp index 4071d31cdb1cd0..81ea8315a189a5 100644 --- a/src/common/transformations/src/transformations/smart_reshape/proposal_scales_stridedslice.cpp +++ b/src/common/transformations/src/transformations/smart_reshape/proposal_scales_stridedslice.cpp @@ -53,8 +53,8 @@ ov::pass::Proposal1Scales::Proposal1Scales() { [](const Output& output) { return output.get_partial_shape().rank().is_static() && output.get_partial_shape().rank().get_length() == 1; }); - auto proposal_label = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), reshape_label}); + auto proposal_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), reshape_label}); matcher_pass_callback callback = [parameter_label, proposal_label](ov::pass::pattern::Matcher& m) -> bool { return crop_scales_for_proposal(m.get_pattern_value_map(), parameter_label, proposal_label); @@ -77,8 +77,8 @@ ov::pass::Proposal4Scales::Proposal4Scales() { [](const Output& output) { return output.get_partial_shape().rank().is_static() && output.get_partial_shape().rank().get_length() == 1; }); - auto proposal_label = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), reshape_label}); + auto proposal_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), reshape_label}); matcher_pass_callback callback = [parameter_label, proposal_label](ov::pass::pattern::Matcher& m) -> bool { return crop_scales_for_proposal(m.get_pattern_value_map(), parameter_label, proposal_label); diff --git a/src/common/transformations/src/transformations/smart_reshape/strided_slice_squeeze.cpp b/src/common/transformations/src/transformations/smart_reshape/strided_slice_squeeze.cpp index 68070212ccadbb..0130c01746b6f9 100644 --- a/src/common/transformations/src/transformations/smart_reshape/strided_slice_squeeze.cpp +++ b/src/common/transformations/src/transformations/smart_reshape/strided_slice_squeeze.cpp @@ -118,8 +118,10 @@ ov::pass::SqueezeStridedSlice::SqueezeStridedSlice() { auto squeeze_label = ov::pass::pattern::wrap_type( {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, ov::pass::pattern::consumers_count(1)); - auto ss_label = ov::pass::pattern::wrap_type( - {squeeze_label, ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}); + auto ss_label = ov::pass::pattern::wrap_type({squeeze_label, + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::any_input()}); matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) -> bool { auto slice = ov::as_type_ptr(m.get_match_root()); diff --git a/src/common/transformations/src/transformations/symbolic_transformations/dereshape_matmul.cpp b/src/common/transformations/src/transformations/symbolic_transformations/dereshape_matmul.cpp index 4d7b75576c44b3..89c77c6a4eb2de 100644 --- a/src/common/transformations/src/transformations/symbolic_transformations/dereshape_matmul.cpp +++ b/src/common/transformations/src/transformations/symbolic_transformations/dereshape_matmul.cpp @@ -184,13 +184,13 @@ void pull_reshape_through_optional_concat_and_bea(const ov::pass::pattern::Patte } } // namespace -#define IN_RESHAPE \ +#define IN_RESHAPE \ ov::pass::pattern::wrap_type([](std::shared_ptr n) -> bool { \ return ov::pass::pattern::consumers_count(1)(n->output(0)) && reshape_keeps_last_two_dims(n); \ }); #define SCALAR_INPUT \ - ov::pass::pattern::any_input([](ov::Output out) { \ + ov::pass::pattern::any_input([](ov::Output out) { \ return out.get_partial_shape().is_static() && ov::shape_size(out.get_shape()) == 1; \ }); @@ -201,36 +201,42 @@ ov::pass::DeReshapeMatMul::DeReshapeMatMul() { // lhs of MatMul auto lhs_reshape = IN_RESHAPE; - auto lhs_concat_0 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), lhs_reshape}, concat_predicate); - auto lhs_concat_1 = ov::pass::pattern::wrap_type({lhs_reshape, ov::pass::pattern::any_input()}, concat_predicate); + auto lhs_concat_0 = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), lhs_reshape}, concat_predicate); + auto lhs_concat_1 = + ov::pass::pattern::wrap_type({lhs_reshape, ov::pass::pattern::any_input()}, concat_predicate); auto lhs_concat = std::make_shared(OutputVector{lhs_concat_0, lhs_concat_1}); auto lhs_reshape_or_concat = std::make_shared(OutputVector{lhs_reshape, lhs_concat}); auto lhs_bea_scalar = SCALAR_INPUT; - auto lhs_bea = ov::pass::pattern::wrap_type({lhs_reshape_or_concat, lhs_bea_scalar}, - ov::pass::pattern::consumers_count(1)); + auto lhs_bea = + ov::pass::pattern::wrap_type({lhs_reshape_or_concat, lhs_bea_scalar}, + ov::pass::pattern::consumers_count(1)); auto lhs_bea_or_concat = std::make_shared(OutputVector{lhs_reshape_or_concat, lhs_bea}); // rhs of MatMul auto rhs_reshape = IN_RESHAPE; - auto rhs_concat_0 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), rhs_reshape}, concat_predicate); - auto rhs_concat_1 = ov::pass::pattern::wrap_type({rhs_reshape, ov::pass::pattern::any_input()}, concat_predicate); + auto rhs_concat_0 = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), rhs_reshape}, concat_predicate); + auto rhs_concat_1 = + ov::pass::pattern::wrap_type({rhs_reshape, ov::pass::pattern::any_input()}, concat_predicate); auto rhs_concat = std::make_shared(OutputVector{rhs_concat_0, rhs_concat_1}); auto rhs_reshape_or_concat = std::make_shared(OutputVector{rhs_reshape, rhs_concat}); auto rhs_bea_scalar = SCALAR_INPUT; - auto rhs_bea = ov::pass::pattern::wrap_type({rhs_reshape_or_concat, rhs_bea_scalar}, - ov::pass::pattern::consumers_count(1)); + auto rhs_bea = + ov::pass::pattern::wrap_type({rhs_reshape_or_concat, rhs_bea_scalar}, + ov::pass::pattern::consumers_count(1)); auto rhs_bea_or_concat = std::make_shared(OutputVector{rhs_reshape_or_concat, rhs_bea}); // END: symmetrical patterns for MatMul inputs - auto matmul = - ov::pass::pattern::wrap_type({lhs_bea_or_concat, rhs_bea_or_concat}, ov::pass::pattern::consumers_count(1)); + auto matmul = ov::pass::pattern::wrap_type({lhs_bea_or_concat, rhs_bea_or_concat}, + ov::pass::pattern::consumers_count(1)); auto add = ov::pass::pattern::wrap_type( OutputVector{matmul, ov::pass::pattern::any_input()}, @@ -253,10 +259,10 @@ ov::pass::DeReshapeMatMul::DeReshapeMatMul() { }); auto matmul_or_add = std::make_shared(OutputVector{matmul, add}); - auto final_reshape = - ov::pass::pattern::wrap_type({matmul_or_add, ov::pass::pattern::any_input()}, [](std::shared_ptr n) -> bool { - return reshape_keeps_last_two_dims(n); - }); + auto final_reshape = ov::pass::pattern::wrap_type({matmul_or_add, ov::pass::pattern::any_input()}, + [](std::shared_ptr n) -> bool { + return reshape_keeps_last_two_dims(n); + }); ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { const auto& pm = m.get_pattern_map(); @@ -343,13 +349,17 @@ ov::pass::DeReshapeMatMul::DeReshapeMatMul() { ov::pass::DeReshapeFullyConnected::DeReshapeFullyConnected() { MATCHER_SCOPE(DeReshapeFullyConnected); -auto input = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("BATCHES_1...,Y")), ov::pass::pattern::any_input()}, - ov::pass::pattern::shape_matches("BATCHES_2...,Y")); + auto input = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("BATCHES_1...,Y")), + ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("BATCHES_2...,Y")); auto converted = ov::pass::pattern::optional(input, ov::pass::pattern::consumers_count(1)); - auto mm_label = ov::pass::pattern::wrap_type({converted, ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2))}, - ov::pass::pattern::consumers_count(1) && ov::pass::pattern::shape_matches("BATCHES_2...,Z"), - {{"transpose_a", false}}); - auto output = ov::pass::pattern::wrap_type({mm_label, ov::pass::pattern::any_input()}, ov::pass::pattern::shape_matches("BATCHES_1...,Z")); + auto mm_label = ov::pass::pattern::wrap_type( + {converted, ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(2))}, + ov::pass::pattern::consumers_count(1) && ov::pass::pattern::shape_matches("BATCHES_2...,Z"), + {{"transpose_a", false}}); + auto output = ov::pass::pattern::wrap_type({mm_label, ov::pass::pattern::any_input()}, + ov::pass::pattern::shape_matches("BATCHES_1...,Z")); ov::matcher_pass_callback matcher_pass_callback = [=](ov::pass::pattern::Matcher& m) { const auto& pm = m.get_pattern_map(); diff --git a/src/common/transformations/src/transformations/symbolic_transformations/reshape_optimizations.cpp b/src/common/transformations/src/transformations/symbolic_transformations/reshape_optimizations.cpp index 8704d5c21c7f83..11f32e6215b113 100644 --- a/src/common/transformations/src/transformations/symbolic_transformations/reshape_optimizations.cpp +++ b/src/common/transformations/src/transformations/symbolic_transformations/reshape_optimizations.cpp @@ -18,8 +18,10 @@ using namespace ov::symbol::util; ov::pass::ReshapeOptimizations::ReshapeOptimizations() { MATCHER_SCOPE(ReshapeOptimizations); auto data_label = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()); - auto pattern_label = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape() && ov::pass::pattern::class_other_than()); - auto reshape_label = ov::pass::pattern::wrap_type({data_label, pattern_label}, ov::pass::pattern::has_static_rank()); + auto pattern_label = ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape() && + ov::pass::pattern::class_other_than()); + auto reshape_label = ov::pass::pattern::wrap_type({data_label, pattern_label}, + ov::pass::pattern::has_static_rank()); ov::matcher_pass_callback matcher_pass_callback = [](ov::pass::pattern::Matcher& m) { const auto& reshape = ov::as_type_ptr(m.get_match_root()); diff --git a/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp b/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp index 905ff02ea331e6..4d6a449daaf52b 100644 --- a/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp +++ b/src/common/transformations/src/transformations/symbolic_transformations/symbolic_optimizations.cpp @@ -122,8 +122,10 @@ ov::pass::LabelResolvingThroughSelect::LabelResolvingThroughSelect() { auto add = ov::pass::pattern::wrap_type(); auto input_reshape = ov::pass::pattern::wrap_type({add, ov::pass::pattern::any_input()}); - auto select_then = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), input_reshape, ov::pass::pattern::any_input()}); - auto select_else = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), input_reshape}); + auto select_then = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), input_reshape, ov::pass::pattern::any_input()}); + auto select_else = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), input_reshape}); auto select = std::make_shared(OutputVector{select_then, select_else}); auto softmax = ov::pass::pattern::wrap_type({select}); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_binary.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_binary.cpp index e449cd5d6fcdac..b0c19afaecfd9e 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_binary.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_binary.cpp @@ -85,17 +85,19 @@ bool IsSpecialPRelu(NodePtr node) { TSBinaryBackward::TSBinaryBackward() { MATCHER_SCOPE(TSBinaryBackward); - auto main_node_label = ov::pass::pattern::wrap_type([](const Output& output) -> bool { - return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); - }); + return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); + }); auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = + ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { return ov::pass::pattern::has_static_rank()(output); }); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_concat.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_concat.cpp index a0e2486ae6826f..008529a9660e9c 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_concat.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_concat.cpp @@ -69,7 +69,8 @@ TSConcatBackward::TSConcatBackward() { auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = + ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { return ov::pass::pattern::has_static_rank()(output); }); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_cumsum.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_cumsum.cpp index 8aeb2cfaff0699..f67944996b2adc 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_cumsum.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_cumsum.cpp @@ -55,7 +55,8 @@ TSCumSumBackward::TSCumSumBackward() { auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = + ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { return ov::pass::pattern::has_static_rank()(output); }); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_data_movement.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_data_movement.cpp index aeabafc240a35a..e4353b25748d6d 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_data_movement.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_data_movement.cpp @@ -72,15 +72,16 @@ TSDataMovementForward::TSDataMovementForward() { TSDataMovementBackward::TSDataMovementBackward() { MATCHER_SCOPE(TSDataMovementBackward); - auto main_node_label = - ov::pass::pattern::wrap_type( + auto main_node_label = ov::pass::pattern:: + wrap_type( [](const Output& output) -> bool { return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); }); auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = + ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { return ov::pass::pattern::has_static_rank()(output); }); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_fuse.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_fuse.cpp index ee6e59832eee8e..60dc71f44d7d0e 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_fuse.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_fuse.cpp @@ -22,11 +22,11 @@ using namespace ov::pass::transpose_sinking::utils; TSFuse::TSFuse() { MATCHER_SCOPE(TransposeFuse); - auto transpose_1_label = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, - CheckTransposeConsumers); - auto transpose_2_label = - ov::pass::pattern::wrap_type({transpose_1_label, ov::pass::pattern::wrap_type()}); + auto transpose_1_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + CheckTransposeConsumers); + auto transpose_2_label = ov::pass::pattern::wrap_type( + {transpose_1_label, ov::pass::pattern::wrap_type()}); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_gather.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_gather.cpp index 1b36152a7a924e..61f7ce07569d69 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_gather.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_gather.cpp @@ -154,12 +154,16 @@ TSGatherForward::TSGatherForward() { TSGatherBackward::TSGatherBackward() { MATCHER_SCOPE(TSGatherBackward); - auto gather_label = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, - CheckTransposeConsumers); - auto transpose_label = ov::pass::pattern::wrap_type({gather_label, ov::pass::pattern::wrap_type()}, - [](const Output& output) -> bool { - return ov::pass::pattern::has_static_rank()(output); - }); + auto gather_label = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), + ov::pass::pattern::any_input(), + ov::pass::pattern::wrap_type()}, + CheckTransposeConsumers); + auto transpose_label = ov::pass::pattern::wrap_type( + {gather_label, ov::pass::pattern::wrap_type()}, + [](const Output& output) -> bool { + return ov::pass::pattern::has_static_rank()(output); + }); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_interpolate.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_interpolate.cpp index f098815f7609b9..042ef9e23e41d5 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_interpolate.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_interpolate.cpp @@ -64,13 +64,15 @@ TSInterpolateForward::TSInterpolateForward() { TSInterpolateBackward::TSInterpolateBackward() { MATCHER_SCOPE(TSInterpolateBackward); - auto main_node_label = ov::pass::pattern::wrap_type([](const Output& output) -> bool { - return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); - }); + auto main_node_label = + ov::pass::pattern::wrap_type([](const Output& output) -> bool { + return ov::pass::pattern::has_static_rank()(output) && CheckTransposeConsumers(output); + }); auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = + ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { return ov::pass::pattern::has_static_rank()(output); }); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_reduction.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_reduction.cpp index 794c14a6929b59..45ced9055e8a4a 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_reduction.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_reduction.cpp @@ -91,13 +91,15 @@ TSReductionForward::TSReductionForward() { TSReductionBackward::TSReductionBackward() { MATCHER_SCOPE(TSReductionBackward); - auto reduce_label = ov::pass::pattern::wrap_type( - {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, - CheckTransposeConsumers); - auto transpose_label = ov::pass::pattern::wrap_type({reduce_label, ov::pass::pattern::wrap_type()}, - [](const Output& output) -> bool { - return ov::pass::pattern::has_static_rank()(output); - }); + auto reduce_label = + ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + CheckTransposeConsumers); + auto transpose_label = ov::pass::pattern::wrap_type( + {reduce_label, ov::pass::pattern::wrap_type()}, + [](const Output& output) -> bool { + return ov::pass::pattern::has_static_rank()(output); + }); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_slice.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_slice.cpp index 1cbcf27487a864..018c7d9862ded9 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_slice.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_slice.cpp @@ -62,7 +62,8 @@ TSSliceBackward::TSSliceBackward() { auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = + ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { return ov::pass::pattern::has_static_rank()(output); }); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_split.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_split.cpp index cee444f491c8b2..ec28871ace3412 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_split.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_split.cpp @@ -157,7 +157,9 @@ TSSplitBackward::TSSplitBackward() { MATCHER_SCOPE(TSSplitBackward); auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), transpose_const_label}, IsSplitSinked); + auto transpose_label = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), transpose_const_label}, + IsSplitSinked); matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_value_map(); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_squeeze.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_squeeze.cpp index 7edcd10b4294fe..18b0ca805ce29c 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_squeeze.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_squeeze.cpp @@ -183,15 +183,17 @@ TSSqueezeForward::TSSqueezeForward() { TSSqueezeBackward::TSSqueezeBackward() { MATCHER_SCOPE(TSSqueezeBackward); - auto squeeze_with_1_input = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}, CheckTransposeConsumers); - auto squeeze_label = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, - CheckTransposeConsumers); + auto squeeze_with_1_input = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}, CheckTransposeConsumers); + auto squeeze_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + CheckTransposeConsumers); auto pattern = std::make_shared(OutputVector{squeeze_with_1_input, squeeze_label}); - auto transpose_label = ov::pass::pattern::wrap_type({pattern, ov::pass::pattern::wrap_type()}, - [](const Output& output) -> bool { - return ov::pass::pattern::has_static_rank()(output); - }); + auto transpose_label = ov::pass::pattern::wrap_type( + {pattern, ov::pass::pattern::wrap_type()}, + [](const Output& output) -> bool { + return ov::pass::pattern::has_static_rank()(output); + }); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_tile.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_tile.cpp index a605c38f7f08a4..a09b24de7313b4 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_tile.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_tile.cpp @@ -56,7 +56,8 @@ TSTileBackward::TSTileBackward() { auto transpose_const_label = ov::pass::pattern::wrap_type(); - auto transpose_label = ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, + auto transpose_label = + ov::pass::pattern::wrap_type({main_node_label, transpose_const_label}, [](const Output& output) -> bool { return ov::pass::pattern::has_static_rank()(output); }); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp index 1e50fea5d58c70..430f3b15cc0dd6 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp @@ -81,22 +81,24 @@ TSUnaryBackward::TSUnaryBackward() { return CheckTransposeConsumers(output); }; - auto unary_with_1_input_label = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}, unary_restrictions); - - auto unary_with_2_inputs_label = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, unary_restrictions); - auto unary_with_3_inputs_label = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, - unary_restrictions); + auto unary_with_1_input_label = + ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}, unary_restrictions); + + auto unary_with_2_inputs_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, + unary_restrictions); + auto unary_with_3_inputs_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, + unary_restrictions); auto unary_label = std::make_shared( ov::OutputVector{unary_with_1_input_label, unary_with_2_inputs_label, unary_with_3_inputs_label}); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_unsqueeze.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_unsqueeze.cpp index 3031c8092b032c..dc02b01c7635e8 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_unsqueeze.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_unsqueeze.cpp @@ -196,13 +196,14 @@ TSUnsqueezeForward::TSUnsqueezeForward() { TSUnsqueezeBackward::TSUnsqueezeBackward() { MATCHER_SCOPE(TSUnsqueezeBackward); - auto unsqueeze_label = - ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, - CheckTransposeConsumers); - auto transpose_label = ov::pass::pattern::wrap_type({unsqueeze_label, ov::pass::pattern::wrap_type()}, - [](const Output& output) -> bool { - return ov::pass::pattern::has_static_rank()(output); - }); + auto unsqueeze_label = ov::pass::pattern::wrap_type( + {ov::pass::pattern::any_input(), ov::pass::pattern::wrap_type()}, + CheckTransposeConsumers); + auto transpose_label = ov::pass::pattern::wrap_type( + {unsqueeze_label, ov::pass::pattern::wrap_type()}, + [](const Output& output) -> bool { + return ov::pass::pattern::has_static_rank()(output); + }); ov::matcher_pass_callback matcher_pass_callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) { const auto& pattern_to_output = m.get_pattern_map(); diff --git a/src/common/transformations/src/transformations/utils/utils.cpp b/src/common/transformations/src/transformations/utils/utils.cpp index dbf5fa544c0d0d..15d4798cc90918 100644 --- a/src/common/transformations/src/transformations/utils/utils.cpp +++ b/src/common/transformations/src/transformations/utils/utils.cpp @@ -147,14 +147,16 @@ bool has_f16_constants(const std::shared_ptr& function) { } bool is_large_language_model(const ov::Model& model, std::function)> func) { -const auto past = ov::pass::pattern::wrap_type(); + const auto past = ov::pass::pattern::wrap_type(); const auto convert_past = ov::pass::pattern::optional(past); const auto beam_idx = ov::pass::pattern::wrap_type(); - const auto gather_past = ov::pass::pattern::wrap_type({convert_past, beam_idx, ov::pass::pattern::wrap_type()}); + const auto gather_past = ov::pass::pattern::wrap_type( + {convert_past, beam_idx, ov::pass::pattern::wrap_type()}); const auto gather_convert = ov::pass::pattern::optional(gather_past); const auto concat_past_input = std::make_shared(OutputVector{convert_past, gather_convert}); - const auto concat = ov::pass::pattern::wrap_type({concat_past_input, ov::pass::pattern::any_input()}); + const auto concat = + ov::pass::pattern::wrap_type({concat_past_input, ov::pass::pattern::any_input()}); const auto convert_present = ov::pass::pattern::optional(concat); const auto present = ov::pass::pattern::wrap_type({convert_present}); const auto kvcache_matcher = std::make_shared(present, "KVCacheMatcher"); @@ -588,11 +590,11 @@ std::shared_ptr NewGenSlice(const std::shared_ptr& data, end_mask[axis] = 0; auto opt2 = ov::pass::pattern::wrap_type({data, begin, end, stride}, - {{"begin_mask", begin_mask}, - {"end_mask", end_mask}, - {"new_axis_mask", new_axis_mask}, - {"shrink_axis_mask", shrink_axis_mask}, - {"ellipsis_mask", ellipsis_mask}}); + {{"begin_mask", begin_mask}, + {"end_mask", end_mask}, + {"new_axis_mask", new_axis_mask}, + {"shrink_axis_mask", shrink_axis_mask}, + {"ellipsis_mask", ellipsis_mask}}); return opt1 | opt2; } @@ -605,7 +607,7 @@ std::tuple, std::shared_ptr> match_multi_query_bcst(const std::shared_ptr& kv) { using namespace ov::pass; -auto reshape_kv = ov::pass::pattern::wrap_type({kv, ov::pass::pattern::any_input()}); + auto reshape_kv = ov::pass::pattern::wrap_type({kv, ov::pass::pattern::any_input()}); auto unsqueeze_kv = ov::pass::pattern::wrap_type({kv, ov::pass::pattern::any_input()}); auto check_one = [](const Output& output) -> bool { @@ -620,13 +622,18 @@ auto reshape_kv = ov::pass::pattern::wrap_type({kv, ov::pas }; auto constant_bcst = ov::pass::pattern::wrap_type(check_one); - auto computed_bcst = - ov::pass::pattern::wrap_type({constant_bcst, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, {{"mode", "numpy"}}); + auto computed_bcst = ov::pass::pattern::wrap_type( + {constant_bcst, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}, + {{"mode", "numpy"}}); - auto multiply_kv = ov::pass::pattern::wrap_type({reshape_kv | unsqueeze_kv, constant_bcst | computed_bcst}); - auto computed_bcst3 = ov::pass::pattern::wrap_type({unsqueeze_kv, ov::pass::pattern::any_input()}, {{"mode", "bidirectional"}}); + auto multiply_kv = + ov::pass::pattern::wrap_type({reshape_kv | unsqueeze_kv, constant_bcst | computed_bcst}); + auto computed_bcst3 = + ov::pass::pattern::wrap_type({unsqueeze_kv, ov::pass::pattern::any_input()}, + {{"mode", "bidirectional"}}); - auto result = ov::pass::pattern::wrap_type({multiply_kv | computed_bcst3, ov::pass::pattern::any_input()}); + auto result = ov::pass::pattern::wrap_type( + {multiply_kv | computed_bcst3, ov::pass::pattern::any_input()}); return std::make_tuple(result, reshape_kv, unsqueeze_kv, computed_bcst, multiply_kv, computed_bcst3); } diff --git a/src/common/transformations/tests/common_optimizations/convert_pagedattn_inputs.cpp b/src/common/transformations/tests/common_optimizations/convert_pagedattn_inputs.cpp index 217f4fada04ecb..e4f05d3ce44215 100644 --- a/src/common/transformations/tests/common_optimizations/convert_pagedattn_inputs.cpp +++ b/src/common/transformations/tests/common_optimizations/convert_pagedattn_inputs.cpp @@ -210,12 +210,12 @@ TEST_P(ConvertPagedAttnInputsTest, checkPrecisionAndShape) { auto subsequence_begins = std::make_shared(ov::element::i32, PartialShape{DYN}); auto past_lens = std::make_shared(ov::element::i32, PartialShape{DYN}); auto key_cache_0 = std::make_shared(keyCachePrecision, - getCacheShape(keyCachePrecision, - numKeyHeads, - keyHeadSize, - keyCacheGroupSize, - blockSize[0], - quantKeybychannel)); + getCacheShape(keyCachePrecision, + numKeyHeads, + keyHeadSize, + keyCacheGroupSize, + blockSize[0], + quantKeybychannel)); auto value_cache_0 = std::make_shared( valueCachePrecision, getCacheShape(valueCachePrecision, numKeyHeads, valueHeadSize, valueCacheGroupSize, blockSize[1], false)); diff --git a/src/common/transformations/tests/common_optimizations/eliminate_unsqueeze_gather.cpp b/src/common/transformations/tests/common_optimizations/eliminate_unsqueeze_gather.cpp index 24e60c2ce8db1b..fca4fe5389103f 100644 --- a/src/common/transformations/tests/common_optimizations/eliminate_unsqueeze_gather.cpp +++ b/src/common/transformations/tests/common_optimizations/eliminate_unsqueeze_gather.cpp @@ -41,10 +41,12 @@ class EliminateUnsqueezeGatherTest : public TransformationTestsF, static std::shared_ptr transform(const TensorShape& inShape, const TensorType& inType, size_t axis) { const auto parameter = std::make_shared(inType, inShape); const auto unsqueeze = - std::make_shared(parameter, ov::op::v0::Constant::create(element::i64, Shape{1}, {axis})); - const auto gather = std::make_shared(unsqueeze, - ov::op::v0::Constant::create(element::i64, Shape{1}, {0}), - ov::op::v0::Constant::create(element::i64, Shape{1}, {axis})); + std::make_shared(parameter, + ov::op::v0::Constant::create(element::i64, Shape{1}, {axis})); + const auto gather = + std::make_shared(unsqueeze, + ov::op::v0::Constant::create(element::i64, Shape{1}, {0}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {axis})); const auto relu = std::make_shared(gather); return std::make_shared(OutputVector{relu}, ParameterVector{parameter}, "Actual"); } @@ -100,7 +102,9 @@ TEST_F(TransformationTestsF, GatherUnsqueezeReshape) { auto gather = std::make_shared(data, indices, axis); auto unsqueeze = - std::make_shared(gather, ov::op::v0::Constant::create(element::i32, Shape{1}, {1}), false); + std::make_shared(gather, + ov::op::v0::Constant::create(element::i32, Shape{1}, {1}), + false); const auto relu = std::make_shared(unsqueeze); model = std::make_shared(OutputVector{relu}, ParameterVector{data, indices}); manager.register_pass(); @@ -200,7 +204,8 @@ TEST_F(TransformationTestsF, GatherUnsqueezes) { auto unsqueeze_1 = std::make_shared(gather, axis); auto unsqueeze_2 = std::make_shared(gather, axis); - auto concat = std::make_shared(OutputVector{unsqueeze_0, unsqueeze_1, unsqueeze_2, axis}, 0); + auto concat = + std::make_shared(OutputVector{unsqueeze_0, unsqueeze_1, unsqueeze_2, axis}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data, indices}); manager.register_pass(); diff --git a/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp b/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp index 3b75582aa812f1..6e65133db6892e 100644 --- a/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp +++ b/src/common/transformations/tests/common_optimizations/mark_subgraph_to_keep_in_mixed_precision_test.cpp @@ -1367,11 +1367,13 @@ TEST(TransformationTests, MarkDivWithEpsToKeepInMixedPrecision_disable_for_quant TEST_F(TransformationTestsF, MarkRandomUniformAsPrecisionSensitive) { auto param = std::make_shared(ov::element::i32, ov::PartialShape{2}); - auto random_uniform = std::make_shared(param, - ov::op::v0::Constant::create(element::f32, {}, {0}), - ov::op::v0::Constant::create(element::f32, {}, {1}), - element::f32); - auto less = std::make_shared(random_uniform, ov::op::v0::Constant::create(element::f32, {1, 1}, {0.5})); + auto random_uniform = + std::make_shared(param, + ov::op::v0::Constant::create(element::f32, {}, {0}), + ov::op::v0::Constant::create(element::f32, {}, {1}), + element::f32); + auto less = + std::make_shared(random_uniform, ov::op::v0::Constant::create(element::f32, {1, 1}, {0.5})); auto res = std::make_shared(less); model = std::make_shared(OutputVector{res}, ParameterVector{param}); diff --git a/src/common/transformations/tests/common_optimizations/moc_transformations.cpp b/src/common/transformations/tests/common_optimizations/moc_transformations.cpp index fa75ad158a21e4..2cdf7a65cdb378 100644 --- a/src/common/transformations/tests/common_optimizations/moc_transformations.cpp +++ b/src/common/transformations/tests/common_optimizations/moc_transformations.cpp @@ -121,7 +121,7 @@ TEST(TransformationTests, TestModelTensorsConsistencyUseShapesFalse) { TEST_F(TransformationTestsF, SqueezeRemainsSqueezeAfterMOC) { { -auto input = std::make_shared(element::f32, Shape{30}); + auto input = std::make_shared(element::f32, Shape{30}); auto shape = ov::op::v0::Constant::create(element::i64, Shape{5}, {2, 3, 1, 5, 1}); auto reshape = std::make_shared(input, shape, false); auto unsqueeze_axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {0}); @@ -140,7 +140,7 @@ TEST_F(TransformationTestsF, MOCTest) { std::shared_ptr weights; std::shared_ptr weights_ref; { -auto data = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); + auto data = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); auto data1 = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); auto a_mul = std::make_shared(data, data1); weights = std::make_shared(element::f32, ov::Shape{3, 5}); @@ -155,7 +155,7 @@ auto data = std::make_shared(element::f32, ov::PartialSha manager.register_pass(false); } { -auto data = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); + auto data = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); auto data1 = std::make_shared(element::f32, ov::PartialShape{-1, -1, 5}); auto a_mul = std::make_shared(data, data1); weights_ref = std::make_shared(element::f32, ov::Shape{3, 5}); diff --git a/src/common/transformations/tests/common_optimizations/sdpa_fusion_test.cpp b/src/common/transformations/tests/common_optimizations/sdpa_fusion_test.cpp index eeff8876da8f63..8186a618c8700c 100644 --- a/src/common/transformations/tests/common_optimizations/sdpa_fusion_test.cpp +++ b/src/common/transformations/tests/common_optimizations/sdpa_fusion_test.cpp @@ -74,7 +74,8 @@ class SDPA { auto broadcast_to_shape = ov::op::v0::Constant::create(element::i32, Shape{sinks_broadcast_shape.size()}, broadcast_shape_value); auto sinks_param = make_shared(element::f16, sinks_shape); - m_sinks = make_shared(sinks_param, broadcast_to_shape, ov::op::BroadcastType::BIDIRECTIONAL); + m_sinks = + make_shared(sinks_param, broadcast_to_shape, ov::op::BroadcastType::BIDIRECTIONAL); m_sinks_rank = sinks_broadcast_shape.size(); params.push_back(sinks_param); } @@ -161,11 +162,12 @@ class SDPA { // Adjust the code for sinks if you see other values for them. // For now, there has been only one model with sinks: gpt-oss if (m_sinks_slice_type == SinksSliceType::Slice) { - softmax = make_shared(softmax, - ov::op::v0::Constant::create(element::i64, Shape{1}, {0}), - ov::op::v0::Constant::create(element::i64, Shape{1}, {-1}), - ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), - ov::op::v0::Constant::create(element::i64, Shape{1}, {m_sinks_rank - 1})); + softmax = make_shared( + softmax, + ov::op::v0::Constant::create(element::i64, Shape{1}, {0}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {-1}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {m_sinks_rank - 1})); } else { std::vector start(m_sinks_rank, 0); std::vector stop(m_sinks_rank, 0); @@ -177,13 +179,13 @@ class SDPA { begin_mask[begin_mask.size() - 1] = 0; end_mask[end_mask.size() - 1] = 0; - softmax = - make_shared(softmax, - ov::op::v0::Constant::create(element::i64, Shape{m_sinks_rank}, start), - ov::op::v0::Constant::create(element::i64, Shape{m_sinks_rank}, stop), - ov::op::v0::Constant::create(element::i64, Shape{m_sinks_rank}, step), - begin_mask, - end_mask); + softmax = make_shared( + softmax, + ov::op::v0::Constant::create(element::i64, Shape{m_sinks_rank}, start), + ov::op::v0::Constant::create(element::i64, Shape{m_sinks_rank}, stop), + ov::op::v0::Constant::create(element::i64, Shape{m_sinks_rank}, step), + begin_mask, + end_mask); } } auto output = make_shared(softmax, nodes[InputType::V]); diff --git a/src/common/transformations/tests/common_optimizations/shared_ops_optimization.cpp b/src/common/transformations/tests/common_optimizations/shared_ops_optimization.cpp index a6a8ca435f086f..2ba465968a41d1 100644 --- a/src/common/transformations/tests/common_optimizations/shared_ops_optimization.cpp +++ b/src/common/transformations/tests/common_optimizations/shared_ops_optimization.cpp @@ -43,18 +43,23 @@ class SharedTransformationTestsF : public TransformationTestsF { const int64_t& step, const int64_t& axis) { return std::make_shared(out, - ov::op::v0::Constant::create(element::i64, Shape{1}, {start}), - ov::op::v0::Constant::create(element::i64, Shape{1}, {stop}), - ov::op::v0::Constant::create(element::i64, Shape{1}, {step}), - ov::op::v0::Constant::create(element::i64, Shape{1}, {axis})); + ov::op::v0::Constant::create(element::i64, Shape{1}, {start}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {stop}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {step}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {axis})); } static Output make_tile(const Output& out, const std::vector& repeats) { - return std::make_shared(out, ov::op::v0::Constant::create(element::i64, Shape{repeats.size()}, repeats)); + return std::make_shared( + out, + ov::op::v0::Constant::create(element::i64, Shape{repeats.size()}, repeats)); } static Output make_reshape(const Output& out, const std::vector& order) { - return std::make_shared(out, ov::op::v0::Constant::create(element::i64, Shape{order.size()}, order), true); + return std::make_shared( + out, + ov::op::v0::Constant::create(element::i64, Shape{order.size()}, order), + true); } }; @@ -68,7 +73,8 @@ TEST_F(SharedTransformationTestsF, SharedSlice) { auto slice_3 = make_slice(data, 1, 2, 3, 3); auto slice_4 = make_slice(data, 1, 2, 3, 3); - auto concat = std::make_shared(OutputVector{slice_0, slice_1, slice_2, slice_3, slice_4}, 0); + auto concat = + std::make_shared(OutputVector{slice_0, slice_1, slice_2, slice_3, slice_4}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data}); manager.register_pass(); } @@ -78,7 +84,8 @@ TEST_F(SharedTransformationTestsF, SharedSlice) { auto slice_0 = make_slice(data, 1, 2, 3, 3); auto slice_2 = make_slice(data, 1, 3, 3, 3); - auto concat = std::make_shared(OutputVector{slice_0, slice_0, slice_2, slice_0, slice_0}, 0); + auto concat = + std::make_shared(OutputVector{slice_0, slice_0, slice_2, slice_0, slice_0}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data}); } } @@ -181,8 +188,10 @@ TEST_F(SharedTransformationTestsF, SharedRecursively) { TEST_F(SharedTransformationTestsF, SharedConcat) { { - auto pre_constant_0 = ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); - auto pre_constant_1 = ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); + auto pre_constant_0 = + ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); + auto pre_constant_1 = + ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); auto data = std::make_shared(element::f32, PartialShape{-1}); auto post_constant = ov::op::v0::Constant::create(element::f32, Shape{1}, std::vector{3.14f}); @@ -194,7 +203,8 @@ TEST_F(SharedTransformationTestsF, SharedConcat) { manager.register_pass(); } { - auto pre_constant_0 = ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); + auto pre_constant_0 = + ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); auto data = std::make_shared(element::f32, PartialShape{-1}); auto post_constant = ov::op::v0::Constant::create(element::f32, Shape{1}, std::vector{3.14f}); @@ -222,15 +232,15 @@ TEST_F(SharedTransformationTestsF, SharedSliceInThreeGroups) { auto slice_2_2 = make_slice(data, 3, 4, 5, 6); auto concat = std::make_shared(OutputVector{slice_0_0, - slice_1_0, - slice_2_0, - slice_0_1, - slice_1_1, - slice_2_1, - slice_0_2, - slice_1_2, - slice_2_2}, - 0); + slice_1_0, + slice_2_0, + slice_0_1, + slice_1_1, + slice_2_1, + slice_0_2, + slice_1_2, + slice_2_2}, + 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data}); manager.register_pass(); @@ -243,15 +253,15 @@ TEST_F(SharedTransformationTestsF, SharedSliceInThreeGroups) { auto slice_2_0 = make_slice(data, 3, 4, 5, 6); auto concat = std::make_shared(OutputVector{slice_0_0, - slice_1_0, - slice_2_0, - slice_0_0, - slice_1_0, - slice_2_0, - slice_0_0, - slice_1_0, - slice_2_0}, - 0); + slice_1_0, + slice_2_0, + slice_0_0, + slice_1_0, + slice_2_0, + slice_0_0, + slice_1_0, + slice_2_0}, + 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data}); } @@ -259,8 +269,10 @@ TEST_F(SharedTransformationTestsF, SharedSliceInThreeGroups) { TEST_F(SharedTransformationTestsF, SharedConcatCheckOpWithResultIsntReplaced) { { - auto pre_constant_0 = ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); - auto pre_constant_1 = ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); + auto pre_constant_0 = + ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); + auto pre_constant_1 = + ov::op::v0::Constant::create(element::f32, Shape{4}, std::vector{3.14f, 42.f, 0.f, 14.f}); auto data = std::make_shared(element::f32, PartialShape{-1}); auto post_constant = ov::op::v0::Constant::create(element::f32, Shape{1}, std::vector{3.14f}); @@ -355,9 +367,11 @@ TEST_F(SharedTransformationTestsF, Sharedv1Broadcasts) { auto input = std::make_shared(element::f32, PartialShape::dynamic()); auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); auto broadcast_v1_0 = std::make_shared(input, target_shape); - auto broadcast_v1_1 = std::make_shared(input, target_shape, ov::op::AutoBroadcastType::PDPD); + auto broadcast_v1_1 = + std::make_shared(input, target_shape, ov::op::AutoBroadcastType::PDPD); auto broadcast_v1_2 = std::make_shared(input, target_shape); - auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_2}, 0); + auto concat = + std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{input, target_shape}); manager.register_pass(); } @@ -365,8 +379,10 @@ TEST_F(SharedTransformationTestsF, Sharedv1Broadcasts) { auto input = std::make_shared(element::f32, PartialShape::dynamic()); auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); auto broadcast_v1_0 = std::make_shared(input, target_shape); - auto broadcast_v1_1 = std::make_shared(input, target_shape, ov::op::AutoBroadcastType::PDPD); - auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_0}, 0); + auto broadcast_v1_1 = + std::make_shared(input, target_shape, ov::op::AutoBroadcastType::PDPD); + auto concat = + std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_0}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{input, target_shape}); } } @@ -376,9 +392,11 @@ TEST_F(SharedTransformationTestsF, Sharedv3Broadcasts) { auto input = std::make_shared(element::f32, PartialShape::dynamic()); auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); auto broadcast_v1_0 = std::make_shared(input, target_shape); - auto broadcast_v1_1 = std::make_shared(input, target_shape, ov::op::BroadcastType::BIDIRECTIONAL); + auto broadcast_v1_1 = + std::make_shared(input, target_shape, ov::op::BroadcastType::BIDIRECTIONAL); auto broadcast_v1_2 = std::make_shared(input, target_shape); - auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_2}, 0); + auto concat = + std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{input, target_shape}); manager.register_pass(); } @@ -386,8 +404,10 @@ TEST_F(SharedTransformationTestsF, Sharedv3Broadcasts) { auto input = std::make_shared(element::f32, PartialShape::dynamic()); auto target_shape = std::make_shared(element::i64, PartialShape::dynamic()); auto broadcast_v1_0 = std::make_shared(input, target_shape); - auto broadcast_v1_1 = std::make_shared(input, target_shape, ov::op::BroadcastType::BIDIRECTIONAL); - auto concat = std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_0}, 0); + auto broadcast_v1_1 = + std::make_shared(input, target_shape, ov::op::BroadcastType::BIDIRECTIONAL); + auto concat = + std::make_shared(OutputVector{broadcast_v1_0, broadcast_v1_1, broadcast_v1_0}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{input, target_shape}); } } @@ -497,10 +517,10 @@ OutputVector createShapeNodesInMemory(const std::vector& node_order_in_m memory.reset(::malloc(node_order_in_memory.size() * sizeof(ov::op::v3::ShapeOf)), ::free); for (size_t i = 0; i < node_order_in_memory.size(); ++i) { ov::op::v3::ShapeOf* node_addr = static_cast(memory.get()) + node_order_in_memory[i]; - auto node_ptr = - std::shared_ptr(new (node_addr) ov::op::v3::ShapeOf(input, output_type), [](ov::op::v3::ShapeOf* node) { - node->ov::op::v3::ShapeOf::~ShapeOf(); - }); + auto node_ptr = std::shared_ptr(new (node_addr) ov::op::v3::ShapeOf(input, output_type), + [](ov::op::v3::ShapeOf* node) { + node->ov::op::v3::ShapeOf::~ShapeOf(); + }); std::stringstream ss; ss << node_name_prefix << i; node_ptr->set_friendly_name(ss.str()); @@ -696,10 +716,18 @@ TEST_F(SharedTransformationTestsF, SharedMaxPool) { { auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto op_1 = - std::make_shared(data, Strides{1, 1}, Strides{1, 1}, Shape{1, 1}, Shape{1, 1}, Shape{3, 3}); - auto op_2 = - std::make_shared(data, Strides{1, 1}, Strides{1, 1}, Shape{1, 1}, Shape{1, 1}, Shape{3, 3}); + auto op_1 = std::make_shared(data, + Strides{1, 1}, + Strides{1, 1}, + Shape{1, 1}, + Shape{1, 1}, + Shape{3, 3}); + auto op_2 = std::make_shared(data, + Strides{1, 1}, + Strides{1, 1}, + Shape{1, 1}, + Shape{1, 1}, + Shape{3, 3}); auto concat = std::make_shared(OutputVector{op_1, op_2}, 0); model = std::make_shared(OutputVector{concat}, ParameterVector{data}); @@ -708,8 +736,12 @@ TEST_F(SharedTransformationTestsF, SharedMaxPool) { { auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); - auto op_1 = - std::make_shared(data, Strides{1, 1}, Strides{1, 1}, Shape{1, 1}, Shape{1, 1}, Shape{3, 3}); + auto op_1 = std::make_shared(data, + Strides{1, 1}, + Strides{1, 1}, + Shape{1, 1}, + Shape{1, 1}, + Shape{3, 3}); auto concat = std::make_shared(OutputVector{op_1, op_1}, 0); model_ref = std::make_shared(OutputVector{concat}, ParameterVector{data}); @@ -723,30 +755,30 @@ TEST_F(SharedTransformationTestsF, TopologicalOrder) { auto shape_of = std::make_shared(data); auto gather_0 = std::make_shared(shape_of, - ov::op::v0::Constant::create(element::i32, {1}, {0}), - ov::op::v0::Constant::create(element::i32, {}, {0})); + ov::op::v0::Constant::create(element::i32, {1}, {0}), + ov::op::v0::Constant::create(element::i32, {}, {0})); auto gather_1 = std::make_shared(shape_of, - ov::op::v0::Constant::create(element::i32, {1}, {0}), - ov::op::v0::Constant::create(element::i32, {}, {0})); + ov::op::v0::Constant::create(element::i32, {1}, {0}), + ov::op::v0::Constant::create(element::i32, {}, {0})); auto gather_2 = std::make_shared(shape_of, - ov::op::v0::Constant::create(element::i32, {1}, {0}), - ov::op::v0::Constant::create(element::i32, {}, {0})); + ov::op::v0::Constant::create(element::i32, {1}, {0}), + ov::op::v0::Constant::create(element::i32, {}, {0})); auto add_0 = std::make_shared(gather_0, gather_0); auto add_1 = std::make_shared(gather_1, gather_1); auto add_2 = std::make_shared(gather_2, gather_2); - auto concat_0 = - std::make_shared(OutputVector{gather_0, add_0, ov::op::v0::Constant::create(element::i64, {1}, {0})}, - 0); - auto concat_1 = - std::make_shared(OutputVector{gather_1, add_1, ov::op::v0::Constant::create(element::i64, {1}, {0})}, - 0); - auto concat_2 = - std::make_shared(OutputVector{gather_2, add_2, ov::op::v0::Constant::create(element::i64, {1}, {0})}, - 0); + auto concat_0 = std::make_shared( + OutputVector{gather_0, add_0, ov::op::v0::Constant::create(element::i64, {1}, {0})}, + 0); + auto concat_1 = std::make_shared( + OutputVector{gather_1, add_1, ov::op::v0::Constant::create(element::i64, {1}, {0})}, + 0); + auto concat_2 = std::make_shared( + OutputVector{gather_2, add_2, ov::op::v0::Constant::create(element::i64, {1}, {0})}, + 0); auto concat = std::make_shared(OutputVector{concat_0, concat_1}, 0); auto output = std::make_shared(OutputVector{concat, concat_2}, 0); @@ -758,12 +790,12 @@ TEST_F(SharedTransformationTestsF, TopologicalOrder) { auto data = std::make_shared(element::f32, PartialShape{-1, -1, -1, -1}); auto shape_of = std::make_shared(data); auto gather_0 = std::make_shared(shape_of, - ov::op::v0::Constant::create(element::i32, {1}, {0}), - ov::op::v0::Constant::create(element::i32, {}, {0})); + ov::op::v0::Constant::create(element::i32, {1}, {0}), + ov::op::v0::Constant::create(element::i32, {}, {0})); auto add_0 = std::make_shared(gather_0, gather_0); - auto concat_0 = - std::make_shared(OutputVector{gather_0, add_0, ov::op::v0::Constant::create(element::i64, {1}, {0})}, - 0); + auto concat_0 = std::make_shared( + OutputVector{gather_0, add_0, ov::op::v0::Constant::create(element::i64, {1}, {0})}, + 0); auto concat = std::make_shared(OutputVector{concat_0, concat_0}, 0); auto output = std::make_shared(OutputVector{concat, concat_0}, 0); model_ref = std::make_shared(OutputVector{output}, ParameterVector{data}); diff --git a/src/common/transformations/tests/op_conversions/sdpa_to_paged_attention_test.cpp b/src/common/transformations/tests/op_conversions/sdpa_to_paged_attention_test.cpp index e5e090cb4f6513..53c47100fab8b6 100644 --- a/src/common/transformations/tests/op_conversions/sdpa_to_paged_attention_test.cpp +++ b/src/common/transformations/tests/op_conversions/sdpa_to_paged_attention_test.cpp @@ -520,7 +520,8 @@ TEST_P(SDPAToPATest, SDPAToPA_Qwen7bChat_General) { auto attention_mask_to_sdpa = Qwen7bChatSDPA::gen_attention_mask(Q, attention_mask, total_seq_len_2); // SDPA: - auto sdpa = makeOP({Q, K, V, attention_mask_to_sdpa}, {{"causal", false}}); + auto sdpa = + makeOP({Q, K, V, attention_mask_to_sdpa}, {{"causal", false}}); auto res = makeOP({sdpa}); model = std::make_shared(OutputVector{res}, params); @@ -691,7 +692,9 @@ TEST_F(SDPAToPATest, SDPAToPA_Qwen7bChat_PositionIDsReplacerQwenPattern) { auto max_context_len = std::make_shared(element::i32, PartialShape{}); auto max_context_len_i64 = std::make_shared(max_context_len, element::i64); auto max_context_len_reshaped = - std::make_shared(max_context_len_i64, ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), true); + std::make_shared(max_context_len_i64, + ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), + true); max_context_len->set_friendly_name("max_context_len"); auto rotary_emb_sincos = std::make_shared(element::f32, PartialShape{1, DYN, 1, 128}); @@ -700,14 +703,15 @@ TEST_F(SDPAToPATest, SDPAToPA_Qwen7bChat_PositionIDsReplacerQwenPattern) { auto fake_input = std::make_shared(element::i64, PartialShape{DYN, DYN}); auto shape = std::make_shared(fake_input, element::i64); auto gather = std::make_shared(shape, - ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), - ov::op::v0::Constant::create(element::i64, Shape{1}, {0})); + ov::op::v0::Constant::create(element::i64, Shape{1}, {1}), + ov::op::v0::Constant::create(element::i64, Shape{1}, {0})); auto minus_one = ov::op::v0::Constant::create(element::i32, Shape{1}, {-1}); auto minus_one_converted = std::make_shared(minus_one, element::i64); - auto minus_one_reshaped = std::make_shared(minus_one_converted, - ov::op::v0::Constant::create(element::i64, Shape{1}, {-1}), - true); + auto minus_one_reshaped = + std::make_shared(minus_one_converted, + ov::op::v0::Constant::create(element::i64, Shape{1}, {-1}), + true); auto past_offset = std::make_shared(gather, minus_one_reshaped); auto start_const = ov::op::v0::Constant::create(element::i64, Shape{1}, {0}); @@ -716,10 +720,10 @@ TEST_F(SDPAToPATest, SDPAToPA_Qwen7bChat_PositionIDsReplacerQwenPattern) { auto axis_const = ov::op::v0::Constant::create(element::i64, Shape{1}, {1}); auto slice_1 = std::make_shared(rotary_emb_sincos, - start_const, - max_context_len_reshaped, - step_const, - axis_const); + start_const, + max_context_len_reshaped, + step_const, + axis_const); auto slice_2 = std::make_shared(slice_1, past_offset, stop_const, step_const, axis_const); auto result = std::make_shared(slice_2); @@ -732,9 +736,10 @@ TEST_F(SDPAToPATest, SDPAToPA_Qwen7bChat_PositionIDsReplacerQwenPattern) { auto rotary_emb_sincos = std::make_shared(element::f32, PartialShape{1, DYN, 1, 128}); auto position_ids = std::make_shared(element::i64, PartialShape{DYN}); - auto gather_new = std::make_shared(rotary_emb_sincos, - position_ids, - ov::op::v0::Constant::create(element::i64, Shape{}, {1})); + auto gather_new = + std::make_shared(rotary_emb_sincos, + position_ids, + ov::op::v0::Constant::create(element::i64, Shape{}, {1})); auto new_shape = ov::op::v0::Constant::create(element::i64, Shape{4}, {-1, 1, 1, 128}); auto reshaped = std::make_shared(gather_new, new_shape, true); @@ -882,8 +887,8 @@ TEST_F(SDPAToPATest, SDPAToPA_Baichuan2_13b_General) { auto Add141 = makeOP({Select139, Unsqueeze140}, {{"auto_broadcast", "numpy"}}); auto Multiply143 = makeOP({Gather116, {-1l}}, {{"auto_broadcast", "numpy"}}); auto Slice147 = makeOP({Add141, Multiply143, {LLONG_MAX}, {1}, {2}}); - auto sdpa = - makeOP({Transpose62, Concat72, Concat82, Slice147}, {{"causal", false}}); + auto sdpa = makeOP({Transpose62, Concat72, Concat82, Slice147}, + {{"causal", false}}); auto res = makeOP({sdpa}); @@ -1860,7 +1865,8 @@ TEST_F(SDPAToPATest, SDPAToPA_Codegen2) { auto Maximum0 = makeOP({ShapeOf5, Concat11}, {{"auto_broadcast", "numpy"}}); auto Broadcast4 = makeOP({Minimum0, Maximum0}, {{"mode", "numpy"}}); auto ScaledDotProductAttention = - makeOP({Transpose0, Concat7, Concat9, Broadcast4}, {{"causal", false}}); + makeOP({Transpose0, Concat7, Concat9, Broadcast4}, + {{"causal", false}}); auto res = make_shared(ScaledDotProductAttention); @@ -2105,7 +2111,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { {0.000010f}); auto Add0 = makeOP({ReduceMean0, Constant6}, {{"auto_broadcast", "numpy"}}); auto Sqrt0 = makeOP({Add0}); - auto Divide0 = makeOP({Constant4, Sqrt0}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); + auto Divide0 = + makeOP({Constant4, Sqrt0}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); auto Multiply1 = makeOP({Gather1, Divide0}, {{"auto_broadcast", "numpy"}}); auto Multiply2 = makeOP({Constant3, Multiply1}, {{"auto_broadcast", "numpy"}}); auto Constant7 = makeConst(element::u8, @@ -2131,7 +2138,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { MOCK_VALUE); auto Multiply3 = makeOP({Subtract1, Constant9}, {{"auto_broadcast", "numpy"}}); auto Convert6 = makeOP({Multiply3}, {{"destination_type", "f32"}}); - auto MatMul0 = makeOP({Multiply2, Convert6}, {{"transpose_a", false}, {"transpose_b", true}}); + auto MatMul0 = + makeOP({Multiply2, Convert6}, {{"transpose_a", false}, {"transpose_b", true}}); auto Constant10 = makeConst(element::f32, ov::Shape({ 1, @@ -2164,7 +2172,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { auto Broadcast0 = makeOP({Constant11, Concat1}, {{"mode", "bidirectional"}}); auto Unsqueeze0 = makeOP({position_ids, 1}); auto Convert8 = makeOP({Unsqueeze0}, {{"destination_type", "f32"}}); - auto MatMul1 = makeOP({Broadcast0, Convert8}, {{"transpose_a", false}, {"transpose_b", false}}); + auto MatMul1 = + makeOP({Broadcast0, Convert8}, {{"transpose_a", false}, {"transpose_b", false}}); auto Transpose1 = makeOP({MatMul1, {0, 2, 1}}); auto Cos0 = makeOP({Transpose1}); auto Constant12 = makeConst(element::f32, @@ -2176,7 +2185,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { {1.346574f}); auto Multiply4 = makeOP({Cos0, Constant12}, {{"auto_broadcast", "numpy"}}); auto Unsqueeze1 = makeOP({Multiply4, 1}); - auto Multiply5 = makeOP({VariadicSplit0->output(0), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); + auto Multiply5 = + makeOP({VariadicSplit0->output(0), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); auto Sin0 = makeOP({Transpose1}); auto Constant13 = makeConst(element::f32, ov::Shape({ @@ -2187,10 +2197,13 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { {1.346574f}); auto Multiply6 = makeOP({Sin0, Constant13}, {{"auto_broadcast", "numpy"}}); auto Unsqueeze2 = makeOP({Multiply6, 1}); - auto Multiply7 = makeOP({VariadicSplit0->output(1), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); + auto Multiply7 = + makeOP({VariadicSplit0->output(1), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); auto Subtract2 = makeOP({Multiply5, Multiply7}, {{"auto_broadcast", "numpy"}}); - auto Multiply8 = makeOP({VariadicSplit0->output(1), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); - auto Multiply9 = makeOP({VariadicSplit0->output(0), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); + auto Multiply8 = + makeOP({VariadicSplit0->output(1), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); + auto Multiply9 = + makeOP({VariadicSplit0->output(0), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); auto Add3 = makeOP({Multiply8, Multiply9}, {{"auto_broadcast", "numpy"}}); auto Concat2 = makeOP({Subtract2, Add3}, {{"axis", -1}}); auto Concat3 = makeOP({Gather0, {8l}, {0l}, {64l}}, {{"axis", 0}}); @@ -2222,7 +2235,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { MOCK_VALUE); auto Multiply10 = makeOP({Subtract3, Constant16}, {{"auto_broadcast", "numpy"}}); auto Convert11 = makeOP({Multiply10}, {{"destination_type", "f32"}}); - auto MatMul2 = makeOP({Multiply2, Convert11}, {{"transpose_a", false}, {"transpose_b", true}}); + auto MatMul2 = + makeOP({Multiply2, Convert11}, {{"transpose_a", false}, {"transpose_b", true}}); auto Reshape1 = makeOP({MatMul2, {0, 0, 8, 64}}, {{"special_zero", true}}); auto Transpose2 = makeOP({Reshape1, {0, 2, 1, 3}}); auto ShapeOf3 = makeOP({Transpose2}, {{"output_type", "i32"}}); @@ -2234,11 +2248,15 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { auto Add4 = makeOP({Divide2, Convert12}, {{"auto_broadcast", "numpy"}}); auto Concat4 = makeOP({Add4, {-1}}, {{"axis", 0}}); auto VariadicSplit1 = makeOP({Transpose2, -1, Concat4}); - auto Multiply11 = makeOP({VariadicSplit1->output(0), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); - auto Multiply12 = makeOP({VariadicSplit1->output(1), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); + auto Multiply11 = + makeOP({VariadicSplit1->output(0), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); + auto Multiply12 = + makeOP({VariadicSplit1->output(1), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); auto Subtract4 = makeOP({Multiply11, Multiply12}, {{"auto_broadcast", "numpy"}}); - auto Multiply13 = makeOP({VariadicSplit1->output(1), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); - auto Multiply14 = makeOP({VariadicSplit1->output(0), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); + auto Multiply13 = + makeOP({VariadicSplit1->output(1), Unsqueeze1}, {{"auto_broadcast", "numpy"}}); + auto Multiply14 = + makeOP({VariadicSplit1->output(0), Unsqueeze2}, {{"auto_broadcast", "numpy"}}); auto Add5 = makeOP({Multiply13, Multiply14}, {{"auto_broadcast", "numpy"}}); auto Concat5 = makeOP({Subtract4, Add5}, {{"axis", -1}}); auto Concat6 = makeOP({Gather4, Concat5}, {{"axis", -2}}); @@ -2278,7 +2296,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { MOCK_VALUE); auto Multiply15 = makeOP({Subtract5, Constant19}, {{"auto_broadcast", "numpy"}}); auto Convert15 = makeOP({Multiply15}, {{"destination_type", "f32"}}); - auto MatMul3 = makeOP({Multiply2, Convert15}, {{"transpose_a", false}, {"transpose_b", true}}); + auto MatMul3 = + makeOP({Multiply2, Convert15}, {{"transpose_a", false}, {"transpose_b", true}}); auto Constant20 = makeConst(element::f32, ov::Shape({ 1, @@ -2348,7 +2367,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { auto Unsqueeze14 = makeOP({Add7, 0}); auto Concat11 = makeOP({Gather3, {1l}, Reshape5, Unsqueeze14}, {{"axis", 0}}); auto Broadcast5 = makeOP({BitwiseAnd3, Concat11}, {{"mode", "bidirectional"}}); - auto Select0 = makeOP({Broadcast5, 0.000000f, -65504.000000f}, {{"auto_broadcast", "numpy"}}); + auto Select0 = + makeOP({Broadcast5, 0.000000f, -65504.000000f}, {{"auto_broadcast", "numpy"}}); auto Reshape9 = makeOP({Gather10, {1}}, {{"special_zero", false}}); auto Add11 = makeOP({Reshape9, Reshape5}, {{"auto_broadcast", "numpy"}}); auto Slice0 = makeOP({Select0, {0}, Add11, {1}, {3}}); @@ -2362,7 +2382,7 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { MOCK_VALUE); auto ScaledDotProductAttention = makeOP({Concat2, Reshape2, Reshape4, Slice0, 0.125000f, Constant24}, - {{"causal", false}}); + {{"causal", false}}); auto res = make_shared(ScaledDotProductAttention); @@ -2465,7 +2485,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { {0.000010f}); auto Add0 = makeOP({ReduceMean0, Constant7}, {{"auto_broadcast", "numpy"}}); auto Sqrt0 = makeOP({Add0}); - auto Divide0 = makeOP({Constant5, Sqrt0}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); + auto Divide0 = + makeOP({Constant5, Sqrt0}, {{"auto_broadcast", "numpy"}, {"m_pythondiv", true}}); auto Multiply1 = makeOP({Gather0, Divide0}, {{"auto_broadcast", "numpy"}}); auto Multiply2 = makeOP({Constant4, Multiply1}, {{"auto_broadcast", "numpy"}}); auto Constant8 = makeConst(element::u8, @@ -2491,7 +2512,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { MOCK_VALUE); auto Multiply3 = makeOP({Subtract1, Constant10}, {{"auto_broadcast", "numpy"}}); auto Convert6 = makeOP({Multiply3}, {{"destination_type", "f32"}}); - auto MatMul0 = makeOP({Multiply2, Convert6}, {{"transpose_a", false}, {"transpose_b", true}}); + auto MatMul0 = + makeOP({Multiply2, Convert6}, {{"transpose_a", false}, {"transpose_b", true}}); auto Constant11 = makeConst(element::f32, ov::Shape({ 1, @@ -2525,7 +2547,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { auto Broadcast0 = makeOP({Constant12, Concat1}, {{"mode", "bidirectional"}}); auto Unsqueeze2 = makeOP({Unsqueeze1, 1}); auto Convert8 = makeOP({Unsqueeze2}, {{"destination_type", "f32"}}); - auto MatMul1 = makeOP({Broadcast0, Convert8}, {{"transpose_a", false}, {"transpose_b", false}}); + auto MatMul1 = + makeOP({Broadcast0, Convert8}, {{"transpose_a", false}, {"transpose_b", false}}); auto Transpose1 = makeOP({MatMul1, {0, 2, 1}}); auto Cos0 = makeOP({Transpose1}); auto Constant13 = makeConst(element::f32, @@ -2537,7 +2560,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { {1.346574f}); auto Multiply4 = makeOP({Cos0, Constant13}, {{"auto_broadcast", "numpy"}}); auto Unsqueeze3 = makeOP({Multiply4, 1}); - auto Multiply5 = makeOP({VariadicSplit0->output(0), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); + auto Multiply5 = + makeOP({VariadicSplit0->output(0), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); auto Sin0 = makeOP({Transpose1}); auto Constant14 = makeConst(element::f32, ov::Shape({ @@ -2548,10 +2572,13 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { {1.346574f}); auto Multiply6 = makeOP({Sin0, Constant14}, {{"auto_broadcast", "numpy"}}); auto Unsqueeze4 = makeOP({Multiply6, 1}); - auto Multiply7 = makeOP({VariadicSplit0->output(1), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); + auto Multiply7 = + makeOP({VariadicSplit0->output(1), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); auto Subtract2 = makeOP({Multiply5, Multiply7}, {{"auto_broadcast", "numpy"}}); - auto Multiply8 = makeOP({VariadicSplit0->output(1), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); - auto Multiply9 = makeOP({VariadicSplit0->output(0), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); + auto Multiply8 = + makeOP({VariadicSplit0->output(1), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); + auto Multiply9 = + makeOP({VariadicSplit0->output(0), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); auto Add3 = makeOP({Multiply8, Multiply9}, {{"auto_broadcast", "numpy"}}); auto Concat2 = makeOP({Subtract2, Add3}, {{"axis", -1}}); auto Transpose2 = makeOP({Concat2, {0, 2, 1, 3}}); @@ -2579,7 +2606,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { MOCK_VALUE); auto Multiply10 = makeOP({Subtract3, Constant17}, {{"auto_broadcast", "numpy"}}); auto Convert11 = makeOP({Multiply10}, {{"destination_type", "f32"}}); - auto MatMul2 = makeOP({Multiply2, Convert11}, {{"transpose_a", false}, {"transpose_b", true}}); + auto MatMul2 = + makeOP({Multiply2, Convert11}, {{"transpose_a", false}, {"transpose_b", true}}); auto Reshape2 = makeOP({MatMul2, {0, 0, 8, 64}}, {{"special_zero", true}}); auto Transpose3 = makeOP({Reshape2, {0, 2, 1, 3}}); auto ShapeOf2 = makeOP({Transpose3}, {{"output_type", "i32"}}); @@ -2591,11 +2619,15 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { auto Add4 = makeOP({Divide2, Convert12}, {{"auto_broadcast", "numpy"}}); auto Concat3 = makeOP({Add4, {-1}}, {{"axis", 0}}); auto VariadicSplit1 = makeOP({Transpose3, -1, Concat3}); - auto Multiply11 = makeOP({VariadicSplit1->output(0), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); - auto Multiply12 = makeOP({VariadicSplit1->output(1), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); + auto Multiply11 = + makeOP({VariadicSplit1->output(0), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); + auto Multiply12 = + makeOP({VariadicSplit1->output(1), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); auto Subtract4 = makeOP({Multiply11, Multiply12}, {{"auto_broadcast", "numpy"}}); - auto Multiply13 = makeOP({VariadicSplit1->output(1), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); - auto Multiply14 = makeOP({VariadicSplit1->output(0), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); + auto Multiply13 = + makeOP({VariadicSplit1->output(1), Unsqueeze3}, {{"auto_broadcast", "numpy"}}); + auto Multiply14 = + makeOP({VariadicSplit1->output(0), Unsqueeze4}, {{"auto_broadcast", "numpy"}}); auto Add5 = makeOP({Multiply13, Multiply14}, {{"auto_broadcast", "numpy"}}); auto Concat4 = makeOP({Subtract4, Add5}, {{"axis", -1}}); auto Transpose4 = makeOP({Concat4, {0, 2, 1, 3}}); @@ -2623,7 +2655,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { MOCK_VALUE); auto Multiply15 = makeOP({Subtract5, Constant20}, {{"auto_broadcast", "numpy"}}); auto Convert15 = makeOP({Multiply15}, {{"destination_type", "f32"}}); - auto MatMul3 = makeOP({Multiply2, Convert15}, {{"transpose_a", false}, {"transpose_b", true}}); + auto MatMul3 = + makeOP({Multiply2, Convert15}, {{"transpose_a", false}, {"transpose_b", true}}); auto Constant21 = makeConst(element::f32, ov::Shape({ 1, @@ -2677,7 +2710,8 @@ TEST_F(SDPAToPATest, SDPAToPA_gpt_oss_General) { auto Gather4 = makeOP({ShapeOf3, -1, 0}, {{"batch_dims", 0}}); auto Unsqueeze5 = makeOP({Gather4, 0}); auto Concat5 = makeOP({{0l}, {1l}, {-1l}, Unsqueeze5}, {{"axis", 0}}); - auto Reshape6 = makeOP({PagedAttentionExtension->output(0), Concat5}, {{"special_zero", true}}); + auto Reshape6 = + makeOP({PagedAttentionExtension->output(0), Concat5}, {{"special_zero", true}}); auto Transpose7 = makeOP({Reshape6, {0, 2, 1, 3}}); auto res = makeOP({Transpose7}); diff --git a/src/common/transformations/tests/symbolic_transformations/dereshape_fullyconnected.cpp b/src/common/transformations/tests/symbolic_transformations/dereshape_fullyconnected.cpp index 31c77c2c9d1baf..8f5b64d1afb13a 100644 --- a/src/common/transformations/tests/symbolic_transformations/dereshape_fullyconnected.cpp +++ b/src/common/transformations/tests/symbolic_transformations/dereshape_fullyconnected.cpp @@ -24,14 +24,16 @@ TEST_F(TransformationTestsF, DeReshapeFC) { { auto data = make_shared(element::f32, shape); - auto in_reshape = make_shared(data, ov::op::v0::Constant::create(element::i64, {2}, {-1, 40}), true); + auto in_reshape = + make_shared(data, ov::op::v0::Constant::create(element::i64, {2}, {-1, 40}), true); auto second_input = make_shared(element::f32, Shape{40, 80}); auto matmul = make_shared(in_reshape, second_input); auto batch_dims = ov::op::util::node_to_get_shape_value_of_indices_from_shape_source(data, {0, 1}); - auto pattern = - make_shared(OutputVector{batch_dims, ov::op::v0::Constant::create(element::i64, {1}, {80})}, 0); + auto pattern = make_shared( + OutputVector{batch_dims, ov::op::v0::Constant::create(element::i64, {1}, {80})}, + 0); auto out_reshape = make_shared(matmul, pattern, false); model = make_shared(OutputVector{out_reshape}, ParameterVector{data, second_input}); @@ -51,15 +53,17 @@ TEST_F(TransformationTestsF, DeReshapeFCWithConvert) { set_shape_symbols(shape); // we label shape with consecutive labels: A, B, C { auto data = make_shared(element::f16, shape); - auto in_reshape = make_shared(data, ov::op::v0::Constant::create(element::i64, {2}, {-1, 40}), true); + auto in_reshape = + make_shared(data, ov::op::v0::Constant::create(element::i64, {2}, {-1, 40}), true); auto convert = make_shared(in_reshape, element::f32); auto second_input = make_shared(element::f32, Shape{40, 80}); auto matmul = make_shared(convert, second_input); auto batch_dims = ov::op::util::node_to_get_shape_value_of_indices_from_shape_source(data, {0, 1}); - auto pattern = - make_shared(OutputVector{batch_dims, ov::op::v0::Constant::create(element::i64, {1}, {80})}, 0); + auto pattern = make_shared( + OutputVector{batch_dims, ov::op::v0::Constant::create(element::i64, {1}, {80})}, + 0); auto out_reshape = make_shared(matmul, pattern, false); model = make_shared(OutputVector{out_reshape}, ParameterVector{data, second_input}); @@ -80,7 +84,8 @@ TEST_F(TransformationTestsF, DeReshapeFCNegative) { set_shape_symbols(shape); // we label shape with consecutive labels: A, B, C { auto data = make_shared(element::f16, shape); - auto in_reshape = make_shared(data, ov::op::v0::Constant::create(element::i64, {2}, {-1, 40}), true); + auto in_reshape = + make_shared(data, ov::op::v0::Constant::create(element::i64, {2}, {-1, 40}), true); auto convert = make_shared(in_reshape, element::f32); auto second_input = make_shared(element::f32, Shape{40, 80}); diff --git a/src/common/transformations/tests/symbolic_transformations/dereshape_matmul.cpp b/src/common/transformations/tests/symbolic_transformations/dereshape_matmul.cpp index 5d633a6d06dd93..615127fa2079e3 100644 --- a/src/common/transformations/tests/symbolic_transformations/dereshape_matmul.cpp +++ b/src/common/transformations/tests/symbolic_transformations/dereshape_matmul.cpp @@ -261,7 +261,8 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar } if (bea_scalar_mode == 1 || bea_scalar_mode == 3) - lhs_output = make_shared(lhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); + lhs_output = + make_shared(lhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); // RHS input of MatMul auto rhs_input = make_shared(element::f32, rhs_original_pshape); @@ -282,16 +283,19 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar } if (bea_scalar_mode == 2 || bea_scalar_mode == 3) - rhs_output = make_shared(rhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); + rhs_output = + make_shared(rhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); Output matmul = make_shared(lhs_output, rhs_output); if (final_add_mode == 1) // 1 - add has matmul on lhs - matmul = - make_shared(matmul, ov::op::v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1})); + matmul = make_shared( + matmul, + ov::op::v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1})); else if (final_add_mode == 2) // 2 - add has matmul on rhs - matmul = - make_shared(ov::op::v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1}), matmul); + matmul = make_shared( + ov::op::v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1}), + matmul); auto output_reshape = reshape(matmul, out_reshape_idx, dims); @@ -301,7 +305,9 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar outputs.emplace_back(output_reshape); for (auto& output : outputs) - output = std::make_shared(output, ov::op::v0::Constant::create(element::i32, {1}, {-1}), false); + output = std::make_shared(output, + ov::op::v0::Constant::create(element::i32, {1}, {-1}), + false); auto output = make_shared(outputs, 0); model = make_shared(output, inputs, "Tested model"); } @@ -344,7 +350,8 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar } if (bea_scalar_mode == 1 || bea_scalar_mode == 3) - lhs_output = make_shared(lhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); + lhs_output = + make_shared(lhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); // RHS input of MatMul auto rhs_input = make_shared(element::f32, rhs_original_pshape); @@ -372,12 +379,14 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar } if (bea_scalar_mode == 2 || bea_scalar_mode == 3) - rhs_output = make_shared(rhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); + rhs_output = + make_shared(rhs_output, ov::op::v0::Constant::create(element::f32, {}, {0.125})); Output matmul = make_shared(lhs_output, rhs_output); if (final_add_mode > 0) { - const auto original_add_in = ov::op::v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1}); + const auto original_add_in = + ov::op::v0::Constant::create(element::f32, Shape(lhs_reshape_idx.size(), 1), {1}); auto divisor = ov::op::util::node_to_get_shape_value_of_indices_from_shape_source(lhs_input, {1}); auto first_batch_dim = std::make_shared(ov::op::v0::Constant::create(element::i64, {1}, {1}), @@ -401,7 +410,9 @@ class DeReshapeMatMulTest : public TransformationTestsF, public testing::WithPar outputs.emplace_back(matmul); for (auto& output : outputs) - output = std::make_shared(output, ov::op::v0::Constant::create(element::i32, {1}, {-1}), false); + output = std::make_shared(output, + ov::op::v0::Constant::create(element::i32, {1}, {-1}), + false); auto output = make_shared(outputs, 0); model_ref = make_shared(output, inputs, "Reference model"); diff --git a/src/common/transformations/tests/symbolic_transformations/symbol_optimization.cpp b/src/common/transformations/tests/symbolic_transformations/symbol_optimization.cpp index df5a22bd62cb8e..461b6cf8a36435 100644 --- a/src/common/transformations/tests/symbolic_transformations/symbol_optimization.cpp +++ b/src/common/transformations/tests/symbolic_transformations/symbol_optimization.cpp @@ -59,12 +59,13 @@ TEST_F(TransformationTestsF, ApplySymbolEquivalence_Concat_Values) { auto shape = make_shared(concat); auto gather = make_shared(shape, - ov::op::v0::Constant::create(element::i64, {1}, {-1}), - ov::op::v0::Constant::create(element::i64, {}, {0})); + ov::op::v0::Constant::create(element::i64, {1}, {-1}), + ov::op::v0::Constant::create(element::i64, {}, {0})); auto reshape = make_shared( concat, - make_shared(OutputVector{gather, ov::op::v0::Constant::create(element::i64, {1}, {-1})}, 0), + make_shared(OutputVector{gather, ov::op::v0::Constant::create(element::i64, {1}, {-1})}, + 0), false); model = make_shared(OutputVector{reshape}, ParameterVector{input_2, input_1}); @@ -81,19 +82,20 @@ TEST_F(TransformationTestsF, ApplySymbolEquivalence_Concat_Values) { auto shape_1 = make_shared(input_1); auto gather_1 = make_shared(shape_1, - ov::op::v0::Constant::create(element::i64, {1}, {3}), - ov::op::v0::Constant::create(element::i64, {}, {0})); + ov::op::v0::Constant::create(element::i64, {1}, {3}), + ov::op::v0::Constant::create(element::i64, {}, {0})); auto shape_2 = make_shared(input_2); auto gather_2 = make_shared(shape_2, - ov::op::v0::Constant::create(element::i64, {1}, {3}), - ov::op::v0::Constant::create(element::i64, {}, {0})); + ov::op::v0::Constant::create(element::i64, {1}, {3}), + ov::op::v0::Constant::create(element::i64, {}, {0})); auto sum = make_shared(gather_1, gather_2); auto reshape = make_shared( concat, - make_shared(OutputVector{sum, ov::op::v0::Constant::create(element::i64, {1}, {-1})}, 0), + make_shared(OutputVector{sum, ov::op::v0::Constant::create(element::i64, {1}, {-1})}, + 0), false); model_ref = make_shared(OutputVector{reshape}, ParameterVector{input_2, input_1}); } @@ -102,8 +104,8 @@ TEST_F(TransformationTestsF, ApplySymbolEquivalence_Concat_Values) { Output get_dim_by_idx(const Output& source, const int64_t& idx, element::Type type = element::i64) { auto shape = make_shared(source, type); auto gather = make_shared(shape, - ov::op::v0::Constant::create(element::i64, {}, {idx}), - ov::op::v0::Constant::create(element::i64, {}, {0})); + ov::op::v0::Constant::create(element::i64, {}, {idx}), + ov::op::v0::Constant::create(element::i64, {}, {0})); return gather->output(0); } @@ -112,8 +114,8 @@ Output get_dim_by_idx(const Output& source, element::Type type = element::i64) { auto shape = make_shared(source, type); auto gather = make_shared(shape, - ov::op::v0::Constant::create(element::i64, {idx.size()}, idx), - ov::op::v0::Constant::create(element::i64, {}, {0})); + ov::op::v0::Constant::create(element::i64, {idx.size()}, idx), + ov::op::v0::Constant::create(element::i64, {}, {0})); return gather->output(0); } @@ -127,16 +129,18 @@ TEST_F(TransformationTestsF, ValueOptimizationSingleValue) { auto reshape_0 = make_shared( input, - make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, + 0), false); auto reshape_1 = make_shared( input, - make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_1}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_1}, + 0), false); auto range = make_shared(ov::op::v0::Constant::create(element::i32, {}, {0}), - dim_2, - ov::op::v0::Constant::create(element::i32, {}, {1}), - element::i32); + dim_2, + ov::op::v0::Constant::create(element::i32, {}, {1}), + element::i32); model = make_shared(OutputVector{reshape_0, reshape_1, range}, ParameterVector{input}); @@ -152,16 +156,18 @@ TEST_F(TransformationTestsF, ValueOptimizationSingleValue) { auto dim_2 = std::make_shared(dim_1); auto reshape_0 = make_shared( input, - make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, + 0), false); auto reshape_1 = make_shared( input, - make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_1}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_1}, + 0), false); auto range = make_shared(ov::op::v0::Constant::create(element::i32, {}, {0}), - dim_2, - ov::op::v0::Constant::create(element::i32, {}, {1}), - element::i32); + dim_2, + ov::op::v0::Constant::create(element::i32, {}, {1}), + element::i32); model_ref = make_shared(OutputVector{reshape_0, reshape_1, range}, ParameterVector{input}); } @@ -177,11 +183,13 @@ TEST_F(TransformationTestsF, ValueOptimizationDoubleValue) { auto reshape_0 = make_shared( input, - make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, + 0), false); auto reshape_1 = make_shared( input, - make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_1}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_1}, + 0), false); model = make_shared(OutputVector{reshape_0, reshape_1}, ParameterVector{input}); @@ -198,11 +206,13 @@ TEST_F(TransformationTestsF, ValueOptimizationDoubleValue) { auto reshape_0 = make_shared( input, - make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_1}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_1}, + 0), false); auto reshape_1 = make_shared( input, - make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_0}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {0}), dim_0}, + 0), false); model_ref = make_shared(OutputVector{reshape_0, reshape_1}, ParameterVector{input}); @@ -219,11 +229,13 @@ TEST_F(TransformationTestsF, ValueOptimizationSymbolAndValue) { auto reshape_0 = make_shared( input, - make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i64, {1}, {-1}), dim_0}, + 0), false); auto reshape_1 = make_shared( input, - make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {-1}), dim_1}, 0), + make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {-1}), dim_1}, + 0), false); model = make_shared(OutputVector{reshape_0, reshape_1}, ParameterVector{input}); @@ -235,9 +247,9 @@ TEST_F(TransformationTestsF, ValueOptimizationSymbolAndValue) { } { auto input = make_shared(element::f32, PartialShape({-1, -1, 4, -1})); - auto dim_0 = make_shared( - OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {-1}), get_dim_by_idx(input, {3, 2}, element::i32)}, - 0); + auto dim_0 = make_shared(OutputVector{ov::op::v0::Constant::create(element::i32, {1}, {-1}), + get_dim_by_idx(input, {3, 2}, element::i32)}, + 0); auto dim_1 = std::make_shared(dim_0, element::i64); auto reshape_0 = make_shared(input, dim_1, false); From 4f9ab5dddac0a9e843e6452683308a72a80feaf9 Mon Sep 17 00:00:00 2001 From: Evgeny Kotov Date: Fri, 5 Dec 2025 11:31:05 +0100 Subject: [PATCH 3/3] Remove using namespace ov::op::util directives to fix UNITY build conflicts --- .../eliminate_duplicate_ti_inputs.cpp | 28 +++-- .../eliminate_loop_inputs_outputs.cpp | 20 ++-- .../eliminate_unsqueeze_gather.cpp | 15 ++- .../fuse_rotary_positional_embeddings.cpp | 64 +++++----- .../common_optimizations/gelu_fusion.cpp | 1 - .../optimize_strided_slice.cpp | 9 +- .../select_with_one_value_condition.cpp | 7 +- .../common_optimizations/sequence_fusion.cpp | 46 ++++---- .../convert_ti_to_sequences.cpp | 110 ++++++++++-------- .../detection_output_downgrade.cpp | 1 - .../detection_output_upgrade.cpp | 1 - .../transpose_sinking/ts_unary.cpp | 5 +- 12 files changed, 152 insertions(+), 155 deletions(-) diff --git a/src/common/transformations/src/transformations/common_optimizations/eliminate_duplicate_ti_inputs.cpp b/src/common/transformations/src/transformations/common_optimizations/eliminate_duplicate_ti_inputs.cpp index 31a6e90b310cf6..24e87fc88ccee6 100644 --- a/src/common/transformations/src/transformations/common_optimizations/eliminate_duplicate_ti_inputs.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/eliminate_duplicate_ti_inputs.cpp @@ -13,8 +13,6 @@ #include "openvino/op/tensor_iterator.hpp" #include "openvino/pass/pattern/op/wrap_type.hpp" -using namespace ov::op::util; - ov::pass::EliminateDuplicateTIInputs::EliminateDuplicateTIInputs() { MATCHER_SCOPE(EliminateDuplicateTIInputs); auto ti = ov::pass::pattern::wrap_type(); @@ -24,22 +22,22 @@ ov::pass::EliminateDuplicateTIInputs::EliminateDuplicateTIInputs() { return false; } - std::vector> should_stay; - std::map, - std::vector>> + std::vector> should_stay; + std::map, + std::vector>> need_to_eliminate; auto input_descs = ti->get_input_descriptions(); for (auto& key : input_descs) { - auto is_equal = [&](const std::shared_ptr& input) -> bool { + auto is_equal = [&](const std::shared_ptr& input) -> bool { if (ti->input_value(input->m_input_index) == ti->input_value(key->m_input_index)) { - auto invariant_l = ov::as_type_ptr(input); - auto invariant_r = ov::as_type_ptr(key); + auto invariant_l = ov::as_type_ptr(input); + auto invariant_r = ov::as_type_ptr(key); if (invariant_l && invariant_r) { return true; } - auto slice_l = ov::as_type_ptr(input); - auto slice_r = ov::as_type_ptr(key); + auto slice_l = ov::as_type_ptr(input); + auto slice_r = ov::as_type_ptr(key); if (slice_l && slice_r) { return slice_l->m_axis == slice_r->m_axis && slice_l->m_start == slice_r->m_start && @@ -47,8 +45,8 @@ ov::pass::EliminateDuplicateTIInputs::EliminateDuplicateTIInputs() { slice_l->m_stride == slice_r->m_stride; } - auto merged_l = ov::as_type_ptr(input); - auto merged_r = ov::as_type_ptr(key); + auto merged_l = ov::as_type_ptr(input); + auto merged_r = ov::as_type_ptr(key); if (merged_l && merged_r) { return merged_l->m_body_value_index == merged_r->m_body_value_index; @@ -92,12 +90,12 @@ ov::pass::EliminateDuplicateTIInputs::EliminateDuplicateTIInputs() { for (const auto& remain : should_stay) { auto par = body->get_parameters()[remain->m_body_parameter_index]; auto in = ti->input_value(remain->m_input_index); - if (auto invariant = ov::as_type_ptr(remain)) { + if (auto invariant = ov::as_type_ptr(remain)) { new_ti->set_invariant_input(par, in); - } else if (auto merged = ov::as_type_ptr(remain)) { + } else if (auto merged = ov::as_type_ptr(remain)) { auto results = body->get_results(); new_ti->set_merged_input(par, in, results[merged->m_body_value_index]); - } else if (auto slice = ov::as_type_ptr(remain)) { + } else if (auto slice = ov::as_type_ptr(remain)) { new_ti->set_sliced_input(par, in, slice->m_start, diff --git a/src/common/transformations/src/transformations/common_optimizations/eliminate_loop_inputs_outputs.cpp b/src/common/transformations/src/transformations/common_optimizations/eliminate_loop_inputs_outputs.cpp index 413f4f5c7b6e1a..f2417c116ef391 100644 --- a/src/common/transformations/src/transformations/common_optimizations/eliminate_loop_inputs_outputs.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/eliminate_loop_inputs_outputs.cpp @@ -17,18 +17,17 @@ using namespace std; using namespace ov; -using namespace ov::op::util; using namespace ov::element; -using InvariantD = MultiSubGraphOp::InvariantInputDescription; -using SlicedD = MultiSubGraphOp::SliceInputDescription; -using MergedD = MultiSubGraphOp::MergedInputDescription; -using OutputD = MultiSubGraphOp::BodyOutputDescription; -using ConcatD = MultiSubGraphOp::ConcatOutputDescription; +using InvariantD = ov::op::util::MultiSubGraphOp::InvariantInputDescription; +using SlicedD = ov::op::util::MultiSubGraphOp::SliceInputDescription; +using MergedD = ov::op::util::MultiSubGraphOp::MergedInputDescription; +using OutputD = ov::op::util::MultiSubGraphOp::BodyOutputDescription; +using ConcatD = ov::op::util::MultiSubGraphOp::ConcatOutputDescription; using ResultPtr = std::shared_ptr; -using OutputDescPtr = MultiSubGraphOp::OutputDescription::Ptr; +using OutputDescPtr = ov::op::util::MultiSubGraphOp::OutputDescription::Ptr; using OutputDescMap = std::unordered_map; -using InputDescPtr = MultiSubGraphOp::InputDescription::Ptr; +using InputDescPtr = ov::op::util::MultiSubGraphOp::InputDescription::Ptr; using BodyResultIdxMap = std::unordered_map; namespace { @@ -97,7 +96,8 @@ ov::pass::EliminateLoopInputsOutputs::EliminateLoopInputsOutputs() { const auto& pattern_to_output = m.get_pattern_value_map(); - auto subgraph = as_type_ptr(pattern_to_output.at(subgraph_label).get_node_shared_ptr()); + auto subgraph = + as_type_ptr(pattern_to_output.at(subgraph_label).get_node_shared_ptr()); if (!subgraph) { return false; } @@ -105,7 +105,7 @@ ov::pass::EliminateLoopInputsOutputs::EliminateLoopInputsOutputs() { const auto& body_params = body_model->get_parameters(); const auto& body_results = body_model->get_results(); - std::shared_ptr new_node; + std::shared_ptr new_node; const auto& subgraph_in_values = subgraph->input_values(); int64_t body_condition_output_idx = -1; int64_t current_iteration_input_idx = -1; diff --git a/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp b/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp index c6de78e448fca2..b714899f1018cb 100644 --- a/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/eliminate_unsqueeze_gather.cpp @@ -20,7 +20,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::op::util; ov::pass::EliminateUnsqueezeGather::EliminateUnsqueezeGather() { MATCHER_SCOPE(EliminateUnsqueezeGather); // Remove Unsqueeze + Gather pair, if Gather gathers data by `1` dimension that was previously added by Unsqueeze @@ -30,7 +29,7 @@ ov::pass::EliminateUnsqueezeGather::EliminateUnsqueezeGather() { ov::pass::pattern::consumers_count(1)); const auto gatherIndices = ov::op::v0::Constant::create(element::i64, Shape{}, {0}); const auto gatherAxis = ov::pass::pattern::any_input(); - const auto gather = ov::pass::pattern::wrap_type({unsqueeze, gatherIndices, gatherAxis}); + const auto gather = ov::pass::pattern::wrap_type({unsqueeze, gatherIndices, gatherAxis}); ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { auto& patternValue = m.get_pattern_value_map(); @@ -75,12 +74,12 @@ inline bool scalar_with_one_consumer(const Output& out) { ov::pass::EliminateGatherUnsqueeze::EliminateGatherUnsqueeze() { MATCHER_SCOPE(EliminateGatherUnsqueeze); - const auto gather_label = ov::pass::pattern::wrap_type(scalar_with_one_consumer); - const auto be_label = - ov::pass::pattern::wrap_type({gather_label, ov::pass::pattern::any_input()}, - scalar_with_one_consumer); + const auto gather_label = ov::pass::pattern::wrap_type(scalar_with_one_consumer); + const auto be_label = ov::pass::pattern::wrap_type( + {gather_label, ov::pass::pattern::any_input()}, + scalar_with_one_consumer); const auto or_label = std::make_shared(OutputVector{gather_label, be_label}); const auto unsqueeze_label = ov::pass::pattern::wrap_type( {or_label, ov::pass::pattern::any_input()}, diff --git a/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp b/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp index a2f4f69355e5cd..ff8edca6a62651 100644 --- a/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp @@ -168,7 +168,6 @@ ov::pass::RoPEFusionFlux::RoPEFusionFlux() { } ov::pass::RoPEFusionGPTNEOX::RoPEFusionGPTNEOX(int rank) { - using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionGPTNEOX); // rope pattern matching triggers a little design flaw: @@ -190,10 +189,10 @@ ov::pass::RoPEFusionGPTNEOX::RoPEFusionGPTNEOX(int rank) { auto int32_max = std::numeric_limits::max(); - auto x2 = NewGenSlice(x, "half_ndims", int32_max, 1, rank - 1); + auto x2 = ov::op::util::NewGenSlice(x, "half_ndims", int32_max, 1, rank - 1); auto x2neg = ov::pass::pattern::wrap_type({x2 | varsplit->output(1), -1.0f}, {{"auto_broadcast", "numpy"}}); - auto x1 = NewGenSlice(x, 0, "half_ndims", 1, rank - 1); + auto x1 = ov::op::util::NewGenSlice(x, 0, "half_ndims", 1, rank - 1); auto x_rotate_half = ov::pass::pattern::wrap_type({x2neg, x1 | varsplit->output(0)}, {{"axis", -1}}); @@ -259,7 +258,6 @@ ov::pass::RoPEFusionGPTNEOX::RoPEFusionGPTNEOX(int rank) { } ov::pass::RoPEFusionCosSinPreprocess::RoPEFusionCosSinPreprocess() { - using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionCosSinPreprocess); auto cos_const = ov::pass::pattern::wrap_type(ov::pass::pattern::type_matches(element::f32)); @@ -274,7 +272,7 @@ ov::pass::RoPEFusionCosSinPreprocess::RoPEFusionCosSinPreprocess() { auto prepare_cos_sin_gptneox = [&](std::shared_ptr const_tab) { auto slice = ov::pass::pattern::wrap_type({const_tab, {0}, node_batch_size, {1}, {0}}); - auto strided_slice = NewGenStridedSlice(const_tab, {0}, node_batch_size, {1}, 0); + auto strided_slice = ov::op::util::NewGenStridedSlice(const_tab, {0}, node_batch_size, {1}, 0); return ov::pass::pattern::wrap_type({strided_slice | slice, gather_positions}, {{"axis", 2}}); }; @@ -287,7 +285,7 @@ ov::pass::RoPEFusionCosSinPreprocess::RoPEFusionCosSinPreprocess() { auto prepare_cos_sin_llama = [&](std::shared_ptr const_tab) { auto ScatterUpdate = ov::pass::pattern::wrap_type({{0, 0, 0}, 2, seq_len, 0}); auto slice_Slice = ov::pass::pattern::wrap_type({const_tab, {0}, seq_len, {1}, {2}}); - auto slice_StridedSlice = NewGenStridedSlice(const_tab, {0, 0, 0}, ScatterUpdate, {1, 1, 1}, 2); + auto slice_StridedSlice = ov::op::util::NewGenStridedSlice(const_tab, {0, 0, 0}, ScatterUpdate, {1, 1, 1}, 2); auto squeeze = ov::pass::pattern::wrap_type( {slice_StridedSlice | slice_Slice, ov::pass::pattern::any_input()}, ov::pass::pattern::shape_matches("[?, head_dims]")); @@ -296,7 +294,7 @@ ov::pass::RoPEFusionCosSinPreprocess::RoPEFusionCosSinPreprocess() { // another simplified pattern for gathering at position_ids auto slice_Slice2 = ov::pass::pattern::wrap_type({const_tab, {0}, seq_len, {1}, {0}}); - auto slice_StridedSlice2 = NewGenStridedSlice(const_tab, {0}, seq_len, {1}, 0); + auto slice_StridedSlice2 = ov::op::util::NewGenStridedSlice(const_tab, {0}, seq_len, {1}, 0); auto index_Gather2 = ov::pass::pattern::wrap_type( {slice_Slice2 | slice_StridedSlice2, gather_positions_2d, 0}, {{"batch_dims", 0}}); @@ -350,15 +348,14 @@ ov::pass::RoPEFusionCosSinPreprocess::RoPEFusionCosSinPreprocess() { // only a fraction of head_size is rotary-embedded ov::pass::RoPEFusionIOSlicing::RoPEFusionIOSlicing() { - using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionIOSlicing); auto int32_max = std::numeric_limits::max(); auto data = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); auto varsplit = ov::pass::pattern::wrap_type({data, 3, {"ndims", "?"}}); varsplit->set_output_size(2); - auto x = NewGenSlice(data, 0, "ndims", 1, 3); - auto y = NewGenSlice(data, "ndims", int32_max, 1, 3); + auto x = ov::op::util::NewGenSlice(data, 0, "ndims", 1, 3); + auto y = ov::op::util::NewGenSlice(data, "ndims", int32_max, 1, 3); auto x_emb = ov::pass::pattern::wrap_type( {x | varsplit->output(0), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()}) | ov::pass::pattern::wrap_type({x | varsplit->output(0), @@ -400,7 +397,6 @@ ov::pass::RoPEFusionIOSlicing::RoPEFusionIOSlicing() { // gptneox-preprocess of input data ov::pass::RoPEFusionPreprocess::RoPEFusionPreprocess() { - using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionPreprocess); // Pattern for input to be sliced (for models with combined QKV projection) @@ -409,7 +405,7 @@ ov::pass::RoPEFusionPreprocess::RoPEFusionPreprocess() { auto input_to_trans = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); // Slice input if needed: [B, L, H, S] -> [B, L', H, S] - auto input_slice = NewGenSlice(input_to_slice, {"slice_start"}, {"slice_stop"}, 1, 3); + auto input_slice = ov::op::util::NewGenSlice(input_to_slice, {"slice_start"}, {"slice_stop"}, 1, 3); // Transpose input if needed: [B, L, H, S] -> [B, H, L, S] auto x = ov::pass::pattern::wrap_type({input_slice | input_to_trans, {0, 2, 1, 3}}); @@ -476,7 +472,6 @@ static std::shared_ptr repeat_interleave_pattern(const ov::Outputoutput(1)); auto view_Reshape = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(4)); - auto slice_Slice_965 = NewGenSlice(view_Reshape, 0, "ndims", 1, 3); + auto slice_Slice_965 = ov::op::util::NewGenSlice(view_Reshape, 0, "ndims", 1, 3); // view_Reshape : B,L,H,S auto varsplit_view_Reshape = ov::pass::pattern::wrap_type({view_Reshape, 3, {"ndims", "end"}}); varsplit_view_Reshape->set_output_size(2); // x interleave (-x[:,:,:, 1::2], x[:,:,:, 0::2]) - auto slice_Slice_1174 = NewGenSlice(slice_Slice_965 | varsplit_view_Reshape->output(0), 1, INT_MAX, 2, 3); + auto slice_Slice_1174 = + ov::op::util::NewGenSlice(slice_Slice_965 | varsplit_view_Reshape->output(0), 1, INT_MAX, 2, 3); auto neg_Multiply_1177 = ov::pass::pattern::wrap_type({slice_Slice_1174, -1.0f}, {{"auto_broadcast", "numpy"}}); @@ -501,7 +497,8 @@ ov::pass::RoPEFusionGPTJ::RoPEFusionGPTJ() { ov::pass::pattern::wrap_type({neg_Multiply_1177, {"-1", "1", "head_num", "32", "1"}}, {{"special_zero", false}}); - auto slice_Slice_1168 = NewGenSlice(slice_Slice_965 | varsplit_view_Reshape->output(0), 0, INT_MAX, 2, 3); + auto slice_Slice_1168 = + ov::op::util::NewGenSlice(slice_Slice_965 | varsplit_view_Reshape->output(0), 0, INT_MAX, 2, 3); auto Unsqueeze_65525 = ov::pass::pattern::wrap_type({slice_Slice_1168, -1}); auto Unsqueeze_28999 = ov::pass::pattern::wrap_type({slice_Slice_1168, {"-1", "1", "head_num", "32", "1"}}, @@ -511,7 +508,7 @@ ov::pass::RoPEFusionGPTJ::RoPEFusionGPTJ() { {{"axis", -1}}); auto ShapeOf_169068 = ov::pass::pattern::wrap_type({stack_1182}); - auto flatten_Slice_1194 = NewGenSlice(ShapeOf_169068, 0, 3, 1, 0); + auto flatten_Slice_1194 = ov::op::util::NewGenSlice(ShapeOf_169068, 0, 3, 1, 0); auto flatten_Concat_1197 = ov::pass::pattern::wrap_type({flatten_Slice_1194, {-1}}, {{"axis", 0}}); // If with special zero, no need to use shapeof to get full shape auto flatten_Reshape_1198 = ov::pass::pattern::wrap_type({stack_1182, flatten_Concat_1197}); @@ -530,7 +527,7 @@ ov::pass::RoPEFusionGPTJ::RoPEFusionGPTJ() { // *cos + *sin auto rotary_emb = ov::pass::pattern::wrap_type({mul_cos, mul_sin}, {{"auto_broadcast", "numpy"}}); - auto slice_Slice_971 = NewGenSlice(view_Reshape, "ndims", INT_MAX, 1, 3); + auto slice_Slice_971 = ov::op::util::NewGenSlice(view_Reshape, "ndims", INT_MAX, 1, 3); auto result = ov::pass::pattern::wrap_type({rotary_emb, slice_Slice_971 | varsplit_view_Reshape->output(1)}, {{"axis", -1}}); @@ -602,7 +599,6 @@ ov::pass::RoPEFusionGPTJ::RoPEFusionGPTJ() { } ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { - using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionChatGLM); // [seq_length, batch_size, input_size(will be cropped to match hidden state size)] @@ -639,7 +635,7 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { input_key = std::move(cur_key); } - auto slice0 = NewGenSlice(input_key, 0, "ndims", 1, 3); + auto slice0 = ov::op::util::NewGenSlice(input_key, 0, "ndims", 1, 3); auto var_split0 = ov::pass::pattern::wrap_type({input_key, 3, {"ndims", "end"}}); var_split0->set_output_size(2); @@ -678,7 +674,8 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { auto slice2 = ov::pass::pattern::wrap_type({cos_sin_cache, {0, 0}, scatter_update0, {1, 1}, {0}}); auto ss_stop = ov::pass::pattern::wrap_type(); - auto strided_slice0 = NewGenStridedSlice(cos_sin_cache, {0, 0}, ss_stop | scatter_update0, {1, 1}, 1); + auto strided_slice0 = + ov::op::util::NewGenStridedSlice(cos_sin_cache, {0, 0}, ss_stop | scatter_update0, {1, 1}, 1); auto concat1 = ov::pass::pattern::wrap_type({{-1}, {1}, seq_length, {"ndims/2"}, {2}}, {{"axis", 0}}); @@ -697,7 +694,7 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { ov::pass::pattern::value_matches("seq_len, batch, 1, ndims/2, 2")); auto slice3 = ov::pass::pattern::wrap_type({cos_sin_cache, {0}, seq_length, {1}, {0}}); - auto strided_slice1 = NewGenStridedSlice(cos_sin_cache, {0}, seq_length, {1}, 0); + auto strided_slice1 = ov::op::util::NewGenStridedSlice(cos_sin_cache, {0}, seq_length, {1}, 0); // [seq_length, 1, batch, half_rotary_dims, 2] reshape1 = ov::pass::pattern::wrap_type( @@ -730,7 +727,7 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { auto concat2 = ov::pass::pattern::wrap_type({y_even, y_odd}, {{"axis", -1}}); auto shape_of0 = ov::pass::pattern::wrap_type({concat2}); - auto slice4 = NewGenSlice(shape_of0, 0, 3, 1, 0); + auto slice4 = ov::op::util::NewGenSlice(shape_of0, 0, 3, 1, 0); auto concat3 = ov::pass::pattern::wrap_type({slice4, {-1}}, {{"axis", 0}}); std::shared_ptr const_target_shape6 = nullptr; @@ -752,7 +749,7 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { {concat2, concat3 | const_target_shape6 | const_target_shape7}, {{"special_zero", true}}); } - auto slice5 = NewGenSlice(input_key, "ndims", INT_MAX, 1, 3); + auto slice5 = ov::op::util::NewGenSlice(input_key, "ndims", INT_MAX, 1, 3); auto concat4 = ov::pass::pattern::wrap_type({reshape2, slice5 | var_split0->output(1)}, {{"axis", -1}}); @@ -821,7 +818,6 @@ ov::pass::RoPEFusionChatGLM::RoPEFusionChatGLM(const bool support_2d_rope) { } ov::pass::RoPEFusionChatGLMHF::RoPEFusionChatGLMHF() { - using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionChatGLMHF); auto qk_linear = ov::pass::pattern::any_input(ov::pass::pattern::shape_matches("[?, 1, ?]")); @@ -839,7 +835,7 @@ ov::pass::RoPEFusionChatGLMHF::RoPEFusionChatGLMHF() { auto vsplit_out1 = ov::pass::pattern::wrap_type( {reshape, 3, ov::pass::pattern::any_input()}, ov::pass::pattern::output_index_matches(1) && ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims]")); - auto slice_1 = NewGenSlice(reshape, 0, "ndims", 1, 3) | vsplit_out0; + auto slice_1 = ov::op::util::NewGenSlice(reshape, 0, "ndims", 1, 3) | vsplit_out0; auto const_idx = ov::pass::pattern::wrap_type( ov::pass::pattern::type_matches(ov::element::i32) && const_idx_predicate); @@ -850,13 +846,13 @@ ov::pass::RoPEFusionChatGLMHF::RoPEFusionChatGLMHF() { auto multiply = ov::pass::pattern::wrap_type({slice_1, repeat_interleave_cos}, {{"auto_broadcast", "numpy"}}); - auto slice_2 = NewGenSlice(slice_1, 1, INT_MAX, 2, 3); + auto slice_2 = ov::op::util::NewGenSlice(slice_1, 1, INT_MAX, 2, 3); auto neg = ov::pass::pattern::wrap_type({slice_2, -1}, {{"auto_broadcast", "numpy"}}); auto unsqueeze_1 = ov::pass::pattern::wrap_type( {neg, ov::pass::pattern::any_input()}, ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims/2, 1]"), {{"special_zero", false}}); - auto slice_3 = NewGenSlice(slice_1, 0, INT_MAX, 2, 3); + auto slice_3 = ov::op::util::NewGenSlice(slice_1, 0, INT_MAX, 2, 3); auto unsqueeze_2 = ov::pass::pattern::wrap_type( {slice_3, ov::pass::pattern::any_input()}, ov::pass::pattern::shape_matches("[?, head_cnt, 1, ndims/2, 1]"), @@ -870,7 +866,7 @@ ov::pass::RoPEFusionChatGLMHF::RoPEFusionChatGLMHF() { {{"auto_broadcast", "numpy"}}); auto add = ov::pass::pattern::wrap_type({multiply, multiply_1}, {{"auto_broadcast", "numpy"}}); - auto slice_5 = NewGenSlice(reshape, "ndims", INT_MAX, 1, 3) | vsplit_out1; + auto slice_5 = ov::op::util::NewGenSlice(reshape, "ndims", INT_MAX, 1, 3) | vsplit_out1; auto result = ov::pass::pattern::wrap_type({add, slice_5}, {{"axis", -1}}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { @@ -912,7 +908,6 @@ ov::pass::RoPEFusionChatGLMHF::RoPEFusionChatGLMHF() { } ov::pass::RoPEFusionQwen::RoPEFusionQwen() { - using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionQwen); // rotary_emb_cos & rotary_emb_sin are sliced by present kv-length (past-kv-length + cur_len) @@ -931,7 +926,7 @@ ov::pass::RoPEFusionQwen::RoPEFusionQwen() { {ListUnpack_410_VariadicSplit, ov::pass::pattern::any_input()}, ov::pass::pattern::shape_matches("[?, ?, head_cnt, head_size]"), {{"special_zero", true}}); - auto slice_Slice_543 = NewGenSlice(view_Reshape_424, 0, "head_size", 1, 3); + auto slice_Slice_543 = ov::op::util::NewGenSlice(view_Reshape_424, 0, "head_size", 1, 3); auto ShapeOf_485735 = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input()}, {}); auto Multiply_567524 = @@ -955,7 +950,8 @@ ov::pass::RoPEFusionQwen::RoPEFusionQwen() { ov::pass::pattern::shape_matches("[?, 1, 1, 128]"), {{"special_zero", false}}); - auto slice_StridedSlice_446 = NewGenStridedSlice(rotary_emb_cos, ScatterUpdate_463814, {0, INT_MAX}, {1, 1}, 1); + auto slice_StridedSlice_446 = + ov::op::util::NewGenStridedSlice(rotary_emb_cos, ScatterUpdate_463814, {0, INT_MAX}, {1, 1}, 1); auto mul_Multiply_552 = ov::pass::pattern::wrap_type( {slice_Slice_543, slice_StridedSlice_446 | slice_Slice_446 | reshape_cos_to_expected_layout}, {{"auto_broadcast", "numpy"}}); @@ -1012,7 +1008,8 @@ ov::pass::RoPEFusionQwen::RoPEFusionQwen() { auto cat_Concat_593 = ov::pass::pattern::wrap_type( {ListUnpack_586_Squeeze_0 | ListUnpack_Squeeze_0_1, ListUnpack_586_Squeeze | ListUnpack_Squeeze_1}, {{"axis", -1}}); - auto slice_StridedSlice_470 = NewGenStridedSlice(rotary_emb_sin, ScatterUpdate_463814, {0, INT_MAX}, {1, 1}, 1); + auto slice_StridedSlice_470 = + ov::op::util::NewGenStridedSlice(rotary_emb_sin, ScatterUpdate_463814, {0, INT_MAX}, {1, 1}, 1); auto slice_Slice_470 = ov::pass::pattern::wrap_type({rotary_emb_sin, Gather_377635 | neg_Multiply, INT_MAX, 1, 1}); auto gather_sin_by_pos_ids = @@ -1202,7 +1199,6 @@ ov::pass::RoPEShareCosSin::RoPEShareCosSin() { } ov::pass::RoPEFusionGPTOSS::RoPEFusionGPTOSS() { - using namespace ov::op::util; MATCHER_SCOPE(RoPEFusionGPTOSS); // gpt-oss style diff --git a/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp index dab6da3c316744..e81347b715635e 100644 --- a/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/gelu_fusion.cpp @@ -28,7 +28,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::op::util; constexpr auto SQRT2 = static_cast(M_SQRT2); constexpr auto SQRT1_2 = static_cast(M_SQRT1_2); constexpr auto SQRT_2_PI = 0.79788456080286535588f; // std::sqrt(M_2_PI) diff --git a/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp b/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp index adeff53d35c8db..6b341ee625ac1f 100644 --- a/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp @@ -395,7 +395,6 @@ bool ov::pass::GroupedSliceToVSplitOptimization::run_on_model(const std::shared_ ov::pass::SliceSequenceToSingleSlice::SliceSequenceToSingleSlice() { MATCHER_SCOPE(SliceSequenceToSingleSlice); - using namespace ov::op::util; auto const_axes_1_pattern = ov::pass::pattern::wrap_type(); auto const_axes_2_pattern = ov::pass::pattern::wrap_type(); auto slice_1_pattern = ov::pass::pattern::wrap_type({ov::pass::pattern::any_input(), @@ -452,10 +451,10 @@ ov::pass::SliceSequenceToSingleSlice::SliceSequenceToSingleSlice() { auto step = concat_boundaries(slice_1->input_value(3), slice_2->input_value(3)); auto axes = concat_boundaries(slice_1->input_value(4), slice_2->input_value(4)); auto one_slice = std::make_shared(slice_1->input_value(0), - try_fold_unary_output(begin), - try_fold_unary_output(end), - try_fold_unary_output(step), - try_fold_unary_output(axes)); + ov::op::util::try_fold_unary_output(begin), + ov::op::util::try_fold_unary_output(end), + ov::op::util::try_fold_unary_output(step), + ov::op::util::try_fold_unary_output(axes)); ov::copy_runtime_info({slice_1, slice_2}, {one_slice, begin, end, step, axes}); one_slice->set_friendly_name(slice_2->get_friendly_name()); diff --git a/src/common/transformations/src/transformations/common_optimizations/select_with_one_value_condition.cpp b/src/common/transformations/src/transformations/common_optimizations/select_with_one_value_condition.cpp index 592a80bcdc585e..3f691ba99a5938 100644 --- a/src/common/transformations/src/transformations/common_optimizations/select_with_one_value_condition.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/select_with_one_value_condition.cpp @@ -18,7 +18,6 @@ using namespace std; using namespace ov; using namespace ov::element; -using namespace ov::op::util; ov::pass::SelectWithOneValueCondition::SelectWithOneValueCondition() { MATCHER_SCOPE(SelectWithOneValueCondition); @@ -29,8 +28,8 @@ ov::pass::SelectWithOneValueCondition::SelectWithOneValueCondition() { auto select_pattern = make_shared(condition, then_branch, else_branch); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { - NodeRegistry copy_from; - NodeRegistry copy_to; + pass::NodeRegistry copy_from; + pass::NodeRegistry copy_to; auto& pattern_map = m.get_pattern_value_map(); auto& select_value = pattern_map.at(select_pattern); auto select = ov::as_type_ptr(select_value.get_node_shared_ptr()); @@ -74,7 +73,7 @@ ov::pass::SelectWithOneValueCondition::SelectWithOneValueCondition() { return replace_output_update_name(select->output(0), branch_output); } else if (select_shape.is_static()) { // if the shape of the selected branch is not the same, it needs the broadcasting - NodeRegistry copy_to; + pass::NodeRegistry copy_to; auto select_rank = select_shape.size(); vector select_shape_values(select_rank); for (size_t i = 0; i < select_rank; ++i) { diff --git a/src/common/transformations/src/transformations/common_optimizations/sequence_fusion.cpp b/src/common/transformations/src/transformations/common_optimizations/sequence_fusion.cpp index de2b8735d50698..9a9f8ec1eb990d 100644 --- a/src/common/transformations/src/transformations/common_optimizations/sequence_fusion.cpp +++ b/src/common/transformations/src/transformations/common_optimizations/sequence_fusion.cpp @@ -29,7 +29,6 @@ using namespace std; using namespace ov::element; -using namespace ov::op::util; namespace { bool is_equal_consts(const shared_ptr& l, const shared_ptr& r) { @@ -45,7 +44,8 @@ bool is_equal_consts(const shared_ptr& l, const shared_ptr& return false; } -bool check_WRB(const shared_ptr& cell_1, const shared_ptr& cell_2) { +bool check_WRB(const shared_ptr& cell_1, + const shared_ptr& cell_2) { int64_t idx_W = 2, idx_R = 3, idx_B = 4; auto increase_indexes = [&]() { ++idx_B; @@ -79,7 +79,8 @@ bool check_WRB(const shared_ptr& cell_1, const shared_ptr& cell_1, const shared_ptr& cell_2) { +bool is_equal_cells(const shared_ptr& cell_1, + const shared_ptr& cell_2) { bool is_equal = true; auto gru_cell_1 = ov::as_type_ptr(cell_1); auto gru_cell_2 = ov::as_type_ptr(cell_2); @@ -95,14 +96,15 @@ bool is_equal_cells(const shared_ptr& cell_1, const shared_ptr& prev_cell, const shared_ptr& current_cell) { +bool check_lstm_cell(const shared_ptr& prev_cell, + const shared_ptr& current_cell) { // check intermediate C outputs in case of LSTMCell // LSTMCell - C -> LSTMCell if ((ov::as_type_ptr(prev_cell) || ov::as_type_ptr(prev_cell))) { const auto& target_inputs = prev_cell->get_output_target_inputs(1); bool valid = target_inputs.empty() || (target_inputs.size() == 1 && - ov::as_type(target_inputs.begin()->get_node()) == current_cell.get() && + ov::as_type(target_inputs.begin()->get_node()) == current_cell.get() && target_inputs.begin()->get_index() == 2); // if intermediate C output is connected to other node, except ov::op::v4::LSTMCell, @@ -112,21 +114,21 @@ bool check_lstm_cell(const shared_ptr& prev_cell, const shared_ptr< return true; } -shared_ptr find_cell_chain(ov::pass::NodeRegistry& cp_from, - ov::pass::NodeRegistry& cp_to, - const shared_ptr& current_cell, - ov::OutputVector& x_to_concat, - ov::OutputVector& attention_to_concat, - map>& h_outputs_to_redirect, - int& cells_cnt, - const shared_ptr& axis_1) { +shared_ptr find_cell_chain(ov::pass::NodeRegistry& cp_from, + ov::pass::NodeRegistry& cp_to, + const shared_ptr& current_cell, + ov::OutputVector& x_to_concat, + ov::OutputVector& attention_to_concat, + map>& h_outputs_to_redirect, + int& cells_cnt, + const shared_ptr& axis_1) { cells_cnt = 1; - shared_ptr current = current_cell; + shared_ptr current = current_cell; while (true) { cp_from.add(current); // check the source node of HiddenState input auto prev = current->input_value(1).get_node_shared_ptr(); - auto prev_cell = ov::as_type_ptr(prev); + auto prev_cell = ov::as_type_ptr(prev); auto in_X = current->input(0); x_to_concat.push_back(cp_to.make(in_X.get_source_output(), axis_1)); @@ -150,8 +152,8 @@ shared_ptr find_cell_chain(ov::pass::NodeRegistry& cp_from, } bool create_sequence(ov::pass::NodeRegistry& cp_to, - const shared_ptr& first_cell, - const shared_ptr& last_cell, + const shared_ptr& first_cell, + const shared_ptr& last_cell, const ov::OutputVector& x_to_concat, const ov::OutputVector& attention_to_concat, const map>& h_outputs_to_redirect, @@ -300,12 +302,12 @@ bool create_sequence(ov::pass::NodeRegistry& cp_to, ov::pass::SequenceFusion::SequenceFusion() { MATCHER_SCOPE(SequenceFusion); - auto cell = ov::pass::pattern::wrap_type(); + auto cell = ov::pass::pattern::wrap_type(); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { - NodeRegistry copy_from; - NodeRegistry copy_to; + ov::pass::NodeRegistry copy_from; + ov::pass::NodeRegistry copy_to; auto cell = m.get_match_root(); - shared_ptr current_cell = ov::as_type_ptr(cell); + shared_ptr current_cell = ov::as_type_ptr(cell); if (!current_cell) { return false; } @@ -313,7 +315,7 @@ ov::pass::SequenceFusion::SequenceFusion() { // GRUCell -> GRUCell (the last cell) -> OtherNode // GRUCell (hidden_size = 128) -> GRUCell (hs = 128, the last) -> GRUCell (hs = 64) for (const auto& target : cell->get_output_target_inputs(0)) { - auto cell_1 = ov::as_type_ptr(target.get_node()->shared_from_this()); + auto cell_1 = ov::as_type_ptr(target.get_node()->shared_from_this()); if (cell_1 && is_equal_cells(cell_1, current_cell)) { return false; } diff --git a/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp b/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp index 4de110f32a7b62..0d80714a8b5dc4 100644 --- a/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp +++ b/src/common/transformations/src/transformations/op_conversions/convert_ti_to_sequences.cpp @@ -47,7 +47,6 @@ using namespace ov; using namespace ov::pass; -using namespace ov::op::util; namespace { bool convertTensorIteratorToSequence(const std::shared_ptr& ti, @@ -274,7 +273,7 @@ bool check_condition_increment_pattern( } const auto& condition_map = condition_matcher.get_pattern_value_map(); int64_t counter_step = -1; - if (!get_constant_value(condition_map.at(counter_step_label).get_node_shared_ptr(), counter_step) || + if (!ov::op::util::get_constant_value(condition_map.at(counter_step_label).get_node_shared_ptr(), counter_step) || counter_step != 1) { return false; } @@ -301,7 +300,7 @@ bool check_condition_increment_pattern( return false; } // get initial value of counter - if (!get_constant_value(loop->input_value(input_idx).get_node_shared_ptr(), initial_counter)) { + if (!ov::op::util::get_constant_value(loop->input_value(input_idx).get_node_shared_ptr(), initial_counter)) { return false; } // suitable counter-parameter is found and checked @@ -324,7 +323,8 @@ bool check_condition_increment_pattern( break; } } else if (condition_map.count(num_iter_const_label)) { - if (!get_constant_value(condition_map.at(num_iter_const_label).get_node_shared_ptr(), num_iters) || + if (!ov::op::util::get_constant_value(condition_map.at(num_iter_const_label).get_node_shared_ptr(), + num_iters) || num_iters < 1) { return false; } @@ -862,7 +862,7 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda if (output_descs.size() != 1) return false; const auto body_output_desc = - ov::as_type_ptr(output_descs[0]); + ov::as_type_ptr(output_descs[0]); if (!body_output_desc || body_output_desc->m_iteration != -1) return false; @@ -883,33 +883,36 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda const auto& loop_output_map = loop_output_matcher.get_pattern_value_map(); int64_t iteration_counter_step = -1; - if (!get_constant_value(loop_condition_map.at(iteration_counter_step_label).get_node_shared_ptr(), - iteration_counter_step) || + if (!ov::op::util::get_constant_value(loop_condition_map.at(iteration_counter_step_label).get_node_shared_ptr(), + iteration_counter_step) || iteration_counter_step != 1) return false; int64_t sequence_index_step = -1; - if (!get_constant_value(loop_condition_map.at(sequence_index_step_label).get_node_shared_ptr(), - sequence_index_step) || + if (!ov::op::util::get_constant_value(loop_condition_map.at(sequence_index_step_label).get_node_shared_ptr(), + sequence_index_step) || sequence_index_step != 1) return false; int64_t iteration_counter_limit = -1; - if (!get_constant_value(loop_condition_map.at(iteration_counter_limit_label).get_node_shared_ptr(), - iteration_counter_limit)) + if (!ov::op::util::get_constant_value( + loop_condition_map.at(iteration_counter_limit_label).get_node_shared_ptr(), + iteration_counter_limit)) return false; int64_t sequence_index_limit = -1; - if (!get_constant_value(loop_condition_map.at(sequence_index_limit_label).get_node_shared_ptr(), - sequence_index_limit)) + if (!ov::op::util::get_constant_value(loop_condition_map.at(sequence_index_limit_label).get_node_shared_ptr(), + sequence_index_limit)) return false; if (iteration_counter_limit != sequence_index_limit) return false; int64_t gather_axis = -1; - if (!get_constant_value(loop_output_map.at(gather_axis_label).get_node_shared_ptr(), gather_axis) || + if (!ov::op::util::get_constant_value(loop_output_map.at(gather_axis_label).get_node_shared_ptr(), + gather_axis) || gather_axis != 0) return false; int64_t scatter_axis = -1; - if (!get_constant_value(loop_output_map.at(scatter_axis_label).get_node_shared_ptr(), scatter_axis) || + if (!ov::op::util::get_constant_value(loop_output_map.at(scatter_axis_label).get_node_shared_ptr(), + scatter_axis) || scatter_axis != 0) return false; @@ -935,7 +938,7 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda const auto& input_descs = loop->get_input_descriptions(); for (const auto& desc : input_descs) { if (body_parameters[desc->m_body_parameter_index] == X_body) { - if (!ov::as_type_ptr(desc)) { + if (!ov::as_type_ptr(desc)) { return false; } if (loop->input_value(desc->m_input_index) != pattern_map.at(scatter_label)) { @@ -943,7 +946,7 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda } } if (body_parameters[desc->m_body_parameter_index] == H_body) { - auto merged_desc = ov::as_type_ptr(desc); + auto merged_desc = ov::as_type_ptr(desc); if (!merged_desc) { return false; } @@ -954,7 +957,7 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda } } if (body_parameters[desc->m_body_parameter_index] == C_body) { - auto merged_desc = ov::as_type_ptr(desc); + auto merged_desc = ov::as_type_ptr(desc); if (!merged_desc) { return false; } @@ -965,13 +968,13 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda } } if (body_parameters[desc->m_body_parameter_index] == sequence_index) { - auto merged_desc = ov::as_type_ptr(desc); + auto merged_desc = ov::as_type_ptr(desc); if (!merged_desc) { return false; } } if (body_parameters[desc->m_body_parameter_index] == iteration_counter) { - auto merged_desc = ov::as_type_ptr(desc); + auto merged_desc = ov::as_type_ptr(desc); if (!merged_desc) { return false; } @@ -1088,7 +1091,7 @@ ov::pass::ConvertLoopWithScatterUpdateToLSTMSequence::ConvertLoopWithScatterUpda for (auto&& loop_consumer : loop->output(0).get_target_inputs()) { auto node = loop_consumer.get_node()->shared_from_this(); - if (ov::is_type(node)) { + if (ov::is_type(node)) { auto shapeof = std::make_shared(H_squeezed); auto indices = op::v0::Constant::create(element::i32, Shape{3}, {1, 0, 2}); auto shapeof_gather = std::make_shared(shapeof, indices, zero); @@ -1328,27 +1331,27 @@ class EliminateGatherWithRange : public ov::pass::MatcherPass { using namespace ov::pass; auto data_label = ov::pass::pattern::any_input(ov::pass::pattern::rank_equals(3)); - auto shapeof_label = ov::pass::pattern::wrap_type({data_label}); + auto shapeof_label = ov::pass::pattern::wrap_type({data_label}); auto shapeof_gather_label = - ov::pass::pattern::wrap_type({shapeof_label, - ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type()}); + ov::pass::pattern::wrap_type({shapeof_label, + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}); auto shapeof_gather2_label = - ov::pass::pattern::wrap_type({shapeof_gather_label, - ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type()}); + ov::pass::pattern::wrap_type({shapeof_gather_label, + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}); auto reshape_label = ov::pass::pattern::wrap_type( {shapeof_gather2_label, ov::pass::pattern::wrap_type()}); auto range_label = ov::pass::pattern::wrap_type({ov::pass::pattern::wrap_type(), reshape_label, ov::pass::pattern::wrap_type()}); - auto match_node = ov::pass::pattern::wrap_type( + auto match_node = ov::pass::pattern::wrap_type( {data_label, range_label, ov::pass::pattern::wrap_type()}); matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) { const auto& pattern_map = m.get_pattern_value_map(); - auto gather = ov::as_type_ptr(m.get_match_root()); + auto gather = ov::as_type_ptr(m.get_match_root()); if (!gather) return false; auto axis = gather->get_axis(); @@ -1365,9 +1368,10 @@ class EliminateGatherWithRange : public ov::pass::MatcherPass { const auto shapeof_gather2 = pattern_map.at(shapeof_gather2_label).get_node_shared_ptr(); int64_t shapeof_gather2_index = -1; int64_t shapeof_gather2_axis = -1; - if (!get_constant_value(shapeof_gather2->get_input_node_shared_ptr(1), shapeof_gather2_index)) + if (!ov::op::util::get_constant_value(shapeof_gather2->get_input_node_shared_ptr(1), shapeof_gather2_index)) return false; - if (!get_constant_value(shapeof_gather2->get_input_node_shared_ptr(2), shapeof_gather2_axis) || + if (!ov::op::util::get_constant_value(shapeof_gather2->get_input_node_shared_ptr(2), + shapeof_gather2_axis) || shapeof_gather2_axis != 0) return false; const auto reshape = pattern_map.at(reshape_label).get_node_shared_ptr(); @@ -1377,13 +1381,13 @@ class EliminateGatherWithRange : public ov::pass::MatcherPass { const auto range = pattern_map.at(range_label).get_node_shared_ptr(); int64_t range_start = -1; int64_t range_step = -1; - if (!get_constant_value(range->get_input_node_shared_ptr(0), range_start) || range_start != 0) + if (!ov::op::util::get_constant_value(range->get_input_node_shared_ptr(0), range_start) || range_start != 0) return false; - if (!get_constant_value(range->get_input_node_shared_ptr(2), range_step) || range_step != 1) + if (!ov::op::util::get_constant_value(range->get_input_node_shared_ptr(2), range_step) || range_step != 1) return false; int64_t gather_axis = -1; - if (!get_constant_value(gather->get_input_node_shared_ptr(2), gather_axis) || + if (!ov::op::util::get_constant_value(gather->get_input_node_shared_ptr(2), gather_axis) || gather_axis != shapeof_gather_indexes[shapeof_gather2_index]) return false; @@ -1503,7 +1507,7 @@ ov::pass::FuseReverseLSTMSequence::FuseReverseLSTMSequence() { if (squeeze->input_value(0) != lstm->output(0)) return false; int64_t squeeze_axis = -1; - if (!get_constant_value(squeeze->get_input_node_shared_ptr(1), squeeze_axis) || squeeze_axis != 1) + if (!ov::op::util::get_constant_value(squeeze->get_input_node_shared_ptr(1), squeeze_axis) || squeeze_axis != 1) return false; auto new_squeeze = node_registry.make(new_lstm->output(0), squeeze->input_value(1)); const auto match_root = m.get_match_root(); @@ -1511,7 +1515,7 @@ ov::pass::FuseReverseLSTMSequence::FuseReverseLSTMSequence() { for (auto& consumer : second_transpose->output(0).get_target_inputs()) { auto node = consumer.get_node()->shared_from_this(); - if (ov::is_type(node)) { + if (ov::is_type(node)) { auto shapeof = std::make_shared(new_lstm_input); replace_node(node, shapeof); } @@ -1546,11 +1550,11 @@ ov::pass::FuseLSTMSequencesToBidirectionalLSTMSequence::FuseLSTMSequencesToBidir auto lstm_sequence_forward_first_input_label = std::make_shared(OutputVector{transpose_forward_label, data_label}); auto shapeof_forward_label = - ov::pass::pattern::wrap_type({lstm_sequence_forward_first_input_label}); + ov::pass::pattern::wrap_type({lstm_sequence_forward_first_input_label}); auto gather_forward_label = - ov::pass::pattern::wrap_type({shapeof_forward_label, - ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type()}); + ov::pass::pattern::wrap_type({shapeof_forward_label, + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}); auto max_sequence_len_forward_label = ov::pass::pattern::wrap_type(); auto broadcast_forward_label = ov::pass::pattern::wrap_type({max_sequence_len_forward_label, gather_forward_label}); @@ -1575,11 +1579,11 @@ ov::pass::FuseLSTMSequencesToBidirectionalLSTMSequence::FuseLSTMSequencesToBidir auto lstm_sequence_reverse_first_input_label = std::make_shared(OutputVector{transpose_reverse_label, data_label}); auto shapeof_reverse_label = - ov::pass::pattern::wrap_type({lstm_sequence_reverse_first_input_label}); + ov::pass::pattern::wrap_type({lstm_sequence_reverse_first_input_label}); auto gather_reverse_label = - ov::pass::pattern::wrap_type({shapeof_reverse_label, - ov::pass::pattern::wrap_type(), - ov::pass::pattern::wrap_type()}); + ov::pass::pattern::wrap_type({shapeof_reverse_label, + ov::pass::pattern::wrap_type(), + ov::pass::pattern::wrap_type()}); auto max_sequence_len_reverse_label = ov::pass::pattern::wrap_type(); auto broadcast_reverse_label = ov::pass::pattern::wrap_type({max_sequence_len_reverse_label, gather_reverse_label}); @@ -1626,7 +1630,7 @@ ov::pass::FuseLSTMSequencesToBidirectionalLSTMSequence::FuseLSTMSequencesToBidir if (squeeze_forward->input_value(0) != lstm_forward->output(0)) return false; int64_t squeeze_forward_axis = -1; - if (!get_constant_value(squeeze_forward->get_input_node_shared_ptr(1), squeeze_forward_axis) || + if (!ov::op::util::get_constant_value(squeeze_forward->get_input_node_shared_ptr(1), squeeze_forward_axis) || squeeze_forward_axis != 1) return false; @@ -1634,7 +1638,7 @@ ov::pass::FuseLSTMSequencesToBidirectionalLSTMSequence::FuseLSTMSequencesToBidir if (squeeze_reverse->input_value(0) != lstm_reverse->output(0)) return false; int64_t squeeze_reverse_axis = -1; - if (!get_constant_value(squeeze_reverse->get_input_node_shared_ptr(1), squeeze_reverse_axis) || + if (!ov::op::util::get_constant_value(squeeze_reverse->get_input_node_shared_ptr(1), squeeze_reverse_axis) || squeeze_reverse_axis != 1) return false; @@ -1684,17 +1688,21 @@ ov::pass::FuseLSTMSequencesToBidirectionalLSTMSequence::FuseLSTMSequencesToBidir auto gather_forward = pattern_map.at(gather_forward_label); int64_t gather_index = -1; int64_t gather_axis = -1; - if (!get_constant_value(gather_forward->get_input_node_shared_ptr(1), gather_index) || gather_index != 0) + if (!ov::op::util::get_constant_value(gather_forward->get_input_node_shared_ptr(1), gather_index) || + gather_index != 0) return false; - if (!get_constant_value(gather_forward->get_input_node_shared_ptr(2), gather_axis) || gather_axis != 0) + if (!ov::op::util::get_constant_value(gather_forward->get_input_node_shared_ptr(2), gather_axis) || + gather_axis != 0) return false; auto gather_reverse = pattern_map.at(gather_reverse_label); gather_index = -1; gather_axis = -1; - if (!get_constant_value(gather_reverse->get_input_node_shared_ptr(1), gather_index) || gather_index != 0) + if (!ov::op::util::get_constant_value(gather_reverse->get_input_node_shared_ptr(1), gather_index) || + gather_index != 0) return false; - if (!get_constant_value(gather_reverse->get_input_node_shared_ptr(2), gather_axis) || gather_axis != 0) + if (!ov::op::util::get_constant_value(gather_reverse->get_input_node_shared_ptr(2), gather_axis) || + gather_axis != 0) return false; from.push_back(max_sequence_len_forward); diff --git a/src/common/transformations/src/transformations/op_conversions/detection_output_downgrade.cpp b/src/common/transformations/src/transformations/op_conversions/detection_output_downgrade.cpp index 481f59f2b9fcdd..8fb10a0329157a 100644 --- a/src/common/transformations/src/transformations/op_conversions/detection_output_downgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/detection_output_downgrade.cpp @@ -13,7 +13,6 @@ using namespace std; using namespace ov; -using namespace ov::op::util; pass::ConvertDetectionOutput8ToDetectionOutput1::ConvertDetectionOutput8ToDetectionOutput1() { MATCHER_SCOPE(ConvertDetectionOutput8ToDetectionOutput1); diff --git a/src/common/transformations/src/transformations/op_conversions/detection_output_upgrade.cpp b/src/common/transformations/src/transformations/op_conversions/detection_output_upgrade.cpp index f2006be8246bd4..167b07ea03052e 100644 --- a/src/common/transformations/src/transformations/op_conversions/detection_output_upgrade.cpp +++ b/src/common/transformations/src/transformations/op_conversions/detection_output_upgrade.cpp @@ -12,7 +12,6 @@ using namespace std; using namespace ov; -using namespace ov::op::util; pass::ConvertDetectionOutput1ToDetectionOutput8::ConvertDetectionOutput1ToDetectionOutput8() { MATCHER_SCOPE(ConvertDetectionOutput1ToDetectionOutput8); diff --git a/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp b/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp index 430f3b15cc0dd6..9e11ec726d4c34 100644 --- a/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp +++ b/src/common/transformations/src/transformations/transpose_sinking/ts_unary.cpp @@ -29,7 +29,6 @@ #include "transformations/utils/utils.hpp" using namespace ov; -using namespace ov::op::util; using namespace ov::pass::transpose_sinking; using namespace ov::pass::transpose_sinking::utils; @@ -49,7 +48,7 @@ TSUnaryForward::TSUnaryForward() { // We consider HardSigmoid, Swish, Selu, ConvertLike as unary ops // and handle only 0th input of these ops. - create_pattern