[PT FE] [ONNX FE] Partially upcast random_normal to f32 (#21400)

* upcast randn to fp32 * style fix * corrected tests * add layer tests with statistics * style-fix * move make_random_normal to cmmmon * style-fix * added randn layer tests; updated CMakeLists.txt * moved to inline * fix problem with _USE_MATH_DEFINES on Win * pass NodeRegistry as reference; some other minor corrections * adjust thresholds to avoid sporadicity * move random_normal_helper and hide from public api * fix install * fix install: 2nd try * Frontend common * remove last frontend_common::static * build fix * try to fix mock1 build: 2nd attempt * try to fix mock1 build: 3rd attempt * Update src/core/tests/CMakeLists.txt * Fixed build: attemp 2 * Update src/plugins/intel_cpu/tests/unit/CMakeLists.txt * Update CMakeLists.txt --------- Co-authored-by: Ilya Lavrenov <[email protected]>
openvinotoolkit · Dec 7, 2023 · b71906c · b71906c
1 parent c61de14
commit b71906c
Show file tree

Hide file tree

Showing 19 changed files with 229 additions and 166 deletions.
diff --git a/cmake/developer_package/frontends/frontends.cmake b/cmake/developer_package/frontends/frontends.cmake
@@ -57,10 +57,10 @@ function(ov_generate_frontends_hpp)
     # for some reason dependency on source files does not work
     # so, we have to use explicit target and make it dependency for frontend_common
     add_custom_target(_ov_frontends_hpp DEPENDS ${ov_frontends_hpp})
-    add_dependencies(frontend_common_obj _ov_frontends_hpp)
+    add_dependencies(openvino_frontend_common_obj _ov_frontends_hpp)
 
     # add dependency for object files
-    get_target_property(sources frontend_common_obj SOURCES)
+    get_target_property(sources openvino_frontend_common_obj SOURCES)
     foreach(source IN LISTS sources)
         if("${source}" MATCHES "\\$\\<TARGET_OBJECTS\\:([A-Za-z0-9_]*)\\>")
             # object library
@@ -220,6 +220,7 @@ macro(ov_add_frontend)
             PUBLIC
                 $<BUILD_INTERFACE:${${TARGET_NAME}_INCLUDE_DIR}>
             PRIVATE
+                $<TARGET_PROPERTY:openvino::frontend::common,INTERFACE_INCLUDE_DIRECTORIES>
                 ${frontend_root_dir}/src
                 ${CMAKE_CURRENT_BINARY_DIR})
 

diff --git a/src/cmake/openvino.cmake b/src/cmake/openvino.cmake
@@ -21,7 +21,7 @@ endif()
 add_library(${TARGET_NAME}
     $<TARGET_OBJECTS:ngraph_obj>
     $<TARGET_OBJECTS:ngraph_obj_version>
-    $<TARGET_OBJECTS:frontend_common_obj>
+    $<TARGET_OBJECTS:openvino_frontend_common_obj>
     $<TARGET_OBJECTS:inference_engine_obj>
     $<TARGET_OBJECTS:inference_engine_obj_version>
     $<TARGET_OBJECTS:inference_engine_transformations_obj>

diff --git a/src/core/tests/frontend/CMakeLists.txt b/src/core/tests/frontend/CMakeLists.txt
@@ -12,7 +12,7 @@ target_compile_definitions(${MOCK1_FE_NAME} PRIVATE "-DMOCK_VARIANT=\"1\"")
 
 target_include_directories(${MOCK1_FE_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
-target_link_libraries(${MOCK1_FE_NAME} PRIVATE frontend_common)
+target_link_libraries(${MOCK1_FE_NAME} PRIVATE openvino::frontend::common)
 add_dependencies(ov_core_unit_tests ${MOCK1_FE_NAME})
 
 ov_add_clang_format_target(${MOCK1_FE_NAME}_clang FOR_TARGETS ${MOCK1_FE_NAME})

diff --git a/src/frontends/common/CMakeLists.txt b/src/frontends/common/CMakeLists.txt
@@ -2,18 +2,33 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-set(TARGET_NAME "frontend_common")
+set(TARGET_NAME "openvino_frontend_common")
+
+set(FRONTEND_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
+set(FRONTEND_DEV_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/dev_api)
 
 file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
 file(GLOB_RECURSE LIBRARY_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp)
 file(GLOB_RECURSE LIBRARY_PUBLIC_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp)
 
-set(FRONTEND_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
-
 source_group("src" FILES ${LIBRARY_SRC})
 source_group("include" FILES ${LIBRARY_HEADERS})
 source_group("public include" FILES ${LIBRARY_PUBLIC_HEADERS})
 
+# create frontend common library
+
+add_library(${TARGET_NAME} INTERFACE)
+
+target_include_directories(${TARGET_NAME} INTERFACE
+    $<BUILD_INTERFACE:${FRONTEND_DEV_INCLUDE_DIR}>
+    $<BUILD_INTERFACE:${FRONTEND_INCLUDE_DIR}>)
+
+target_link_libraries(${TARGET_NAME} INTERFACE openvino::runtime)
+
+add_library(openvino::frontend::common ALIAS ${TARGET_NAME})
+
+ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
+
 # create library
 
 add_library(${TARGET_NAME}_obj OBJECT ${LIBRARY_SRC} ${LIBRARY_HEADERS} ${LIBRARY_PUBLIC_HEADERS})
@@ -23,7 +38,7 @@ target_include_directories(${TARGET_NAME}_obj
         $<BUILD_INTERFACE:${FRONTEND_INCLUDE_DIR}>
     PRIVATE
         ${CMAKE_CURRENT_SOURCE_DIR}/src
-        $<TARGET_PROPERTY:ngraph,INTERFACE_INCLUDE_DIRECTORIES>
+        $<TARGET_PROPERTY:openvino::frontend::common,INTERFACE_INCLUDE_DIRECTORIES>
         # for ov_frontends.hpp in static build
         ${CMAKE_CURRENT_BINARY_DIR}/src)
 
@@ -60,17 +75,6 @@ ov_ncc_naming_style(FOR_TARGET ${TARGET_NAME}_obj
                     ADDITIONAL_INCLUDE_DIRECTORIES
                         $<TARGET_PROPERTY:ngraph,INTERFACE_INCLUDE_DIRECTORIES>)
 
-# INTERFACE library for BW compatibility
-
-add_library(${TARGET_NAME} INTERFACE)
-target_link_libraries(${TARGET_NAME} INTERFACE openvino::runtime)
-target_include_directories(${TARGET_NAME} INTERFACE $<BUILD_INTERFACE:${FRONTEND_INCLUDE_DIR}>
-    $<BUILD_INTERFACE:$<TARGET_PROPERTY:ngraph,INTERFACE_INCLUDE_DIRECTORIES>>)
-
-add_library(ngraph::${TARGET_NAME} ALIAS ${TARGET_NAME})
-add_library(openvino::frontend::common ALIAS ${TARGET_NAME})
-add_library(${TARGET_NAME}::static ALIAS ${TARGET_NAME})
-
 # Installation rules header files
 
 install(DIRECTORY ${FRONTEND_INCLUDE_DIR}/openvino

diff --git a/src/frontends/common/dev_api/openvino/frontend/common/random_normal_helper.hpp b/src/frontends/common/dev_api/openvino/frontend/common/random_normal_helper.hpp
@@ -0,0 +1,42 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "ngraph/output_vector.hpp"
+#include "openvino/frontend/visibility.hpp"
+#include "openvino/pass/graph_rewrite.hpp"
+
+namespace ov {
+namespace frontend {
+
+/// \brief Creates a random normal tensor with the given shape and type.
+/// \details Uses Box-Mueller algorithm to generate random numbers from a Gauassian distribution
+/// \param sizes Shape of the output tensor
+/// \param target_type Type of the output tensor
+/// \param mean Mean of the distribution
+/// \param scale Standard deviation of the distribution
+/// \param seed Seed for the random number generator
+FRONTEND_API OutputVector make_random_normal(pass::NodeRegistry& registry,
+                                       const Output<Node>& sizes,
+                                       element::Type target_type,
+                                       const Output<Node>& mean,
+                                       const Output<Node>& scale,
+                                       float seed);
+
+/// \brief Creates a random normal tensor with the given shape and type.
+/// \details Uses Box-Mueller algorithm to generate random numbers from a Gauassian distribution
+/// \param sizes Shape of the output tensor
+/// \param target_type Type of the output tensor
+/// \param mean Mean of the distribution
+/// \param scale Standard deviation of the distribution
+/// \param seed Seed for the random number generator
+FRONTEND_API std::pair<OutputVector, pass::NodeRegistry> make_random_normal(const Output<Node>& sizes,
+                                                                      element::Type target_type,
+                                                                      const Output<Node>& mean,
+                                                                      const Output<Node>& scale,
+                                                                      float seed);
+
+}  // namespace frontend
+}  // namespace ov
diff --git a/src/frontends/common/include/openvino/frontend/visibility.hpp b/src/frontends/common/include/openvino/frontend/visibility.hpp
@@ -9,7 +9,7 @@
 // Increment each time when FrontEnd/InputModel/Place interface is changed
 #define OV_FRONTEND_API_VERSION 1
 
-#if defined(USE_STATIC_FRONTEND_COMMON) || defined(OPENVINO_STATIC_LIBRARY)
+#if defined(OPENVINO_STATIC_LIBRARY)
 #    define FRONTEND_API
 #    define FRONTEND_C_API
 #else
@@ -20,5 +20,5 @@
 #    else
 #        define FRONTEND_API   OPENVINO_CORE_IMPORTS
 #        define FRONTEND_C_API OPENVINO_EXTERN_C OPENVINO_CORE_IMPORTS
-#    endif  // frontend_common_EXPORTS
-#endif      // USE_STATIC_FRONTEND_COMMON || OPENVINO_STATIC_LIBRARY
+#    endif  // openvino_frontend_common_EXPORTS
+#endif      // OPENVINO_STATIC_LIBRARY
diff --git a/src/frontends/common/src/random_normal_helper.cpp b/src/frontends/common/src/random_normal_helper.cpp
@@ -0,0 +1,77 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "openvino/frontend/common/random_normal_helper.hpp"
+
+#include "ngraph/output_vector.hpp"
+#include "openvino/op/constant.hpp"
+#include "openvino/opsets/opset12.hpp"
+#include "openvino/pass/graph_rewrite.hpp"
+#include "transformations/rt_info/disable_fp16_compression.hpp"
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+namespace ov {
+namespace frontend {
+
+OutputVector make_random_normal(pass::NodeRegistry& registry,
+                                const Output<Node>& sizes,
+                                element::Type target_type,
+                                const Output<Node>& mean,
+                                const Output<Node>& scale,
+                                float seed) {
+    // We start by generating two random series from a uniform distribution
+    const uint64_t global_seed = 0;
+
+    // ONNX specifies the seed as a float, but OpenVINO uses uint64_t
+    const auto op_seed = static_cast<uint64_t>(seed * 1000);
+
+    // We need to use two op_seeds to make sure we get different results for two RandomUniform series
+    // But we also have to keep original logic and pass "0" (auto-generated seed) to RandomUniform
+    const uint64_t seed_1 = op_seed;
+    const uint64_t seed_2 = (op_seed == 0 ? op_seed : op_seed + 10000);
+
+    auto min_val = registry.make<op::v0::Constant>(target_type, Shape{1}, std::numeric_limits<float>::min());
+    auto max_val = registry.make<op::v0::Constant>(target_type, Shape{1}, 1);
+
+    auto uniform_1 = registry.make<op::v8::RandomUniform>(sizes, min_val, max_val, target_type, global_seed, seed_1);
+    auto uniform_2 = registry.make<op::v8::RandomUniform>(sizes, min_val, max_val, target_type, global_seed, seed_2);
+
+    // Compute Box–Muller transform
+    // random_normal = scale * sqrt(-2.0 * log(uniform_1)) * cos(2.0 * pi * uniform_2) + mean
+    auto pi = registry.make<op::v0::Constant>(target_type, Shape{1}, M_PI);
+    auto minus_two = registry.make<op::v0::Constant>(target_type, Shape{1}, -2.0);
+    auto two = registry.make<op::v0::Constant>(target_type, Shape{1}, 2.0);
+
+    auto log = registry.make<op::v0::Log>(uniform_1);
+    auto multiply_minus_two_log = registry.make<op::v1::Multiply>(log, minus_two);
+    auto sqrt = registry.make<op::v0::Sqrt>(multiply_minus_two_log);
+
+    auto multiply_2pi = registry.make<op::v1::Multiply>(two, pi);
+    auto multiply_2pi_uniform_2 = registry.make<op::v1::Multiply>(multiply_2pi, uniform_2);
+    auto cos = registry.make<op::v0::Cos>(multiply_2pi_uniform_2);
+
+    auto sqrt_x_cos = registry.make<op::v1::Multiply>(sqrt, cos);
+    auto product = registry.make<op::v1::Multiply>(scale, sqrt_x_cos);
+    auto sum = registry.make<op::v1::Add>(product, mean);
+
+    // if we don't disable down-casting then log(float32_min) gives -inf
+    disable_fp16_compression(uniform_1);
+    disable_fp16_compression(log);
+
+    return {sum};
+}
+
+std::pair<OutputVector, pass::NodeRegistry> make_random_normal(const Output<Node>& sizes,
+                                                               element::Type target_type,
+                                                               const Output<Node>& mean,
+                                                               const Output<Node>& scale,
+                                                               float seed) {
+    pass::NodeRegistry registry;
+    OutputVector res = make_random_normal(registry, sizes, target_type, mean, scale, seed);
+    return std::make_pair(res, registry);
+}
+
+}  // namespace frontend
+}  // namespace ov
diff --git a/src/frontends/onnx/frontend/CMakeLists.txt b/src/frontends/onnx/frontend/CMakeLists.txt
@@ -16,9 +16,7 @@ target_compile_definitions(${TARGET_NAME} PRIVATE ONNX_OPSET_VERSION=${ONNX_OPSE
 ov_ncc_naming_style(FOR_TARGET ${TARGET_NAME}
                     SOURCE_DIRECTORIES "${${TARGET_NAME}_INCLUDE_DIR}"
                     DEFINITIONS
-                        $<TARGET_PROPERTY:onnx,INTERFACE_COMPILE_DEFINITIONS>
-                    ADDITIONAL_INCLUDE_DIRECTORIES
-                        $<TARGET_PROPERTY:frontend_common::static,INTERFACE_INCLUDE_DIRECTORIES>)
+                        $<TARGET_PROPERTY:onnx,INTERFACE_COMPILE_DEFINITIONS>)
 
 install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/onnx_import
         DESTINATION ${FRONTEND_INSTALL_INCLUDE}/ngraph/frontend

diff --git a/src/frontends/onnx/frontend/src/op/random_normal.cpp b/src/frontends/onnx/frontend/src/op/random_normal.cpp
@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "utils/random_normal.hpp"
-
 #include "exceptions.hpp"
 #include "ngraph/shape.hpp"
+#include "openvino/frontend/common/random_normal_helper.hpp"
+#include "openvino/op/constant.hpp"
 #include "utils/common.hpp"
 
 OPENVINO_SUPPRESS_DEPRECATED_START
@@ -23,11 +23,13 @@ OutputVector random_normal(const Node& node) {
 
     const auto mean = node.get_attribute_value<float>("mean", 0.0f);
     const auto scale = node.get_attribute_value<float>("scale", 1.0f);
-    const auto seed = node.get_attribute_value<float>("seed", 0);
+    auto scale_node = ov::op::v0::Constant::create(target_type, Shape{1}, {scale});
+    auto mean_node = ov::op::v0::Constant::create(target_type, Shape{1}, {mean});
 
+    const auto seed = node.get_attribute_value<float>("seed", 0);
     const auto shape = node.get_attribute_as_constant<std::vector<int64_t>>("shape");
-
-    return detail::make_random_normal(shape, target_type, mean, scale, seed);
+    auto res = ov::frontend::make_random_normal(shape, target_type, mean_node, scale_node, seed);
+    return res.first;
 }
 
 }  // namespace set_1

diff --git a/src/frontends/onnx/frontend/src/op/random_normal_like.cpp b/src/frontends/onnx/frontend/src/op/random_normal_like.cpp
@@ -4,8 +4,8 @@
 
 #include "ngraph/shape.hpp"
 #include "op/random_uniform_like.hpp"
+#include "openvino/frontend/common/random_normal_helper.hpp"
 #include "utils/common.hpp"
-#include "utils/random_normal.hpp"
 
 OPENVINO_SUPPRESS_DEPRECATED_START
 namespace ngraph {
@@ -25,11 +25,15 @@ OutputVector random_normal_like(const Node& node) {
     }
 
     const auto shape = std::make_shared<default_opset::ShapeOf>(input);
+    const auto seed = node.get_attribute_value<float>("seed", 0.0f);
+
     const auto mean = node.get_attribute_value<float>("mean", 0.0f);
     const auto scale = node.get_attribute_value<float>("scale", 1.0f);
-    const auto seed = node.get_attribute_value<float>("seed", 0.0f);
+    auto scale_node = ov::op::v0::Constant::create(target_type, Shape{1}, {scale});
+    auto mean_node = ov::op::v0::Constant::create(target_type, Shape{1}, {mean});
 
-    return detail::make_random_normal(shape, target_type, mean, scale, seed);
+    auto res = ov::frontend::make_random_normal(shape, target_type, mean_node, scale_node, seed);
+    return res.first;
 }
 
 }  // namespace set_1

diff --git a/src/frontends/onnx/frontend/src/utils/random_normal.cpp b/src/frontends/onnx/frontend/src/utils/random_normal.cpp