[ONNX] Global Pool ops (#1823)

* [ONNX] Global Pool ops

* Remove is_global flag

* Style fix

* Review fix pt. 1

* Change comments style

src/ngraph/frontend/onnx_import/CMakeLists.txt

@@ -59,6 +59,10 @@ add_library(onnx_import STATIC
         op/floor.hpp
         op/gemm.cpp
         op/gemm.hpp
+        op/global_average_pool.cpp
+        op/global_average_pool.hpp
+        op/global_max_pool.cpp
+        op/global_max_pool.hpp
         op/greater.hpp
         op/hard_sigmoid.cpp
         op/hard_sigmoid.hpp

src/ngraph/frontend/onnx_import/core/attribute.hpp

@@ -180,7 +180,7 @@ namespace ngraph
                 }
 
                 template <>
-                inline const std::string& get_value(const onnx::AttributeProto& attribute)
+                inline std::string get_value(const onnx::AttributeProto& attribute)
                 {
                     if (unlikely(attribute.type() != onnx::AttributeProto_AttributeType_STRING))
                     {

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

+//*****************************************************************************
+// Copyright 2017-2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#include "ngraph/node.hpp"
+#include "ngraph/node_vector.hpp"
+#include "ngraph/op/avg_pool.hpp"
+
+#include "utils/convpool.hpp"
+
+namespace ngraph
+{
+    namespace onnx_import
+    {
+        namespace op
+        {
+            namespace set_1
+            {
+                NodeVector global_average_pool(const Node& node)
+                {
+                    return convpool::make_ng_pool<ngraph::op::AvgPool>(node);
+                }
+
+            } // namespace set_1
+
+        } // namespace op
+
+    } // namespace onnx_import
+
+} // namespace ngraph

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

+//*****************************************************************************
+// Copyright 2017-2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#pragma once
+
+#include "ngraph/node_vector.hpp"
+
+#include "core/node.hpp"
+
+namespace ngraph
+{
+    namespace onnx_import
+    {
+        namespace op
+        {
+            namespace set_1
+            {
+                /// \brief Convert ONNX GlobalAveragePool operation to an nGraph node.
+                ///
+                /// \param node   The ONNX node object representing this operation.
+                ///
+                /// \return The vector containing Ngraph nodes producing output of ONNX GlobalAveragePool
+                ///         operation.
+                NodeVector global_average_pool(const Node& node);
+
+            } // namespace set_1
+
+        } // namespace op
+
+    } // namespace onnx_import
+
+} // namespace ngraph

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

+//*****************************************************************************
+// Copyright 2017-2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#include "ngraph/node.hpp"
+#include "ngraph/node_vector.hpp"
+#include "ngraph/op/max_pool.hpp"
+
+#include "utils/convpool.hpp"
+
+namespace ngraph
+{
+    namespace onnx_import
+    {
+        namespace op
+        {
+            namespace set_1
+            {
+                NodeVector global_max_pool(const Node& node)
+                {
+                    return convpool::make_ng_pool<ngraph::op::MaxPool>(node);
+                }
+
+            } // namespace set_1
+
+        } // namespace op
+
+    } // namespace onnx_import
+
+} // namespace ngraph

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

+//*****************************************************************************
+// Copyright 2017-2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//*****************************************************************************
+
+#pragma once
+
+#include "ngraph/node_vector.hpp"
+
+#include "core/node.hpp"
+
+namespace ngraph
+{
+    namespace onnx_import
+    {
+        namespace op
+        {
+            namespace set_1
+            {
+                /// \brief Convert ONNX GlobalMaxPool operation to an nGraph node.
+                ///
+                /// \param node   The ONNX node object representing this operation.
+                ///
+                /// \return The vector containing Ngraph nodes producing output of ONNX GlobalMaxPool
+                ///         operation.
+                NodeVector global_max_pool(const Node& node);
+
+            } // namespace set_1
+
+        } // namespace op
+
+    } // namespace onnx_import
+
+} // namespace ngraph

src/ngraph/frontend/onnx_import/ops_bridge.cpp

@@ -37,6 +37,8 @@
 #include "op/flatten.hpp"
 #include "op/floor.hpp"
 #include "op/gemm.hpp"
+#include "op/global_average_pool.hpp"
+#include "op/global_max_pool.hpp"
 #include "op/greater.hpp"
 #include "op/hard_sigmoid.hpp"
 #include "op/identity.hpp"
@@ -148,6 +150,8 @@ namespace ngraph
                     REGISTER_OPERATOR("Flatten", 1, flatten);
                     REGISTER_OPERATOR("Floor", 1, floor);
                     REGISTER_OPERATOR("Gemm", 1, gemm);
+                    REGISTER_OPERATOR("GlobalAveragePool", 1, global_average_pool);
+                    REGISTER_OPERATOR("GlobalMaxPool", 1, global_max_pool);
                     REGISTER_OPERATOR("Greater", 1, greater);
                     REGISTER_OPERATOR("HardSigmoid", 1, hard_sigmoid);
                     REGISTER_OPERATOR("Identity", 1, identity);

src/ngraph/frontend/onnx_import/utils/convpool.cpp

@@ -31,7 +31,9 @@ namespace ngraph
         {
             Shape get_kernel_shape(const Node& node)
             {
-                return node.get_attribute_value<std::vector<std::size_t>>("kernel_shape", {1, 1});
+                std::size_t input_spacial_dims = node.get_ng_inputs()[0]->get_shape().size() - 2;
+                return node.get_attribute_value<std::vector<std::size_t>>(
+                    "kernel_shape", std::vector<std::size_t>(input_spacial_dims, 1UL));
             }
 
             namespace detail
@@ -121,7 +123,7 @@ namespace ngraph
                     pads = CoordinateDiff(static_cast<std::ptrdiff_t>(kernel_shape.size()), 0UL);
                 }
 
-                if (pads.size() <= 3)
+                if (pads.size() != kernel_shape.size() * 2)
                 {
                     // Paddings specified in (H, W, C) format.
                     return {pads, pads};

src/ngraph/frontend/onnx_import/utils/convpool.hpp

@@ -16,7 +16,10 @@
 
 #pragma once
 
+#include <string>
+
 #include "ngraph/coordinate_diff.hpp"
+#include "ngraph/op/avg_pool.hpp"
 #include "ngraph/shape.hpp"
 
 #include "core/attribute.hpp"
@@ -84,13 +87,11 @@ namespace ngraph
                 return get_pads(node, get_kernel_shape(node));
             }
 
-            /**
-             * @brief Create an nGraph pooling operation based on an ONNX pooling op.
-             *
-             * @tparam T Class of an nGraph pooling operation (e.g. AveragePool, MaxPool)
-             * @param node incoming ONNX opearation
-             * @return nGraph node equivalent of the ONNX operation
-             */
+            /// \brief Create an nGraph pooling operation based on an ONNX pooling op.
+            ///
+            /// \param T Class of an nGraph pooling operation (e.g. AveragePool, MaxPool)
+            /// \param node incoming ONNX opearation
+            /// \return nGraph node equivalent of the ONNX operation
             template <class T>
             inline NodeVector make_ng_pool(const Node& node)
             {
@@ -98,19 +99,44 @@ namespace ngraph
                 auto data = node.get_ng_inputs().at(0);
 
                 // Parse ONNX op attributes
-                Shape kernel_shape = convpool::get_kernel_shape(node);
+                Shape kernel_shape;
+                if (node.op_type().find("Global") != std::string::npos)
+                {
+                    kernel_shape = node.get_ng_inputs()[0]->get_shape();
+                    // Remove N and C dimensions and leave only spatial dims.
+                    kernel_shape.erase(std::begin(kernel_shape),
+                                       std::next(std::begin(kernel_shape), 2));
+                }
+                else
+                {
+                    kernel_shape = convpool::get_kernel_shape(node);
+                }
                 auto strides = convpool::get_strides(node);
                 auto dilations = convpool::get_dilations(node);
                 auto paddings = convpool::get_pads(node);
 
+                bool count_include_pad = node.get_attribute_value<int64_t>("count_include_pad", 0);
+
                 // Convert padding from CoordinateDiff to Shape objects
                 const CoordinateDiff& padding_above{paddings.first};
                 const CoordinateDiff& padding_below{paddings.second};
                 Shape padding_below_shape{std::begin(padding_below), std::end(padding_below)};
                 Shape padding_above_shape{std::begin(padding_above), std::end(padding_above)};
 
-                return {std::make_shared<T>(
-                    data, kernel_shape, strides, padding_below_shape, padding_above_shape)};
+                if (count_include_pad)
+                {
+                    return {std::make_shared<ngraph::op::AvgPool>(data,
+                                                                  kernel_shape,
+                                                                  strides,
+                                                                  padding_below_shape,
+                                                                  padding_above_shape,
+                                                                  count_include_pad)};
+                }
+                else
+                {
+                    return {std::make_shared<T>(
+                        data, kernel_shape, strides, padding_below_shape, padding_above_shape)};
+                }
             }
 
         } // namespace convpool