Delayed constant serialization (#29106)

### Details:
- New PostponedConstantReplacer class to wrap nodes in serialization. If
a node has "postponed_constant " rt info property, it will be
substituted with a new constant, got from evaluate.
PostponedConstantReplacer and new constant objects to be deleted after
usage.
- New python PostponedConstant operation which does not has an initial
value and calculates in via callback on evaluate call
 - Some fixes in serialization
 - C++ and python tests

### Tickets:
 - CVS-162940

Author: olpipi

src/bindings/python/src/openvino/__init__.py

@@ -52,12 +52,12 @@
 from openvino._pyopenvino import RemoteTensor
 
 # Import public classes from _ov_api
+from openvino._op_base import Op
 from openvino._ov_api import Model
 from openvino._ov_api import Core
 from openvino._ov_api import CompiledModel
 from openvino._ov_api import InferRequest
 from openvino._ov_api import AsyncInferQueue
-from openvino._ov_api import Op
 
 # Import all public modules
 from openvino.package_utils import LazyLoader

src/bindings/python/src/openvino/_op_base.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2025 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Union, Optional, Tuple, List
+
+from openvino._pyopenvino import Op as OpBase
+from openvino._pyopenvino import Node, Output
+
+
+class Op(OpBase):
+    def __init__(self, py_obj: "Op", inputs: Optional[Union[List[Union[Node, Output]], Tuple[Union[Node, Output, List[Union[Node, Output]]]]]] = None) -> None:
+        super().__init__(py_obj)
+        self._update_type_info()
+        if isinstance(inputs, tuple):
+            inputs = None if len(inputs) == 0 else list(inputs)
+            if inputs is not None and len(inputs) == 1 and isinstance(inputs[0], list):
+                inputs = inputs[0]
+        if inputs is not None:
+            self.set_arguments(inputs)
+            self.constructor_validate_and_infer_types()

src/bindings/python/src/openvino/_ov_api.py

@@ -4,7 +4,7 @@
 
 import io
 from types import TracebackType
-from typing import Any, Iterable, Union, Optional, Dict, Tuple, List
+from typing import Any, Iterable, Union, Optional, Dict
 from typing import Type as TypingType
 from pathlib import Path
 
@@ -13,8 +13,7 @@
 from openvino._pyopenvino import Core as CoreBase
 from openvino._pyopenvino import CompiledModel as CompiledModelBase
 from openvino._pyopenvino import AsyncInferQueue as AsyncInferQueueBase
-from openvino._pyopenvino import Op as OpBase
-from openvino._pyopenvino import Node, Output, Tensor, Type
+from openvino._pyopenvino import Node, Tensor, Type
 
 from openvino.utils.data_helpers import (
     OVDict,
@@ -25,19 +24,6 @@
 from openvino.package_utils import deprecatedclassproperty
 
 
-class Op(OpBase):
-    def __init__(self, py_obj: "Op", inputs: Optional[Union[List[Union[Node, Output]], Tuple[Union[Node, Output, List[Union[Node, Output]]]]]] = None) -> None:
-        super().__init__(py_obj)
-        self._update_type_info()
-        if isinstance(inputs, tuple):
-            inputs = None if len(inputs) == 0 else list(inputs)
-            if inputs is not None and len(inputs) == 1 and isinstance(inputs[0], list):
-                inputs = inputs[0]
-        if inputs is not None:
-            self.set_arguments(inputs)
-            self.constructor_validate_and_infer_types()
-
-
 class ModelMeta(type):
     def __dir__(cls) -> list:
         return list(set(cls.__dict__.keys()) | set(dir(ModelBase)))

src/bindings/python/src/openvino/utils/__init__.py

@@ -10,3 +10,4 @@
 from openvino.package_utils import deprecated
 from openvino.package_utils import classproperty
 from openvino.package_utils import deprecatedclassproperty
+from openvino.utils.postponed_constant import make_postponed_constant

src/bindings/python/src/openvino/utils/postponed_constant.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2025 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+
+from typing import Callable, List, Optional
+from openvino import Op, Type, Shape, Tensor, PartialShape
+
+
+class PostponedConstant(Op):
+    """Postponed Constant is a way to materialize a big constant only when it is going to be serialized to IR and then immediately dispose."""
+    def __init__(self, element_type: Type, shape: Shape, maker: Callable[[Tensor], None], name: Optional[str] = None) -> None:
+        super().__init__(self)
+        self.get_rt_info()["postponed_constant"] = True  # value doesn't matter
+        self.m_element_type = element_type
+        self.m_shape = shape
+        self.m_maker = maker
+        if name is not None:
+            self.friendly_name = name
+        self.constructor_validate_and_infer_types()
+
+    def evaluate(self, outputs: List[Tensor], _: List[Tensor]) -> bool:
+        self.m_maker(outputs[0])
+        return True
+
+    def validate_and_infer_types(self) -> None:
+        self.set_output_type(0, self.m_element_type, PartialShape(self.m_shape))
+
+    def clone_with_new_inputs(self, new_inputs: List[Tensor]) -> Op:
+        return PostponedConstant(self.m_element_type, self.m_shape, self.m_maker, self.friendly_name)
+
+    def has_evaluate(self) -> bool:
+        return True
+
+
+# `maker` is a function that returns ov.Tensor that represents a target Constant
+def make_postponed_constant(element_type: Type, shape: Shape, maker: Callable[[Tensor], None], name: Optional[str] = None) -> Op:
+    return PostponedConstant(element_type, shape, maker, name)

src/bindings/python/tests/test_utils/test_utils.py

@@ -4,9 +4,11 @@
 
 import pytest
 import os
+import numpy as np
+import openvino as ov
 from pathlib import Path
-from openvino.utils import deprecated, get_cmake_path
-from tests.utils.helpers import compare_models, get_relu_model
+from openvino.utils import deprecated, get_cmake_path, make_postponed_constant
+from tests.utils.helpers import compare_models, get_relu_model, create_filenames_for_ir
 
 
 def test_compare_functions():
@@ -94,3 +96,95 @@ def mock_walk(path):
     result = get_cmake_path()
 
     assert result == ""
+
+
+class Maker:
+    def __init__(self):
+        self.calls_count = 0
+
+    def __call__(self, tensor: ov.Tensor) -> None:
+        self.calls_count += 1
+        tensor_data = np.array([2, 2, 2, 2], dtype=np.float32).reshape(1, 1, 2, 2)
+        ov.Tensor(tensor_data).copy_to(tensor)
+
+    def called_times(self):
+        return self.calls_count
+
+
+def create_model(maker):
+    input_shape = ov.Shape([1, 2, 1, 2])
+    param_node = ov.opset13.parameter(input_shape, ov.Type.f32, name="data")
+
+    postponned_constant = make_postponed_constant(ov.Type.f32, input_shape, maker)
+
+    add_1 = ov.opset13.add(param_node, postponned_constant)
+
+    const_2 = ov.op.Constant(ov.Type.f32, input_shape, [1, 2, 3, 4])
+    add_2 = ov.opset13.add(add_1, const_2)
+
+    return ov.Model(add_2, [param_node], "test_model")
+
+
+@pytest.fixture
+def prepare_ir_paths(request, tmp_path):
+    xml_path, bin_path = create_filenames_for_ir(request.node.name, tmp_path)
+
+    yield xml_path, bin_path
+
+    # IR Files deletion should be done after `Model` is destructed.
+    # It may be achieved by splitting scopes (`Model` will be destructed
+    # just after test scope finished), or by calling `del Model`
+    os.remove(xml_path)
+    os.remove(bin_path)
+
+
+def test_save_postponned_constant(prepare_ir_paths):
+    maker = Maker()
+    model = create_model(maker)
+    assert maker.called_times() == 0
+
+    model_export_file_name, weights_export_file_name = prepare_ir_paths
+    ov.save_model(model, model_export_file_name, compress_to_fp16=False)
+
+    assert maker.called_times() == 1
+
+
+def test_save_postponned_constant_twice(prepare_ir_paths):
+    maker = Maker()
+    model = create_model(maker)
+    assert maker.called_times() == 0
+
+    model_export_file_name, weights_export_file_name = prepare_ir_paths
+    ov.save_model(model, model_export_file_name, compress_to_fp16=False)
+    assert maker.called_times() == 1
+    ov.save_model(model, model_export_file_name, compress_to_fp16=False)
+    assert maker.called_times() == 2
+
+
+def test_serialize_postponned_constant(prepare_ir_paths):
+    maker = Maker()
+    model = create_model(maker)
+    assert maker.called_times() == 0
+
+    model_export_file_name, weights_export_file_name = prepare_ir_paths
+    ov.serialize(model, model_export_file_name, weights_export_file_name)
+    assert maker.called_times() == 1
+
+
+def test_infer_postponned_constant():
+    maker = Maker()
+    model = create_model(maker)
+    assert maker.called_times() == 0
+
+    compiled_model = ov.compile_model(model, "CPU")
+    assert isinstance(compiled_model, ov.CompiledModel)
+
+    request = compiled_model.create_infer_request()
+    input_data = np.ones([1, 2, 1, 2], dtype=np.float32)
+    input_tensor = ov.Tensor(input_data)
+
+    results = request.infer({"data": input_tensor})
+    assert maker.called_times() == 1
+
+    expected_output = np.array([4, 5, 6, 7], dtype=np.float32).reshape(1, 2, 1, 2)
+    assert np.allclose(results[list(results)[0]], expected_output, 1e-4, 1e-4)