[ONNX] norm builders should produce v1 ops (#4354)

src/ngraph/builder/norm.hpp

@@ -34,62 +34,65 @@ namespace ngraph
             MAX
         };
 
-        /// \brief      Calculates L-0 norm of input tensor.
-        ///
-        /// \note       The L-0 norm represents the cardinality of elements different
-        ///             from zero. This actually is not a "true" norm.
-        ///
-        /// \param[in]  value           The input tensor.
-        /// \param[in]  reduction_axes  The axes along which we calculate norm.
-        ///
-        /// \return     L-0 norm of value.
-        ///
-        std::shared_ptr<Node> l0_norm(const Output<Node>& value, const AxisSet& reduction_axes);
+        namespace opset1
+        {
+            /// \brief      Calculates L-0 norm of input tensor.
+            ///
+            /// \note       The L-0 norm represents the cardinality of elements different
+            ///             from zero. This actually is not a "true" norm.
+            ///
+            /// \param[in]  value           The input tensor.
+            /// \param[in]  reduction_axes  The axes along which we calculate norm.
+            ///
+            /// \return     L-0 norm of value. The output sub-graph is composed of v1 ops.
+            ///
+            std::shared_ptr<Node> l0_norm(const Output<Node>& value, const AxisSet& reduction_axes);
 
-        /// \brief      Calculates L-1 norm of a value.
-        ///
-        /// \note       The L-1 norm represents the sum of absolute values.
-        ///
-        /// \param[in]  value           The input tensor.
-        /// \param[in]  reduction_axes  The axes along which we calculate norm.
-        /// \param[in]  bias            The bias added to the calculated sum.
-        ///
-        /// \return     L-1 norm of value.
-        ///
-        std::shared_ptr<Node>
-            l1_norm(const Output<Node>& value, const AxisSet& reduction_axes, float bias = 0.f);
+            /// \brief      Calculates L-1 norm of a value.
+            ///
+            /// \note       The L-1 norm represents the sum of absolute values.
+            ///
+            /// \param[in]  value           The input tensor.
+            /// \param[in]  reduction_axes  The axes along which we calculate norm.
+            /// \param[in]  bias            The bias added to the calculated sum.
+            ///
+            /// \return     L-1 norm of value. The output sub-graph is composed of v1 ops.
+            ///
+            std::shared_ptr<Node>
+                l1_norm(const Output<Node>& value, const AxisSet& reduction_axes, float bias = 0.f);
 
-        /// \brief      Calculates L-2 norm of input tensor.
-        ///
-        /// \note       The L-2 norm represents the square root of sum of squares of each
-        ///             individual element.
-        ///
-        /// \param[in]  value           The input tensor.
-        /// \param[in]  reduction_axes  The axes along which we calculate norm.
-        /// \param[in]  bias            The bias combined with calculated sum.
-        /// \param[in]  bias_mode       The method of bias application.
-        /// \param[in]  keep_dims       The flag indicates if axes will be removed or kept.
-        ///
-        /// \return     L-2 norm of value.
-        ///
-        std::shared_ptr<Node> l2_norm(const Output<Node>& value,
-                                      const AxisSet& reduction_axes,
-                                      float bias = 0.f,
-                                      BiasMode bias_mode = BiasMode::ADD,
-                                      bool keep_dims = false);
+            /// \brief      Calculates L-2 norm of input tensor.
+            ///
+            /// \note       The L-2 norm represents the square root of sum of squares of each
+            ///             individual element.
+            ///
+            /// \param[in]  value           The input tensor.
+            /// \param[in]  reduction_axes  The axes along which we calculate norm.
+            /// \param[in]  bias            The bias combined with calculated sum.
+            /// \param[in]  bias_mode       The method of bias application.
+            /// \param[in]  keep_dims       The flag indicates if axes will be removed or kept.
+            ///
+            /// \return     L-2 norm of value. The output sub-graph is composed of v1 ops.
+            ///
+            std::shared_ptr<Node> l2_norm(const Output<Node>& value,
+                                          const AxisSet& reduction_axes,
+                                          float bias = 0.f,
+                                          BiasMode bias_mode = BiasMode::ADD,
+                                          bool keep_dims = false);
 
-        /// \brief      Creates node which calculates L-p norm on input tensor.
-        ///
-        /// \param[in]  value           The input tensor.
-        /// \param[in]  reduction_axes  The axes along which we calculate norm.
-        /// \param[in]  p_norm          The p norm to calculate.
-        /// \param[in]  bias            The bias added to the calculated sum.
-        ///
-        /// \return     L-p norm of value.
-        ///
-        std::shared_ptr<Node> lp_norm(const Output<Node>& value,
-                                      const AxisSet& reduction_axes,
-                                      std::size_t p_norm = 2,
-                                      float bias = 0.f);
+            /// \brief      Creates node which calculates L-p norm on input tensor.
+            ///
+            /// \param[in]  value           The input tensor.
+            /// \param[in]  reduction_axes  The axes along which we calculate norm.
+            /// \param[in]  p_norm          The p norm to calculate.
+            /// \param[in]  bias            The bias added to the calculated sum.
+            ///
+            /// \return     L-p norm of value. The output sub-graph is composed of v1 ops.
+            ///
+            std::shared_ptr<Node> lp_norm(const Output<Node>& value,
+                                          const AxisSet& reduction_axes,
+                                          std::size_t p_norm = 2,
+                                          float bias = 0.f);
+        }
     } // namespace builder
 } // namespace ngraph

src/ngraph/frontend/onnx_import/op/lp_norm.cpp

@@ -55,7 +55,7 @@ namespace ngraph
                         << "Invalid `p` attribute value: " << p_norm
                         << "Only normalization of 1st or 2nd order is supported.";
 
-                    std::shared_ptr<ngraph::Node> norm = ngraph::builder::lp_norm(
+                    std::shared_ptr<ngraph::Node> norm = ngraph::builder::opset1::lp_norm(
                         data, AxisSet{normalize_axis}, static_cast<std::size_t>(p_norm));
 
                     const auto target_shape = default_opset::Constant::create(

src/ngraph/frontend/onnx_import/op/lp_pool.cpp

@@ -55,7 +55,7 @@ namespace ngraph
                         AxisSet reduction_axes{
                             common::get_monotonic_range<std::size_t>(orig_shape.size(), 2)};
 
-                        slice = ngraph::builder::lp_norm(
+                        slice = ngraph::builder::opset1::lp_norm(
                             slice, reduction_axes, static_cast<std::size_t>(p_norm));
 
                         // output shape is all ones except N channel

src/ngraph/frontend/onnx_import/op/reduce.hpp

@@ -97,7 +97,7 @@ namespace ngraph
                 ///
                 inline NodeVector reduce_l1(const Node& node)
                 {
-                    auto l1_norm_reduction = std::bind(ngraph::builder::l1_norm,
+                    auto l1_norm_reduction = std::bind(ngraph::builder::opset1::l1_norm,
                                                        std::placeholders::_1,
                                                        std::placeholders::_2,
                                                        0.f);
@@ -119,7 +119,7 @@ namespace ngraph
                 ///
                 inline NodeVector reduce_l2(const Node& node)
                 {
-                    auto l2_norm_reduction = std::bind(ngraph::builder::l2_norm,
+                    auto l2_norm_reduction = std::bind(ngraph::builder::opset1::l2_norm,
                                                        std::placeholders::_1,
                                                        std::placeholders::_2,
                                                        0.f,

src/ngraph/op/fused/grn.cpp

@@ -68,7 +68,7 @@ NodeVector op::GRN::decompose_op() const
     }
 
     // Calculate l2 norm across channels.
-    shared_ptr<Node> norm = builder::l2_norm(data, AxisSet{1}, m_bias);
+    shared_ptr<Node> norm = builder::opset1::l2_norm(data, AxisSet{1}, m_bias);
     // Get back reduced axis.
     norm = std::make_shared<Broadcast>(norm, data.get_shape(), AxisSet{1});
     data = data / norm;

src/ngraph/op/fused/normalize_l2.cpp

@@ -96,7 +96,8 @@ NodeVector op::NormalizeL2::decompose_op() const
     // Calculate l2 norm across axes determined by axes input
     auto builder_bias_mode =
         (m_eps_mode == EpsMode::MAX) ? builder::BiasMode::MAX : builder::BiasMode::ADD;
-    Output<Node> norm = builder::l2_norm(data, reduction_axes, m_eps, builder_bias_mode, true);
+    Output<Node> norm =
+        builder::opset1::l2_norm(data, reduction_axes, m_eps, builder_bias_mode, true);
 
     data = make_shared<op::Divide>(data, norm, AutoBroadcastSpec(AutoBroadcastType::NUMPY));
 

test/provenance.cpp

@@ -389,7 +389,7 @@ TEST(provenance, builder)
 {
     auto p1 = make_shared<op::Parameter>(element::i32, PartialShape{2, 3, 4});
     p1->add_provenance_tag("P1");
-    auto norm = builder::lp_norm(p1, {0}, 1, 0);
+    auto norm = builder::opset1::lp_norm(p1, {0}, 1, 0);
     norm->add_provenance_tag("norm");
     for (auto node : topological_sort(NodeVector{norm}))
     {