Merge branch 'master' into yet_another_staging_testing

Author: ababushk

docs/articles_en/openvino-workflow/running-inference/optimize-inference/precision-control.rst

@@ -94,6 +94,35 @@ capabilities).
    for ``inference_precision`` attribute.
 
 
+Activation Scaling
+###################
+
+Since ``f16`` has a smaller dynamic range compared to ``f32`` or ``bf16``, overflow might occur when using ``f16`` for ``inference_precision``.
+To address this issue, activation scaling divides the input of linear operations such as ``MatMul`` or ``Convolution`` by an activations scale factor, ensuring the layer's output does not exceed ``f16``'s dynamic range.
+
+The layer's output is then multiplied back by the activations scale factor to restore its original value, but overflow can occur again during this process.
+Activation scaling uses :doc:`LPT (Low Precision Transformations) <../../../documentation/openvino-extensibility/openvino-plugin-library/advanced-guides/low-precision-transformations>` to delay multiplication by the scale factor as much as possible, preventing overflow.
+The activations scale factor can be specified in the ``rt_info`` of the model IR or via ``ov::hint::activations_scale_factor``.
+Currently, this property is supported on GPU.
+
+.. scrollbox::   
+
+   .. code-block:: cpp
+
+      <?xml version="1.0" ?>
+      <net name="model_file_name" version="10">
+         ...
+         <rt_info>
+            ...
+            <runtime_options>
+                  <ACTIVATIONS_SCALE_FACTOR value="8.0" />
+            </runtime_options>
+            ...
+         </rt_info>
+      </net>
+
+
+
 .. _limited_inference_precision:
 
 Limitation of the ``bf16`` inference precision

src/bindings/c/include/openvino/c/openvino.h

@@ -37,3 +37,4 @@
 #include "openvino/c/ov_remote_context.h"
 #include "openvino/c/ov_shape.h"
 #include "openvino/c/ov_tensor.h"
+#include "openvino/c/ov_util.h"

src/bindings/c/include/openvino/c/ov_util.h

@@ -0,0 +1,27 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/c/ov_common.h"
+
+/**
+ * @brief Callback function type for logging messages.
+ * @param message The log message as a null-terminated C string.
+ */
+typedef void (*ov_util_log_callback_func)(const char* message);
+
+/**
+ * @brief Sets user log message handling callback.
+ * @param [in] func The function pointer to user-defined message logging callback.
+ *                  Null pointer is accepted (no logging).
+ */
+OPENVINO_C_API(void)
+ov_util_set_log_callback(ov_util_log_callback_func func);
+
+/**
+ * @brief Resets log message handling callback to its default (standard output).
+ */
+OPENVINO_C_API(void)
+ov_util_reset_log_callback();

src/bindings/c/src/ov_util.cpp

@@ -0,0 +1,23 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "openvino/c/ov_util.h"
+
+#include "openvino/core/log.hpp"
+
+void ov_util_set_log_callback(ov_util_log_callback_func f) {
+    if (f) {
+        static std::function<void(std::string_view)> callback;
+        callback = [f](std::string_view msg) {
+            f(msg.data());
+        };
+        ov::util::set_log_callback(callback);
+    } else {
+        ov::util::set_log_callback({});
+    }
+}
+
+void ov_util_reset_log_callback() {
+    ov::util::reset_log_callback();
+}

src/bindings/c/tests/ov_util_test.cpp

@@ -0,0 +1,53 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <gtest/gtest.h>
+
+#include <cstring>
+
+#include "openvino/c/openvino.h"
+#include "openvino/util/log.hpp"
+
+namespace {
+void test_log_msg(const char* msg) {
+    ov::util::LogHelper{ov::util::LOG_TYPE::_LOG_TYPE_INFO, "1664804", 101}.stream() << msg;
+}
+
+std::string got_message;
+void callback_func(const char* msg) {
+    got_message = msg;
+}
+bool compare_msg(const char* msg) {
+    const auto msg_size = std::strlen(msg);
+    if (got_message.size() < msg_size) {
+        return false;
+    }
+    return std::strncmp(msg, got_message.data() + got_message.size() - msg_size, msg_size) == 0;
+}
+}  // namespace
+
+TEST(ov_util, set_log_callback) {
+    got_message.clear();
+    test_log_msg("default");
+    EXPECT_TRUE(got_message.empty());
+    ov_util_set_log_callback(&callback_func);
+    const char test_msg[] = "callback";
+    test_log_msg(test_msg);
+    EXPECT_TRUE(compare_msg(test_msg));
+}
+
+TEST(ov_util, reset_log_callback) {
+    got_message.clear();
+    ov_util_set_log_callback(&callback_func);
+    ov_util_reset_log_callback();
+    test_log_msg("default");
+    EXPECT_TRUE(got_message.empty());
+}
+
+TEST(ov_util, no_log_callback) {
+    got_message.clear();
+    ov_util_set_log_callback(NULL);
+    EXPECT_NO_THROW(test_log_msg("default"));
+    EXPECT_TRUE(got_message.empty());
+}

src/core/shape_inference/include/pad_shape_inference.hpp

@@ -123,16 +123,16 @@ std::vector<TRShape> shape_infer(const util::PadBase* op,
                 }
             }
         } else {
-            NODE_SHAPE_INFER_CHECK(
-                op,
-                input_shapes,
-                pads_begin_rank.is_dynamic() || cmp::le(pads_begin_shape[0].get_length(), arg_rank_len),
-                "Number of elements of pads_begin must be >= 0 and <= arg rank");
-            NODE_SHAPE_INFER_CHECK(
-                op,
-                input_shapes,
-                pads_begin_rank.is_dynamic() || cmp::le(pads_end_shape[0].get_length(), arg_rank_len),
-                "Number of elements of pads_end must be >= 0 and <= arg rank");
+            NODE_SHAPE_INFER_CHECK(op,
+                                   input_shapes,
+                                   pads_begin_rank.is_dynamic() || pads_begin_shape[0].is_dynamic() ||
+                                       cmp::le(pads_begin_shape[0].get_length(), arg_rank_len),
+                                   "Number of elements of pads_begin must be >= 0 and <= arg rank");
+            NODE_SHAPE_INFER_CHECK(op,
+                                   input_shapes,
+                                   pads_end_rank.is_dynamic() || pads_end_shape[0].is_dynamic() ||
+                                       cmp::le(pads_end_shape[0].get_length(), arg_rank_len),
+                                   "Number of elements of pads_end must be >= 0 and <= arg rank");
             output_shape.resize(arg_shape_rank.get_length());
         }
     } else {

src/core/tests/type_prop/pad.cpp

@@ -280,6 +280,24 @@ TYPED_TEST_P(PadTest, pad_begin_and_end_has_inf_interval_as_bounds) {
     EXPECT_THAT(get_shape_symbols(pad->get_output_partial_shape(0)), Each(nullptr));
 }
 
+TYPED_TEST_P(PadTest, pad_begin_and_end_dynamic) {
+    auto arg_shape = PartialShape{9, {3, 5}, {3, 5}, {3, 4}, {3, 4}};
+    auto begin_shape = PartialShape{-1};
+    auto end_shape = PartialShape{-1};
+    set_shape_symbols(arg_shape);
+    set_shape_symbols(begin_shape);
+    set_shape_symbols(end_shape);
+
+    auto arg = make_shared<op::v0::Parameter>(element::f32, arg_shape);
+    auto begin = make_shared<op::v0::Parameter>(element::i32, begin_shape);
+    auto end = make_shared<op::v0::Parameter>(element::i32, end_shape);
+
+    auto pad = this->make_op(arg, begin, end, op::PadMode::CONSTANT);
+
+    EXPECT_EQ(pad->get_output_partial_shape(0), PartialShape({-1, -1, -1, -1, -1}));
+    EXPECT_THAT(get_shape_symbols(pad->get_output_partial_shape(0)), Each(nullptr));
+}
+
 REGISTER_TYPED_TEST_SUITE_P(PadTest,
                             pad_default_ctor,
                             pad_arg_pad_value_type_mismatch,
@@ -301,7 +319,8 @@ REGISTER_TYPED_TEST_SUITE_P(PadTest,
                             pad_dynamic_input_type_with_static_value,
                             pad_preserve_partial_values_and_symbols_via_evaluates_bounds,
                             pad_begin_and_end_has_inf_interval_as_bounds,
-                            pad_preserve_partial_values_and_symbols_on_inputs);
+                            pad_preserve_partial_values_and_symbols_on_inputs,
+                            pad_begin_and_end_dynamic);
 
 using PadOpTypes = Types<op::v1::Pad, op::v12::Pad>;
 INSTANTIATE_TYPED_TEST_SUITE_P(type_prop, PadTest, PadOpTypes);

src/frontends/common_translators/include/common_translators.hpp

@@ -22,6 +22,8 @@ COMMON_OP_CONVERTER(translate_erfc);
 
 COMMON_OP_CONVERTER(translate_equal);
 
+COMMON_OP_CONVERTER(translate_unsqueeze);
+
 OutputVector translate_atan2_util(const NodeContext& context, const Output<Node>& lhs, const Output<Node>& rhs);
 OutputVector translate_erfc_util(const NodeContext& context, const Output<Node>& data);
 

src/frontends/common_translators/src/op/unsqueeze.cpp

@@ -0,0 +1,56 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "openvino/op/unsqueeze.hpp"
+
+#include "common_translators.hpp"
+#include "openvino/core/validation_util.hpp"
+#include "openvino/frontend/complex_type_mark.hpp"
+#include "openvino/op/convert.hpp"
+#include "openvino/op/less.hpp"
+#include "openvino/op/select.hpp"
+#include "openvino/op/subtract.hpp"
+#include "utils.hpp"
+
+using namespace ov::op;
+
+namespace ov {
+namespace frontend {
+namespace common_translators {
+
+OutputVector translate_unsqueeze(const NodeContext& context) {
+    num_inputs_check(context, 2, 2, true);
+    auto x = context.get_input(0);
+    auto dim = context.get_input(1);
+
+    auto complex = as_type_ptr<ComplexTypeMark>(x.get_node_shared_ptr());
+    bool is_complex = complex != nullptr;
+
+    if (is_complex) {
+        if (dim.get_element_type() != element::i32) {
+            dim = context.mark_node(std::make_shared<v0::Convert>(dim, element::i32));
+        }
+
+        auto data = complex->get_input_source_output(0);
+
+        auto one = context.mark_node(v0::Constant::create(element::i32, Shape{1}, {1}));
+
+        auto zero = context.mark_node(v0::Constant::create(element::i32, Shape{1}, {0}));
+
+        auto neg_dim = context.mark_node(std::make_shared<v1::Subtract>(dim, one));
+        auto zero_cond = context.mark_node(std::make_shared<v1::Less>(dim, zero));
+        auto new_dim = context.mark_node(std::make_shared<v1::Select>(zero_cond, neg_dim, dim));
+        const auto dim_const = ov::util::get_constant_from_source(new_dim);
+        auto res = context.mark_node(std::make_shared<v0::Unsqueeze>(data, dim_const));
+        res = context.mark_node(std::make_shared<ComplexTypeMark>(res));
+        return {res};
+    }
+
+    auto res = context.mark_node(std::make_shared<v0::Unsqueeze>(x, dim));
+    return {res};
+};
+
+}  // namespace common_translators
+}  // namespace frontend
+}  // namespace ov

src/frontends/pytorch/src/frontend.cpp

@@ -32,7 +32,6 @@
 #include "transforms/index_loop_getitem_replacer.hpp"
 #include "transforms/listconstruct_replacer.hpp"
 #include "transforms/min_max_prim_list_construct_replacer.hpp"
-#include "transforms/prim_list_construct_pad.hpp"
 #include "transforms/prim_list_tuple_construct_replacer.hpp"
 #include "transforms/prim_list_unpack_replacer.hpp"
 #include "transforms/prim_unpack_parameter_replacer.hpp"
@@ -317,7 +316,6 @@ void FrontEnd::normalize(const std::shared_ptr<ov::Model>& model) const {
     // TODO: remove AtenIndexToSelect when problem with  dynamic input rank is gone.
     manager.register_pass<ov::frontend::pytorch::pass::AtenIndexToSelect>();
     manager.register_pass<ov::frontend::pytorch::pass::AtenIndexPutReplacer>();
-    manager.register_pass<ov::frontend::pytorch::pass::PrimListConstructPadReplacer>();
     manager.register_pass<ov::frontend::pytorch::pass::IndexLoopGetitemReplacer>();
 
     // Check if model is symmetrically quantized