RandomUniformFusion transformation.

inference-engine/src/transformations/include/transformations/common_optimizations/random_uniform_fusion.hpp

@@ -0,0 +1,60 @@
+// Copyright (C) 2018-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <ngraph/pass/graph_rewrite.hpp>
+#include <transformations_visibility.hpp>
+
+namespace ngraph {
+namespace pass {
+
+class TRANSFORMATIONS_API RandomUniformFusion;
+class TRANSFORMATIONS_API RandomUniformMaxValFusion;
+class TRANSFORMATIONS_API RandomUniformMinValFusion;
+
+}  // namespace pass
+}  // namespace ngraph
+
+/**
+ * @ingroup ie_transformation_common_api
+ * @brief RandomUniformMaxValFusion transformation replaces RandomUniform -> Mul subgraph
+ * with a single RandomUniform node.
+ *
+ * * Restrictions:
+ * RandomUniform node should have floating output type and input max value = 1.0.
+ */
+class ngraph::pass::RandomUniformMaxValFusion : public ngraph::pass::MatcherPass {
+public:
+    NGRAPH_RTTI_DECLARATION;
+    RandomUniformMaxValFusion();
+};
+
+/**
+ * @ingroup ie_transformation_common_api
+ * @brief RandomUniformMinValFusion transformation replaces RandomUniform -> Add subgraph
+ * with a RandomUniform and replaces min and max const with corrected values.
+ *
+ * * Restrictions:
+ * RandomUniform node should have floating output type and input min value = 0.0.
+ */
+class ngraph::pass::RandomUniformMinValFusion : public ngraph::pass::MatcherPass {
+public:
+    NGRAPH_RTTI_DECLARATION;
+    RandomUniformMinValFusion();
+};
+
+/**
+ * @ingroup ie_transformation_common_api
+ * @brief RandomUniformFusion transformation replaces RandomUniform with Add or Mul sub-graphs with single
+ * RandomUniform.
+ */
+class ngraph::pass::RandomUniformFusion : public ngraph::pass::GraphRewrite {
+public:
+    NGRAPH_RTTI_DECLARATION;
+    RandomUniformFusion() {
+        add_matcher<ngraph::pass::RandomUniformMaxValFusion>();
+        add_matcher<ngraph::pass::RandomUniformMinValFusion>();
+    }
+};

inference-engine/src/transformations/src/transformations/common_optimizations/common_optimizations.cpp

@@ -26,6 +26,7 @@
 #include "transformations/common_optimizations/hsigmoid_fusion.hpp"
 #include "transformations/common_optimizations/hswish_fusion.hpp"
 #include "transformations/common_optimizations/convert_quantize_dequantize.hpp"
+#include "transformations/common_optimizations/random_uniform_fusion.hpp"
 #include "transformations/common_optimizations/relu_fake_quantize_fusion.hpp"
 #include "transformations/common_optimizations/add_fake_quantize_fusion.hpp"
 #include "transformations/common_optimizations/mul_fake_quantize_fusion.hpp"
@@ -133,6 +134,7 @@ bool ngraph::pass::CommonOptimizations::run_on_function(std::shared_ptr<ngraph::
     common_fusions->add_matcher<ngraph::pass::GeluFusion>();
     common_fusions->add_matcher<ngraph::pass::TransposeToReshape>();
     common_fusions->add_matcher<ngraph::pass::LeakyReluFusion>();
+    common_fusions->add_matcher<ngraph::pass::RandomUniformFusion>();
     common_fusions->set_name("ngraph::pass::CommonFusions");
 
     manager.register_pass<ngraph::pass::ConvertPadToGroupConvolution, false>();

inference-engine/src/transformations/src/transformations/common_optimizations/random_uniform_fusion.cpp

@@ -0,0 +1,104 @@
+// Copyright (C) 2018-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "transformations/common_optimizations/random_uniform_fusion.hpp"
+
+#include <memory>
+#include <ngraph/opsets/opset8.hpp>
+#include <ngraph/pattern/op/wrap_type.hpp>
+#include <ngraph/rt_info.hpp>
+
+#include "itt.hpp"
+
+NGRAPH_RTTI_DEFINITION(ngraph::pass::RandomUniformFusion, "RandomUniformFusion", 0);
+NGRAPH_RTTI_DEFINITION(ngraph::pass::RandomUniformMaxValFusion, "RandomUniformMaxValFusion", 0);
+NGRAPH_RTTI_DEFINITION(ngraph::pass::RandomUniformMinValFusion, "RandomUniformMinValFusion", 0);
+
+ngraph::pass::RandomUniformMaxValFusion::RandomUniformMaxValFusion() {
+    MATCHER_SCOPE(RandomUniformMaxValFusion);
+    auto data_pattern = ngraph::pattern::any_input();
+    auto ru_min_const_pattern = ngraph::pattern::wrap_type<opset8::Constant>();
+    auto ru_max_const_pattern = ngraph::pattern::wrap_type<opset8::Constant>();
+    auto random_uniform_pattern =
+        ngraph::pattern::wrap_type<opset8::RandomUniform>({data_pattern, ru_min_const_pattern, ru_max_const_pattern},
+                                                          pattern::consumers_count(1));
+    auto mul_const_pattern = ngraph::pattern::wrap_type<opset8::Constant>();
+    auto mul_pattern = ngraph::pattern::wrap_type<opset8::Multiply>({random_uniform_pattern, mul_const_pattern});
+
+    ngraph::matcher_pass_callback callback = [=](pattern::Matcher& m) {
+        auto pattern_map = m.get_pattern_value_map();
+        auto data = pattern_map[data_pattern];
+        auto random_uniform = pattern_map[random_uniform_pattern];
+        auto ru_max_val_const = pattern_map[ru_max_const_pattern];
+        auto mul = pattern_map[mul_pattern];
+        auto mul_const = pattern_map[mul_const_pattern];
+        auto ru = std::dynamic_pointer_cast<opset8::RandomUniform>(random_uniform.get_node_shared_ptr());
+        if (!ru)
+            return false;
+        if (!ru->get_out_type().is_real())
+            return false;
+
+        auto max_val_const = std::dynamic_pointer_cast<opset8::Constant>(ru_max_val_const.get_node_shared_ptr());
+        if (!max_val_const)
+            return false;
+        auto max_value = max_val_const->cast_vector<float>()[0];
+        if (max_value != 1.0f)
+            return false;
+
+        auto new_ru = ru->clone_with_new_inputs({data, ru->input_value(1), mul_const});
+        new_ru->set_friendly_name(m.get_match_root()->get_friendly_name());
+        copy_runtime_info({mul.get_node_shared_ptr(), ru}, new_ru);
+        ngraph::replace_node(m.get_match_root(), new_ru);
+
+        return true;
+    };
+
+    auto m = std::make_shared<ngraph::pattern::Matcher>(mul_pattern, matcher_name);
+    this->register_matcher(m, callback);
+}
+
+ngraph::pass::RandomUniformMinValFusion::RandomUniformMinValFusion() {
+    MATCHER_SCOPE(RandomUniformMinValFusion);
+    auto data_pattern = ngraph::pattern::any_input();
+    auto ru_min_const_pattern = ngraph::pattern::wrap_type<opset8::Constant>();
+    auto ru_max_const_pattern = ngraph::pattern::wrap_type<opset8::Constant>();
+    auto random_uniform_pattern =
+        ngraph::pattern::wrap_type<opset8::RandomUniform>({data_pattern, ru_min_const_pattern, ru_max_const_pattern},
+                                                          pattern::consumers_count(1));
+    auto add_const_pattern = ngraph::pattern::wrap_type<opset8::Constant>();
+    auto add_pattern = ngraph::pattern::wrap_type<opset8::Add>({random_uniform_pattern, add_const_pattern});
+
+    ngraph::matcher_pass_callback callback = [=](pattern::Matcher& m) {
+        auto pattern_map = m.get_pattern_value_map();
+        auto data = pattern_map[data_pattern];
+        auto random_uniform = pattern_map[random_uniform_pattern];
+        auto add = pattern_map[add_pattern];
+        auto add_const = pattern_map[add_const_pattern];
+        auto ru_max_const = pattern_map[ru_max_const_pattern];
+        auto ru_min_val_const = pattern_map[ru_min_const_pattern];
+        auto ru = std::dynamic_pointer_cast<opset8::RandomUniform>(random_uniform.get_node_shared_ptr());
+        if (!ru)
+            return false;
+        if (!ru->get_out_type().is_real())
+            return false;
+
+        auto min_val_const = std::dynamic_pointer_cast<opset8::Constant>(ru_min_val_const.get_node_shared_ptr());
+        if (!min_val_const)
+            return false;
+        auto max_value = min_val_const->cast_vector<float>()[0];
+        if (max_value != 0.0f)
+            return false;
+
+        auto new_add = register_new_node<ngraph::opset8::Add>(add_const, ru_max_const);
+        auto new_ru = ru->clone_with_new_inputs({data, add_const, new_add});
+        new_ru->set_friendly_name(m.get_match_root()->get_friendly_name());
+        copy_runtime_info({add.get_node_shared_ptr(), ru}, new_ru);
+        ngraph::replace_node(m.get_match_root(), new_ru);
+
+        return true;
+    };
+
+    auto m = std::make_shared<ngraph::pattern::Matcher>(add_pattern, matcher_name);
+    this->register_matcher(m, callback);
+}

inference-engine/tests/functional/inference_engine/transformations/random_uniform_fusion_test.cpp

@@ -0,0 +1,106 @@
+// Copyright (C) 2018-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <gtest/gtest.h>
+
+#include <memory>
+#include <ngraph/function.hpp>
+#include <ngraph/opsets/opset8.hpp>
+#include <ngraph/pass/manager.hpp>
+#include <string>
+#include <transformations/common_optimizations/random_uniform_fusion.hpp>
+#include <transformations/init_node_info.hpp>
+
+#include "common_test_utils/ngraph_test_utils.hpp"
+
+using namespace testing;
+
+TEST(TransformationTests, RandomUniformMaxValFusing) {
+  std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+  {
+    auto input = std::make_shared<ngraph::opset8::Parameter>(
+        ngraph::element::i32, ngraph::Shape{3});
+    auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32,
+                                                      ngraph::Shape{1}, {0.0});
+    auto max_const = ngraph::opset8::Constant::create(ngraph::element::f32,
+                                                      ngraph::Shape{1}, {1.0});
+    auto ru = std::make_shared<ngraph::opset8::RandomUniform>(
+        input, min_const, max_const, ngraph::element::f32, 100, 200);
+
+    auto mul_const = ngraph::opset8::Constant::create(ngraph::element::f32,
+                                                      ngraph::Shape{1}, {30.0});
+    auto mul = std::make_shared<ngraph::opset8::Multiply>(ru, mul_const);
+
+    f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul},
+                                           ngraph::ParameterVector{input});
+
+    ngraph::pass::Manager manager;
+    manager.register_pass<ngraph::pass::InitNodeInfo>();
+    manager.register_pass<ngraph::pass::RandomUniformMaxValFusion>();
+    manager.run_passes(f);
+    ASSERT_NO_THROW(check_rt_info(f));
+  }
+
+  {
+    auto input = std::make_shared<ngraph::opset8::Parameter>(
+        ngraph::element::i32, ngraph::Shape{3});
+    auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32,
+                                                      ngraph::Shape{1}, {0.0});
+    auto add_const = ngraph::opset8::Constant::create(ngraph::element::f32,
+                                                      ngraph::Shape{1}, {30.0});
+    auto ru = std::make_shared<ngraph::opset8::RandomUniform>(
+        input, min_const, add_const, ngraph::element::f32, 100, 200);
+
+    f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ru},
+                                               ngraph::ParameterVector{input});
+  }
+
+  auto res = compare_functions(f, f_ref);
+  ASSERT_TRUE(res.first) << res.second;
+}
+
+TEST(TransformationTests, RandomUniformMinValFusing) {
+  std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+  {
+    auto input = std::make_shared<ngraph::opset8::Parameter>(
+        ngraph::element::i32, ngraph::Shape{3});
+    auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32,
+                                                      ngraph::Shape{1}, {0.0});
+    auto max_const = ngraph::opset8::Constant::create(ngraph::element::f32,
+                                                      ngraph::Shape{1}, {30.0});
+    auto ru = std::make_shared<ngraph::opset8::RandomUniform>(
+        input, min_const, max_const, ngraph::element::f32, 100, 200);
+
+    auto add_const = ngraph::opset8::Constant::create(
+        ngraph::element::f32, ngraph::Shape{1}, {-10.0});
+    auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
+
+    f = std::make_shared<ngraph::Function>(ngraph::NodeVector{add},
+                                           ngraph::ParameterVector{input});
+
+    ngraph::pass::Manager manager;
+    manager.register_pass<ngraph::pass::InitNodeInfo>();
+    manager.register_pass<ngraph::pass::RandomUniformMinValFusion>();
+    manager.run_passes(f);
+    ASSERT_NO_THROW(check_rt_info(f));
+  }
+
+  {
+    auto input = std::make_shared<ngraph::opset8::Parameter>(
+        ngraph::element::i32, ngraph::Shape{3});
+    auto add_const = ngraph::opset8::Constant::create(
+        ngraph::element::f32, ngraph::Shape{1}, {-10.0});
+    auto ru_max_const = ngraph::opset8::Constant::create(
+        ngraph::element::f32, ngraph::Shape{1}, {30.0});
+    auto add = std::make_shared<ngraph::opset8::Add>(add_const, ru_max_const);
+    auto ru = std::make_shared<ngraph::opset8::RandomUniform>(
+        input, add_const, add, ngraph::element::f32, 100, 200);
+
+    f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ru},
+                                               ngraph::ParameterVector{input});
+  }
+
+  auto res = compare_functions(f, f_ref);
+  ASSERT_TRUE(res.first) << res.second;
+}