From 969060c8db5f06e7251d0979925ab57a946c0147 Mon Sep 17 00:00:00 2001
From: Wilson Seok <wilson.seok@intel.com>
Date: Wed, 2 Mar 2022 01:50:31 -0800
Subject: [PATCH] Add op impl check tests (#10339)

* Remove fp16 of Convert layer test from skip_tests.config.cpp as it works now

* update repo

* add initial op impl check tests

* add op imple check tests

* add op impl check tests

* add rnn cell based ops

* modify lstmsequence

* update rnn cell base op test

* add priorbox, priorboxclustered, proposal

* add ROIAlign to ReverseSequence

* add Roll to ScatterElementsUpdate

* add select to swish tests

* add tensoriterator to variadicsplit test

* temporary block of LSTMCell v1 due to crash in mkldnn

* use ov namespace instead of ngraph as possible

* update indexing of vector array

* update multiple parameter vector

* add loop test

* fix cpplint errors

* fix build error
---
 .../op_impl_check/single_op_graph.cpp         | 667 +++++++++++++++++-
 1 file changed, 666 insertions(+), 1 deletion(-)

diff --git a/src/tests/functional/plugin/shared/src/single_layer_tests/op_impl_check/single_op_graph.cpp b/src/tests/functional/plugin/shared/src/single_layer_tests/op_impl_check/single_op_graph.cpp
index ed5a17b7d4a..c78823e79f6 100644
--- a/src/tests/functional/plugin/shared/src/single_layer_tests/op_impl_check/single_op_graph.cpp
+++ b/src/tests/functional/plugin/shared/src/single_layer_tests/op_impl_check/single_op_graph.cpp
@@ -536,6 +536,397 @@ std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Parameter>
     return std::make_shared<ov::Model>(in, ParameterVector{in}, "Parameter-1");
 }
 
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::PriorBox> &node) {
+    ov::op::v0::PriorBox::Attributes attrs;
+    attrs.min_size = {2.0f};
+    attrs.aspect_ratio = {1.5f};
+    attrs.scale_all_sizes = false;
+    const auto LS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {2, 2});
+    const auto IS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {10, 10});
+    auto Node = std::make_shared<ov::op::v0::PriorBox>(LS, IS, attrs);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "PrioBoxGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v8::PriorBox> &node) {
+    ov::op::v8::PriorBox::Attributes attrs;
+    attrs.min_size = {2.0f};
+    attrs.max_size = {5.0f};
+    attrs.aspect_ratio = {1.5f};
+    attrs.scale_all_sizes = true;
+    attrs.min_max_aspect_ratios_order = false;
+    const auto LS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {2, 2});
+    const auto IS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {10, 10});
+    auto Node = std::make_shared<ov::op::v8::PriorBox>(LS, IS, attrs);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "PrioBoxGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::PriorBoxClustered> &node) {
+    ov::op::v0::PriorBoxClustered::Attributes attrs;
+    attrs.widths = {3.0f};
+    attrs.heights = {3.0f};
+    attrs.clip = true;
+    const auto LS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {2, 2});
+    const auto IS = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {10, 10});
+    auto Node = std::make_shared<ov::op::v0::PriorBoxClustered>(LS, IS, attrs);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "PrioBoxClustedGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Proposal> &node) {
+    ov::op::v0::Proposal::Attributes attrs;
+    attrs.base_size = 16;
+    attrs.min_size = 16;
+    attrs.pre_nms_topn = 6000;
+    attrs.post_nms_topn = 10;
+    attrs.nms_thresh = 0.7f;
+    attrs.feat_stride = 16;
+    attrs.min_size = 16;
+    attrs.ratio = {0.5f};
+    attrs.scale = {32.0f};
+    attrs.clip_before_nms = true;
+    attrs.clip_after_nms = false;
+    attrs.normalize = false;
+    attrs.box_size_scale = 1.0f;
+    attrs.box_coordinate_scale = 1.0f;
+    attrs.framework = "";
+    attrs.infer_probs = false;
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 2, 10, 10},
+                                                                              {1, 4, 10, 10},
+                                                                              {3}});
+    auto Node = std::make_shared<ov::op::v0::Proposal>(params.at(0), params.at(1), params.at(2), attrs);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ProposalGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v4::Proposal> &node) {
+    ov::op::v4::Proposal::Attributes attrs;
+    attrs.base_size = 16;
+    attrs.min_size = 16;
+    attrs.pre_nms_topn = 6000;
+    attrs.post_nms_topn = 10;
+    attrs.nms_thresh = 0.7f;
+    attrs.feat_stride = 16;
+    attrs.min_size = 16;
+    attrs.ratio = {0.5f};
+    attrs.scale = {32.0f};
+    attrs.clip_before_nms = true;
+    attrs.clip_after_nms = false;
+    attrs.normalize = false;
+    attrs.box_size_scale = 1.0f;
+    attrs.box_coordinate_scale = 1.0f;
+    attrs.framework = "";
+    attrs.infer_probs = true;
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 2, 10, 10},
+                                                                              {1, 4, 10, 10},
+                                                                              {3}});
+    auto Node = std::make_shared<ov::op::v4::Proposal>(params.at(0), params.at(1), params.at(2), attrs);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ProposalGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v3::ROIAlign> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 1, 16, 16}});
+    const auto coords = ngraph::builder::makeConstant<float>(ov::element::f32, {2, 4}, {2, 2, 8, 8, 2, 2, 8, 8});
+    const auto roisIdx = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2}, {0, 1});
+    auto Node = std::make_shared<ov::op::v3::ROIAlign>(params.at(0), coords, roisIdx, 2, 2, 2, 1, "avg");
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ROIAlignGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ROIPooling> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 3, 8, 8},
+                                                                              {1, 5}});
+    auto Node = std::make_shared<ov::op::v0::ROIPooling>(params.at(0), params.at(1), Shape{1, 1}, 1);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ROIPoolingGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v8::RandomUniform> &node) {
+    const auto out_shape_ = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {4}, {1, 3, 3, 3});
+    const auto min_value = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {0.f});
+    const auto max_value = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {1.f});
+    auto Node = std::make_shared<ov::op::v8::RandomUniform>(out_shape_, min_value, max_value, ov::element::f32, 10, 10);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "RandomUniformGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Range> &node) {
+    const auto start = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {1.f});
+    const auto stop = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {5.f});
+    const auto step = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {1.f});
+    auto Node = std::make_shared<ov::op::v0::Range>(start, stop, step);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "RangeGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v4::Range> &node) {
+    const auto start = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {1.f});
+    const auto stop = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {5.f});
+    const auto step = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {1.f});
+    auto Node = std::make_shared<ov::op::v4::Range>(start, stop, step, ov::element::f32);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, ov::ParameterVector{}, "RangeGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::RegionYolo> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 8, 2, 2}});
+    auto Node = std::make_shared<ov::op::v0::RegionYolo>(params.at(0), 4, 1, 1, true, std::vector<int64_t>{0}, 1, 3);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "RegionYoloGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ReorgYolo> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 8, 4, 4}});
+    auto Node = std::make_shared<ov::op::v0::ReorgYolo>(params.at(0), ov::Strides{2});
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ReorgYoloGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Reshape> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2, 3}});
+    const auto shape = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {1}, {12});
+    auto Node = std::make_shared<ov::op::v1::Reshape>(params.at(0), shape, false);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ReshapeGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Result> &node) {
+    const auto params = ngraph::builder::makeParams(ov::element::f32, {{2, 2}});
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(params.at(0))};
+    return std::make_shared<ov::Model>(results, params, "ResultGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Reverse> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 4, 3}});
+    const auto axis = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 1, 2});
+    auto Node = std::make_shared<ov::op::v1::Reverse>(params.at(0), axis, op::v1::Reverse::Mode::INDEX);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ReverseGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ReverseSequence  > &node) {
+    const auto params = ngraph::builder::makeDynamicParams({ov::element::f32, ov::element::i32},
+                                                           {{3, 10}, {3}});
+    auto Node = std::make_shared<ov::op::v0::ReverseSequence>(params.at(0), params.at(1), 0, 1);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ReverseSequenceGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v7::Roll> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{4, 2, 3}});
+    const auto shift = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {2, 1, 3});
+    const auto axes = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 1, 2});
+    auto Node = std::make_shared<ov::op::v7::Roll>(params.at(0), shift, axes);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "RollGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v5::Round> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{10}});
+    auto Node = std::make_shared<ov::op::v5::Round>(params.at(0), op::v5::Round::RoundMode::HALF_TO_EVEN);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "RoundGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v3::ScatterElementsUpdate> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2}, {2, 2}});
+    const auto indices = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {2, 2}, {1, 1, 0, 0});
+    const auto axis = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {1}, {0});
+    auto Node = std::make_shared<ov::op::v3::ScatterElementsUpdate>(params.at(0), indices, params.at(1), axis);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ScatterElementsUpdateGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Select> &node) {
+    const auto params = ngraph::builder::makeDynamicParams({ov::element::boolean, ov::element::f32, ov::element::f32},
+                                                           {{2, 2, 2}, {2, 2, 2}, {2, 2, 2}});
+    auto Node = std::make_shared<ov::op::v1::Select>(params.at(0), params.at(1), params.at(2), op::AutoBroadcastType::NONE);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SelectGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Selu> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{3}});
+    const auto alpha = ngraph::builder::makeConstant<float>(ov::element::f32, {1}, {1.67326324});
+    const auto lambda = ngraph::builder::makeConstant<float>(ov::element::f32, {1}, {1.05070098});
+    auto Node = std::make_shared<ov::op::v0::Selu>(params.at(0), alpha, lambda);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SeluGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ShapeOf> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 4, 8, 16, 64}});
+    auto Node = std::make_shared<ov::op::v0::ShapeOf>(params.at(0));
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ShapeOfGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v3::ShapeOf> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 4, 8, 16, 64}});
+    auto Node = std::make_shared<ov::op::v3::ShapeOf>(params.at(0));
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ShapeOfGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ShuffleChannels> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 15, 2, 2}});
+    auto Node = std::make_shared<ov::op::v0::ShuffleChannels>(params.at(0), 1, 5);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "ShuffleChannelsGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v8::Slice> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 4, 3}});
+    const auto start = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 0, 4});
+    const auto stop = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {2, 4, -5});
+    const auto step = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {3, 2, -2});
+    const auto axes = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 1, 2});
+    auto Node = std::make_shared<ov::op::v8::Slice>(params.at(0), start, stop, step, axes);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SliceGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v4::SoftPlus> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{4, 4}});
+    auto Node = std::make_shared<ov::op::v4::SoftPlus>(params.at(0));
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SoftPlusGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Softmax> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2, 3}});
+    auto Node = std::make_shared<ov::op::v1::Softmax>(params.at(0), 0);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SoftmaxGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v8::Softmax> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2, 3}});
+    auto Node = std::make_shared<ov::op::v8::Softmax>(params.at(0), 0);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SoftmaxGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::SpaceToBatch> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 1, 3, 2, 1}});
+    const auto blockShape = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {5}, {1, 1, 3, 2, 2});
+    const auto padsBegin = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {5}, {0, 0, 1, 0, 3});
+    const auto padsEnd = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {5}, {0, 0, 2, 0, 0});
+    auto Node = std::make_shared<ov::op::v1::SpaceToBatch>(params.at(0), blockShape, padsBegin, padsEnd);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SpaceToBatchGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::SpaceToDepth> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 2, 4, 4}});
+    auto Node = std::make_shared<ov::op::v0::SpaceToDepth>(params.at(0), "BLOCKS_FIRST", 2);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SpaceToDepthGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Split> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 8, 2}});
+    const auto axis = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {}, {1});
+    auto Node = std::make_shared<ov::op::v1::Split>(params.at(0), axis, 4);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SplitGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Squeeze> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 4, 1, 1, 2}});
+    const auto axes = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {2}, {0, 2});
+    auto Node = std::make_shared<ov::op::v0::Squeeze>(params.at(0), axes);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SqueezeGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::StridedSlice> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{128, 1}});
+    const auto begin = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 0, 0});
+    const auto end = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {0, 0, 0});
+    const auto stride = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {1, 1, 1});
+    auto Node = std::make_shared<ov::op::v1::StridedSlice>(params.at(0), begin, end, stride,
+                                                           std::vector<int64_t>{0, 1, 1},
+                                                           std::vector<int64_t>{0, 1, 1},
+                                                           std::vector<int64_t>{1, 0, 0},
+                                                           std::vector<int64_t>{1, 0, 0},
+                                                           std::vector<int64_t>{0, 0, 0});
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "StridedSliceGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v4::Swish> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 4}});
+    const auto beta = ngraph::builder::makeConstant<float>(ov::element::f32, {}, {0.6f});
+    auto Node = std::make_shared<ov::op::v4::Swish>(params.at(0), beta);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SwishGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Tile> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 1, 3}});
+    const auto repeats = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {2}, {2, 1});
+    auto Node = std::make_shared<ov::op::v0::Tile>(params.at(0), repeats);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "TileGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::TopK> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3, 2}});
+    const auto k = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {}, {3});
+    auto Node = std::make_shared<ov::op::v1::TopK>(params.at(0),
+                                                   k,
+                                                   1,
+                                                   ov::op::v1::TopK::Mode::MAX,
+                                                   ov::op::v1::TopK::SortType::SORT_VALUES);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node->output(0)),
+                             std::make_shared<ov::op::v0::Result>(Node->output(1))};
+    return std::make_shared<ov::Model>(results, params, "TopKGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v3::TopK> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3, 2}});
+    const auto k = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {}, {3});
+    auto Node = std::make_shared<ov::op::v3::TopK>(params.at(0),
+                                                   k,
+                                                   1,
+                                                   ov::op::v3::TopK::Mode::MAX,
+                                                   ov::op::v3::TopK::SortType::SORT_VALUES);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node->output(0)),
+                             std::make_shared<ov::op::v0::Result>(Node->output(1))};
+    return std::make_shared<ov::Model>(results, params, "TopKGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::Transpose> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2, 3}});
+    const auto inputOrder = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {3}, {2, 1, 0});
+    auto Node = std::make_shared<ov::op::v1::Transpose>(params.at(0), inputOrder);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "TransposeGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Unsqueeze> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{4, 2}});
+    const auto axes = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {2}, {1, -1});
+    auto Node = std::make_shared<ov::op::v0::Unsqueeze>(params.at(0), axes);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "UnsqueezeGraph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::VariadicSplit> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 8, 2, 2}});
+    const auto axis = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {1}, {1});
+    const auto splitLengths = ngraph::builder::makeConstant<int64_t>(ov::element::i64, {4}, {1, 3, 2, 2});
+    auto Node = std::make_shared<ov::op::v1::VariadicSplit>(params.at(0), axis, splitLengths);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node->output(0)),
+                             std::make_shared<ov::op::v0::Result>(Node->output(1)),
+                             std::make_shared<ov::op::v0::Result>(Node->output(2)),
+                             std::make_shared<ov::op::v0::Result>(Node->output(3))};
+    return std::make_shared<ov::Model>(results, params, "VariadicSplitGraph");
+}
+
 std::shared_ptr<ov::Model> generateBinaryEltwise(const std::shared_ptr<ov::op::Op> &node) {
     const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 2}, {1, 2}});
     std::shared_ptr<ov::Node> eltwiseNode;
@@ -702,6 +1093,262 @@ std::shared_ptr<ov::Model> generateReadValueBase(const std::shared_ptr<ov::op::O
         return nullptr;
     }
 }
+
+
+std::shared_ptr<ov::Model> generateDeformableConvolutionBase(const std::shared_ptr<ov::op::Op> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{1, 2, 4, 4},
+                                                                              {1, 18, 2, 2},
+                                                                              {1, 2, 3, 3}});
+    std::shared_ptr<ov::Node> deformableConvolutionNode;
+    if (ov::is_type<ov::op::v1::DeformableConvolution>(node)) {
+        deformableConvolutionNode = std::make_shared<ov::op::v1::DeformableConvolution>(params.at(0), params.at(1), params.at(2),
+                                                                                        ov::Strides {1, 1},
+                                                                                        ov::CoordinateDiff {0, 0},
+                                                                                        ov::CoordinateDiff {0, 0},
+                                                                                        ov::Strides {1, 1});
+    } else if (ov::is_type<ov::op::v8::DeformableConvolution>(node)) {
+        deformableConvolutionNode = std::make_shared<ov::op::v8::DeformableConvolution>(params.at(0), params.at(1), params.at(2),
+                                                                                        ov::Strides {1, 1},
+                                                                                        ov::CoordinateDiff {0, 0},
+                                                                                        ov::CoordinateDiff {0, 0},
+                                                                                        ov::Strides {1, 1});
+    } else {
+        return nullptr;
+    }
+
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(deformableConvolutionNode)};
+    return std::make_shared<ov::Model>(results, params, "DeformableConvolutionBaseGraph");
+}
+
+std::shared_ptr<ov::Model> generateDetectionOutputBase(const std::shared_ptr<ov::op::Op> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 8},
+                                                                              {2, 6},
+                                                                              {2, 1, 8}});
+    ov::op::v0::DetectionOutput::Attributes attrs;
+    ov::op::v8::DetectionOutput::Attributes attrs_v8;
+    attrs.num_classes = 3;
+    attrs_v8.background_label_id = attrs.background_label_id = -1;
+    attrs_v8.top_k = attrs.top_k = -1;
+    attrs_v8.variance_encoded_in_target = attrs.variance_encoded_in_target = true;
+    attrs_v8.keep_top_k = attrs.keep_top_k = {2};
+    attrs_v8.code_type = attrs.code_type = "caffe.PriorBoxParameter.CORNER";
+    attrs_v8.share_location = attrs.share_location = true;
+    attrs_v8.nms_threshold = attrs.nms_threshold = 0.5;
+    attrs_v8.confidence_threshold = attrs.confidence_threshold = 0.3;
+    attrs_v8.clip_after_nms = attrs.clip_after_nms = false;
+    attrs_v8.clip_before_nms = attrs.clip_before_nms = true;
+    attrs_v8.decrease_label_id = attrs.decrease_label_id = false;
+    attrs_v8.normalized = attrs.normalized = true;
+    attrs_v8.input_height = attrs.input_height = 0;
+    attrs_v8.input_width = attrs.input_width = 0;
+    attrs_v8.objectness_score = attrs.objectness_score = 0;
+
+    std::shared_ptr<ov::Node> DetectionOutputNode;
+    if (ov::is_type<ov::op::v0::DetectionOutput>(node)) {
+        DetectionOutputNode = std::make_shared<ov::op::v0::DetectionOutput>(params.at(0), params.at(1), params.at(2), attrs);
+    } else if (ov::is_type<ov::op::v8::DetectionOutput>(node)) {
+        DetectionOutputNode = std::make_shared<ov::op::v8::DetectionOutput>(params.at(0), params.at(1), params.at(2), attrs_v8);
+    } else {
+        return nullptr;
+    }
+
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(DetectionOutputNode)};
+    return std::make_shared<ov::Model>(results, params, "DetectionOutputBaseGraph");
+}
+
+std::shared_ptr<ov::Model> generateEmbeddingBagOffsetsBase(const std::shared_ptr<ov::op::Op> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{5, 2}});
+    const auto indices = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {4}, {}, true);
+    const auto offsets = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {3}, {}, true);
+    const auto default_index = ngraph::builder::makeConstant<int32_t>(ov::element::i32, ov::Shape(), std::vector<int32_t>{0});
+
+    std::shared_ptr<ov::Node> EmbeddingBagOffsetsSumNode;
+    if (ov::is_type<ov::op::v3::EmbeddingBagOffsetsSum>(node)) {
+        EmbeddingBagOffsetsSumNode = std::make_shared<ov::op::v3::EmbeddingBagOffsetsSum>(params.at(0), indices, offsets, default_index);
+    } else {
+        return nullptr;
+    }
+
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(EmbeddingBagOffsetsSumNode)};
+    return std::make_shared<ov::Model>(results, params, "EmbeddingBagOffsetsBaseGraph");
+}
+
+std::shared_ptr<ov::Model> generateEmbeddingBagPackedBase(const std::shared_ptr<ov::op::Op> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{5, 2}});
+    const auto indices = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {2, 3}, {}, true);
+
+    std::shared_ptr<ov::Node> EmbeddingBagPackedSumNode;
+    if (ov::is_type<ov::op::v3::EmbeddingBagPackedSum>(node)) {
+        EmbeddingBagPackedSumNode = std::make_shared<ov::op::v3::EmbeddingBagPackedSum>(params.at(0), indices);
+    } else {
+        return nullptr;
+    }
+
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(EmbeddingBagPackedSumNode)};
+    return std::make_shared<ov::Model>(results, params, "EmbeddingBagPackedBaseGraph");
+}
+
+std::shared_ptr<ov::Model> generateFFTBase(const std::shared_ptr<ov::op::Op> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 10, 10, 2}});
+    const auto axes = ngraph::builder::makeConstant<int32_t>(ov::element::i32, {1}, {2});
+
+    std::shared_ptr<ov::Node> FFTBaseNode;
+    if (ov::is_type<ov::op::v7::DFT>(node)) {
+        FFTBaseNode = std::make_shared<ov::op::v7::DFT>(params.at(0), axes);
+    } else if (ov::is_type<ov::op::v7::IDFT>(node)) {
+        FFTBaseNode = std::make_shared<ov::op::v7::IDFT>(params.at(0), axes);
+    } else {
+        return nullptr;
+    }
+
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(FFTBaseNode)};
+    return std::make_shared<ov::Model>(results, params, "FFTBaseGraph");
+}
+
+std::shared_ptr<ov::Model> generateGatherBase(const std::shared_ptr<ov::op::Op> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::i32, {{2, 2, 3, 3}, {2}});
+    const auto axis = ngraph::builder::makeConstant<int64_t>(ov::element::i64, ov::Shape(), std::vector<int64_t>{2});
+
+    std::shared_ptr<ov::Node> GatherBaseNode;
+    if (ov::is_type<ov::op::v1::Gather>(node)) {
+        GatherBaseNode = std::make_shared<ov::op::v1::Gather>(params.at(0), params.at(1), axis);
+    } else if (ov::is_type<ov::op::v7::Gather>(node)) {
+        GatherBaseNode = std::make_shared<ov::op::v7::Gather>(params.at(0), params.at(1), axis);
+    } else if (ov::is_type<ov::op::v8::Gather>(node)) {
+        GatherBaseNode = std::make_shared<ov::op::v8::Gather>(params.at(0), params.at(1), axis);
+    } else {
+        return nullptr;
+    }
+
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(GatherBaseNode)};
+    return std::make_shared<ov::Model>(results, params, "GatherBaseGraph");
+}
+
+std::shared_ptr<ov::Model> generateGatherNDBase(const std::shared_ptr<ov::op::Op> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::i32, {{2, 3, 4, 2}, {2, 3, 3, 2}});
+
+    std::shared_ptr<ov::Node> GatherNDBaseNode;
+    if (ov::is_type<ov::op::v5::GatherND>(node)) {
+        GatherNDBaseNode = std::make_shared<ov::op::v5::GatherND>(params.at(0), params.at(1));
+    } else if (ov::is_type<ov::op::v8::GatherND>(node)) {
+        GatherNDBaseNode = std::make_shared<ov::op::v8::GatherND>(params.at(0), params.at(1));
+    } else {
+        return nullptr;
+    }
+
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(GatherNDBaseNode)};
+    return std::make_shared<ov::Model>(results, params, "GatherNDBaseGraph");
+}
+
+std::shared_ptr<ov::Model> generateRNNCellBase(const std::shared_ptr<ov::op::Op> &node) {
+    std::shared_ptr<ov::Node> RNNCellBaseNode;
+    if (ov::is_type<ov::op::v3::GRUCell>(node)) {
+        const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3}, {2, 3}});
+        const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {9, 3}, {}, true);
+        const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {9, 3}, {}, true);
+        const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {9}, {}, true);
+        RNNCellBaseNode = std::make_shared<ov::op::v3::GRUCell>(params.at(0), params.at(1),
+                                                                W, R, B, 3);
+        ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode)};
+        return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
+    } else if (ov::is_type<ov::op::v0::LSTMCell>(node)) {
+        const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3}, {2, 3}, {2, 3}});
+        const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {12, 3}, {}, true);
+        const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {12, 3}, {}, true);
+        const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {12}, {}, true);
+        const auto P = ngraph::builder::makeConstant<float>(ov::element::f32, {9}, {}, true);
+        RNNCellBaseNode = std::make_shared<ov::op::v0::LSTMCell>(params.at(0), params.at(1), params.at(2),
+                                                                 W, R, B, P, 3);
+        ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(0)),
+                                 std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(1))};
+        //return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
+        return nullptr; // Temporary nullptr return due to crash in mkldnn
+    } else if (ov::is_type<ov::op::v4::LSTMCell>(node)) {
+        const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3}, {2, 3}, {2, 3}});
+        const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {12, 3}, {}, true);
+        const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {12, 3}, {}, true);
+        const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {12}, {}, true);
+        RNNCellBaseNode = std::make_shared<ov::op::v4::LSTMCell>(params.at(0), params.at(1), params.at(2),
+                                                                 W, R, B, 3);
+        ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(0)),
+                                 std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(1))};;
+        return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
+    } else if (ov::is_type<ov::op::v5::LSTMSequence>(node)) {
+        const auto params = ngraph::builder::makeDynamicParams({ov::element::f32, ov::element::f32, ov::element::f32, ov::element::i64},
+                                                               {{5, 10, 10}, {5, 1, 10}, {5, 1, 10}, {5}});
+        const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 40, 10}, {}, true);
+        const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 40, 10}, {}, true);
+        const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 40}, {}, true);
+        RNNCellBaseNode = std::make_shared<ov::op::v5::LSTMSequence>(params.at(0), params.at(1), params.at(2), params.at(3),
+                                                                     W, R, B, 10, ov::op::RecurrentSequenceDirection::FORWARD);
+        ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(0)),
+                                 std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(1)),
+                                 std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(2))};
+        return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
+    } else if (ov::is_type<ov::op::v0::RNNCell>(node)) {
+        const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 3}, {2, 3}});
+        const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {3, 3}, {}, true);
+        const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {3, 3}, {}, true);
+        const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {3}, {}, true);
+        RNNCellBaseNode = std::make_shared<ov::op::v0::RNNCell>(params.at(0), params.at(1),
+                                                                W, R, B, 3);
+        ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode)};
+        return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
+    } else if (ov::is_type<ov::op::v5::RNNSequence>(node)) {
+        const auto params = ngraph::builder::makeDynamicParams({ov::element::f32, ov::element::f32, ov::element::i64},
+                                                               {{2, 5, 3}, {2, 1, 3}, {2}});
+        const auto W = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 3, 3}, {}, true);
+        const auto R = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 3, 3}, {}, true);
+        const auto B = ngraph::builder::makeConstant<float>(ov::element::f32, {1, 3}, {}, true);
+        RNNCellBaseNode = std::make_shared<ov::op::v5::RNNSequence>(params.at(0), params.at(1), params.at(2),
+                                                                    W, R, B, 3, ov::op::RecurrentSequenceDirection::FORWARD);
+        ov::ResultVector results{std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(0)),
+                                 std::make_shared<ov::op::v0::Result>(RNNCellBaseNode->output(1))};
+        return std::make_shared<ov::Model>(results, params, "RNNCellBaseGraph");
+    } else {
+        return nullptr;
+    }
+}
+
+std::shared_ptr<ov::Model> generateSubGraphOp(const std::shared_ptr<ov::op::Op> &node) {
+    const auto params = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2}, {2, 2}, {2, 2}});
+    const auto params_body = ngraph::builder::makeDynamicParams(ov::element::f32, {{2, 2}, {2, 2}, {2, 2}});
+    const auto body_condition = ngraph::builder::makeConstant<bool>(ov::element::boolean, ov::Shape{1}, {true});
+    const auto trip_count = ngraph::builder::makeConstant<int64_t>(ngraph::element::i64, ov::Shape{1}, {3});
+    const auto exec_condition = ngraph::builder::makeConstant<bool>(ov::element::boolean, ov::Shape{1}, {true});
+    // Body
+    auto sum = std::make_shared<ov::op::v1::Add>(params_body.at(0), params_body.at(1));
+    auto Zo = std::make_shared<ov::op::v1::Multiply>(sum, params_body.at(2));
+    auto body = std::make_shared<ov::Model>(ov::OutputVector{body_condition, Zo}, params_body);
+
+    ov::Output<ov::Node> SubGraphOpNode;
+    if (ov::is_type<ov::op::v0::TensorIterator>(node)) {
+        auto tensor_iterator = std::make_shared<ov::op::v0::TensorIterator>();
+        tensor_iterator->set_function(body);
+
+        tensor_iterator->set_sliced_input(params_body.at(0), params.at(0), 0, 1, 1, -1, 1);
+        tensor_iterator->set_sliced_input(params_body.at(1), params.at(1), 0, 1, 1, -1, 0);
+        tensor_iterator->set_merged_input(params_body.at(2), params.at(2), Zo);
+
+        // Output 0 is last Zo
+        SubGraphOpNode = tensor_iterator->get_iter_value(Zo, -1);
+    } else if (ov::is_type<ov::op::v5::Loop>(node)) {
+        auto loop = std::make_shared<ov::op::v5::Loop>(trip_count, exec_condition);
+        loop->set_function(body);
+
+        loop->set_invariant_input(params_body.at(0), params.at(0));
+        loop->set_invariant_input(params_body.at(1), params.at(1));
+        loop->set_merged_input(params_body.at(2), params.at(2), Zo);
+
+        loop->set_special_body_ports(ov::op::v5::Loop::SpecialBodyPorts{-1, 0});
+        SubGraphOpNode = loop->get_iter_value(Zo, -1);
+    } else {
+        return nullptr;
+    }
+
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(SubGraphOpNode)};
+    return std::make_shared<ov::Model>(results, params, "SubGraphOpGraph");
+}
 }  // namespace
 
 template <typename T>
@@ -724,6 +1371,24 @@ std::shared_ptr<ov::Model> generateGraph() {
         return generateNmsBase(node);
     } else if (ov::is_type<ov::op::util::ReadValueBase>(node)) {
         return generateReadValueBase(node);
+    } else if (ov::is_type<ov::op::util::DeformableConvolutionBase>(node)) {
+        return generateDeformableConvolutionBase(node);
+    } else if (ov::is_type<ov::op::util::DetectionOutputBase>(node)) {
+        return generateDetectionOutputBase(node);
+    } else if (ov::is_type<ov::op::util::EmbeddingBagOffsetsBase>(node)) {
+        return generateEmbeddingBagOffsetsBase(node);
+    } else if (ov::is_type<ov::op::util::EmbeddingBagPackedBase>(node)) {
+        return generateEmbeddingBagPackedBase(node);
+    } else if (ov::is_type<ov::op::util::FFTBase>(node)) {
+        return generateFFTBase(node);
+    } else if (ov::is_type<ov::op::util::GatherBase>(node)) {
+        return generateGatherBase(node);
+    } else if (ov::is_type<ov::op::util::GatherNDBase>(node)) {
+        return generateGatherNDBase(node);
+    } else if (ov::is_type<ov::op::util::RNNCellBase>(node)) {
+        return generateRNNCellBase(node);
+    } else if (ov::is_type<ov::op::util::SubGraphOp>(node)) {
+        return generateSubGraphOp(node);
     }
 
     return generate(node);
@@ -747,4 +1412,4 @@ OpGenerator getOpGeneratorMap() {
 
 }  // namespace subgraph
 }  // namespace test
-}  // namespace ov
+}  // namespace ov
\ No newline at end of file