[ONNX] Frontend refactoring (openvinotoolkit#21964)

* Removed an old exported symbols and ngraph namespace * Updated graph_cache.hpp/cpp * Update graph_cache.cpp: code style * Added OPENVINO_OP to naming exceptions
rkazants · Jan 5, 2024 · 64e3a4f · 64e3a4f
1 parent 51eb107
commit 64e3a4f
Show file tree

Hide file tree

Showing 28 changed files with 57 additions and 74 deletions.
diff --git a/cmake/developer_package/ncc_naming_style/openvino.style b/cmake/developer_package/ncc_naming_style/openvino.style
@@ -1,5 +1,5 @@
 # custom OpenVINO values
-CppMethod: '^(operator\W+|[a-z_\d]+|signaling_NaN|quiet_NaN)$'
+CppMethod: '^(operator\W+|[a-z_\d]+|signaling_NaN|quiet_NaN|OPENVINO_OP)$'
 ClassName: '^([A-Z][\w]+|b?float16|numeric_limits|ngraph_error|stopwatch|unsupported_op)$'
 StructName: '^([A-Z][\w]+|element_type_traits|hash|oi_pair|stat)$'
 FunctionName: '^(operator\W+|[a-z_\d]+)|PrintTo$'

diff --git a/src/frontends/onnx/frontend/include/onnx_import/core/null_node.hpp b/src/frontends/onnx/frontend/include/onnx_import/core/null_node.hpp
@@ -4,36 +4,18 @@
 
 #pragma once
 
-#if !defined(IN_OV_COMPONENT) && !defined(NGRAPH_LEGACY_HEADER_INCLUDED)
-#    define NGRAPH_LEGACY_HEADER_INCLUDED
-#    ifdef _MSC_VER
-#        pragma message( \
-            "The nGraph API is deprecated and will be removed in the 2024.0 release. For instructions on transitioning to the new API, please refer to https://docs.openvino.ai/latest/openvino_2_0_transition_guide.html")
-#    else
-#        warning("The nGraph API is deprecated and will be removed in the 2024.0 release. For instructions on transitioning to the new API, please refer to https://docs.openvino.ai/latest/openvino_2_0_transition_guide.html")
-#    endif
-#endif
-
-#include <memory>
-
-#include "onnx_import/onnx_importer_visibility.hpp"
-#include "openvino/core/deprecated.hpp"
 #include "openvino/op/op.hpp"
 
 namespace ov {
 namespace op {
 namespace util {
-NGRAPH_API_DEPRECATED ONNX_IMPORTER_API bool is_null(const ov::Node* node);
-NGRAPH_API_DEPRECATED ONNX_IMPORTER_API bool is_null(const std::shared_ptr<ov::Node>& node);
-NGRAPH_API_DEPRECATED ONNX_IMPORTER_API bool is_null(const Output<ov::Node>& output);
+bool is_null(const ov::Node* node);
+bool is_null(const std::shared_ptr<ov::Node>& node);
+bool is_null(const Output<ov::Node>& output);
 }  // namespace util
 }  // namespace op
 }  // namespace ov
 namespace ngraph {
-namespace op {
-using namespace ov::op::util;
-}
-
 namespace onnx_import {
 /// \brief Represents a missing optional input or output of an ONNX node
 ///
@@ -44,7 +26,7 @@ namespace onnx_import {
 ///
 /// More:
 /// https://github.com/onnx/onnx/blob/master/docs/IR.md#optional-inputs-and-outputs
-class NGRAPH_API_DEPRECATED ONNX_IMPORTER_API NullNode : public ov::op::Op {
+class NullNode : public ov::op::Op {
 public:
     OPENVINO_OP("NullNode");
     NullNode() {

diff --git a/src/frontends/onnx/frontend/src/core/graph_cache.cpp b/src/frontends/onnx/frontend/src/core/graph_cache.cpp
@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <core/graph_cache.hpp>
-#include <ngraph/except.hpp>
+#include "core/graph_cache.hpp"
+
+#include "openvino/core/except.hpp"
 
 namespace ngraph {
 namespace onnx_import {
-void GraphCache::emplace_node(const std::string& name, Output<ngraph::Node>&& node) {
+void GraphCache::emplace_node(const std::string& name, Output<ov::Node>&& node) {
     m_graph_cache_map[name] = std::move(node);
 }
 
@@ -18,7 +19,7 @@ void GraphCache::remove_node(const std::string& name) {
     }
 }
 
-Output<ngraph::Node> GraphCache::get_node(const std::string& name) const {
+Output<ov::Node> GraphCache::get_node(const std::string& name) const {
     try {
         return m_graph_cache_map.at(name);
     } catch (const std::out_of_range&) {

diff --git a/src/frontends/onnx/frontend/src/core/graph_cache.hpp b/src/frontends/onnx/frontend/src/core/graph_cache.hpp
@@ -8,7 +8,7 @@
 #include <memory>
 #include <string>
 
-#include "ngraph/node.hpp"
+#include "openvino/core/node.hpp"
 
 namespace ngraph {
 namespace onnx_import {
@@ -21,7 +21,7 @@ class GraphCache {
     ///
     /// \param[in]  name       The name of node added to the cache.
     /// \param[in]  node       The node added to the cache.
-    void emplace_node(const std::string& name, Output<ngraph::Node>&& node);
+    void emplace_node(const std::string& name, Output<ov::Node>&& node);
 
     /// \brief      Remove node from the cache
     ///
@@ -30,12 +30,12 @@ class GraphCache {
 
     /// \brief      Get the node from the cache
     ///
-    /// \note       If the node is not found the ngraph_error exception is thrown.
+    /// \note       If the node is not found the ov::Exception is thrown.
     ///
     /// \param[in]  name       The name of the node.
     ///
     /// \return     The node named `name`.
-    virtual Output<ngraph::Node> get_node(const std::string& name) const;
+    virtual Output<ov::Node> get_node(const std::string& name) const;
 
     /// \brief      Return true if the node named `name` exist in the cache.
     ///
@@ -47,7 +47,7 @@ class GraphCache {
     virtual ~GraphCache() = default;
 
 private:
-    std::map<std::string, Output<ngraph::Node>> m_graph_cache_map;
+    std::map<std::string, Output<ov::Node>> m_graph_cache_map;
 };
 }  // namespace onnx_import
 }  // namespace ngraph
diff --git a/src/frontends/onnx/frontend/src/op/aten.cpp b/src/frontends/onnx/frontend/src/op/aten.cpp
@@ -33,11 +33,11 @@ OutputVector aten(const Node& node) {
     CHECK_VALID_NODE(node, inputs.size() >= 2, "Minimum 2 inputs are required. Got: ", inputs.size());
 
     const bool is_packed_two_inputs =
-        inputs.size() == 2 || (inputs.size() == 3 && ngraph::op::is_null(inputs[2])) ||
-        (inputs.size() == 4 && ngraph::op::is_null(inputs[2]) && ngraph::op::is_null(inputs[3]));
+        inputs.size() == 2 || (inputs.size() == 3 && ov::op::util::is_null(inputs[2])) ||
+        (inputs.size() == 4 && ov::op::util::is_null(inputs[2]) && ov::op::util::is_null(inputs[3]));
     const bool is_packed_three_inputs =
-        inputs.size() == 4 && ngraph::op::is_null(inputs[2]) && !ngraph::op::is_null(inputs[3]);
-    const bool is_offsets_three_inputs = inputs.size() == 3 && !ngraph::op::is_null(inputs[2]);
+        inputs.size() == 4 && ov::op::util::is_null(inputs[2]) && !ov::op::util::is_null(inputs[3]);
+    const bool is_offsets_three_inputs = inputs.size() == 3 && !ov::op::util::is_null(inputs[2]);
 
     Output<ov::Node> embedding_bag;
     if (is_packed_two_inputs) {

diff --git a/src/frontends/onnx/frontend/src/op/clip.cpp b/src/frontends/onnx/frontend/src/op/clip.cpp
@@ -38,7 +38,7 @@ OutputVector clip(const Node& node) {
 
     // If second input is provided, assign to min input, otherwise set lowest
     // numeric limit of data type as min input.
-    if (inputs.size() > 1 && !ngraph::op::is_null(inputs.at(1))) {
+    if (inputs.size() > 1 && !ov::op::util::is_null(inputs.at(1))) {
         min = inputs.at(1);
     } else {
         OPENVINO_SUPPRESS_DEPRECATED_START
@@ -48,7 +48,7 @@ OutputVector clip(const Node& node) {
 
     // If third input is provided, assign to max input, otherwise set maximum
     // numeric limit of data type as max input.
-    if (inputs.size() == 3 && !ngraph::op::is_null(inputs.at(2))) {
+    if (inputs.size() == 3 && !ov::op::util::is_null(inputs.at(2))) {
         max = inputs.at(2);
     } else {
         OPENVINO_SUPPRESS_DEPRECATED_START

diff --git a/src/frontends/onnx/frontend/src/op/com.microsoft/attention.cpp b/src/frontends/onnx/frontend/src/op/com.microsoft/attention.cpp
@@ -383,7 +383,7 @@ std::shared_ptr<ngraph::Node> raw_mask(const Output<ngraph::Node>& mask_index,
 }
 
 bool is_past_input_available(const OutputVector& op_inputs) {
-    return op_inputs.size() > 4 && !ngraph::op::is_null(op_inputs[4]);
+    return op_inputs.size() > 4 && !ov::op::util::is_null(op_inputs[4]);
 }
 
 NodeTuple get_attention_mask(const OutputVector& op_inputs, bool unidirectional) {
@@ -410,7 +410,7 @@ NodeTuple get_attention_mask(const OutputVector& op_inputs, bool unidirectional)
     if (unidirectional) {
         std::tie(attention_mask, bin_mask) = unidirectional_mask(type, seq_len, all_seq_len, past_seq_len);
     }
-    if (op_inputs.size() > 3 && !ngraph::op::is_null(op_inputs[3])) {
+    if (op_inputs.size() > 3 && !ov::op::util::is_null(op_inputs[3])) {
         const auto& mask_index = op_inputs[3];
         NGRAPH_CHECK(mask_index.get_element_type() == element::i32, "'mask_index' type must be int32");
         auto batch_size = get_dimensions(input_shape, {0});
@@ -477,7 +477,7 @@ std::shared_ptr<ngraph::Node> attention_softmax(const OutputVector& op_inputs,
     // (Q x K' + mask) / sqrt(head_size)
     softmax_input = std::make_shared<default_opset::Divide>(softmax_input, sqrt);
     // handle 'extra_add' input
-    if (op_inputs.size() > 5 && !ngraph::op::is_null(op_inputs[5])) {
+    if (op_inputs.size() > 5 && !ov::op::util::is_null(op_inputs[5])) {
         NGRAPH_CHECK(!is_past_input_available(op_inputs),
                      "Cannot use both 'past' and 'extra_add' inputs in the same node");
         const auto& extra_add = op_inputs[5];

diff --git a/src/frontends/onnx/frontend/src/op/com.microsoft/embed_layer_normalization.cpp b/src/frontends/onnx/frontend/src/op/com.microsoft/embed_layer_normalization.cpp
@@ -30,7 +30,7 @@ OutputVector embed_layer_normalization(const Node& node) {
     const auto zero = default_opset::Constant::create(element::i32, Shape{1}, {0});
     std::shared_ptr<ngraph::Node> input = std::make_shared<default_opset::Gather>(word_embeddings, input_ids, zero, 0);
     // add position embeddings
-    if (num_nodes > 8 && !ngraph::op::is_null(nodes[8])) {
+    if (num_nodes > 8 && !ov::op::util::is_null(nodes[8])) {
         // if we have position_ids
         const auto& position_ids = nodes[8];
         const auto gathered_position_embeddings =
@@ -51,8 +51,8 @@ OutputVector embed_layer_normalization(const Node& node) {
         input = std::make_shared<default_opset::Add>(input, gathered_position_embeddings);
     }
     // add segment embeddings if available
-    if (!ngraph::op::is_null(segment_ids)) {
-        NGRAPH_CHECK(!ngraph::op::is_null(segment_embeddings),
+    if (!ov::op::util::is_null(segment_ids)) {
+        NGRAPH_CHECK(!ov::op::util::is_null(segment_embeddings),
                      "segment_ids provided, but segment_embedding input is missing");
         NGRAPH_CHECK(nodes[1].get_element_type() == element::i32, "segment_ids must have int32 type");
         auto gathered_segment_embeddings =
@@ -75,7 +75,7 @@ OutputVector embed_layer_normalization(const Node& node) {
 
     // compute mask_index output
     std::shared_ptr<ngraph::Node> mask_index;
-    if (num_nodes > 7 && !ngraph::op::is_null(nodes[7])) {
+    if (num_nodes > 7 && !ov::op::util::is_null(nodes[7])) {
         NGRAPH_CHECK(nodes[7].get_element_type() == element::i32, "mask must have int32 type");
         auto axis = default_opset::Constant::create(element::i32, Shape{}, {1});
         mask_index = std::make_shared<default_opset::ReduceSum>(nodes[7], axis, false);

diff --git a/src/frontends/onnx/frontend/src/op/com.microsoft/fusedgemm.cpp b/src/frontends/onnx/frontend/src/op/com.microsoft/fusedgemm.cpp
@@ -27,7 +27,7 @@ OutputVector fusedgemm(const Node& node) {
     Output<ngraph::Node> input_b = inputs.at(1);
     Output<ngraph::Node> input_c;
 
-    if (num_inputs == 3 && !ngraph::op::is_null(inputs[2])) {
+    if (num_inputs == 3 && !ov::op::util::is_null(inputs[2])) {
         input_c = inputs.at(2);
     } else {
         input_c = default_opset::Constant::create(input_b.get_element_type(), ngraph::Shape{}, {0});

diff --git a/src/frontends/onnx/frontend/src/op/constant_of_shape.cpp b/src/frontends/onnx/frontend/src/op/constant_of_shape.cpp
@@ -28,7 +28,7 @@ OutputVector constant_of_shape(const onnx_import::Node& node) {
     }
     const auto& inputs = node.get_ng_inputs();
     if (inputs.size() == 0 || common::is_failsafe_node(inputs[0].get_node_shared_ptr()) ||
-        ngraph::op::is_null(inputs[0])) {
+        ov::op::util::is_null(inputs[0])) {
         return {constant_value};
     }
     return {std::make_shared<default_opset::Broadcast>(constant_value, inputs[0])};

diff --git a/src/frontends/onnx/frontend/src/op/conv.cpp b/src/frontends/onnx/frontend/src/op/conv.cpp
@@ -60,7 +60,7 @@ OutputVector conv(const Node& node,
                                                              auto_pad_type);
 
     // no bias param
-    if (ngraph::op::is_null(bias)) {
+    if (ov::op::util::is_null(bias)) {
         return {conv_node};
     } else {
         const auto& bias_ps = bias.get_partial_shape();

diff --git a/src/frontends/onnx/frontend/src/op/dequantize_linear.cpp b/src/frontends/onnx/frontend/src/op/dequantize_linear.cpp
@@ -21,7 +21,7 @@ namespace onnx_import {
 namespace op {
 namespace detail {
 std::shared_ptr<ngraph::Node> get_zero_point(const OutputVector& inputs) {
-    if (inputs.size() == 3 && !ngraph::op::is_null(inputs[2])) {
+    if (inputs.size() == 3 && !ov::op::util::is_null(inputs[2])) {
         const auto& zero_point = inputs[2];
 
         if (zero_point.get_element_type() != element::f32) {

diff --git a/src/frontends/onnx/frontend/src/op/dft.cpp b/src/frontends/onnx/frontend/src/op/dft.cpp
@@ -17,7 +17,7 @@ OutputVector dft(const Node& node) {
     const OutputVector ng_inputs{node.get_ng_inputs()};
     const ov::Output<ov::Node> data = ng_inputs.at(0);
 
-    const auto dft_length_provided = ng_inputs.size() > 1 && !ngraph::op::is_null(ng_inputs[1]);
+    const auto dft_length_provided = ng_inputs.size() > 1 && !ov::op::util::is_null(ng_inputs[1]);
     const auto axis = node.get_attribute_value<int64_t>("axis", 1);
     const auto inverse = node.get_attribute_value<int64_t>("inverse", 0);
     const auto onesided = node.get_attribute_value<int64_t>("onesided", 0);

diff --git a/src/frontends/onnx/frontend/src/op/dropout.cpp b/src/frontends/onnx/frontend/src/op/dropout.cpp
@@ -40,7 +40,7 @@ OutputVector dropout(const Node& node) {
     // seed attribute and ratio input are ignored because traning mode is not
     // supported anyway
     bool training_mode = false;  // default value
-    if (ng_inputs.size() > 2 && !ngraph::op::is_null(ng_inputs.at(2))) {
+    if (ng_inputs.size() > 2 && !ov::op::util::is_null(ng_inputs.at(2))) {
         CHECK_VALID_NODE(node,
                          ov::op::util::is_constant(ng_inputs.at(2).get_node_shared_ptr()),
                          "Non-constant training_mode input is not supported.");

diff --git a/src/frontends/onnx/frontend/src/op/gru.cpp b/src/frontends/onnx/frontend/src/op/gru.cpp
@@ -29,7 +29,7 @@ struct GRUInputMap : public recurrent::OpInputMap {
             const auto& ng_inputs = node.get_ng_inputs();
             const auto el_type = ng_inputs.at(0).get_element_type();
 
-            if (ng_inputs.size() > 3 && !ngraph::op::is_null(ng_inputs.at(3))) {
+            if (ng_inputs.size() > 3 && !ov::op::util::is_null(ng_inputs.at(3))) {
                 auto bias = ng_inputs.at(3);
                 // gates_count * 2 since B is: [Wb, Rb]
                 const int split_parts = 2 * 3;

diff --git a/src/frontends/onnx/frontend/src/op/loop.cpp b/src/frontends/onnx/frontend/src/op/loop.cpp
@@ -57,7 +57,7 @@ OutputVector loop(const Node& node) {
     // optional inputs
     Output<ngraph::Node> trip_count;
     // trip count skipped or has value max(int64_t) means infinitive loop
-    if (ngraph::op::is_null(ng_inputs.at(0)) ||
+    if (ov::op::util::is_null(ng_inputs.at(0)) ||
         (ngraph::op::is_constant(ng_inputs.at(0).get_node_shared_ptr()) &&
          ov::as_type_ptr<default_opset::Constant>(ng_inputs.at(0).get_node_shared_ptr())->cast_vector<int64_t>()[0] ==
              std::numeric_limits<int64_t>::max())) {
@@ -67,8 +67,8 @@ OutputVector loop(const Node& node) {
         trip_count = ng_inputs.at(0);
     }
 
-    Output<ngraph::Node> termination_cond;                           // true means that first interation should be run
-    if (ngraph::op::is_null(ng_inputs.at(1).get_node_shared_ptr()))  // termination condition skipped
+    Output<ngraph::Node> termination_cond;                             // true means that first interation should be run
+    if (ov::op::util::is_null(ng_inputs.at(1).get_node_shared_ptr()))  // termination condition skipped
     {
         termination_cond = ngraph::op::Constant::create(ngraph::element::boolean, {1}, {true});
     } else if (ngraph::op::is_constant(ng_inputs.at(1).get_node_shared_ptr()) &&

diff --git a/src/frontends/onnx/frontend/src/op/lstm.cpp b/src/frontends/onnx/frontend/src/op/lstm.cpp
@@ -98,7 +98,7 @@ struct LSTMNgInputMap {
         // `B` - The bias tensor for input gate.
         // ONNX Shape: [num_directions, 8*hidden_size]
         // OpenVino Shape: [num_directions, 4*hidden_size]
-        if (ng_inputs.size() > 3 && !ngraph::op::is_null(ng_inputs.at(3))) {
+        if (ng_inputs.size() > 3 && !ov::op::util::is_null(ng_inputs.at(3))) {
             auto bias = ng_inputs.at(3);
             auto split_bias = ov::op::util::split(bias, 2, 1);
             m_input_map[LSTMInput::LSTM_INPUT_B] =
@@ -121,7 +121,7 @@ struct LSTMNgInputMap {
         }
         // `sequence_lens`- The lengths of the sequences in a batch.
         // Shape: [batch_size]
-        if (ng_inputs.size() > 4 && !ngraph::op::is_null(ng_inputs.at(4))) {
+        if (ng_inputs.size() > 4 && !ov::op::util::is_null(ng_inputs.at(4))) {
             m_input_map[LSTMInput::LSTM_INPUT_SEQ_LENGTHS] = ng_inputs.at(4);
         } else {
             m_input_map[LSTMInput::LSTM_INPUT_SEQ_LENGTHS] =
@@ -130,7 +130,7 @@ struct LSTMNgInputMap {
         // `initial_h` - The initial value of the hidden.
         // ONNX Shape: [num_directions, batch_size, hidden_size]
         // OpenVino Shape: [batch_size, num_directions, hidden_size]
-        if (ng_inputs.size() > 5 && !ngraph::op::is_null(ng_inputs.at(5))) {
+        if (ng_inputs.size() > 5 && !ov::op::util::is_null(ng_inputs.at(5))) {
             m_input_map[LSTMInput::LSTM_INPUT_INIT_H] = ov::op::util::reorder_axes(ng_inputs.at(5), {1, 0, 2});
         } else {
             auto init_h_shape = std::make_shared<default_opset::Concat>(
@@ -143,7 +143,7 @@ struct LSTMNgInputMap {
         // `initial_c` - The initial value of the cell.
         // ONNX Shape: [num_directions, batch_size, hidden_size]
         // OpenVino Shape: [batch_size, num_directions, hidden_size]
-        if (ng_inputs.size() > 6 && !ngraph::op::is_null(ng_inputs.at(6))) {
+        if (ng_inputs.size() > 6 && !ov::op::util::is_null(ng_inputs.at(6))) {
             m_input_map[LSTMInput::LSTM_INPUT_INIT_C] = ov::op::util::reorder_axes(ng_inputs.at(6), {1, 0, 2});
         } else {
             auto init_c_shape = std::make_shared<default_opset::Concat>(
@@ -156,7 +156,7 @@ struct LSTMNgInputMap {
         // `P` - The weight tensor for peepholes.
         // ONNX Shape: [num_directions, 3*hidden_size]
         // OpenVino Shape: [num_directions, 4*hidden_size]
-        if (ng_inputs.size() > 7 && !ngraph::op::is_null(ng_inputs.at(7))) {
+        if (ng_inputs.size() > 7 && !ov::op::util::is_null(ng_inputs.at(7))) {
             m_input_map[LSTMInput::LSTM_INPUT_P] =
                 ov::op::util::convert_lstm_peepholes_format(ng_inputs.at(7),
                                                             ov::op::util::LSTMPeepholesFormat::IOF,

diff --git a/src/frontends/onnx/frontend/src/op/non_max_suppression.cpp b/src/frontends/onnx/frontend/src/op/non_max_suppression.cpp
@@ -19,7 +19,7 @@ namespace onnx_import {
 namespace op {
 namespace set_1 {
 OutputVector non_max_suppression(const Node& node) {
-    using ngraph::op::is_null;
+    using ov::op::util::is_null;
     // TODO: this op will not be tested until at least
     //       a reference implementation is added
 

diff --git a/src/frontends/onnx/frontend/src/op/pad.cpp b/src/frontends/onnx/frontend/src/op/pad.cpp
@@ -74,7 +74,7 @@ OutputVector pad(const Node& node) {
     Output<ngraph::Node> padding_begin;
     Output<ngraph::Node> padding_end;
 
-    if (inputs.size() == 3 && !ngraph::op::is_null(inputs[2])) {
+    if (inputs.size() == 3 && !ov::op::util::is_null(inputs[2])) {
         values = reshape::interpret_as_scalar(inputs[2]);
     } else {
         values = default_opset::Constant::create(data.get_element_type(), ngraph::Shape{}, {0});

diff --git a/src/frontends/onnx/frontend/src/op/qlinear_conv.cpp b/src/frontends/onnx/frontend/src/op/qlinear_conv.cpp
@@ -47,7 +47,7 @@ OutputVector qlinear_conv(const Node& node) {
                                           1,
                                           node)[0];
 
-    if (!ngraph::op::is_null(B)) {
+    if (!ov::op::util::is_null(B)) {
         B = std::make_shared<opset6::Multiply>(std::make_shared<opset6::Convert>(B, x_scale.get_element_type()),
                                                std::make_shared<opset6::Multiply>(x_scale, w_scale))
                 ->output(0);

diff --git a/src/frontends/onnx/frontend/src/op/resize.cpp b/src/frontends/onnx/frontend/src/op/resize.cpp
@@ -121,7 +121,7 @@ OutputVector resize(const onnx_import::Node& node) {
 
     auto attrs = get_resize_attrs(node);
 
-    if (inputs.size() == 4 && !ngraph::op::is_null(inputs[3])) {
+    if (inputs.size() == 4 && !ov::op::util::is_null(inputs[3])) {
         attrs.shape_calculation_mode = default_opset::Interpolate::ShapeCalcMode::SIZES;
         const auto& sizes = inputs.at(3);
         return {std::make_shared<default_opset::Interpolate>(data, sizes, attrs)};

diff --git a/src/frontends/onnx/frontend/src/op/scan.cpp b/src/frontends/onnx/frontend/src/op/scan.cpp
@@ -165,7 +165,7 @@ namespace set_1 {
 OutputVector scan(const Node& node) {
     // ONNX Scan-8 can have optional `sequence_lens` input,
     // and sequence scan_input axis is assumed to be always 1.
-    OPENVINO_ASSERT(ngraph::op::is_null(node.get_ng_inputs().at(0)),
+    OPENVINO_ASSERT(ov::op::util::is_null(node.get_ng_inputs().at(0)),
                     node.get_description(),
                     " ONNX Scan-8 `sequence_lens` input is not supported. ");
     return import_onnx_scan(node, 1, 1, "directions");

diff --git a/src/frontends/onnx/frontend/src/op/slice.cpp b/src/frontends/onnx/frontend/src/op/slice.cpp
@@ -17,7 +17,7 @@ namespace onnx_import {
 namespace op {
 namespace set_10 {
 OutputVector slice(const Node& node) {
-    using ngraph::op::is_null;
+    using ov::op::util::is_null;
 
     OutputVector inputs{node.get_ng_inputs()};
     const auto& data = inputs.at(0);