Revert GPT-OSS ROPE fusion (#33183)

peterchen-intel · web-flow · commit 82bbf0292c5b · 2025-12-10T20:32:06.000+01:00
### Details: - *This reverts commit 4312e0a.* - *...* ### Tickets: - *CVS-177675*
diff --git a/src/common/transformations/include/ov_ops/rotary_positional_embeddings.hpp b/src/common/transformations/include/ov_ops/rotary_positional_embeddings.hpp
@@ -33,7 +33,6 @@ class TRANSFORMATIONS_API RoPE : public Op {
         bool is_qwen = false;           // Qwen is special which overrides other setting
         bool use_rope_cache = false;    // use precomputed RoPE cache for trigonometric values (cosine and sine)
         bool support_3d_rope = false;   // use same logic as RoPEFusionGPTNEOX(4), used by gpu plugin
-        size_t cos_sin_ndims = 0;       // last dimension of con/sin table
         size_t head_cnt = 0;
         size_t head_size = 0;
         int gather_position_arg_id =
diff --git a/src/common/transformations/include/transformations/common_optimizations/fuse_rotary_positional_embeddings.hpp b/src/common/transformations/include/transformations/common_optimizations/fuse_rotary_positional_embeddings.hpp
@@ -21,7 +21,6 @@ class TRANSFORMATIONS_API RoPEFusionIOSlicing;
 class TRANSFORMATIONS_API RoPEFusionPreprocess;
 class TRANSFORMATIONS_API RoPEFusionCosSinPreprocess;
 class TRANSFORMATIONS_API RoPEShareCosSin;
-class TRANSFORMATIONS_API RoPEFusionGPTOSS;
 
 }  // namespace pass
 }  // namespace ov
@@ -92,12 +91,6 @@ class ov::pass::RoPEShareCosSin : public ov::pass::MatcherPass {
     std::vector<std::shared_ptr<ov::Node>> m_shared_inputs{2, nullptr};
 };
 
-class ov::pass::RoPEFusionGPTOSS : public ov::pass::MatcherPass {
-public:
-    OPENVINO_MATCHER_PASS_RTTI("RoPEFusionGPTOSS");
-    RoPEFusionGPTOSS();
-};
-
 /**
  * @ingroup ov_transformation_common_api
  * @brief Fuses special sub-graph into an internal Rotary Positional Embedding operation
diff --git a/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp b/src/common/transformations/src/transformations/common_optimizations/fuse_rotary_positional_embeddings.cpp
@@ -61,7 +61,6 @@ bool ov::pass::RoPEFusion::run_on_model(const std::shared_ptr<ov::Model>& model)
     symbolic_ctx_manager->register_pass<ov::pass::RoPEFusionGPTNEOX>(4);
     symbolic_ctx_manager->register_pass<ov::pass::RoPEFusionGPTNEOX>(3);
     symbolic_ctx_manager->register_pass<ov::pass::RoPEFusionGPTJ>();
-    symbolic_ctx_manager->register_pass<ov::pass::RoPEFusionGPTOSS>();
     // optional heads & tails are fused in separate matcher pass,
     // after RoPENode has been created.
     symbolic_ctx_manager->register_pass<ov::pass::RoPEFusionCosSinPreprocess>();
@@ -1112,75 +1111,3 @@ ov::pass::RoPEShareCosSin::RoPEShareCosSin() {
     auto m = std::make_shared<pattern::Matcher>(result, matcher_name);
     this->register_matcher(m, callback);
 }
-
-ov::pass::RoPEFusionGPTOSS::RoPEFusionGPTOSS() {
-    using namespace ov::op::util;
-    MATCHER_SCOPE(RoPEFusionGPTOSS);
-
-    // gpt-oss style
-    // first_half, second_half = torch.chunk(x, 2, dim=-1)
-    // first_ = first_half * cos - second_half * sin
-    // second_ = second_half * cos + first_half * sin
-    // return torch.cat((first_, second_), dim=-1)
-    auto x = pattern::any_input(pattern::rank_equals(4));
-    auto t_cos = pattern::any_input(pattern::shape_matches("[?, 1, ?, half_ndims]"));
-    auto t_sin = pattern::any_input(pattern::shape_matches("[?, 1, ?, half_ndims]"));
-
-    auto vsplit_out0 = pattern::wrap_type<op::v1::VariadicSplit>(
-        {x, -1, {"half_ndims", "?"}},
-        pattern::output_index_matches(0) && pattern::shape_matches("[?, ?, ?, half_ndims]"));
-    auto vsplit_out1 = pattern::wrap_type<op::v1::VariadicSplit>(
-        {x, -1, {"half_ndims", "?"}},
-        pattern::output_index_matches(1) && pattern::shape_matches("[?, ?, ?, half_ndims]"));
-    auto first_half_mul_cos = pattern::wrap_type<v1::Multiply>({vsplit_out0, t_cos}, {{"auto_broadcast", "numpy"}});
-    auto second_half_mul_sin = pattern::wrap_type<v1::Multiply>({vsplit_out1, t_sin}, {{"auto_broadcast", "numpy"}});
-    auto neg = pattern::wrap_type<v1::Multiply>({second_half_mul_sin, -1.0f}, {{"auto_broadcast", "numpy"}});
-    auto sub_Subtract = pattern::wrap_type<v1::Add>({first_half_mul_cos, neg}, {{"auto_broadcast", "numpy"}});
-
-    auto second_half_mul_cos = pattern::wrap_type<v1::Multiply>({vsplit_out1, t_cos}, {{"auto_broadcast", "numpy"}});
-    auto first_half_mul_sin = pattern::wrap_type<v1::Multiply>({vsplit_out0, t_sin}, {{"auto_broadcast", "numpy"}});
-    auto add_Add =
-        pattern::wrap_type<v1::Add>({second_half_mul_cos, first_half_mul_sin}, {{"auto_broadcast", "numpy"}});
-    auto concat_result = pattern::wrap_type<opset1::Concat>({sub_Subtract, add_Add}, {{"axis", -1}});
-
-    auto result = concat_result;
-
-    matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
-        const auto& pattern_map = m.get_pattern_value_map();
-        auto root = m.get_match_root();
-        const auto& x_val = pattern_map.at(x);
-        const auto& v_cos = pattern_map.at(t_cos);
-
-        auto symbols = m.get_symbols();
-        const auto& half_ndims = symbols["half_ndims"];
-        if (!half_ndims.is_integer()) {
-            return false;
-        }
-
-        op::internal::RoPE::Config config;
-        OutputVector new_args;
-        config.rotary_ndims = 2ul * static_cast<size_t>(half_ndims.i());
-        config.cos_sin_ndims = static_cast<size_t>(half_ndims.i());
-
-        new_args.push_back(x_val);
-        new_args.push_back(v_cos);
-        new_args.push_back(pattern_map.at(t_sin));
-        auto new_node = std::make_shared<internal::RoPE>(new_args, config);
-        new_node->set_friendly_name(root->get_friendly_name());
-        ov::copy_runtime_info({pattern_map.at(neg).get_node_shared_ptr(),
-                               pattern_map.at(sub_Subtract).get_node_shared_ptr(),
-                               pattern_map.at(first_half_mul_cos).get_node_shared_ptr(),
-                               pattern_map.at(first_half_mul_sin).get_node_shared_ptr(),
-                               pattern_map.at(second_half_mul_cos).get_node_shared_ptr(),
-                               pattern_map.at(second_half_mul_sin).get_node_shared_ptr(),
-                               pattern_map.at(add_Add).get_node_shared_ptr(),
-                               pattern_map.at(result).get_node_shared_ptr()},
-                              new_node);
-        ov::replace_node(root, new_node);
-        register_new_node(new_node);
-        return true;
-    };
-
-    auto m = std::make_shared<ov::pass::pattern::Matcher>(result, matcher_name);
-    this->register_matcher(m, callback);
-}
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp
@@ -89,16 +89,10 @@ void jit_rotary_kernel<isa>::rotary_half(size_t step) {
     vfmsub231ps(vmm_dst0, vmm_cos, vmm_src0);
     store(reg_dst, vmm_dst0, m_jcp.dst_prc, step);
 
-    // cos[i + sin_cos_offset]
-    // if con/sin table is not same size with input, it is reused for both halves.
-    const bool shift_cos_sin = m_jcp.cos_sin_ndims != half_rotary_ndims;
-    if (shift_cos_sin) {
-        load(vmm_cos, reg_cos, ov::element::f32, step, false, half_rotary_ndims * sizeof(float));
-    }
-    // sin[i + sin_cos_offset]
-    if (shift_cos_sin) {
-        load(vmm_sin, reg_sin, ov::element::f32, step, false, half_rotary_ndims * sizeof(float));
-    }
+    // cos[i + halfRotaryNdims]
+    load(vmm_cos, reg_cos, ov::element::f32, step, false, half_rotary_ndims * sizeof(float));
+    // sin[i + halfRotaryNdims]
+    load(vmm_sin, reg_sin, ov::element::f32, step, false, half_rotary_ndims * sizeof(float));
     // cos[i + half_rotary_dims] * src1
     uni_vmulps(vmm_dst0, vmm_cos, vmm_src1);
     // cos[i + half_rotary_dims] * src1 + sin[i + half_rotary_dims] * src0
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.hpp
@@ -27,7 +27,6 @@ struct jit_rotary_compile_params {
     ov::element::Type src_prc;
     ov::element::Type dst_prc;
     size_t rotary_ndims = 0UL;
-    size_t cos_sin_ndims = 0UL;
     bool interleave = false;
     bool mix_cos_sin = false;
 };
diff --git a/src/plugins/intel_cpu/src/nodes/paged_attn.cpp b/src/plugins/intel_cpu/src/nodes/paged_attn.cpp
@@ -24,6 +24,7 @@
 #include "onednn/iml_type_mapper.h"
 #include "openvino/core/except.hpp"
 #include "openvino/core/node.hpp"
+#include "openvino/core/shape.hpp"
 #include "openvino/core/type/element_type.hpp"
 #include "openvino/runtime/system_conf.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
@@ -175,7 +176,7 @@ void PagedAttention::initSupportedPrimitiveDescriptors() {
     // sinks, float, [1, H, 1, 1]
     config.inConfs[PagedAttentionExecutor::ID_SINKS].setMemDesc(
         creatorsMap.at(LayoutType::ncsp)
-            ->createSharedDesc(ov::element::f32, getInputShapeAtPort(PagedAttentionExecutor::ID_SINKS)));
+            ->createSharedDesc(rtPrecision, getInputShapeAtPort(PagedAttentionExecutor::ID_SINKS)));
 
     supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::ref_any);
 }
@@ -300,6 +301,10 @@ bool PagedAttention::isSupportedOperation(const std::shared_ptr<const ov::Node>&
                 return false;
             }
         }
+        if (ov::shape_size(op->get_input_shape(PagedAttentionExecutor::ID_SINKS)) != 0) {
+            errorMessage = "PageAttn sinks input is not supported yet";
+            return false;
+        }
         auto orgInput = static_cast<int>(op->get_input_size());
         if (op->get_type_name() == std::string("PagedAttentionExtension") &&
             orgInput == PagedAttentionExecutor::ID_SLIDING_WINDOW + 1) {
diff --git a/src/plugins/intel_cpu/src/nodes/rope.cpp b/src/plugins/intel_cpu/src/nodes/rope.cpp
@@ -111,7 +111,6 @@ struct RoPE::RoPEExecutorRotateHalf : public RoPE::Executor {
         jcp.dst_prc = precision_of<T>::value;
         jcp.rotary_ndims = config.rotary_ndims;
         jcp.interleave = false;
-        jcp.cos_sin_ndims = config.cos_sin_ndims;
         m_rotaryKernel = createJitKernel(jcp);
     }
 
@@ -154,12 +153,11 @@ struct RoPE::RoPEExecutorRotateHalf : public RoPE::Executor {
             t_sin = t_sin.reshape({1, t_sin.size(0), t_sin.size(1), t_sin.size(2)});
         }
 
-        const auto batch_size = t_src.size(0);
-        const auto head_cnt = t_src.size(1);
-        const auto seq_len = t_src.size(2);
-        const auto feature_size = t_src.size(3);
-        const auto half_rotary_dims = rotary_dims / 2;
-        const size_t cos_sin_offset = (m_config.cos_sin_ndims == half_rotary_dims) ? 0 : half_rotary_dims;
+        auto batch_size = t_src.size(0);
+        auto head_cnt = t_src.size(1);
+        auto seq_len = t_src.size(2);
+        auto feature_size = t_src.size(3);
+
         parallel_for3d(batch_size, head_cnt, seq_len, [&](size_t b, size_t h, size_t p) {
             auto cos_pos = p;
             if (gather) {
@@ -177,12 +175,13 @@ struct RoPE::RoPEExecutorRotateHalf : public RoPE::Executor {
             if (m_rotaryKernel) {
                 execJitKernel(m_rotaryKernel, src, dst, cos, sin);
             } else {
+                auto half_rotary_dims = rotary_dims / 2;
                 size_t i = 0;
                 for (; i < half_rotary_dims; i++) {
                     auto src0 = src[i];
                     auto src1 = src[i + half_rotary_dims];
                     dst[i] = cos[i] * src0 - sin[i] * src1;
-                    dst[i + half_rotary_dims] = cos[i + cos_sin_offset] * src1 + sin[i + cos_sin_offset] * src0;
+                    dst[i + half_rotary_dims] = cos[i + half_rotary_dims] * src1 + sin[i + half_rotary_dims] * src0;
                 }
             }
             if (!can_inplace) {
diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/subgraph_tests/rotary_pos_emb.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/subgraph_tests/rotary_pos_emb.cpp
@@ -79,12 +79,5 @@ INSTANTIATE_TEST_SUITE_P(smoke_RoPETestQwenVL,
                             ::testing::ValuesIn(vit_param)),
                          RoPETestQwenVL::getTestCaseName);
 
-INSTANTIATE_TEST_SUITE_P(smoke_RoPETestGPTOSS,
-                         RoPETestGPTOSS,
-                         ::testing::Combine(
-                            ::testing::Values(ov::element::f32),
-                            ::testing::Values(ov::test::utils::DEVICE_CPU)),
-                         RoPETestGPTOSS::getTestCaseName);
-
 }  // namespace test
 }  // namespace ov
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl_v2/rope_opt.cl b/src/plugins/intel_gpu/src/graph/impls/ocl_v2/rope_opt.cl
@@ -411,14 +411,14 @@ uint cos_sin_p = p;
     output[output_idx + r] = cos[cos_idx + r] * in1 - sin[sin_idx + r] * in2;
 
     output[output_idx + HALF_ROTARY_NDIMS + r] =
-        cos[cos_idx + COS_SIN_TABLE_OFFSET + r] * in2 + sin[sin_idx + COS_SIN_TABLE_OFFSET + r] * in1;
+        cos[cos_idx + HALF_ROTARY_NDIMS + r] * in2 + sin[sin_idx + HALF_ROTARY_NDIMS + r] * in1;
 #else
     INPUT_VEC_TYPE in1 = *(INPUT_VEC_TYPE*)(input + input_idx + r);
     INPUT_VEC_TYPE in2 = *(INPUT_VEC_TYPE*)(input + input_idx + HALF_ROTARY_NDIMS + r);
     INPUT_VEC_TYPE cos1 = *(INPUT_VEC_TYPE*)(cos + cos_idx + r);
-    INPUT_VEC_TYPE cos2 = *(INPUT_VEC_TYPE*)(cos + cos_idx + COS_SIN_TABLE_OFFSET + r);
+    INPUT_VEC_TYPE cos2 = *(INPUT_VEC_TYPE*)(cos + cos_idx + HALF_ROTARY_NDIMS + r);
     INPUT_VEC_TYPE sin1 = *(INPUT_VEC_TYPE*)(sin + sin_idx + r);
-    INPUT_VEC_TYPE sin2 = *(INPUT_VEC_TYPE*)(sin + sin_idx + COS_SIN_TABLE_OFFSET + r);
+    INPUT_VEC_TYPE sin2 = *(INPUT_VEC_TYPE*)(sin + sin_idx + HALF_ROTARY_NDIMS + r);
 
     OUTPUT_VEC_TYPE out1 = cos1 * in1 - sin1 * in2;
     OUTPUT_VEC_TYPE out2 = cos2 * in2 + sin2 * in1;
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl_v2/rope_opt.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl_v2/rope_opt.cpp
@@ -54,7 +54,6 @@ class RopeGenerator : public KernelGenerator {
         jit.make("HEAD_SIZE", desc->config.head_size);
         jit.make("ROTARY_NDIMS", desc->config.rotary_ndims);
         jit.make("HALF_ROTARY_NDIMS", desc->config.rotary_ndims / 2);
-        jit.make("COS_SIN_TABLE_OFFSET", (desc->config.cos_sin_ndims == (desc->config.rotary_ndims / 2)) ? 0 : desc->config.rotary_ndims / 2);
         jit.make("HEAD_COUNT", desc->config.head_cnt);
 
         if (desc->config.head_size > desc->config.rotary_ndims) {
diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/subgraph_tests/rotary_pos_emb.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/subgraph_tests/rotary_pos_emb.cpp
@@ -104,12 +104,5 @@ INSTANTIATE_TEST_SUITE_P(smoke_RoPETestChatGLM,
                             ::testing::Values(ov::test::utils::DEVICE_GPU)),
                          RoPETestChatGLMHF::getTestCaseName);
 
-INSTANTIATE_TEST_SUITE_P(smoke_RoPETestGPTOSS,
-                         RoPETestGPTOSS,
-                         ::testing::Combine(
-                            ::testing::Values(ov::element::f16, ov::element::f32),
-                            ::testing::Values(ov::test::utils::DEVICE_GPU)),
-                         RoPETestGPTOSS::getTestCaseName);
-
 }  // namespace test
 }  // namespace ov
diff --git a/src/tests/functional/plugin/shared/include/shared_test_classes/subgraph/rotary_pos_emb.hpp b/src/tests/functional/plugin/shared/include/shared_test_classes/subgraph/rotary_pos_emb.hpp
@@ -198,19 +198,5 @@ class RoPETestChatGLMHF : public SubgraphBaseTest, public testing::WithParamInte
     static std::string getTestCaseName(const testing::TestParamInfo<rope_params>& obj);
 };
 
-class RoPETestGPTOSS : public SubgraphBaseTest, public testing::WithParamInterface<rope_params> {
-private:
-    std::shared_ptr<ov::Model> buildROPE_GPTOSS(int num_head,
-                                              int rotary_dims,
-                                              ov::element::Type element_type);
-
-protected:
-    void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override;
-    void SetUp() override;
-
-public:
-    static std::string getTestCaseName(const testing::TestParamInfo<rope_params>& obj);
-};
-
 }  // namespace test
 }  // namespace ov
diff --git a/src/tests/functional/plugin/shared/include/subgraph_tests/rotary_pos_emb.hpp b/src/tests/functional/plugin/shared/include/subgraph_tests/rotary_pos_emb.hpp
@@ -115,12 +115,5 @@ TEST_P(RoPETestChatGLMHF, CompareWithRefs) {
     CheckNumberOfNodesWithType(function, {"RoPE"}, 1);
 };
 
-TEST_P(RoPETestGPTOSS, CompareWithRefs) {
-    SKIP_IF_CURRENT_TEST_IS_DISABLED();
-    run();
-    auto function = compiledModel.get_runtime_model();
-    CheckNumberOfNodesWithType(function, {"RoPE"}, 1);
-};
-
 }  // namespace test
 }  // namespace ov
diff --git a/src/tests/functional/plugin/shared/src/subgraph/rotary_pos_emb.cpp b/src/tests/functional/plugin/shared/src/subgraph/rotary_pos_emb.cpp
@@ -1457,83 +1457,5 @@ std::string RoPETestChatGLMHF::getTestCaseName(const testing::TestParamInfo<rope
     return result.str();
 }
 
-std::shared_ptr<ov::Model> RoPETestGPTOSS::buildROPE_GPTOSS(int num_head,
-                                                            int rotary_dims,
-                                                            ov::element::Type element_type) {
-    auto input = std::make_shared<ov::opset1::Parameter>(element_type, PartialShape{-1, -1, num_head, rotary_dims});
-    input->set_friendly_name("input");
-    auto permute_Transpose = makeOP<opset1::Transpose>({input, {0, 2, 1, 3}}, {});
-    auto cos = std::make_shared<ov::opset1::Parameter>(element_type, PartialShape{-1, 1, -1, rotary_dims/2});
-    cos->set_friendly_name("cos");
-    auto sin = std::make_shared<ov::opset1::Parameter>(element_type, PartialShape{-1, 1, -1, rotary_dims/2});
-    sin->set_friendly_name("sin");
-    auto variadicSplit = makeOP<opset1::VariadicSplit>({permute_Transpose, -1, {rotary_dims/2, -1}});
-    auto first_half_mul_cos = makeOP<opset1::Multiply>({variadicSplit->output(0), cos}, {{"auto_broadcast", "numpy"}});
-
-    auto second_half_mul_sin = makeOP<opset1::Multiply>({variadicSplit->output(1), sin}, {{"auto_broadcast", "numpy"}});
-    auto neg_one = makeConst(element_type, {}, std::vector<float>{-1.0f});
-    auto neg = makeOP<opset1::Multiply>({second_half_mul_sin, neg_one}, {{"auto_broadcast", "numpy"}});
-    auto sub_Subtract = makeOP<opset1::Add>({first_half_mul_cos, neg}, {{"auto_broadcast", "numpy"}});
-
-
-    auto second_half_mul_cos = makeOP<opset1::Multiply>({variadicSplit->output(1), cos}, {{"auto_broadcast", "numpy"}});
-    auto first_half_mul_sin = makeOP<opset1::Multiply>({variadicSplit->output(0), sin}, {{"auto_broadcast", "numpy"}});
-    auto add_Add = makeOP<opset1::Add>({second_half_mul_cos, first_half_mul_sin}, {{"auto_broadcast", "numpy"}});
-    auto cat_Concat = makeOP<opset1::Concat>({sub_Subtract, add_Add}, {{"axis", -1}});
-    return std::make_shared<ov::Model>(cat_Concat, ov::ParameterVector{input, cos, sin});
-}
-
-void RoPETestGPTOSS::generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) {
-    const auto& funcInputs = function->inputs();
-
-    auto& input_shape = targetInputStaticShapes[0];
-    auto& cos_shape = targetInputStaticShapes[1];
-    auto& sin_shape = targetInputStaticShapes[2];
-
-    ov::test::utils::InputGenerateData in_data;
-    in_data.start_from = -1;
-    in_data.range = 2;
-    in_data.resolution = 32768;
-    auto cos_data = in_data;
-    cos_data.seed = 10;
-
-    auto sin_data = in_data;
-    sin_data.seed = 20;
-    ov::Tensor t_input = utils::create_and_fill_tensor(funcInputs[0].get_element_type(), input_shape, in_data);
-    ov::Tensor t_cos_cache =
-        utils::create_and_fill_tensor(funcInputs[1].get_element_type(), cos_shape, cos_data);
-    ov::Tensor t_sin_cache =
-        utils::create_and_fill_tensor(funcInputs[2].get_element_type(), sin_shape, sin_data);
-
-    inputs.clear();
-    inputs.insert({funcInputs[0].get_node_shared_ptr(), t_input});
-    inputs.insert({funcInputs[1].get_node_shared_ptr(), t_cos_cache});
-    inputs.insert({funcInputs[2].get_node_shared_ptr(), t_sin_cache});
-}
-
-std::string RoPETestGPTOSS::getTestCaseName(const testing::TestParamInfo<rope_params>& obj) {
-    const auto& [element_type, targetDevice] = obj.param;
-    std::ostringstream result;
-    result << "type=" << element_type << "_"
-           << "targetDevice=" << targetDevice;
-    return result.str();
-}
-
-void RoPETestGPTOSS::SetUp() {
-    const auto& [element_type, _targetDevice] = this->GetParam();
-    targetDevice = _targetDevice;
-
-    const int batch = 5;
-    const int seq_length = 7;
-    const int num_head = 8;
-    const int rotary_dims = 64;
-
-    InputShape input = {{batch, seq_length, num_head, rotary_dims}, {{batch, seq_length, num_head, rotary_dims}}};
-    InputShape cos = {{batch, 1, seq_length, rotary_dims/2}, {{batch, 1, seq_length, rotary_dims/2}}};
-    InputShape sin = {{batch, 1, seq_length, rotary_dims/2}, {{batch, 1, seq_length, rotary_dims/2}}};
-    init_input_shapes({input, cos, sin});
-    function = buildROPE_GPTOSS(num_head, rotary_dims, element_type);
-}
-
 }  // namespace test
 }  // namespace ov
