Fixing NodePredicate conversion to ValuePredicate

Signed-off-by: Evgeniia Nugmanova <evgeniia.nugmanova@intel.com>

Author: jane-intel

src/common/transformations/include/transformations/utils/utils.hpp

@@ -294,8 +294,8 @@ TRANSFORMATIONS_API bool is_on_constant_path(const ov::Output<ov::Node>& output)
 TRANSFORMATIONS_API bool process_subgraph(ov::pass::ModelPass& model_pass, const std::shared_ptr<Node>& node);
 
 template <typename T>
-ov::pass::pattern::op::ValuePredicate constant_predicate(std::function<bool(const std::vector<T>&)> predicate) {
-    return pass::pattern::op::as_value_predicate([=](std::shared_ptr<Node> n) -> bool {
+ov::pass::pattern::op::Predicate constant_predicate(std::function<bool(const std::vector<T>&)> predicate) {
+    return ov::pass::pattern::op::Predicate([=](std::shared_ptr<Node> n) -> bool {
         if (auto constant = as_type_ptr<v0::Constant>(n)) {
             auto values = constant->cast_vector<T>();
             return predicate(values);

src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp

@@ -893,12 +893,11 @@ pass::EliminateScatterUpdate::EliminateScatterUpdate() {
 
 ov::pass::EliminateNopBroadcast::EliminateNopBroadcast() {
     MATCHER_SCOPE(EliminateNopBroadcast);
-    auto root = pattern::wrap_type<op::v1::Broadcast, op::v3::Broadcast, op::v0::Tile>(
-        pattern::op::as_value_predicate([](std::shared_ptr<Node> 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;
-        }));
+    auto root = pattern::wrap_type<op::v1::Broadcast, op::v3::Broadcast, op::v0::Tile>([](std::shared_ptr<Node> 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) {
         const auto& op = m.get_match_root();

src/common/transformations/src/transformations/symbolic_transformations/dereshape_matmul.cpp

@@ -182,10 +182,10 @@ void pull_reshape_through_optional_concat_and_bea(const ov::pass::pattern::Patte
 }
 }  // namespace
 
-#define IN_RESHAPE                                                                                            \
-    pattern::wrap_type<op::v1::Reshape>(pattern::op::as_value_predicate([](std::shared_ptr<Node> n) -> bool { \
-        return pattern::consumers_count(1)(n->output(0)) && reshape_keeps_last_two_dims(n);                   \
-    }));
+#define IN_RESHAPE                                                                          \
+    pattern::wrap_type<op::v1::Reshape>([](std::shared_ptr<Node> n) -> bool {               \
+        return pattern::consumers_count(1)(n->output(0)) && reshape_keeps_last_two_dims(n); \
+    });
 
 #define SCALAR_INPUT                                                                        \
     pattern::any_input([](ov::Output<Node> out) {                                           \
@@ -252,10 +252,9 @@ ov::pass::DeReshapeMatMul::DeReshapeMatMul() {
 
     auto matmul_or_add = std::make_shared<pattern::op::Or>(OutputVector{matmul, add});
     auto final_reshape =
-        pattern::wrap_type<op::v1::Reshape>({matmul_or_add, pattern::any_input()},
-                                            pattern::op::as_value_predicate([](std::shared_ptr<Node> n) -> bool {
-                                                return reshape_keeps_last_two_dims(n);
-                                            }));
+        pattern::wrap_type<op::v1::Reshape>({matmul_or_add, pattern::any_input()}, [](std::shared_ptr<Node> n) -> bool {
+            return reshape_keeps_last_two_dims(n);
+        });
 
     ov::matcher_pass_callback matcher_pass_callback = [=](pattern::Matcher& m) {
         const auto& pm = m.get_pattern_map();

src/core/include/openvino/pass/pattern/op/any.hpp

@@ -21,14 +21,14 @@ class OPENVINO_API Any : public Pattern {
         set_output_type(0, type, s);
     }
     Any(const element::Type& type, const PartialShape& s, const NodePredicate& pred, const NodeVector& wrapped_values)
-        : Any(type, s, as_value_predicate(pred), as_output_vector(wrapped_values)) {}
+        : Any(type, s, Predicate(pred), as_output_vector(wrapped_values)) {}
     /// \brief creates a Any node containing a sub-pattern described by the type and
     ///        shape of \sa node.
     template <typename TPredicate>
     Any(const Output<Node>& node, const TPredicate& pred, const OutputVector& wrapped_values)
         : Any(node.get_element_type(), node.get_partial_shape(), pred, wrapped_values) {}
     Any(const Output<Node>& node, const NodePredicate& pred, const NodeVector& wrapped_values)
-        : Any(node, as_value_predicate(pred), as_output_vector(wrapped_values)) {}
+        : Any(node, Predicate(pred), as_output_vector(wrapped_values)) {}
 
     bool match_value(pattern::Matcher* matcher,
                      const Output<Node>& pattern_value,

src/core/include/openvino/pass/pattern/op/any_of.hpp

@@ -29,15 +29,15 @@ class OPENVINO_API AnyOf : public Pattern {
         set_output_type(0, type, s);
     }
     AnyOf(const element::Type& type, const PartialShape& s, const NodePredicate& pred, const NodeVector& wrapped_values)
-        : AnyOf(type, s, as_value_predicate(pred), as_output_vector(wrapped_values)) {}
+        : AnyOf(type, s, Predicate(pred), as_output_vector(wrapped_values)) {}
 
     /// \brief creates a AnyOf node containing a sub-pattern described by the type and
     ///        shape of \sa node.
     template <typename TPredicate>
     AnyOf(const Output<Node>& node, const TPredicate& pred, const OutputVector& wrapped_values)
         : AnyOf(node.get_element_type(), node.get_partial_shape(), pred, wrapped_values) {}
     AnyOf(const std::shared_ptr<Node>& node, const NodePredicate& pred, const NodeVector& wrapped_values)
-        : AnyOf(node, as_value_predicate(pred), as_output_vector(wrapped_values)) {}
+        : AnyOf(node, Predicate(pred), as_output_vector(wrapped_values)) {}
     bool match_value(Matcher* matcher, const Output<Node>& pattern_value, const Output<Node>& graph_value) override;
 };
 }  // namespace ov::pass::pattern::op

src/core/include/openvino/pass/pattern/op/label.hpp

@@ -46,7 +46,7 @@ class OPENVINO_API Label : public Pattern {
           const PartialShape& s,
           const NodePredicate& pred,
           const NodeVector& wrapped_values = {})
-        : Label(type, s, as_value_predicate(pred), as_output_vector(wrapped_values)) {}
+        : Label(type, s, Predicate(pred), as_output_vector(wrapped_values)) {}
 
     /// \brief creates a Label node containing a sub-pattern described by the type and
     ///        shape of \sa node.
@@ -64,10 +64,7 @@ class OPENVINO_API Label : public Pattern {
     Label(const Output<Node>& value, const TPredicate& pred, const OutputVector& wrapped_values = {})
         : Label(value.get_element_type(), value.get_partial_shape(), Predicate(pred), wrapped_values) {}
     Label(const Output<Node>& node, const NodePredicate& pred, const NodeVector& wrapped_values = {})
-        : Label(node.get_element_type(),
-                node.get_partial_shape(),
-                as_value_predicate(pred),
-                as_output_vector(wrapped_values)) {}
+        : Label(node.get_element_type(), node.get_partial_shape(), Predicate(pred), as_output_vector(wrapped_values)) {}
 
     explicit Label(const element::Type& type = element::dynamic, const PartialShape& s = PartialShape::dynamic())
         : Label(type, s, nullptr, OutputVector{}) {}

src/core/include/openvino/pass/pattern/op/pattern.hpp

@@ -64,9 +64,8 @@ OPENVINO_API op::Predicate all_of(const std::vector<std::function<bool(Output<No
 OPENVINO_API op::Predicate shape_matches(const std::string& shape_notation);
 
 namespace op {
-
-OPENVINO_API
-ValuePredicate as_value_predicate(NodePredicate pred);
+OPENVINO_DEPRECATED("This method is deprecated. Use constructor of ov::pass::pattern::Predicate instead")
+OPENVINO_API Predicate as_value_predicate(NodePredicate pred);
 
 class OPENVINO_API Pattern : public Node {
 public:

src/core/include/openvino/pass/pattern/op/predicate.hpp

@@ -94,18 +94,8 @@ class OPENVINO_API Predicate {
     }
 
     bool operator()(PatternSymbolMap& m, const Output<Node>& output) const;
-
-    template <typename T>
-    bool operator()(const T& arg) const {
-        OPENVINO_ASSERT(!m_requires_map,
-                        "Predicate " + m_name + " called with unexpected argument: " + std::string(typeid(T).name()));
-        if constexpr (std::is_convertible_v<T, Output<Node>>) {
-            PatternSymbolMap dummy_map;
-            return m_pred(dummy_map, arg);
-        }
-        OPENVINO_ASSERT(false,
-                        "Predicate " + m_name + " called with unexpected argument: " + std::string(typeid(T).name()));
-    }
+    bool operator()(const std::shared_ptr<Node>& node) const;
+    bool operator()(const Output<Node>& output) const;
 
     template <typename TPredicate>
     Predicate operator||(const TPredicate& other) const {

src/core/src/pattern/op/pattern.cpp

@@ -17,24 +17,12 @@ constexpr bool value_true_predicate(const Output<Node>&) {
 }
 }  // namespace
 
-struct NodeValuePredicate {
-    bool operator()(const Output<Node>& value) const {
-        return pred(value.get_node_shared_ptr());
-    }
-
-    NodePredicate pred;
-};
-
 Pattern::Pattern(const OutputVector& patterns) : Node(patterns), m_predicate() {}
 
 Pattern::Pattern(const OutputVector& patterns, const op::Predicate& pred) : Node(patterns), m_predicate(pred) {}
 
-ValuePredicate as_value_predicate(NodePredicate pred) {
-    if (pred) {
-        return NodeValuePredicate{std::move(pred)};
-    } else {
-        return value_true_predicate;
-    }
+Predicate as_value_predicate(NodePredicate pred) {
+    return Predicate(pred);
 }
 
 std::ostream& Pattern::write_type_description(std::ostream& out) const {

src/core/src/pattern/op/predicate.cpp

@@ -78,5 +78,17 @@ bool Predicate::operator()(pass::pattern::PatternSymbolMap& m, const Output<Node
     OPENVINO_DEBUG("Predicate `", m_name, "` has ", (result ? "passed" : "failed"), ". Applied to ", output);
     return result;
 }
+
+bool Predicate::operator()(const std::shared_ptr<Node>& node) const {
+    OPENVINO_ASSERT(!m_requires_map, "Predicate " + m_name + " called with unexpected argument: std::shared_ptr<Node>");
+    PatternSymbolMap dummy_map;
+    return m_pred(dummy_map, node);
+}
+
+bool Predicate::operator()(const Output<Node>& output) const {
+    OPENVINO_ASSERT(!m_requires_map, "Predicate " + m_name + " called with unexpected argument: Output<Node>");
+    PatternSymbolMap dummy_map;
+    return m_pred(dummy_map, output);
+}
 }  // namespace op
 }  // namespace ov::pass::pattern

src/plugins/intel_gpu/src/plugin/transformations/clamp_fp16_output.cpp

@@ -28,8 +28,8 @@ ClampFP16Output::ClampFP16Output() {
     using namespace ov::pass::pattern;
     using namespace ov::pass::pattern::op;
 
-    auto in0 = any_input(as_value_predicate(class_other_than<v0::Constant>()));
-    auto in1 = any_input(as_value_predicate(class_other_than<v0::Constant>()));
+    auto in0 = any_input(class_other_than<v0::Constant>());
+    auto in1 = any_input(class_other_than<v0::Constant>());
     auto matmul_m = wrap_type<v0::MatMul>({in0, in1}, type_matches(ov::element::f16) && consumers_count(1));
     auto reshape_m = wrap_type<v1::Reshape>({matmul_m, any_input()}, type_matches(ov::element::f16) && consumers_count(1));
     auto add_m = wrap_type<v1::Add>({matmul_m, any_input()}, type_matches(ov::element::f16) && consumers_count(1));

src/plugins/intel_gpu/src/plugin/transformations/lora_horizontal_fusion.cpp

@@ -58,7 +58,7 @@ LoRAHorizontalFusion::LoRAHorizontalFusion() {
 
     auto axis_const = wrap_type<ov::op::v0::Constant>();
     auto split_const = wrap_type<ov::op::v0::Constant>();
-    auto split = wrap_type<ov::op::v1::VariadicSplit>({main_flow, axis_const, split_const}, ov::pass::pattern::op::as_value_predicate(is_target_pattern));
+    auto split = wrap_type<ov::op::v1::VariadicSplit>({main_flow, axis_const, split_const}, is_target_pattern);
 
     ov::matcher_pass_callback callback = [=](Matcher& m) {
         const auto& pattern_map = m.get_pattern_value_map();