[ShapeInfer] Review detectron ROI feature extractor shape inference aspects (#17532)

* Review detectron ROI feature extractor shape infer
- Check Interval dimension and label propagation.
- Check template implementation of shape_infer.
- Add/Update unit test for static and dynamic shapes.
- Remove `ngraph` namespace from reviewed operator.

* Fix compilation issues

src/core/include/openvino/op/experimental_detectron_roi_feature.hpp

@@ -52,6 +52,10 @@ public:
         return m_attrs;
     }
 
+    ///@brief Set the ExperimentalDetectronROIFeatureExtractor's attributes.
+    ///@param attrs  Attributes to set.
+    void set_attrs(Attributes attrs);
+
 private:
     Attributes m_attrs;
 

src/core/shape_inference/include/experimental_detectron_roi_feature_shape_inference.hpp

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <openvino/op/experimental_detectron_roi_feature.hpp>
-
+#include "dimension_util.hpp"
+#include "openvino/op/experimental_detectron_roi_feature.hpp"
 #include "utils.hpp"
+
 namespace ov {
 namespace op {
 namespace v6 {
@@ -15,74 +16,66 @@ namespace v6 {
 // outputs:
 //          1.  out_shape = [number_of_ROIs, number_of_channels, output_size, output_size]
 //          2.  out_rois_shape = [number_of_ROIs, 4]
-template <class T>
-void shape_infer(const ExperimentalDetectronROIFeatureExtractor* op,
-                 const std::vector<T>& input_shapes,
-                 std::vector<T>& output_shapes) {
-    using DimType = typename std::iterator_traits<typename T::iterator>::value_type;
+template <class TShape>
+std::vector<TShape> shape_infer(const ExperimentalDetectronROIFeatureExtractor* op,
+                                const std::vector<TShape>& input_shapes,
+                                const ITensorAccessor& tensor_accessor = make_tensor_accessor()) {
+    using TDim = typename TShape::value_type;
+    using namespace ov::util;
+    NODE_VALIDATION_CHECK(op, input_shapes.size() >= 2);
 
-    NODE_VALIDATION_CHECK(op, input_shapes.size() >= 2 && output_shapes.size() == 2);
+    auto output_shapes = std::vector<TShape>();
+    output_shapes.reserve(2);
 
     const auto& rois_shape = input_shapes[0];
-    auto& out_shape = output_shapes[0];
-    auto& out_rois_shape = output_shapes[1];
-
-    // all dimensions is initialized by-default as dynamic
-    out_shape.resize(4);
-    out_rois_shape.resize(2);
-
-    // infer static dimensions
-    out_shape[2] = op->get_attrs().output_size;
-    out_shape[3] = op->get_attrs().output_size;
-    out_rois_shape[1] = 4;
-
-    // infer number_of_ROIs (which may be dynamic/static)
-    auto rois_shape_rank = rois_shape.rank();
+    const auto rois_shape_rank = rois_shape.rank();
     NODE_VALIDATION_CHECK(op, rois_shape_rank.compatible(2), "Input rois rank must be equal to 2.");
 
     if (rois_shape_rank.is_static()) {
+        output_shapes.emplace_back(std::initializer_list<TDim>{rois_shape[0], TDim(dim::inf_bound)});
+        output_shapes.emplace_back(std::initializer_list<TDim>{rois_shape[0], 4});
+        auto& out_rois_shape = output_shapes[1];
+
         NODE_VALIDATION_CHECK(op,
-                              rois_shape[1].compatible(4),
+                              TDim::merge(out_rois_shape[1], out_rois_shape[1], rois_shape[1]),
                               "The last dimension of the 'input_rois' input must be equal to 4. "
                               "Got: ",
                               rois_shape[1]);
-
-        out_shape[0] = rois_shape[0];
-        out_rois_shape[0] = rois_shape[0];
+    } else {
+        output_shapes.emplace_back(std::initializer_list<TDim>{TDim(dim::inf_bound), TDim(dim::inf_bound)});
+        output_shapes.emplace_back(std::initializer_list<TDim>{TDim(dim::inf_bound), 4});
     }
 
-    // infer number_of_channels;
-    // by definition, all shapes starting from input 2 must have same number_of_channels
-    DimType channels_intersection;
+    auto& out_rois_feat_shape = output_shapes[0];
+    out_rois_feat_shape.insert(out_rois_feat_shape.end(), 2, TDim(op->get_attrs().output_size));
+
     bool channels_intersection_initialized = false;
-    for (size_t i = 1; i < input_shapes.size(); i++) {
-        const auto& current_shape = input_shapes[i];
-        auto current_rank = current_shape.rank();
-
+    for (size_t i = 1; i < input_shapes.size(); ++i) {
+        const auto& layer_shape = input_shapes[i];
+        const auto layer_rank = layer_shape.rank();
         NODE_VALIDATION_CHECK(op,
-                              current_rank.compatible(4),
+                              layer_rank.compatible(4),
                               "Rank of each element of the pyramid must be equal to 4. Got: ",
-                              current_rank);
+                              layer_rank);
 
-        if (current_rank.is_static()) {
+        if (layer_rank.is_static()) {
             NODE_VALIDATION_CHECK(op,
-                                  current_shape[0].compatible(1),
-                                  "The first dimension of each pyramid element must be equal to 1. "
-                                  "Got: ",
-                                  current_shape[0]);
+                                  layer_shape[0].compatible(1),
+                                  "The first dimension of each pyramid element must be equal to 1. Got: ",
+                                  layer_shape[0]);
 
             if (channels_intersection_initialized) {
                 NODE_VALIDATION_CHECK(op,
-                                      DimType::merge(channels_intersection, channels_intersection, current_shape[1]),
+                                      TDim::merge(out_rois_feat_shape[1], out_rois_feat_shape[1], layer_shape[1]),
                                       "The number of channels must be the same for all layers of the pyramid.");
             } else {
-                channels_intersection = current_shape[1];
+                out_rois_feat_shape[1] = layer_shape[1];
                 channels_intersection_initialized = true;
             }
         }
     }
 
-    out_shape[1] = channels_intersection;
+    return output_shapes;
 }
 }  // namespace v6
 }  // namespace op

src/core/shape_inference/include/experimental_detectron_shape_infer_utils.hpp

@@ -0,0 +1,23 @@
+// Copyright (C) 2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+#pragma once
+
+#include "openvino/core/node.hpp"
+
+namespace ov {
+namespace op {
+namespace detectron {
+namespace validate {
+
+/**
+ * @brief Validates if all op's inputs have got same floating type and return inputs shapes and element type.
+ *
+ * @param op   Pointer to detector operator.
+ * @return Input shapes and element type as pair.
+ */
+std::pair<std::vector<PartialShape>, element::Type> all_inputs_same_floating_type(const Node* const op);
+}  // namespace validate
+}  // namespace detectron
+}  // namespace op
+}  // namespace ov

src/core/shape_inference/src/experimental_detectron_shape_infer_utils.cpp

@@ -0,0 +1,44 @@
+// Copyright (C) 2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "experimental_detectron_shape_infer_utils.hpp"
+
+namespace ov {
+namespace op {
+namespace detectron {
+namespace validate {
+
+/**
+ * @brief Validates if all op's inputs have got same floating type and return inputs shapes and element type.
+ *
+ * @param op   Pointer to detector operator.
+ * @return Input shapes and element type as pair.
+ */
+std::pair<std::vector<PartialShape>, element::Type> all_inputs_same_floating_type(const Node* const op) {
+    auto shapes_and_type = std::make_pair(std::vector<ov::PartialShape>(), element::dynamic);
+    auto& out_et = shapes_and_type.second;
+    auto& input_shapes = shapes_and_type.first;
+
+    const auto input_size = op->get_input_size();
+    input_shapes.reserve(input_size);
+
+    for (size_t i = 0; i < input_size; ++i) {
+        const auto& input_et = op->get_input_element_type(i);
+        NODE_VALIDATION_CHECK(
+            op,
+            element::Type::merge(out_et, out_et, input_et) && (out_et.is_dynamic() || out_et.is_real()),
+            "Input[",
+            i,
+            "] type '",
+            input_et,
+            "' is not floating point or not same as others inputs.");
+        input_shapes.push_back(op->get_input_partial_shape(i));
+    }
+
+    return shapes_and_type;
+}
+}  // namespace validate
+}  // namespace detectron
+}  // namespace op
+}  // namespace ov

src/core/src/op/experimental_detectron_roi_feature.cpp

@@ -2,19 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "ngraph/op/experimental_detectron_roi_feature.hpp"
+#include "openvino/op/experimental_detectron_roi_feature.hpp"
 
 #include <algorithm>
-#include <experimental_detectron_roi_feature_shape_inference.hpp>
 #include <memory>
 #include <utility>
 
+#include "experimental_detectron_roi_feature_shape_inference.hpp"
+#include "experimental_detectron_shape_infer_utils.hpp"
 #include "itt.hpp"
-#include "ngraph/attribute_visitor.hpp"
+#include "openvino/core/attribute_visitor.hpp"
 
 using namespace std;
-using namespace ngraph;
 
+namespace ov {
 op::v6::ExperimentalDetectronROIFeatureExtractor::ExperimentalDetectronROIFeatureExtractor(const OutputVector& args,
                                                                                            const Attributes& attrs)
     : Op(args),
@@ -37,20 +38,12 @@ bool op::v6::ExperimentalDetectronROIFeatureExtractor::visit_attributes(Attribut
 
 void op::v6::ExperimentalDetectronROIFeatureExtractor::validate_and_infer_types() {
     OV_OP_SCOPE(v6_ExperimentalDetectronROIFeatureExtractor_validate_and_infer_types);
-    NODE_VALIDATION_CHECK(this, get_input_size() >= 2, "At least two argument required.");
 
-    std::vector<ov::PartialShape> output_shapes = {ov::PartialShape{}, ov::PartialShape{}};
-    std::vector<ov::PartialShape> input_shapes;
-    for (size_t i = 0; i < get_input_size(); i++)
-        input_shapes.push_back(get_input_partial_shape(i));
+    const auto shapes_and_type = detectron::validate::all_inputs_same_floating_type(this);
+    const auto output_shapes = shape_infer(this, shapes_and_type.first);
 
-    shape_infer(this, input_shapes, output_shapes);
-
-    auto input_et = get_input_element_type(0);
-
-    set_output_size(output_shapes.size());
     for (size_t i = 0; i < output_shapes.size(); i++)
-        set_output_type(i, input_et, output_shapes[i]);
+        set_output_type(i, shapes_and_type.second, output_shapes[i]);
 }
 
 shared_ptr<Node> op::v6::ExperimentalDetectronROIFeatureExtractor::clone_with_new_inputs(
@@ -59,3 +52,8 @@ shared_ptr<Node> op::v6::ExperimentalDetectronROIFeatureExtractor::clone_with_ne
     check_new_args_count(this, new_args);
     return make_shared<op::v6::ExperimentalDetectronROIFeatureExtractor>(new_args, m_attrs);
 }
+
+void op::v6::ExperimentalDetectronROIFeatureExtractor::set_attrs(Attributes attrs) {
+    m_attrs = std::move(attrs);
+}
+}  // namespace ov

src/core/tests/type_prop/experimental_detectron_roi_feature_extractor.cpp

@@ -2,358 +2,485 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <vector>
+#include <array>
 
-#include "gtest/gtest.h"
-#include "ngraph/ngraph.hpp"
-#include "util/type_prop.hpp"
+#include "common_test_utils/test_assertions.hpp"
+#include "gmock/gmock.h"
+#include "openvino/opsets/opset11.hpp"
+#include "type_prop.hpp"
 
-using namespace ngraph;
+using namespace ov;
+using namespace ov::opset11;
+using namespace testing;
+
+class TypePropExperimentalDetectronROIFeatureExtractorV6Test
+    : public TypePropOpTest<op::v6::ExperimentalDetectronROIFeatureExtractor> {
+protected:
+    using Attrs = op::v6::ExperimentalDetectronROIFeatureExtractor::Attributes;
+
+    static Attrs make_attrs(int64_t out_size) {
+        return {out_size, 2, {4, 8, 16, 32}, false};
+    };
+};
 
 using Attrs = op::v6::ExperimentalDetectronROIFeatureExtractor::Attributes;
 using ExperimentalROI = op::v6::ExperimentalDetectronROIFeatureExtractor;
 
-TEST(type_prop, detectron_roi_feature_extractor) {
-    Attrs attrs;
-    attrs.aligned = false;
-    attrs.output_size = 14;
-    attrs.sampling_ratio = 2;
-    attrs.pyramid_scales = {4, 8, 16, 32};
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, default_ctor) {
+    const auto rois = std::make_shared<Parameter>(element::f16, Shape{1000, 4});
+    const auto pyramid_layer0 = std::make_shared<Parameter>(element::f16, PartialShape{1, 256, 200, 336});
+    const auto pyramid_layer1 = std::make_shared<Parameter>(element::f16, PartialShape{1, 256, 100, 168});
+    const auto pyramid_layer2 = std::make_shared<Parameter>(element::f16, PartialShape{1, 256, 50, 84});
+    const auto pyramid_layer3 = std::make_shared<Parameter>(element::f16, PartialShape{1, 256, 25, 42});
 
-    auto input = std::make_shared<op::Parameter>(element::f32, Shape{1000, 4});
-    auto pyramid_layer0 = std::make_shared<op::Parameter>(element::f32, Shape{1, 256, 200, 336});
-    auto pyramid_layer1 = std::make_shared<op::Parameter>(element::f32, Shape{1, 256, 100, 168});
-    auto pyramid_layer2 = std::make_shared<op::Parameter>(element::f32, Shape{1, 256, 50, 84});
-    auto pyramid_layer3 = std::make_shared<op::Parameter>(element::f32, Shape{1, 256, 25, 42});
+    const auto op = make_op();
+    op->set_arguments(OutputVector{rois, pyramid_layer0, pyramid_layer1, pyramid_layer2, pyramid_layer3});
+    op->set_attrs({21, 2, {1, 2, 4, 8}, true});
+    op->validate_and_infer_types();
 
-    auto roi = std::make_shared<ExperimentalROI>(
-        NodeVector{input, pyramid_layer0, pyramid_layer1, pyramid_layer2, pyramid_layer3},
-        attrs);
-
-    ASSERT_EQ(roi->get_output_element_type(0), element::f32);
-    EXPECT_EQ(roi->get_output_shape(0), (Shape{1000, 256, 14, 14}));
+    EXPECT_EQ(op->get_input_size(), 5);
+    EXPECT_EQ(op->get_output_size(), 2);
+    EXPECT_THAT(op->outputs(), Each(Property("Element type", &Output<Node>::get_element_type, element::f16)));
+    EXPECT_THAT(op->outputs(),
+                ElementsAre(Property("ROIs feat shape", &Output<Node>::get_shape, Shape({1000, 256, 21, 21})),
+                            Property("ROIs order shape", &Output<Node>::get_shape, Shape({1000, 4}))));
 }
 
-TEST(type_prop, detectron_roi_feature_extractor_dynamic) {
-    Attrs attrs;
-    attrs.aligned = false;
-    attrs.output_size = 14;
-    attrs.sampling_ratio = 2;
-    attrs.pyramid_scales = {4, 8, 16, 32};
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, static_shapes) {
+    const auto rois = std::make_shared<Parameter>(element::f32, Shape{1000, 4});
+    const auto pyramid_layer0 = std::make_shared<Parameter>(element::f32, Shape{1, 256, 200, 336});
+    const auto pyramid_layer1 = std::make_shared<Parameter>(element::f32, Shape{1, 256, 100, 168});
+    const auto pyramid_layer2 = std::make_shared<Parameter>(element::f32, Shape{1, 256, 50, 84});
+    const auto pyramid_layer3 = std::make_shared<Parameter>(element::f32, Shape{1, 256, 25, 42});
 
-    struct Shapes {
-        PartialShape input_shape;
-        Dimension channels;
-    };
+    const auto op =
+        make_op(NodeVector{rois, pyramid_layer0, pyramid_layer1, pyramid_layer2, pyramid_layer3}, make_attrs(14));
 
-    const auto dyn_dim = Dimension::dynamic();
+    EXPECT_EQ(op->get_output_element_type(0), element::f32);
+    EXPECT_EQ(op->get_output_shape(0), (Shape{1000, 256, 14, 14}));
+}
 
-    std::vector<Shapes> shapes = {{{1000, 4}, dyn_dim}, {{dyn_dim, 4}, 256}, {{dyn_dim, 4}, dyn_dim}};
-    for (const auto& s : shapes) {
-        auto layer0_shape = PartialShape{1, s.channels, 200, 336};
-        auto layer1_shape = PartialShape{1, s.channels, 100, 168};
-        auto layer2_shape = PartialShape{1, s.channels, 50, 84};
-        auto layer3_shape = PartialShape{1, s.channels, 25, 42};
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, dims_and_labels_propagation_all_inputs_labeled) {
+    auto in_shape = PartialShape{{100, 200}, 4};
+    auto l0_shape = PartialShape{1, {2, 20}, 10, 10};
+    auto l1_shape = PartialShape{1, {0, 20}, 32, 32};
+    auto l2_shape = PartialShape{1, {1, 10}, 16, 16};
 
-        auto ref_out_shape = PartialShape{s.input_shape[0], s.channels, 14, 14};
+    set_shape_labels(in_shape, 10);
+    set_shape_labels(l0_shape, 20);
+    set_shape_labels(l1_shape, 30);
+    set_shape_labels(l2_shape, 40);
 
-        auto input = std::make_shared<op::Parameter>(element::f32, s.input_shape);
-        auto pyramid_layer0 = std::make_shared<op::Parameter>(element::f32, layer0_shape);
-        auto pyramid_layer1 = std::make_shared<op::Parameter>(element::f32, layer1_shape);
-        auto pyramid_layer2 = std::make_shared<op::Parameter>(element::f32, layer2_shape);
-        auto pyramid_layer3 = std::make_shared<op::Parameter>(element::f32, layer3_shape);
+    const auto rois = std::make_shared<Parameter>(element::f64, in_shape);
+    const auto pyramid_layer0 = std::make_shared<Parameter>(element::f64, l0_shape);
+    const auto pyramid_layer1 = std::make_shared<Parameter>(element::f64, l1_shape);
+    const auto pyramid_layer2 = std::make_shared<Parameter>(element::f64, l2_shape);
 
-        auto roi = std::make_shared<ExperimentalROI>(
-            NodeVector{input, pyramid_layer0, pyramid_layer1, pyramid_layer2, pyramid_layer3},
-            attrs);
+    const auto op = make_op(OutputVector{rois, pyramid_layer0, pyramid_layer1, pyramid_layer2}, make_attrs(7));
 
-        ASSERT_EQ(roi->get_output_element_type(0), element::f32);
-        ASSERT_TRUE(roi->get_output_partial_shape(0).same_scheme(ref_out_shape));
+    EXPECT_THAT(op->outputs(), Each(Property("Element type", &Output<Node>::get_element_type, element::f64)));
+    EXPECT_THAT(
+        op->outputs(),
+        ElementsAre(Property("ROIs feat shape",
+                             &Output<Node>::get_partial_shape,
+                             AllOf(PartialShape({{100, 200}, {2, 10}, 7, 7}),
+                                   ResultOf(get_shape_labels, ElementsAre(10, 41, no_label, no_label)))),
+                    Property("ROIs order shape",
+                             &Output<Node>::get_partial_shape,
+                             AllOf(PartialShape({{100, 200}, 4}), ResultOf(get_shape_labels, ElementsAre(10, 11))))));
+}
+
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, dims_and_labels_propagation_not_all_inputs_labeled) {
+    auto in_shape = PartialShape{{100, 200}, 4};
+    auto l0_shape = PartialShape{1, 5, 10, 10};
+    auto l1_shape = PartialShape{1, {0, 20}, 32, 32};
+    auto l2_shape = PartialShape{1, {1, 10}, 16, 16};
+
+    set_shape_labels(in_shape, 10);
+    set_shape_labels(l0_shape, 20);
+    set_shape_labels(l1_shape, 30);
+
+    const auto rois = std::make_shared<Parameter>(element::bf16, in_shape);
+    const auto pyramid_layer0 = std::make_shared<Parameter>(element::bf16, l0_shape);
+    const auto pyramid_layer1 = std::make_shared<Parameter>(element::bf16, l1_shape);
+    const auto pyramid_layer2 = std::make_shared<Parameter>(element::bf16, l2_shape);
+
+    const auto op = make_op(NodeVector{rois, pyramid_layer0, pyramid_layer1, pyramid_layer2}, make_attrs(7));
+
+    EXPECT_THAT(op->outputs(), Each(Property("Element type", &Output<Node>::get_element_type, element::bf16)));
+    EXPECT_THAT(
+        op->outputs(),
+        ElementsAre(Property("ROIs feat shape",
+                             &Output<Node>::get_partial_shape,
+                             AllOf(PartialShape({{100, 200}, 5, 7, 7}),
+                                   ResultOf(get_shape_labels, ElementsAre(10, 31, no_label, no_label)))),
+                    Property("ROIs order shape",
+                             &Output<Node>::get_partial_shape,
+                             AllOf(PartialShape({{100, 200}, 4}), ResultOf(get_shape_labels, ElementsAre(10, 11))))));
+}
+
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, all_inputs_dynamic_rank) {
+    const auto rois = std::make_shared<Parameter>(element::f16, PartialShape::dynamic());
+    const auto pyramid_layer0 = std::make_shared<Parameter>(element::f16, PartialShape::dynamic());
+    const auto pyramid_layer1 = std::make_shared<Parameter>(element::f16, PartialShape::dynamic());
+
+    const auto op = make_op(OutputVector{rois, pyramid_layer0, pyramid_layer1}, make_attrs(7));
+
+    EXPECT_THAT(op->outputs(), Each(Property("Element type", &Output<Node>::get_element_type, element::f16)));
+    EXPECT_THAT(op->outputs(),
+                ElementsAre(Property("ROIs feat shape",
+                                     &Output<Node>::get_partial_shape,
+                                     AllOf(PartialShape({-1, -1, 7, 7}), ResultOf(get_shape_labels, Each(no_label)))),
+                            Property("ROIs order shape",
+                                     &Output<Node>::get_partial_shape,
+                                     AllOf(PartialShape({-1, 4}), ResultOf(get_shape_labels, Each(no_label))))));
+}
+
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, all_inputs_static_rank_but_dynamic_dims) {
+    const auto rois = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(2));
+    const auto pyramid_layer0 = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(4));
+    const auto pyramid_layer1 = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(4));
+    const auto pyramid_layer2 = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(4));
+    const auto pyramid_layer3 = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(4));
+    const auto pyramid_layer4 = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(4));
+
+    const auto op =
+        make_op(OutputVector{rois, pyramid_layer0, pyramid_layer1, pyramid_layer2, pyramid_layer3, pyramid_layer4},
+                make_attrs(7));
+
+    EXPECT_THAT(op->outputs(), Each(Property("Element type", &Output<Node>::get_element_type, element::f16)));
+    EXPECT_THAT(op->outputs(),
+                ElementsAre(Property("ROIs feat shape",
+                                     &Output<Node>::get_partial_shape,
+                                     AllOf(PartialShape({-1, -1, 7, 7}), ResultOf(get_shape_labels, Each(no_label)))),
+                            Property("ROIs order shape",
+                                     &Output<Node>::get_partial_shape,
+                                     AllOf(PartialShape({-1, 4}), ResultOf(get_shape_labels, Each(no_label))))));
+}
+
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, input_not_floating_point) {
+    const auto bad_param = std::make_shared<Parameter>(element::i32, PartialShape::dynamic());
+    const auto ok_param = std::make_shared<Parameter>(element::f16, PartialShape::dynamic());
+
+    OV_EXPECT_THROW(std::ignore = make_op(OutputVector{bad_param, ok_param, ok_param}, make_attrs(7)),
+                    NodeValidationFailure,
+                    HasSubstr("Input[0] type 'i32' is not floating point or not same as others inputs"));
+
+    OV_EXPECT_THROW(std::ignore = make_op(OutputVector{ok_param, bad_param, ok_param, ok_param}, make_attrs(7)),
+                    NodeValidationFailure,
+                    HasSubstr("Input[1] type 'i32' is not floating point or not same as others inputs"));
+
+    OV_EXPECT_THROW(std::ignore = make_op(OutputVector{ok_param, ok_param, bad_param}, make_attrs(7)),
+                    NodeValidationFailure,
+                    HasSubstr("Input[2] type 'i32' is not floating point or not same as others inputs"));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(OutputVector{ok_param, ok_param, ok_param, ok_param, bad_param}, make_attrs(7)),
+        NodeValidationFailure,
+        HasSubstr("Input[4] type 'i32' is not floating point or not same as others inputs"));
+}
+
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, input_mixed_floating_point_type) {
+    const auto f32_param = std::make_shared<Parameter>(element::f32, PartialShape::dynamic());
+    const auto f16_param = std::make_shared<Parameter>(element::f16, PartialShape::dynamic());
+
+    OV_EXPECT_THROW(std::ignore = make_op(OutputVector{f32_param, f16_param, f16_param, f16_param}, make_attrs(100)),
+                    NodeValidationFailure,
+                    HasSubstr("Input[1] type 'f16' is not floating point or not same as others inputs"));
+
+    OV_EXPECT_THROW(std::ignore = make_op(OutputVector{f16_param, f32_param, f16_param, f16_param}, make_attrs(100)),
+                    NodeValidationFailure,
+                    HasSubstr("Input[1] type 'f32' is not floating point or not same as others inputs"));
+
+    OV_EXPECT_THROW(std::ignore = make_op(OutputVector{f16_param, f16_param, f32_param}, make_attrs(100)),
+                    NodeValidationFailure,
+                    HasSubstr("Input[2] type 'f32' is not floating point or not same as others inputs"));
+
+    OV_EXPECT_THROW(std::ignore = make_op(OutputVector{f16_param, f16_param, f16_param, f32_param}, make_attrs(100)),
+                    NodeValidationFailure,
+                    HasSubstr("Input[3] type 'f32' is not floating point or not same as others inputs"));
+}
+
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, rois_not_2d) {
+    const auto layer = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(4));
+
+    OV_EXPECT_THROW(
+        std::ignore =
+            make_op(OutputVector{std::make_shared<Parameter>(element::f16, PartialShape{20}), layer}, make_attrs(7)),
+        NodeValidationFailure,
+        HasSubstr("Input rois rank must be equal to 2"));
+
+    OV_EXPECT_THROW(std::ignore = make_op(
+                        OutputVector{std::make_shared<Parameter>(element::f16, PartialShape{20, 4, 1}), layer, layer},
+                        make_attrs(10)),
+                    NodeValidationFailure,
+                    HasSubstr("Input rois rank must be equal to 2"));
+}
+
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, rois_2nd_dim_not_compatible) {
+    const auto layer = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(4));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(OutputVector{std::make_shared<Parameter>(element::f16, PartialShape{20, {0, 3}}), layer},
+                              make_attrs(7)),
+        NodeValidationFailure,
+        HasSubstr("The last dimension of the 'input_rois' input must be equal to 4"));
+
+    OV_EXPECT_THROW(
+        std::ignore =
+            make_op(OutputVector{std::make_shared<Parameter>(element::f16, PartialShape{20, {5, -1}}), layer, layer},
+                    make_attrs(10)),
+        NodeValidationFailure,
+        HasSubstr("The last dimension of the 'input_rois' input must be equal to 4"));
+}
+
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, layers_not_4d) {
+    const auto rois = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(2));
+    const auto layer = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(4));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(OutputVector{rois, std::make_shared<Parameter>(element::f16, PartialShape::dynamic(3))},
+                              make_attrs(10)),
+        NodeValidationFailure,
+        HasSubstr("Rank of each element of the pyramid must be equal to 4"));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(OutputVector{rois, std::make_shared<Parameter>(element::f16, PartialShape::dynamic(5))},
+                              make_attrs(10)),
+        NodeValidationFailure,
+        HasSubstr("Rank of each element of the pyramid must be equal to 4"));
+
+    OV_EXPECT_THROW(std::ignore = make_op(
+                        OutputVector{rois, layer, std::make_shared<Parameter>(element::f16, PartialShape::dynamic(3))},
+                        make_attrs(10)),
+                    NodeValidationFailure,
+                    HasSubstr("Rank of each element of the pyramid must be equal to 4"));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(
+            OutputVector{rois, layer, std::make_shared<Parameter>(element::f16, PartialShape::dynamic(3)), layer},
+            make_attrs(10)),
+        NodeValidationFailure,
+        HasSubstr("Rank of each element of the pyramid must be equal to 4"));
+}
+
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, layers_1st_dim_not_compatible_1) {
+    const auto rois = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(2));
+    const auto layer = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(4));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(OutputVector{rois, std::make_shared<Parameter>(element::f16, PartialShape{2, 5, 16, 16})},
+                              make_attrs(10)),
+        NodeValidationFailure,
+        HasSubstr("The first dimension of each pyramid element must be equal to 1"));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(
+            OutputVector{rois, layer, std::make_shared<Parameter>(element::f16, PartialShape{{2, -1}, -1, -1, -1})},
+            make_attrs(10)),
+        NodeValidationFailure,
+        HasSubstr("The first dimension of each pyramid element must be equal to 1"));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(OutputVector{rois,
+                                           layer,
+                                           layer,
+                                           std::make_shared<Parameter>(element::f16, PartialShape{5, -1, -1, -1}),
+                                           layer},
+                              make_attrs(10)),
+        NodeValidationFailure,
+        HasSubstr("The first dimension of each pyramid element must be equal to 1"));
+}
+
+TEST_F(TypePropExperimentalDetectronROIFeatureExtractorV6Test, num_channels_not_same_on_all_layers) {
+    const auto rois = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(2));
+    const auto layer = std::make_shared<Parameter>(element::f16, PartialShape::dynamic(4));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(OutputVector{rois,
+                                           std::make_shared<Parameter>(element::f16, PartialShape{1, {0, 3}, -1, -1}),
+                                           std::make_shared<Parameter>(element::f16, PartialShape{1, {14, 5}, -1, -1})},
+                              make_attrs(10)),
+        NodeValidationFailure,
+        HasSubstr("The number of channels must be the same for all layers of the pyramid"));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(OutputVector{rois,
+                                           std::make_shared<Parameter>(element::f16, PartialShape{1, {2, 3}, -1, -1}),
+                                           layer,
+                                           std::make_shared<Parameter>(element::f16, PartialShape{1, {4, 5}, -1, -1}),
+                                           layer},
+                              make_attrs(10)),
+        NodeValidationFailure,
+        HasSubstr("The number of channels must be the same for all layers of the pyramid"));
+
+    OV_EXPECT_THROW(
+        std::ignore = make_op(OutputVector{rois,
+                                           std::make_shared<Parameter>(element::f16, PartialShape{1, {2, 3}, -1, -1}),
+                                           std::make_shared<Parameter>(element::f16, PartialShape{1, {4, 5}, -1, -1}),
+                                           layer},
+                              make_attrs(10)),
+        NodeValidationFailure,
+        HasSubstr("The number of channels must be the same for all layers of the pyramid"));
+}
+
+using ROIFeatureIntervalsTestParams = std::tuple<PartialShape, std::array<Dimension, 4>, std::array<Dimension, 4>>;
+
+class ROIFeatureIntervalsTest : public TypePropExperimentalDetectronROIFeatureExtractorV6Test,
+                                public WithParamInterface<ROIFeatureIntervalsTestParams> {
+protected:
+    void SetUp() override {
+        std::tie(input_shape, channels, first_dims) = GetParam();
+
+        exp_rois_feat_shape = PartialShape{input_shape[0],
+                                           channels[0] & channels[1] & channels[2] & channels[3],
+                                           exp_out_size,
+                                           exp_out_size};
     }
-}
 
-struct ROIFeatureIntervalsTestParams {
-    PartialShape input_shape;
-    Dimension channels[4];
-    Dimension first_dims[4];
+    PartialShape input_shape, exp_rois_feat_shape;
+    std::array<Dimension, 4> channels, first_dims;
+    int64_t exp_out_size = 14;
 };
 
-struct ROIFeatureIntervalsTest : ::testing::TestWithParam<ROIFeatureIntervalsTestParams> {};
-
-TEST_P(ROIFeatureIntervalsTest, detectron_roi_feature_extractor_intervals_1) {
-    auto params = GetParam();
-
-    Attrs attrs;
-    attrs.aligned = false;
-    attrs.output_size = 14;
-    attrs.sampling_ratio = 2;
-    attrs.pyramid_scales = {4, 8, 16, 32};
-
-    auto layer0_channels = params.channels[0];
-    auto layer1_channels = params.channels[1];
-    auto layer2_channels = params.channels[2];
-    auto layer3_channels = params.channels[3];
-
-    auto layer0_shape = PartialShape{params.first_dims[0], layer0_channels, 200, 336};
-    auto layer1_shape = PartialShape{params.first_dims[1], layer1_channels, 100, 168};
-    auto layer2_shape = PartialShape{params.first_dims[2], layer2_channels, 50, 84};
-    auto layer3_shape = PartialShape{params.first_dims[3], layer3_channels, 25, 42};
-
-    auto expected_channels = layer0_channels & layer1_channels & layer2_channels & layer3_channels;
-
-    auto ref_out_shape = PartialShape{params.input_shape[0], expected_channels, 14, 14};
-
-    auto input = std::make_shared<op::Parameter>(element::f32, params.input_shape);
-    auto pyramid_layer0 = std::make_shared<op::Parameter>(element::f32, layer0_shape);
-    auto pyramid_layer1 = std::make_shared<op::Parameter>(element::f32, layer1_shape);
-    auto pyramid_layer2 = std::make_shared<op::Parameter>(element::f32, layer2_shape);
-    auto pyramid_layer3 = std::make_shared<op::Parameter>(element::f32, layer3_shape);
-
-    auto roi = std::make_shared<ExperimentalROI>(
-        NodeVector{input, pyramid_layer0, pyramid_layer1, pyramid_layer2, pyramid_layer3},
-        attrs);
-
-    ASSERT_EQ(roi->get_output_element_type(0), element::f32);
-    ASSERT_TRUE(roi->get_output_partial_shape(0).same_scheme(ref_out_shape));
-}
-
 INSTANTIATE_TEST_SUITE_P(
     type_prop,
     ROIFeatureIntervalsTest,
-    ::testing::Values(
-        ROIFeatureIntervalsTestParams{{1000, Dimension(0, 5)},
-                                      {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(0, 33)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(0, 5)},
-                                      {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(33)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(2, 5)},
-                                      {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(0, 72)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(2, 5)},
-                                      {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(64)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(0, 5)},
-                                      {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(0, 330)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(0, 5)},
-                                      {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(256)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(2, 4)},
-                                      {Dimension(0, 512), Dimension(256), Dimension(256), Dimension(0, 720)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(2, 4)},
-                                      {Dimension(0, 380), Dimension(256), Dimension(256), Dimension(256)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(3, 4)},
-                                      {Dimension(0, 380), Dimension(256), Dimension(256), Dimension(256)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(3, 4)},
-                                      {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(0, 330)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(0, 6)},
-                                      {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(128)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(0, 6)},
-                                      {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(0, 720)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(3, 7)},
-                                      {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(128)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(4, 6)},
-                                      {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(0, 330)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(4, 6)},
-                                      {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(256)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(2, 8)},
-                                      {Dimension(256), Dimension(256), Dimension(256), Dimension(0, 330)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{1000, Dimension(2, 8)},
-                                      {Dimension(256), Dimension(256), Dimension(256), Dimension(256)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(0, 4)},
-                                      {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(0, 33)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(0, 4)},
-                                      {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(33)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(1, 4)},
-                                      {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(0, 72)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(1, 4)},
-                                      {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(64)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(2, 4)},
-                                      {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(0, 330)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(2, 4)},
-                                      {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(256)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(3, 5)},
-                                      {Dimension(0, 512), Dimension(256), Dimension(256), Dimension(0, 720)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(3, 5)},
-                                      {Dimension(0, 380), Dimension(256), Dimension(256), Dimension(256)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(4, 6)},
-                                      {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(0, 330)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(4, 6)},
-                                      {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(128)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(3, 8)},
-                                      {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(0, 720)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(3, 8)},
-                                      {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(128)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(4, 11)},
-                                      {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(0, 330)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(4, 11)},
-                                      {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(256)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(2, 16)},
-                                      {Dimension(256), Dimension(256), Dimension(256), Dimension(0, 330)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
-        ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(2, 16)},
-                                      {Dimension(256), Dimension(256), Dimension(256), Dimension(256)},
-                                      {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}}),
-    PrintToDummyParamName());
+    Values(ROIFeatureIntervalsTestParams{{1000, Dimension(0, 5)},
+                                         {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(0, 33)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(0, 5)},
+                                         {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(33)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(2, 5)},
+                                         {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(0, 72)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(2, 5)},
+                                         {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(64)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(0, 5)},
+                                         {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(0, 330)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(0, 5)},
+                                         {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(256)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(2, 4)},
+                                         {Dimension(0, 512), Dimension(256), Dimension(256), Dimension(0, 720)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(2, 4)},
+                                         {Dimension(0, 380), Dimension(256), Dimension(256), Dimension(256)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(3, 4)},
+                                         {Dimension(0, 380), Dimension(256), Dimension(256), Dimension(256)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(3, 4)},
+                                         {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(0, 330)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(0, 6)},
+                                         {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(128)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(0, 6)},
+                                         {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(0, 720)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(3, 7)},
+                                         {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(128)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(4, 6)},
+                                         {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(0, 330)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(4, 6)},
+                                         {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(256)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(2, 8)},
+                                         {Dimension(256), Dimension(256), Dimension(256), Dimension(0, 330)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{1000, Dimension(2, 8)},
+                                         {Dimension(256), Dimension(256), Dimension(256), Dimension(256)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(0, 4)},
+                                         {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(0, 33)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(0, 4)},
+                                         {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(33)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(1, 4)},
+                                         {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(0, 72)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(1, 4)},
+                                         {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(64)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(2, 4)},
+                                         {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(0, 330)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(2, 4)},
+                                         {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(256)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(3, 5)},
+                                         {Dimension(0, 512), Dimension(256), Dimension(256), Dimension(0, 720)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(3, 5)},
+                                         {Dimension(0, 380), Dimension(256), Dimension(256), Dimension(256)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(4, 6)},
+                                         {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(0, 330)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(4, 6)},
+                                         {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(128)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(3, 8)},
+                                         {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(0, 720)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(3, 8)},
+                                         {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(128)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(4, 11)},
+                                         {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(0, 330)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(4, 11)},
+                                         {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(256)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(2, 16)},
+                                         {Dimension(256), Dimension(256), Dimension(256), Dimension(0, 330)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}},
+           ROIFeatureIntervalsTestParams{{Dimension::dynamic(), Dimension(2, 16)},
+                                         {Dimension(256), Dimension(256), Dimension(256), Dimension(256)},
+                                         {Dimension(0, 2), Dimension(1, 3), Dimension(0, 5), Dimension(1, 2)}}),
+    PrintToStringParamName());
 
-struct ROIFeatureIntervalsSameFirstDimsTestParams {
-    PartialShape input_shape;
-    Dimension channels[4];
-};
+TEST_P(ROIFeatureIntervalsTest, interval_shape_inference) {
+    auto layer0_shape = PartialShape{first_dims[0], channels[0], 200, 336};
+    auto layer1_shape = PartialShape{first_dims[1], channels[1], 100, 168};
+    auto layer2_shape = PartialShape{first_dims[2], channels[2], 50, 84};
+    auto layer3_shape = PartialShape{first_dims[3], channels[3], 25, 42};
 
-struct ROIFeatureIntervalsSameFirstDimsTest : ::testing::TestWithParam<ROIFeatureIntervalsSameFirstDimsTestParams> {};
+    auto rois = std::make_shared<Parameter>(element::f32, input_shape);
+    auto pyramid_layer0 = std::make_shared<Parameter>(element::f32, layer0_shape);
+    auto pyramid_layer1 = std::make_shared<Parameter>(element::f32, layer1_shape);
+    auto pyramid_layer2 = std::make_shared<Parameter>(element::f32, layer2_shape);
+    auto pyramid_layer3 = std::make_shared<Parameter>(element::f32, layer3_shape);
 
-TEST_P(ROIFeatureIntervalsSameFirstDimsTest, detectron_roi_feature_extractor_intervals_1) {
-    auto params = GetParam();
+    auto op = make_op(NodeVector{rois, pyramid_layer0, pyramid_layer1, pyramid_layer2, pyramid_layer3},
+                      make_attrs(exp_out_size));
 
-    Attrs attrs;
-    attrs.aligned = false;
-    attrs.output_size = 14;
-    attrs.sampling_ratio = 2;
-    attrs.pyramid_scales = {4, 8, 16, 32};
-
-    auto layer0_channels = params.channels[0];
-    auto layer1_channels = params.channels[1];
-    auto layer2_channels = params.channels[2];
-    auto layer3_channels = params.channels[3];
-
-    auto layer0_shape = PartialShape{1, layer0_channels, 200, 336};
-    auto layer1_shape = PartialShape{1, layer1_channels, 100, 168};
-    auto layer2_shape = PartialShape{1, layer2_channels, 50, 84};
-    auto layer3_shape = PartialShape{1, layer3_channels, 25, 42};
-
-    auto expected_channels = layer0_channels & layer1_channels & layer2_channels & layer3_channels;
-
-    auto ref_out_shape = PartialShape{params.input_shape[0], expected_channels, 14, 14};
-
-    auto input = std::make_shared<op::Parameter>(element::f32, params.input_shape);
-    auto pyramid_layer0 = std::make_shared<op::Parameter>(element::f32, layer0_shape);
-    auto pyramid_layer1 = std::make_shared<op::Parameter>(element::f32, layer1_shape);
-    auto pyramid_layer2 = std::make_shared<op::Parameter>(element::f32, layer2_shape);
-    auto pyramid_layer3 = std::make_shared<op::Parameter>(element::f32, layer3_shape);
-
-    auto roi = std::make_shared<ExperimentalROI>(
-        NodeVector{input, pyramid_layer0, pyramid_layer1, pyramid_layer2, pyramid_layer3},
-        attrs);
-
-    ASSERT_EQ(roi->get_output_element_type(0), element::f32);
-    ASSERT_TRUE(roi->get_output_partial_shape(0).same_scheme(ref_out_shape));
+    EXPECT_EQ(op->get_output_element_type(0), element::f32);
+    EXPECT_EQ(op->get_output_partial_shape(0), exp_rois_feat_shape);
 }
 
-INSTANTIATE_TEST_SUITE_P(
-    type_prop,
-    ROIFeatureIntervalsSameFirstDimsTest,
-    ::testing::Values(
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(0, 33)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(33)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(0, 72)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(64)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(0, 330)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(256)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(0, 512), Dimension(256), Dimension(256), Dimension(0, 720)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{{Dimension(1000), Dimension(4)},
-                                                   {Dimension(0, 380), Dimension(256), Dimension(256), Dimension(256)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(0, 330)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(128)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(0, 720)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{{Dimension(1000), Dimension(4)},
-                                                   {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(128)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension(1000), Dimension(4)},
-            {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(0, 330)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{{Dimension(1000), Dimension(4)},
-                                                   {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(256)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{{Dimension(1000), Dimension(4)},
-                                                   {Dimension(256), Dimension(256), Dimension(256), Dimension(0, 330)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{{Dimension(1000), Dimension(4)},
-                                                   {Dimension(256), Dimension(256), Dimension(256), Dimension(256)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(0, 33)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(0, 128), Dimension(0, 256), Dimension(0, 64), Dimension(33)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(0, 72)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(0, 128), Dimension(0, 256), Dimension(64), Dimension(64)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(0, 330)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(0, 512), Dimension(256), Dimension(0, 640), Dimension(256)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(0, 512), Dimension(256), Dimension(256), Dimension(0, 720)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{{Dimension::dynamic(), Dimension(4)},
-                                                   {Dimension(0, 380), Dimension(256), Dimension(256), Dimension(256)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(0, 330)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(128), Dimension(0, 256), Dimension(0, 640), Dimension(128)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(0, 720)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{{Dimension::dynamic(), Dimension(4)},
-                                                   {Dimension(128), Dimension(0, 256), Dimension(128), Dimension(128)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{
-            {Dimension::dynamic(), Dimension(4)},
-            {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(0, 330)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{{Dimension::dynamic(), Dimension(4)},
-                                                   {Dimension(256), Dimension(256), Dimension(0, 640), Dimension(256)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{{Dimension::dynamic(), Dimension(4)},
-                                                   {Dimension(256), Dimension(256), Dimension(256), Dimension(0, 330)}},
-        ROIFeatureIntervalsSameFirstDimsTestParams{{Dimension::dynamic(), Dimension(4)},
-                                                   {Dimension(256), Dimension(256), Dimension(256), Dimension(256)}}),
-    PrintToDummyParamName());
+TEST_P(ROIFeatureIntervalsTest, interval_shape_inference_layers_1st_dim_static) {
+    auto layer0_shape = PartialShape{1, channels[0], 200, 336};
+    auto layer1_shape = PartialShape{1, channels[1], 100, 168};
+    auto layer2_shape = PartialShape{1, channels[2], 50, 84};
+    auto layer3_shape = PartialShape{1, channels[3], 25, 42};
+
+    auto rois = std::make_shared<Parameter>(element::f32, input_shape);
+    auto pyramid_layer0 = std::make_shared<Parameter>(element::f32, layer0_shape);
+    auto pyramid_layer1 = std::make_shared<Parameter>(element::f32, layer1_shape);
+    auto pyramid_layer2 = std::make_shared<Parameter>(element::f32, layer2_shape);
+    auto pyramid_layer3 = std::make_shared<Parameter>(element::f32, layer3_shape);
+
+    auto op = make_op(NodeVector{rois, pyramid_layer0, pyramid_layer1, pyramid_layer2, pyramid_layer3},
+                      make_attrs(exp_out_size));
+
+    EXPECT_EQ(op->get_output_element_type(0), element::f32);
+    EXPECT_EQ(op->get_output_partial_shape(0), exp_rois_feat_shape);
+}

src/plugins/intel_cpu/src/utils/shape_inference/shape_inference.cpp

@@ -486,7 +486,6 @@ const IShapeInferCommonFactory::TRegistry IShapeInferCommonFactory::registry{
     _OV_OP_SHAPE_INFER_REG(ExperimentalDetectronDetectionOutput, entryIO),
     _OV_OP_SHAPE_INFER_REG(ExperimentalDetectronGenerateProposalsSingleImage, entryIO),
     _OV_OP_SHAPE_INFER_REG(ExperimentalDetectronPriorGridGenerator, entryIO),
-    _OV_OP_SHAPE_INFER_REG(ExperimentalDetectronROIFeatureExtractor, entryIO),
     _OV_OP_SHAPE_INFER_REG(ExperimentalDetectronTopKROIs, entryIO),
     _OV_OP_SHAPE_INFER_REG(ExtractImagePatches, entryIO),
     _OV_OP_SHAPE_INFER_REG(Eye, entryIOC),
@@ -585,6 +584,7 @@ template <>
 const IStaticShapeInferFactory::TRegistry IStaticShapeInferFactory::registry{
     // Default opset
     _OV_OP_SHAPE_INFER_MASK_REG(Tile, ShapeInferBase, util::bit::mask(1)),
+    _OV_OP_SHAPE_INFER_MASK_REG(ExperimentalDetectronROIFeatureExtractor, ShapeInferBase, util::bit::mask()),
     // Operators shape inferences for specific opset version should be specified below
     // opset1
     _OV_OP_SHAPE_INFER_MASK_REG(opset1::Reverse, ShapeInferBase, util::bit::mask(1)),

src/plugins/intel_cpu/tests/unit/shape_inference_test/experimental_detectron_roi_feature_extractor.cpp

@@ -1,39 +0,0 @@
-// Copyright (C) 2018-2023 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-//
-
-#include <gtest/gtest.h>
-
-#include "utils.hpp"
-
-using namespace ov;
-using namespace ov::intel_cpu;
-
-TEST(StaticShapeInferenceTest, ExperimentalDetectronROIFeatureExtractor) {
-    op::v6::ExperimentalDetectronROIFeatureExtractor::Attributes attrs;
-    attrs.aligned = false;
-    attrs.output_size = 14;
-    attrs.sampling_ratio = 2;
-    attrs.pyramid_scales = {4, 8, 16, 32};
-
-    auto input = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{-1, -1});
-    auto pyramid_layer0 = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, -1, -1, -1});
-    auto pyramid_layer1 = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, -1, -1, -1});
-    auto pyramid_layer2 = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, -1, -1, -1});
-    auto pyramid_layer3 = std::make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, -1, -1, -1});
-
-    auto roi = std::make_shared<op::v6::ExperimentalDetectronROIFeatureExtractor>(
-        NodeVector{input, pyramid_layer0, pyramid_layer1, pyramid_layer2, pyramid_layer3},
-        attrs);
-
-    std::vector<StaticShape> input_shapes = {StaticShape{1000, 4},
-                                             StaticShape{1, 256, 200, 336},
-                                             StaticShape{1, 256, 100, 168},
-                                             StaticShape{1, 256, 50, 84},
-                                             StaticShape{1, 256, 25, 42}};
-    std::vector<StaticShape> output_shapes = {StaticShape{}, StaticShape{}};
-    shape_inference(roi.get(), input_shapes, output_shapes);
-
-    EXPECT_EQ(output_shapes[0], (StaticShape{1000, 256, 14, 14}));
-    EXPECT_EQ(output_shapes[1], (StaticShape{1000, 4}));
-}

src/plugins/intel_cpu/tests/unit/shape_inference_test/experimental_detectron_roi_feature_extractor_shape_inference_test.cpp

@@ -0,0 +1,86 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <gtest/gtest.h>
+
+#include "common_test_utils/test_assertions.hpp"
+#include "utils.hpp"
+
+using namespace ov;
+using namespace ov::intel_cpu;
+using namespace testing;
+
+class ExperimentalDetectronROIFeatureExtractorV6StaticShapeInferenceTest
+    : public OpStaticShapeInferenceTest<op::v6::ExperimentalDetectronROIFeatureExtractor> {
+protected:
+    void SetUp() override {
+        output_shapes.resize(2);
+    }
+
+    static op_type::Attributes make_attrs(int64_t out_size) {
+        return {out_size, 2, {4, 8, 16, 32}, false};
+    }
+};
+
+TEST_F(ExperimentalDetectronROIFeatureExtractorV6StaticShapeInferenceTest, default_ctor) {
+    op = make_op();
+    op->set_attrs(make_attrs(16));
+
+    input_shapes = ShapeVector{{1000, 4}, {1, 5, 8, 8}, {1, 5, 16, 16}, {1, 5, 64, 64}};
+    shape_inference(op.get(), input_shapes, output_shapes);
+
+    EXPECT_THAT(output_shapes, ElementsAre(StaticShape{1000, 5, 16, 16}, StaticShape{1000, 4}));
+}
+
+TEST_F(ExperimentalDetectronROIFeatureExtractorV6StaticShapeInferenceTest, inputs_dynamic_rank) {
+    const auto rois = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic());
+    const auto layer_0 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic());
+    const auto layer_1 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic());
+    op = make_op(OutputVector{rois, layer_0, layer_1}, make_attrs(100));
+
+    input_shapes = ShapeVector{{25, 4}, {1, 2, 100, 100}, {1, 2, 20, 300}};
+    shape_inference(op.get(), input_shapes, output_shapes);
+
+    EXPECT_THAT(output_shapes, ElementsAre(StaticShape{25, 2, 100, 100}, StaticShape{25, 4}));
+}
+
+TEST_F(ExperimentalDetectronROIFeatureExtractorV6StaticShapeInferenceTest, inputs_static_rank) {
+    const auto rois = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic(2));
+    const auto layer_0 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic(4));
+    const auto layer_1 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic(4));
+    const auto layer_2 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic(4));
+    const auto layer_3 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic(4));
+    op = make_op(OutputVector{rois, layer_0, layer_1, layer_2, layer_3}, make_attrs(15));
+
+    input_shapes = ShapeVector{{25, 4}, {1, 2, 100, 100}, {1, 2, 20, 300}, {1, 2, 30, 30}, {1, 2, 200, 50}};
+    shape_inference(op.get(), input_shapes, output_shapes);
+
+    EXPECT_THAT(output_shapes, ElementsAre(StaticShape{25, 2, 15, 15}, StaticShape{25, 4}));
+}
+
+TEST_F(ExperimentalDetectronROIFeatureExtractorV6StaticShapeInferenceTest, rois_wrong_rank) {
+    const auto rois = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic());
+    const auto layer_0 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic(4));
+    const auto layer_1 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic(4));
+    const auto layer_2 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic(4));
+    op = make_op(OutputVector{rois, layer_0, layer_1, layer_2}, make_attrs(15));
+
+    input_shapes = ShapeVector{{25, 4, 1}, {1, 2, 20, 300}, {1, 2, 30, 30}, {1, 2, 200, 50}};
+    OV_EXPECT_THROW(shape_inference(op.get(), input_shapes, output_shapes),
+                    NodeValidationFailure,
+                    HasSubstr("Input rois rank must be equal to 2"));
+}
+
+TEST_F(ExperimentalDetectronROIFeatureExtractorV6StaticShapeInferenceTest, layers_num_channels_not_same) {
+    const auto rois = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic(2));
+    const auto layer_0 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic(4));
+    const auto layer_1 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic());
+    const auto layer_2 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape::dynamic());
+    op = make_op(OutputVector{rois, layer_0, layer_1, layer_2}, make_attrs(15));
+
+    input_shapes = ShapeVector{{25, 4}, {1, 2, 20, 300}, {1, 2, 30, 30}, {1, 3, 200, 50}};
+    OV_EXPECT_THROW(shape_inference(op.get(), input_shapes, output_shapes),
+                    NodeValidationFailure,
+                    HasSubstr("The number of channels must be the same for all layers of the pyramid"));
+}