[core] Preserve friendly name and tensor names in PPP

src/bindings/python/src/pyopenvino/graph/preprocess/pre_post_process.cpp

@@ -252,7 +252,8 @@ static void regclass_graph_InputTensorInfo(py::module m) {
         },
         py::arg("layout"),
         R"(
-            Set layout for input tensor info 
+            Set layout for input tensor info
+
             :param layout: layout to be set
             :type layout: Union[str, openvino.runtime.Layout]
         )");
@@ -366,10 +367,24 @@ static void regclass_graph_OutputTensorInfo(py::module m) {
         },
         py::arg("layout"),
         R"(
-            Set layout for output tensor info 
+            Set layout for output tensor info
+
             :param layout: layout to be set
             :type layout: Union[str, openvino.runtime.Layout]
         )");
+
+    info.def(
+        "_set_names_compatibility_mode",
+        [](ov::preprocess::OutputTensorInfo& self, const bool compatibility_mode) {
+            return &self.set_names_compatibility_mode(compatibility_mode);
+        },
+        py::arg("compatibility_mode"),
+        R"(
+            Set keep names compatibility mode
+
+            :param compatibility_mode: Mode to be set: True enable compatiblity, False disable
+            :type compatibility_mode: bool
+        )");
 }
 
 static void regclass_graph_InputInfo(py::module m) {
@@ -419,7 +434,8 @@ static void regclass_graph_OutputModelInfo(py::module m) {
         },
         py::arg("layout"),
         R"(
-            Set layout for output model info 
+            Set layout for output model info
+
             :param layout: layout to be set
             :type layout: Union[str, openvino.runtime.Layout]
         )");

src/bindings/python/tests/test_runtime/test_input_node.py

@@ -75,7 +75,8 @@ def test_input_get_source_output(device):
     net_input = compiled_model.output(0)
     input_node = net_input.get_node().inputs()[0]
     name = input_node.get_source_output().get_node().get_friendly_name()
-    assert name == "relu"
+    # Expected ReLu node name can be changed if conversion precision applied (new Convert node added)
+    assert name in ("relu", "relu.0")
 
 
 def test_input_get_tensor(device):

src/common/transformations/src/transformations/convert_precision.cpp

@@ -203,7 +203,8 @@ bool convert_function_precision(const std::shared_ptr<Model>& f,
                                 bool is_changed,
                                 bool is_subgraph,
                                 bool convert_input_output_precision,
-                                bool store_original_precision_as_rt_attribute) {
+                                bool store_original_precision_as_rt_attribute,
+                                bool names_compatibility_mode) {
     bool is_output_precision_changed = false;
 
     ov::element::TypeVector orig_result_types;
@@ -273,7 +274,8 @@ bool convert_function_precision(const std::shared_ptr<Model>& f,
                                                         is_changed || is_output_precision_changed,
                                                         true,
                                                         true,
-                                                        store_original_precision_as_rt_attribute) ||
+                                                        store_original_precision_as_rt_attribute,
+                                                        names_compatibility_mode) ||
                              is_changed;
             }
         }
@@ -321,24 +323,28 @@ bool convert_function_precision(const std::shared_ptr<Model>& f,
             if (result->get_input_element_type(0) != orig_result_types[i]) {
                 auto result_input = result->input_value(0);
                 const auto convert = std::make_shared<ov::op::v0::Convert>(result_input, orig_result_types[i]);
-                if (result_input.get_node()->get_output_size() > 1) {
-                    convert->set_friendly_name(result_input.get_node()->get_friendly_name() + "." +
-                                               std::to_string(result_input.get_index()));
+
+                auto convert_f_name = result_input.get_node()->get_friendly_name();
+                if (names_compatibility_mode) {
+                    if (result_input.get_node()->get_output_size() > 1) {
+                        convert_f_name += '.' + std::to_string(result_input.get_index());
+                    } else {
+                        result_input.get_node()->set_friendly_name("");
+                    }
+
+                    convert->get_output_tensor(0).set_names(result_input.get_names());
                 } else {
-                    convert->set_friendly_name(result_input.get_node()->get_friendly_name());
-                    result_input.get_node()->set_friendly_name("");
+                    convert_f_name += '.' + std::to_string(result_input.get_index());
                 }
 
-                auto& convert_output_tensor = convert->get_output_tensor(0);
-                convert_output_tensor.set_names(result_input.get_names());
+                convert->set_friendly_name(convert_f_name);
                 OPENVINO_SUPPRESS_DEPRECATED_START
                 const auto& legacy_name = ov::descriptor::get_ov_tensor_legacy_name(result_input.get_tensor());
                 if (!legacy_name.empty()) {
-                    ov::descriptor::set_ov_tensor_legacy_name(convert_output_tensor, legacy_name);
+                    ov::descriptor::set_ov_tensor_legacy_name(convert->get_output_tensor(0), legacy_name);
                 }
                 OPENVINO_SUPPRESS_DEPRECATED_END
 
-                result_input.set_names({});
                 result->input(0).replace_source_output(convert->output(0));
                 result->revalidate_and_infer_types();
             }
@@ -361,6 +367,8 @@ bool convert_precision(ov::pass::PassBase& pass,
     // changing precision we need to understand which Constant consumers belongs
     // to the current ov::Model
     std::unordered_map<const ov::Node*, std::vector<Input<Node>>> const_to_internal_output;
+
+    const auto names_compatibility_mode = f->has_rt_info("version") && f->get_rt_info<int64_t>("version") < 11;
     return convert_function_precision(f,
                                       type_to_fuse,
                                       type_to_extend,
@@ -371,7 +379,8 @@ bool convert_precision(ov::pass::PassBase& pass,
                                       false,
                                       false,
                                       convert_input_output_precision,
-                                      store_original_precision_as_rt_attribute);
+                                      store_original_precision_as_rt_attribute,
+                                      names_compatibility_mode);
 }
 
 using precisions_set_t = std::unordered_set<ov::element::Type_t, EnumClassHash>;

src/common/transformations/tests/utils/convert_precision.cpp

@@ -2145,8 +2145,9 @@ TEST(TransformationTests, ConvertPrecisionExplicitConvertsForParameterAndResult)
         auto param_1 = make_shared<opset10::Parameter>(element::f64, Shape{3});
         auto converted_param = make_shared<opset10::Convert>(param_1, element::f32);
         auto sin = make_shared<opset10::Sin>(converted_param);
+        sin->get_output_tensor(0).add_names({"sine:0"});
         auto converted_sin = make_shared<opset10::Convert>(sin, element::f64);
-        converted_sin->get_output_tensor(0).add_names({"sine:0"});
+        converted_sin->set_friendly_name("sine.0");
         auto result_sin = make_shared<opset10::Result>(converted_sin);
         model_ref = make_shared<Model>(result_sin, ParameterVector{param_1});
     }
@@ -2156,7 +2157,7 @@ TEST(TransformationTests, ConvertPrecisionExplicitConvertsForParameterAndResult)
     ASSERT_TRUE(result.valid) << result.message;
 
     const auto& results = model->get_results();
-    ASSERT_EQ("sine", results[0]->get_input_node_ptr(0)->get_friendly_name());
+    ASSERT_EQ("sine.0", results[0]->get_input_node_ptr(0)->get_friendly_name());
 }
 
 TEST(TransformationTests, ConvertPrecisionExplicitConvertsMultiParam) {
@@ -2220,8 +2221,8 @@ TEST(TransformationTests, ConvertPrecisionExplicitConvertsMultiParam) {
         auto converted_mul = make_shared<opset10::Convert>(mul, element::f64);
         auto sin = make_shared<opset10::Sin>(convert_1);
 
-        converted_add->get_output_tensor(0).add_names({"add:0"});
-        converted_mul->get_output_tensor(0).add_names({"mul:0"});
+        add->get_output_tensor(0).add_names({"add:0"});
+        mul->get_output_tensor(0).add_names({"mul:0"});
         sin->get_output_tensor(0).add_names({"sine:0"});
 
         auto result_add = make_shared<opset10::Result>(converted_add);
@@ -2237,8 +2238,6 @@ TEST(TransformationTests, ConvertPrecisionExplicitConvertsMultiParam) {
     ASSERT_TRUE(result.valid) << result.message;
 
     const auto& results = model->get_results();
-    ASSERT_EQ("add", results[0]->get_input_node_ptr(0)->get_friendly_name());
-    ASSERT_EQ("mul", results[1]->get_input_node_ptr(0)->get_friendly_name());
     ASSERT_EQ("sine", results[2]->get_input_node_ptr(0)->get_friendly_name());
 }
 
@@ -2259,6 +2258,8 @@ TEST(TransformationTests, ConvertPrecisionExplicitConvertsSingleNodeMultipleOutp
         ov::descriptor::set_ov_tensor_legacy_name(split->get_output_tensor(2), "legacy_split:2");
         OPENVINO_SUPPRESS_DEPRECATED_END
         model = make_shared<Model>(split->outputs(), ParameterVector{param_1});
+        // set version 10 to use names compatibility mode
+        model->get_rt_info()["version"] = static_cast<int64_t>(10);
 
         type_to_fuse_map empty_type_to_fuse_map = {};
         bool keep_precision_sensitive_in_fp32 = false;
@@ -2275,6 +2276,9 @@ TEST(TransformationTests, ConvertPrecisionExplicitConvertsSingleNodeMultipleOutp
         auto convert_1 = make_shared<opset10::Convert>(param_1, element::f32);
         auto axis = opset10::Constant::create(element::i32, Shape{}, {0});
         auto split = make_shared<opset10::Split>(convert_1, axis, 3);
+        split->get_output_tensor(0).add_names({"split:0"});
+        split->get_output_tensor(1).add_names({"split:1"});
+        split->get_output_tensor(2).add_names({"split:2"});
 
         auto convert_split_0 = make_shared<opset10::Convert>(split->output(0), element::f64);
         auto convert_split_1 = make_shared<opset10::Convert>(split->output(1), element::f64);
@@ -2348,6 +2352,8 @@ TEST(TransformationTests, ConvertPrecisionExplicitConvertsMultiSubgraphs) {
         result.get_node()->set_friendly_name("if_result");
         result.add_names({"if_result:0"});
         model = make_shared<Model>(OutputVector{result}, ParameterVector{cond, param_1, param_2});
+        // set version 10 to use names compatibility mode
+        model->get_rt_info()["version"] = static_cast<int64_t>(10);
 
         type_to_fuse_map empty_type_to_fuse_map = {};
         bool keep_precision_sensitive_in_fp32 = false;
@@ -2401,6 +2407,7 @@ TEST(TransformationTests, ConvertPrecisionExplicitConvertsMultiSubgraphs) {
         if_op->set_input(convert_1, param_1_then, param_1_else);
         if_op->set_input(convert_2, param_2_then, param_2_else);
         auto result = if_op->set_output(result_then, result_else);
+        result.add_names({"if_result:0"});
         auto converted_result = make_shared<opset10::Convert>(result, element::f64);
         converted_result->get_output_tensor(0).add_names({"if_result:0"});
 

src/core/include/openvino/core/descriptor/output.hpp

@@ -42,7 +42,8 @@ class OPENVINO_API Output {
     std::shared_ptr<Tensor> get_tensor_ptr() const {
         return m_tensor;
     }
-    void set_tensor_ptr(const std::shared_ptr<Tensor>& tensor) {
+
+    virtual void set_tensor_ptr(const std::shared_ptr<Tensor>& tensor) {
         m_tensor = tensor;
     }
     void add_input(Input* input);
@@ -70,8 +71,14 @@ class OPENVINO_API Output {
     Output(const Output&) = default;
     Output(Output&&) = default;
     Output& operator=(const Output&) = default;
+    virtual ~Output() = default;
 
 protected:
+    friend void ov::Output<Node>::set_names(const std::unordered_set<std::string>& names);
+    friend void ov::Output<Node>::add_names(const std::unordered_set<std::string>& names);
+    virtual void set_names(const std::unordered_set<std::string>& names);
+    virtual void add_names(const std::unordered_set<std::string>& names);
+
     Node* m_node;
     size_t m_index;
     std::shared_ptr<Tensor> m_tensor;

src/core/include/openvino/core/node.hpp

@@ -122,6 +122,10 @@ class OPENVINO_API Node : public std::enable_shared_from_this<Node> {
     descriptor::Input& get_input_descriptor(size_t position);
     descriptor::Output& get_output_descriptor(size_t position);
 
+    /// @brief  \brief Factory function to make output descriptor.
+    using OutputDescriptorFactory = std::unique_ptr<descriptor::Output> (*)(Node*,
+                                                                            const size_t,
+                                                                            std::shared_ptr<descriptor::Tensor>);
     /// \brief Construct an uninitialized Node
     Node();
     /// \brief Copying a node
@@ -137,6 +141,13 @@ class OPENVINO_API Node : public std::enable_shared_from_this<Node> {
     /// \param arguments Output i will connect to input i
     /// \param output_size Number of outputs for this node
     Node(const OutputVector& arguments, size_t output_size = 1);
+
+    /// \brief Constructor for Node subclasses that have metaclasses.
+    /// \param arguments Output i will connect to input i.
+    /// \param descriptor_factory Creates output descriptor for this node.
+    /// \param output_size Number of outputs for this node (default 1).
+    Node(const OutputVector& arguments, Node::OutputDescriptorFactory descriptor_factory, size_t output_size = 1);
+
     /// \brief Moves nodes that would be deleted from inputs to nodes to avoid stack overflows
     /// on deep networks.
     void safe_delete(NodeVector& nodes, bool recurse);
@@ -437,7 +448,7 @@ class OPENVINO_API Node : public std::enable_shared_from_this<Node> {
     mutable std::atomic_bool m_name_changing{false};
     static std::atomic<size_t> m_next_instance_id;
     std::deque<descriptor::Input> m_inputs;
-    std::deque<descriptor::Output> m_outputs;
+    std::deque<std::unique_ptr<descriptor::Output>> m_outputs;
     RTMap m_rt_info;
 
     // The vector of SharedRTInfo attributes associated to Functions
@@ -452,6 +463,19 @@ class OPENVINO_API Node : public std::enable_shared_from_this<Node> {
     // update of this field by having specific method with mutex.
     void insert_info(std::shared_ptr<SharedRTInfo> info);
     std::mutex m_insert_mutex;
+
+    /// brief Makes default ov::descriptor::Output for Node at port index.
+    ///
+    /// \param node   Node to
+    /// \param i      Output port index.
+    /// \param tensor Shared tensor descriptor connected to this output descriptor.
+    ///
+    /// \return std::unique_ptr<descriptor::Output>
+    static std::unique_ptr<descriptor::Output> make_output_descriptor(Node* node,
+                                                                      const size_t i,
+                                                                      std::shared_ptr<descriptor::Tensor> tensor);
+    /// \brief Holds function factory for output descriptor.
+    OutputDescriptorFactory m_output_descriptor_factory = make_output_descriptor;
 };
 
 using NodeTypeInfo = Node::type_info_t;

src/core/include/openvino/core/preprocess/output_tensor_info.hpp

@@ -47,6 +47,16 @@ class OPENVINO_API OutputTensorInfo final {
     ///
     /// \return Reference to 'this' to allow chaining with other calls in a builder-like manner
     OutputTensorInfo& set_layout(const ov::Layout& layout);
+
+    /// \brief Enable/disable to keep names in compatibility mode (default set).
+    ///
+    /// In compatibility mode the friendly name or tensor names can be moved to node added by PrePostProcessor.
+    /// When compatiblity mode is disabled names will be not moved.
+    ///
+    /// \param compatibility_mode True if compatibility mode, otherwise disabled.
+    ///
+    /// \return Reference to 'this' to allow chaining with other calls in a builder-like manner
+    OutputTensorInfo& set_names_compatibility_mode(const bool compatibility_mode);
 };
 
 }  // namespace preprocess

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

@@ -36,6 +36,7 @@ class OPENVINO_API Op : public Node {
 protected:
     Op() : Node() {}
     Op(const OutputVector& arguments);
+    Op(const OutputVector& arguments, Node::OutputDescriptorFactory desriptor_factory);
 
 public:
     _OPENVINO_HIDDEN_METHOD static const ::ov::Node::type_info_t& get_type_info_static() {

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

@@ -10,9 +10,20 @@
 namespace ov {
 namespace op {
 namespace v0 {
+
 /// \brief Result operation.
 ///
 /// \ingroup ov_ops_cpp_api
+///
+/// The Result operator output is special output which share tensor with node connected to this node.
+/// The Result's output names are visible as model outputs names.
+/// To set these use
+/// - `Result::output(0)::set_names/add_names` to set/add this names on Result's output.
+///
+/// Using `Result::get_output_tensor(0)::set_names/add_names` will set/add names on tensor without modify
+/// Result's output names.
+/// The Result's output names are appended to connected tensor or transferred to new tensor when Result is connected
+/// with new node.
 class OPENVINO_API Result : public Op {
 public:
     OPENVINO_OP("Result", "opset1");

src/core/src/descriptor/input.cpp

@@ -48,7 +48,7 @@ void ov::descriptor::Input::replace_output(Output& new_output) {
 }
 
 void ov::descriptor::Input::replace_output(const std::shared_ptr<ov::Node>& node, size_t i) {
-    replace_output(node->m_outputs.at(i));
+    replace_output(node->get_output_descriptor(i));
 }
 
 void ov::descriptor::Input::remove_output() {

src/core/src/descriptor/output.cpp

@@ -52,3 +52,11 @@ const ov::PartialShape& ov::descriptor::Output::get_partial_shape() const {
 const ov::element::Type& ov::descriptor::Output::get_element_type() const {
     return m_tensor->get_element_type();
 }
+
+void ov::descriptor::Output::set_names(const std::unordered_set<std::string>& names) {
+    get_tensor().set_names(names);
+}
+
+void ov::descriptor::Output::add_names(const std::unordered_set<std::string>& names) {
+    get_tensor().add_names(names);
+}

src/core/src/descriptor/tensor.cpp

@@ -8,6 +8,7 @@
 #include "openvino/core/descriptor_tensor.hpp"
 #include "openvino/core/except.hpp"
 #include "openvino/core/node.hpp"
+#include "openvino/core/type/element_iterator.hpp"
 #include "openvino/op/util/symbolic_info.hpp"
 
 ov::descriptor::Tensor::Tensor(const element::Type& element_type,
@@ -70,9 +71,7 @@ const ov::Shape& ov::descriptor::Tensor::get_shape() const {
 }
 
 size_t ov::descriptor::Tensor::size() const {
-    const bool bitwidth_less_than_byte = m_element_type.bitwidth() < 8;
-    return bitwidth_less_than_byte ? (shape_size(get_shape()) * m_element_type.bitwidth() + 7) >> 3
-                                   : (shape_size(get_shape()) * m_element_type.size());
+    return element::get_memory_size(get_element_type(), shape_size(get_shape()));
 }
 
 const std::unordered_set<std::string>& ov::descriptor::Tensor::get_names() const {
@@ -106,13 +105,8 @@ void ov::descriptor::Tensor::add_names(const std::unordered_set<std::string>& na
 }
 
 void ov::descriptor::Tensor::clone_from(const ov::descriptor::Tensor& old) {
-    {
-        AtomicGuard lock(m_shape_changing);
-        m_partial_shape = old.get_partial_shape();
-        m_shape_changed = true;
-    }
+    set_tensor_type(*this, old.get_element_type(), old.get_partial_shape());
     set_names(old.get_names());
-    m_element_type = old.get_element_type();
     m_lower_value = old.get_lower_value();
     m_upper_value = old.get_upper_value();
     m_value_symbol = old.get_value_symbol();