Merge branch 'master' into cvs_160853

Author: p-durandin

.github/dependabot.yml

@@ -15,14 +15,11 @@ updates:
       timezone: "Poland"
     open-pull-requests-limit: 3
     assignees:
-      - "jiwaszki"
       - "p-wysocki"
       - "akuporos"
       - "rkazants"
       - "ceciliapeng2011"
       - "meiyang-intel"
-      - "mbencer"
-      - "tomdol"
       - "jane-intel"
     versioning-strategy: increase-if-necessary
 

docs/articles_en/documentation/compatibility-and-support/supported-models.rst

@@ -6,7 +6,7 @@ models from OpenVINO-supported frameworks may also work properly but have not be
 
 **AI Models that run on Intel® Core Ultra™ Processors with OpenVINO™ toolkit:**
 
-.. data-table:: 
+.. data-table::
    :class: modeldata stripe
    :name: supportedModelsTable
    :header-rows: 1
@@ -16,13 +16,11 @@ models from OpenVINO-supported frameworks may also work properly but have not be
    :data-page-length: 10
 
 
-| Marked cells indicate models that passed inference with no errors. Empty cells indicate
-  models that were not tested. No failing runs producing an error have been recorded.
+| Marked cells indicate models that passed inference with no errors.
 |
 | In the precision column, the "optimum-intel default" label corresponds to FP32 for small models
   and INT8 for models greater than 1B parameters.
-|
-| The results as of June 17 2024, for OpenVINO version 2024.2.
+| The results as of February 25 2025, for OpenVINO version 2025.0.
 | The models come from different public model repositories, such as Pytorch Model Zoo and
   HuggingFace; they were executed on the designated hardware with OpenVINO either natively or
   as a backend.

docs/sphinx_setup/_static/download/supported_models.csv

@@ -31,6 +31,33 @@ def __dir__(cls) -> list:
 
 class Model(object, metaclass=ModelMeta):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
+        if not args and not kwargs:
+
+            constructors = [
+                "1. openvino.Model(other: openvino.Model)"
+                "2. openvino.Model(results: list[openvino.op.Result], sinks: list[openvino.Node], parameters: list[openvino.op.Parameter], name: str = '')",
+                "3. openvino.Model(results: list[openvino.Node], parameters: list[openvino.op.Parameter], name: str = '')",
+                "4. openvino.Model(result: openvino.Node, parameters: list[openvino.op.Parameter], name: str = '')",
+                "5. openvino.Model(results: list[openvino.Output], parameters: list[openvino.op.Parameter], name: str = '')",
+                "6. openvino.Model(results: list[openvino.Output], sinks: list[openvino.Node], parameters: list[openvino.op.Parameter], name: str = '')",
+                "7. openvino.Model(results: list[openvino.Output], sinks: list[openvino.Output], parameters: list[openvino.op.Parameter], name: str = '')",
+                "8. openvino.Model(results: list[openvino.Output], sinks: list[openvino.Output], parameters: list[openvino.op.Parameter], \
+                                   variables: list[openvino.op.util.Variable], name: str = '')",
+                "9. openvino.Model(results: list[openvino.op.Result], sinks: list[openvino.Output], parameters: list[openvino.op.Parameter], name: str = '')",
+                "10. openvino.Model(results: list[openvino.op.Result], sinks: list[openvino.Output], parameters: list[openvino.op.Parameter], \
+                                    variables: list[openvino.op.util.Variable], name: str = '')",
+                "11. openvino.Model(results: list[openvino.op.Result], sinks: list[openvino.Node], parameters: list[openvino.op.Parameter], \
+                                    variables: list[openvino.op.util.Variable], name: str = '')",
+                "12. openvino.Model(results: list[openvino.Output], sinks: list[openvino.Node], parameters: list[openvino.op.Parameter], \
+                                    variables: list[openvino.op.util.Variable], name: str = '')",
+                "13. openvino.Model(results: list[openvino.op.Result], parameters: list[openvino.op.Parameter], \
+                                    variables: list[openvino.op.util.Variable], name: str = '')",
+                "14. openvino.Model(results: list[openvino.Output], parameters: list[openvino.op.Parameter], \
+                                    variables: list[openvino.op.util.Variable], name: str = '')",
+            ]
+
+            constructor_info = "\n".join(f"  - {ctor}" for ctor in constructors)
+            raise ValueError(f"Model cannot be instantiated without arguments.\n\nAvailable constructors:\n{constructor_info}")
         if args and not kwargs:
             if isinstance(args[0], ModelBase):
                 self.__model = ModelBase(args[0])

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

@@ -84,11 +84,12 @@ def __make_16bit_traceable(model: torch.nn.Module,
      - Replace known list of modules with ModuleExtension.
      - Convert other modules with weights to FP32.
     """
+    supported = {torch.float16, torch.bfloat16, torch.float8_e4m3fn, torch.float8_e5m2}
     if patch_condition is None:
         def patch_condition(module):
-            supported = {torch.float32, torch.float16, torch.bfloat16}
+            dtype_to_patch = {torch.float32, *supported}
             weight = getattr(module, "weight", None)
-            return weight is not None and weight.dtype in supported
+            return weight is not None and weight.dtype in dtype_to_patch
 
     def fp32_tensor(*shape):
         return torch.full(shape, 0.5, dtype=torch.float32)
@@ -123,10 +124,9 @@ def fp32_tensor(*shape):
     except ImportError:
         pass
     patch_model(model, extensions, orig_forward_name)
-    dtype_to_patch = {torch.float16, torch.bfloat16}
     for _, module in model.named_modules():
         if (module.__class__ not in extensions and
-            (any(p.dtype in dtype_to_patch for p in module.parameters(False))
-             or any(b.dtype in dtype_to_patch for b in module.buffers(False)))):
+            (any(p.dtype in supported for p in module.parameters(False))
+             or any(b.dtype in supported for b in module.buffers(False)))):
             log.debug("Casting module %s to float32", module)
             module.float()

src/bindings/python/src/openvino/frontend/pytorch/patch_model.py

@@ -857,3 +857,8 @@ def test_model_dir():
 
     assert type(dir(model)) == list
     assert len(dir(model)) >= num_of_attrs
+
+
+def test_model_without_arguments():
+    with pytest.raises(ValueError, match="Model cannot be instantiated without arguments."):
+        Model()

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

@@ -62,10 +62,10 @@ class ov::pass::KeepConstantsPrecisionAndAddConverts : public MatcherPass {
 
 /**
  * @ingroup ov_transformation_common_api
- * @brief Prevents ConstantFolding for f16/bf16 Const + Convert_To_FP32 to keep original FW float Constants.
+ * @brief Prevents ConstantFolding for low precision Const + Convert_To_FP32 to keep original FW float Constants.
  * Original precision should be kept as long as possible, this prevents redundant conversions and saves memory.
  * E.g. if original FW model was already compressed no need to upcast during CF, store intermediate f32 consts and
- * then again compress them to f16 during save_model.
+ * then again compress them to low precision during save_model.
  */
 class ov::pass::MarkCompressedFloatConstants : public MatcherPass {
 public:

src/common/transformations/include/transformations/fp16_compression/mark_decompression_convert_constant_folding.hpp

@@ -135,7 +135,10 @@ pass::MarkCompressedFloatConstants::MarkCompressedFloatConstants() {
         if (convert_node->get_destination_type() != element::f32)
             return false;
         if (const_node->get_output_element_type(0) != element::f16 &&
-            const_node->get_output_element_type(0) != element::bf16)
+            const_node->get_output_element_type(0) != element::bf16 &&
+            const_node->get_output_element_type(0) != element::f8e4m3 &&
+            const_node->get_output_element_type(0) != element::f8e5m2 &&
+            const_node->get_output_element_type(0) != element::f8e8m0)
             return false;
 
         mark_as_decompression(convert_node);

src/common/transformations/src/transformations/fp16_compression/mark_decompression_convert_constant_folding.cpp

@@ -13,7 +13,7 @@ template <typename T>
 class SharedBuffer : public ov::AlignedBuffer {
 public:
     SharedBuffer(char* data, size_t size, const T& shared_object) : _shared_object(shared_object) {
-        m_allocated_buffer = data;
+        m_allocated_buffer = nullptr;
         m_aligned_buffer = data;
         m_byte_size = size;
     }

src/core/dev_api/openvino/runtime/shared_buffer.hpp

@@ -83,11 +83,7 @@ class ConversionExtensionBase;
 
 template <typename T>
 constexpr bool use_ov_dynamic_cast() {
-#if defined(__ANDROID__) || defined(ANDROID)
-    return true;
-#else
     return std::is_base_of_v<ov::frontend::ConversionExtensionBase, T>;
-#endif
 }
 
 /// \brief Tests if value is a pointer/shared_ptr that can be statically cast to a

src/core/include/openvino/core/type.hpp

@@ -9,9 +9,11 @@
  */
 #pragma once
 
+#include <filesystem>
 #include <type_traits>
 
 #include "openvino/core/coordinate.hpp"
+#include "openvino/core/partial_shape.hpp"
 #include "openvino/core/rtti.hpp"
 #include "openvino/core/shape.hpp"
 #include "openvino/core/type/element_type.hpp"
@@ -259,4 +261,18 @@ class OPENVINO_API Tensor {
  */
 using TensorVector = std::vector<Tensor>;
 
+/// \brief Read a tensor content from a file. Only raw data is loaded.
+/// \param file_name Path to file to read.
+/// \param element_type Element type, when not specified the it is assumed as element::u8.
+/// \param shape Shape for resulting tensor. If provided shape is static, specified number of elements is read only.
+///              File should contain enough bytes, an exception is raised otherwise.
+///              One of the dimensions can be dynamic. In this case it will be determined automatically based on the
+///              length of the file content and `offset`. Default value is [?].
+/// \param offset_in_bytes Read file starting from specified offset. Default is 0. The remining size of the file should
+/// be compatible with shape.
+OPENVINO_API
+Tensor read_tensor_data(const std::filesystem::path& file_name,
+                        const element::Type& element_type = element::u8,
+                        const PartialShape& shape = PartialShape::dynamic(1),
+                        std::size_t offset_in_bytes = 0);
 }  // namespace ov

src/core/include/openvino/runtime/tensor.hpp

@@ -16,6 +16,7 @@
 #include "transformations/common_optimizations/convolution_to_group_convolution_fusion.hpp"
 #include "transformations/common_optimizations/disable_random_uniform_constant_folding.hpp"
 #include "transformations/common_optimizations/disable_shapeof_constant_folding.hpp"
+#include "transformations/common_optimizations/gelu_fusion.hpp"
 #include "transformations/common_optimizations/mul_conv_fusion.hpp"
 #include "transformations/common_optimizations/ric_fusion.hpp"
 #include "transformations/common_optimizations/shared_ops_optimization.hpp"
@@ -89,12 +90,14 @@ void transformation_pipeline(std::shared_ptr<ov::Model>& model) {
 
     // 2. Fusion transformations:
     REGISTER_PASS(manager, ConvertDivideWithConstant)
-    auto multiply_fusions = manager.register_pass<GraphRewrite>();
-    ADD_MATCHER(multiply_fusions, MultiplyConvolutionFusion)
-    ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionFusion)
-    ADD_MATCHER(multiply_fusions, MultiplyConvolutionBackpropDataFusion)
-    ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionBackpropDataFusion)
-    multiply_fusions->set_name("ov::pass::MultiplyFusions");
+    auto fusions = manager.register_pass<GraphRewrite>();
+    // Gelu fusion have to be executed before MulConv fusion because Mul(X, 0.5) might be fused to Conv weights
+    ADD_MATCHER(fusions, GeluFusion)
+    ADD_MATCHER(fusions, MultiplyConvolutionFusion)
+    ADD_MATCHER(fusions, MultiplyGroupConvolutionFusion)
+    ADD_MATCHER(fusions, MultiplyConvolutionBackpropDataFusion)
+    ADD_MATCHER(fusions, MultiplyGroupConvolutionBackpropDataFusion)
+    fusions->set_name("ov::pass::MultiplyFusions");
     REGISTER_PASS(manager, ReverseInputChannelsFusion)
 
     // 3. CF call due to detected perf degradations

src/core/src/preprocess/pre_post_process.cpp

@@ -11,9 +11,13 @@
 #include "openvino/core/shape.hpp"
 #include "openvino/core/shape_util.hpp"
 #include "openvino/core/strides.hpp"
+#include "openvino/core/tensor_util.hpp"
+#include "openvino/core/type/element_iterator.hpp"
 #include "openvino/runtime/itensor.hpp"
 #include "openvino/runtime/make_tensor.hpp"
 #include "openvino/runtime/remote_tensor.hpp"
+#include "openvino/runtime/shared_buffer.hpp"
+#include "openvino/util/mmap_object.hpp"
 
 namespace ov {
 
@@ -108,4 +112,76 @@ bool Tensor::is_continuous() const {
     OV_TENSOR_STATEMENT(return _impl->is_continuous());
 }
 
+namespace {
+ov::Shape calc_static_shape_for_file(const std::filesystem::path& file_name,
+                                     const ov::element::Type& element_type,
+                                     const ov::PartialShape& partial_shape,
+                                     size_t offset) {
+    auto file_size = std::filesystem::file_size(file_name);
+    if (partial_shape.is_static()) {
+        auto static_shape = partial_shape.get_shape();
+        OPENVINO_ASSERT((ov::shape_size(static_shape)) * element_type.bitwidth() + offset * 8 == file_size * 8,
+                        "Cannot fit file size into requested static PartialShape");
+        return static_shape;
+    }
+    auto partial_shape_copy = partial_shape;
+    auto rank = partial_shape_copy.rank();
+    OPENVINO_ASSERT(rank.is_static(), "Rank cannot be dynamic");
+    std::vector<size_t> dynamic_dimension_numbers;
+    size_t slice_size = 1;
+    for (size_t id = 0; id < partial_shape_copy.size(); ++id) {
+        if (partial_shape_copy[id].is_dynamic()) {
+            dynamic_dimension_numbers.push_back(id);
+        } else {
+            slice_size *= partial_shape_copy[id].get_min_length();
+        }
+    }
+    OPENVINO_ASSERT(dynamic_dimension_numbers.size() == 1,
+                    "Only one dynamic dimension in input shape is supported but got: ",
+                    dynamic_dimension_numbers.size());
+    auto& dynamic_dimension = partial_shape_copy[dynamic_dimension_numbers[0]];
+
+    OPENVINO_ASSERT(file_size > offset, "Offset is bigger than size of file to read.");
+    auto file_size_to_read = file_size - offset;
+
+    OPENVINO_ASSERT((file_size_to_read * 8) % element_type.bitwidth() == 0,
+                    "cannot fit ",
+                    element_type.get_type_name(),
+                    " into ",
+                    file_size_to_read,
+                    " bytes");
+    auto elements_to_read = file_size_to_read * 8 / element_type.bitwidth();
+
+    auto new_dimension_size = elements_to_read / slice_size;
+    OPENVINO_ASSERT(new_dimension_size * slice_size == elements_to_read,
+                    "Cannot fit file size into requested PartialShape");
+
+    OPENVINO_ASSERT(dynamic_dimension.compatible(new_dimension_size),
+                    "Cannot fit file size into requested PartialShape");
+
+    dynamic_dimension = Dimension(new_dimension_size);
+    return partial_shape_copy.get_shape();
+}
+}  // namespace
+
+Tensor read_tensor_data(const std::filesystem::path& file_name,
+                        const ov::element::Type& element_type,
+                        const ov::PartialShape& partial_shape,
+                        size_t offset_in_bytes) {
+    OPENVINO_ASSERT(element_type != ov::element::string);
+    auto static_shape = calc_static_shape_for_file(file_name, element_type, partial_shape, offset_in_bytes);
+
+    auto mapped_memory = ov::load_mmap_object(file_name);
+    auto shared_buffer =
+        std::make_shared<ov::SharedBuffer<std::shared_ptr<ov::MappedMemory>>>(mapped_memory->data() + offset_in_bytes,
+                                                                              mapped_memory->size() - offset_in_bytes,
+                                                                              mapped_memory);
+
+    auto view_tensor = Tensor(element_type, static_shape, shared_buffer->get_ptr());
+    auto impl = get_tensor_impl(view_tensor);
+    impl._so = shared_buffer;
+    view_tensor = make_tensor(impl);
+
+    return view_tensor;
+}
 }  // namespace ov

src/core/src/runtime/tensor.cpp

@@ -2,6 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#define _USE_MATH_DEFINES
+
+#include <math.h>
+
 #include "common_test_utils/ov_test_utils.hpp"
 #include "common_test_utils/test_assertions.hpp"
 #include "common_test_utils/test_tools.hpp"
@@ -2504,3 +2508,50 @@ TEST_F(TransformationTestsF, preprocessing_conv_decompression) {
         model_ref = std::make_shared<ov::Model>(ResultVector{res}, ParameterVector{input});
     }
 }
+
+TEST_F(TransformationTestsF, preprocessing_gelu_fusion) {
+    auto in_shape = Shape{1, 3, 32, 32};
+    auto in_type = element::f32;
+    auto weight_type = element::f32;
+    {
+        auto data = std::make_shared<ov::op::v0::Parameter>(in_type, in_shape);
+
+        auto mul_const_sqrt_1_2 = ov::op::v0::Constant::create(in_type, Shape{1}, {M_SQRT1_2});
+        auto mul_to_erf = std::make_shared<ov::op::v1::Multiply>(data, mul_const_sqrt_1_2);
+        auto erf = std::make_shared<ov::op::v0::Erf>(mul_to_erf);
+
+        auto add_const = ov::op::v0::Constant::create(in_type, Shape{1}, {1.0});
+        auto add = std::make_shared<ov::op::v1::Add>(erf, add_const);
+        auto mul_first = std::make_shared<ov::op::v1::Multiply>(data, add);
+
+        auto mul_const = ov::op::v0::Constant::create(in_type, Shape{1}, {0.5});
+        auto mul = std::make_shared<ov::op::v1::Multiply>(mul_first, mul_const);
+
+        std::shared_ptr<Node> weights = std::make_shared<op::v0::Constant>(weight_type, ov::Shape{1, 3, 3, 3}, 1);
+        auto conv = std::make_shared<op::v1::Convolution>(mul,
+                                                          weights,
+                                                          Strides{},
+                                                          CoordinateDiff{},
+                                                          CoordinateDiff{},
+                                                          Strides{});
+        auto res = std::make_shared<op::v0::Result>(conv);
+        auto f = std::make_shared<ov::Model>(ov::ResultVector{res}, ov::ParameterVector{data});
+        auto p = PrePostProcessor(f);
+        model = p.build();
+    }
+
+    {
+        auto input = std::make_shared<op::v0::Parameter>(in_type, in_shape);
+
+        auto gelu = std::make_shared<op::v7::Gelu>(input);
+        auto weights = op::v0::Constant::create(weight_type, ov::Shape({1, 3, 3, 3}), {1.f});
+        auto conv = std::make_shared<op::v1::Convolution>(gelu,
+                                                          weights,
+                                                          Strides{},
+                                                          CoordinateDiff{},
+                                                          CoordinateDiff{},
+                                                          Strides{});
+        auto res = std::make_shared<op::v0::Result>(conv);
+        model_ref = std::make_shared<ov::Model>(ResultVector{res}, ParameterVector{input});
+    }
+}