Eliminate weightless attr

Author: nshchego

src/common/transformations/include/transformations/common_optimizations/eliminate_weightless_attributes.hpp

@@ -0,0 +1,25 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/pass/matcher_pass.hpp"
+#include "transformations_visibility.hpp"
+
+namespace ov {
+namespace pass {
+
+/**
+ * @ingroup ov_transformation_common_api
+ * @brief EliminateWeightlessAttributes transformation
+ *
+ */
+class TRANSFORMATIONS_API EliminateWeightlessAttributes : public ov::pass::MatcherPass {
+public:
+    OPENVINO_MATCHER_PASS_RTTI("EliminateWeightlessAttributes");
+    EliminateWeightlessAttributes();
+};
+
+}  // namespace pass
+}  // namespace ov

src/common/transformations/src/transformations/common_optimizations/eliminate_weightless_attributes.cpp

@@ -0,0 +1,33 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "transformations/common_optimizations/eliminate_weightless_attributes.hpp"
+
+#include "itt.hpp"
+#include "openvino/core/rt_info/weightless_caching_attributes.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
+
+namespace ov::pass {
+
+EliminateWeightlessAttributes::EliminateWeightlessAttributes() {
+    MATCHER_SCOPE(EliminateWeightlessAttributes);
+
+    auto constant_pattern = pattern::wrap_type<op::v0::Constant>(pattern::has_static_shape());
+
+    matcher_pass_callback callback = [=](pattern::Matcher& m) {
+        auto constant = as_type<op::v0::Constant>(m.get_match_root().get());
+        if (!constant) {
+            return false;
+        }
+
+        auto& rt_info = constant->get_rt_info();
+        rt_info.erase(WeightlessCacheAttribute::get_type_info_static());
+
+        return true;
+    };
+
+    auto m = std::make_shared<ov::pass::pattern::Matcher>(constant_pattern, matcher_name);
+    this->register_matcher(m, callback);
+}
+}  // namespace ov::pass

src/core/src/node.cpp

@@ -745,7 +745,9 @@ bool ov::Node::constant_fold(OutputVector& output_values, const OutputVector& in
         for (size_t i = 0; i < output_tensors.size(); ++i) {
             output_values[i] = make_shared<ov::op::v0::Constant>(output_tensors[i]);
             ov::copy_runtime_info(nodes, output_values[i].get_node_shared_ptr());
-            ov::copy_weightless_cache_attr(nodes[0], output_values[i].get_node_shared_ptr());
+            if (nodes.size() > 0) {
+                ov::copy_weightless_cache_attr(nodes[0], output_values[i].get_node_shared_ptr());
+            }
         }
         return true;
     }

src/frontends/ir/src/frontend.cpp

@@ -234,10 +234,12 @@ InputModel::Ptr FrontEnd::load_impl(const std::vector<ov::Any>& variants) const
         } else if (variant.is<std::wstring>()) {
             weights_path = variant.as<std::wstring>();
 #endif
-        } else if (variant.is<std::shared_ptr<ov::AlignedBuffer>>() && !weights) {
-            weights = variant.as<std::shared_ptr<ov::AlignedBuffer>>();
-        } else if (variant.is<std::shared_ptr<ov::AlignedBuffer>>() && !origin_weights) {
-            origin_weights = variant.as<std::shared_ptr<ov::AlignedBuffer>>();
+        } else if (variant.is<std::shared_ptr<ov::AlignedBuffer>>()) {
+            if (variant_id == 1) {
+                weights = variant.as<std::shared_ptr<ov::AlignedBuffer>>();
+            } else if (variant_id == 2) {
+                origin_weights = variant.as<std::shared_ptr<ov::AlignedBuffer>>();
+            }
         }
     }
     bool enable_mmap = variants[variants.size() - 1].is<bool>() ? variants[variants.size() - 1].as<bool>() : false;

src/frontends/ir/src/ir_deserializer.cpp

@@ -7,6 +7,7 @@
 #include <regex>
 #include <string_view>
 
+#include "../../../core/reference/include/openvino/reference/convert.hpp"
 #include "openvino/core/descriptor_tensor.hpp"
 #include "openvino/core/meta_data.hpp"
 #include "openvino/core/rt_info/weightless_caching_attributes.hpp"
@@ -20,7 +21,6 @@
 #include "openvino/op/util/op_types.hpp"
 #include "openvino/op/util/read_value_base.hpp"
 #include "openvino/op/util/variable.hpp"
-#include "../../../core/reference/include/openvino/reference/convert.hpp"
 #include "openvino/runtime/shared_buffer.hpp"
 #include "openvino/runtime/string_aligned_buffer.hpp"
 #include "openvino/util/xml_parse_utils.hpp"
@@ -402,7 +402,8 @@ void ov::XmlDeserializer::on_adapter(const std::string& name, ov::ValueAccessor<
             value.copy(data, value.size());
             a->set(buffer);
         } else if (name == "value" && type == "Const") {
-            OPENVINO_ASSERT(m_weights, "Empty weights data in bin file or bin file cannot be found!");
+            OPENVINO_ASSERT(m_weights != nullptr || m_origin_weights != nullptr,
+                "Empty weights data in bin file or bin file cannot be found!");
             std::vector<int64_t> shape;
             std::string el_type_str;
 

src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp

@@ -29,6 +29,7 @@
 #include "transformations/common_optimizations/common_optimizations.hpp"
 #include "transformations/common_optimizations/convert_pagedattn_inputs.hpp"
 #include "transformations/common_optimizations/convert_quantize_dequantize.hpp"
+#include "transformations/common_optimizations/eliminate_weightless_attributes.hpp"
 #include "transformations/common_optimizations/fq_mul_fusion.hpp"
 #include "transformations/common_optimizations/fuse_rotary_positional_embeddings.hpp"
 #include "transformations/common_optimizations/lora_subgraph_fusion.hpp"
@@ -402,6 +403,9 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
 
     ov::pass::Manager manager("Plugin:CPU");
     manager.set_per_pass_validation(false);
+    if (config.m_cache_mode != ov::CacheMode::OPTIMIZE_SIZE) {
+        CPU_REGISTER_PASS_COMMON(manager, ov::pass::EliminateWeightlessAttributes);
+    }
     if (useLpt) {
         CPU_REGISTER_PASS_COMMON(manager, ov::pass::MarkDequantization, defaultPrecisions);
     }

src/plugins/intel_cpu/tests/functional/shared_tests_instances/behavior/compiled_model/model_cache.cpp

@@ -7,7 +7,7 @@
 
 using namespace ov::test::behavior;
 
-INSTANTIATE_TEST_SUITE_P(smoke_WeightlessCacheAccuracy,
+INSTANTIATE_TEST_SUITE_P(smoke_,
                          WeightlessCacheAccuracy,
                          ::testing::Combine(::testing::Bool(),
                                             ::testing::Bool(),
@@ -16,7 +16,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_WeightlessCacheAccuracy,
                                             ::testing::Values(ov::test::utils::DEVICE_CPU)),
                          WeightlessCacheAccuracy::get_test_case_name);
 
-INSTANTIATE_TEST_SUITE_P(smoke_WeightlessCacheAccuracyLowPrecision,
+INSTANTIATE_TEST_SUITE_P(smoke_LowPrecision,
                          WeightlessCacheAccuracyLowPrecision,
                          ::testing::Combine(::testing::Bool(),
                                             ::testing::Bool(),

src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp

@@ -317,6 +317,7 @@ std::vector<std::string> disabledTestPatterns() {
         R"(.*FC_3D_BF16.*MatMulLayerCPUTest.*)",
         // Issue: 163242
         R"(.*bf16.*RNNSequenceCPUTest.*)",
+        R"(.*WeightlessCacheAccuracy.TiWithLstmCell.*model_dtype=bf16.*)",
         // Issue: 163250
         R"(.*OnnxModelWithExtensionFromDSO.*)",
         // Issue: 163273

src/tests/functional/plugin/shared/src/behavior/compiled_model/model_cache.cpp

@@ -9,6 +9,7 @@
 #include "common_test_utils/subgraph_builders/ti_with_lstm_cell.hpp"
 #include "common_test_utils/test_assertions.hpp"
 #include "common_test_utils/ov_tensor_utils.hpp"
+#include "openvino/op/matmul.hpp"
 #include "openvino/util/codec_xor.hpp"
 #include "shared_test_classes/subgraph/weights_decompression_builders.hpp"
 
@@ -140,21 +141,25 @@ void WeightlessCacheAccuracy::run() {
 }
 
 TEST_P(WeightlessCacheAccuracy, ReadConcatSplitAssign) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED()
     OV_ASSERT_NO_THROW(m_model = ov::test::utils::make_read_concat_split_assign({1, 1, 2, 4}, m_model_dtype));
     OV_ASSERT_NO_THROW(run());
 }
 
 TEST_P(WeightlessCacheAccuracy, SingleConcatWithConstant) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED()
     OV_ASSERT_NO_THROW(m_model = ov::test::utils::make_single_concat_with_constant({1, 1, 2, 4}, m_model_dtype));
     OV_ASSERT_NO_THROW(run());
 }
 
 TEST_P(WeightlessCacheAccuracy, TiWithLstmCell) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED()
     OV_ASSERT_NO_THROW(m_model = ov::test::utils::make_ti_with_lstm_cell(m_model_dtype));
     OV_ASSERT_NO_THROW(run());
 }
 
 TEST_P(WeightlessCacheAccuracyLowPrecision, MatmulWeightsDecompression) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED()
     ov::test::MatMulDecompressionShapeParams shape_params{{{}, {{1, 4, 16}}}, {1, 16, 32}};
     auto dynShape = shape_params.data_shape.first;
     if (dynShape.rank() == 0) {