[HETERO] Support splitting new graph pattern for pipeline parallel and correct the number of submodels (openvinotoolkit#25224)

### Details:
 - Fix qwen1.5-14b-chat with HETERO pipeline parallelism
     Add supported to patten:
     ```
     ReadValue->Gather->Concat
|------>ShapeOf(fused on other different affinity node) ->....
     ```
- Correct the value of HETERO_NUMBER_OF_SUBMODELS by subtracting the
number of independent submodels to reduce confusion

### Tickets:
 - *ticket-id*

Author: WeldonWangwang

src/inference/src/dev/iplugin.cpp

@@ -391,7 +391,7 @@ std::unordered_set<std::string> ov::get_supported_nodes(
                 }
             }
             // For example, A op need to be removed from supported:
-            //              A (fused on B, to be marked as unsupported)
+            //              A (removed nodes, to be marked as unsupported)
             //              |
             //              B (unsupported)
             //
@@ -400,8 +400,33 @@ std::unordered_set<std::string> ov::get_supported_nodes(
                 update_supported = false;
                 for (auto& op : model->get_ordered_ops()) {
                     const auto& name = op->get_friendly_name();
-                    if (fused_model_op_map.find(name) != fused_model_op_map.end() && supported.count(name)) {
-                        if (!supported.count(fused_model_op_map[name]) &&
+                    if (removed_nodes.count(name) && supported.count(name)) {
+                        if (has_all_consumers_unsupported(supported, op)) {
+                            supported.erase(name);
+                            removed_nodes.erase(name);
+                            update_supported = true;
+                        }
+                    }
+                }
+            }
+            // For example, A op need to be removed from supported:
+            //              A (fused on B, to be marked as unsupported)
+            //              |
+            //              B (unsupported)
+            //
+            //            A ShapeOf (to be marked as unsupported)
+            //              |
+            //              B (unsupported)
+            //
+            update_supported = true;
+            while (update_supported) {
+                update_supported = false;
+                for (auto& op : model->get_ordered_ops()) {
+                    const auto& name = op->get_friendly_name();
+                    bool is_shapeof = ov::is_type<op::util::ShapeOfBase>(op);
+                    if (((fused_model_op_map.find(name) != fused_model_op_map.end()) || is_shapeof) &&
+                        supported.count(name)) {
+                        if ((!supported.count(fused_model_op_map[name]) || is_shapeof) &&
                             has_all_consumers_unsupported(supported, op)) {
                             supported.erase(name);
                             update_supported = true;

src/inference/tests/unit/query_model_test.cpp

@@ -743,3 +743,41 @@ const std::vector<ConfigParams> testConfigs2 = {
 INSTANTIATE_TEST_SUITE_P(GetSupportedNodesTest, GetSupportedNodesCommonTest, ::testing::ValuesIn(testConfigs));
 INSTANTIATE_TEST_SUITE_P(GetSupportedNodesTest, GetSupportedNodesOneConstOp, ::testing::ValuesIn(testConfigs1));
 INSTANTIATE_TEST_SUITE_P(GetSupportedNodesTest, GetSupportedNodesStopSplit, ::testing::ValuesIn(testConfigs2));
+
+TEST_F(GetSupportedNodesTest, FilterShapeOf) {
+    {
+        auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{1, 1});
+        param->set_friendly_name("input");
+        auto weights = ov::op::v0::Constant::create(ov::element::Type_t::f32, {1, 1}, {1});
+        weights->set_friendly_name("weights");
+        auto shapeOf = std::make_shared<ov::op::v0::ShapeOf>(weights);
+        shapeOf->set_friendly_name("shapeof");
+        auto const1 = ov::op::v0::Constant::create(ov::element::Type_t::i32, {1}, {1});
+        const1->set_friendly_name("const1");
+        auto const2 = ov::op::v0::Constant::create(ov::element::Type_t::i64, {}, {0});
+        const2->set_friendly_name("const2");
+        auto gather = std::make_shared<ov::op::v8::Gather>(shapeOf, const1, const2);
+        gather->set_friendly_name("gather");
+        auto const3 = ov::op::v0::Constant::create(ov::element::Type_t::i64, {1}, {1});
+        const3->set_friendly_name("const3");
+        auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{const3, gather}, 0);
+        concat->set_friendly_name("concat");
+        auto reshape = std::make_shared<ov::op::v1::Reshape>(param, concat, false);
+        reshape->set_friendly_name("reshape");
+        auto result = std::make_shared<ov::op::v0::Result>(reshape);
+        result->set_friendly_name("result");
+
+        m_function = std::make_shared<ov::Model>(ov::ResultVector{result}, ov::ParameterVector{param});
+    }
+    Run(
+        [&](std::shared_ptr<ov::Model>& model) {
+            ov::pass::Manager m;
+            m.register_pass<ov::pass::InitNodeInfo>();
+            m.run_passes(model);
+        },
+        [&](const std::shared_ptr<ov::Node>& op) {
+            return true;
+        },
+        {"weights"},
+        0.5f);
+}

src/plugins/hetero/src/compiled_model.cpp

@@ -321,7 +321,8 @@ ov::Any ov::hetero::CompiledModel::get_property(const std::string& name) const {
         }
         return decltype(ov::execution_devices)::value_type{std::move(device_names)};
     } else if (ov::hetero::number_of_submodels == name) {
-        return decltype(ov::hetero::number_of_submodels)::value_type{m_compiled_submodels.size()};
+        return decltype(ov::hetero::number_of_submodels)::value_type{
+            (m_compiled_submodels.size() - get_hetero_plugin()->independent_submodel_size)};
     }
     return m_cfg.get(name);
 }

src/plugins/hetero/src/plugin.cpp

@@ -193,6 +193,7 @@ std::pair<ov::SupportedOpsMap, ov::hetero::SubgraphsMappingInfo> ov::hetero::Plu
             auto result = std::make_shared<ov::op::v0::Result>(param);
             ov::copy_runtime_info(param->shared_from_this(), result);
             new_outputs.push_back(result);
+            independent_submodel_size++;
         }
     }
     model->add_results(new_outputs);

src/plugins/hetero/src/plugin.hpp

@@ -69,6 +69,8 @@ class Plugin : public ov::IPlugin {
         bool allow_exception = false) const;
 
     Configuration m_cfg;
+
+    mutable size_t independent_submodel_size = 0;
 };
 
 }  // namespace hetero