Enable INT8 pool OP (#15046)

* Enable INT8 pool OP
test=develop

* fix unittest
test=develop

* Clean unittest code.
test=develop

paddle/fluid/operators/pool_mkldnn_op.cc

@@ -12,6 +12,7 @@ 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 "paddle/fluid/framework/data_layout_transform.h"
 #include "paddle/fluid/operators/pool_op.h"
 #include "paddle/fluid/platform/mkldnn_helper.h"
 
@@ -71,7 +72,6 @@ class PoolMKLDNNOpKernel : public paddle::framework::OpKernel<T> {
   void Compute(const paddle::framework::ExecutionContext& ctx) const override {
     PADDLE_ENFORCE(paddle::platform::is_cpu_place(ctx.GetPlace()),
                    "It must use CPUPlace.");
-
     auto& dev_ctx =
         ctx.template device_context<platform::MKLDNNDeviceContext>();
     const auto& mkldnn_engine = dev_ctx.GetEngine();
@@ -130,20 +130,25 @@ class PoolMKLDNNOpKernel : public paddle::framework::OpKernel<T> {
         CorrectOutputSize(src_tz, dst_tz, ksize, paddings, strides,
                           padding_right_bottom);
       }
-      auto src_md = platform::MKLDNNMemDesc(
+
-          src_tz, platform::MKLDNNGetDataType<T>(), input_format);
+      mkldnn::memory::data_type dt =
+          paddle::framework::ToMKLDNNDataType(input->type());
+
+      auto src_md = platform::MKLDNNMemDesc(src_tz, dt, input_format);
 
       /* create memory descriptor for pooling without specified format
        * ('any') which lets a primitive (pooling in this case) choose
        * the memory format preferred for best performance
        */
-      auto dst_md = platform::MKLDNNMemDesc(dst_tz, mkldnn::memory::f32,
+      auto dst_md =
-                                            mkldnn::memory::format::any);
+          platform::MKLDNNMemDesc(dst_tz, dt, mkldnn::memory::format::any);
-
+      auto propagation = src_md.data.data_type == mkldnn_f32
+                             ? mkldnn::prop_kind::forward_training
+                             : mkldnn::prop_kind::forward_scoring;
       std::shared_ptr<mkldnn::pooling_forward::primitive_desc> pool_pd =
-          CreatePrimitiveDesc(src_md, dst_md, strides, padding_left_top,
+          CreatePrimitiveDesc(src_md, dst_md, propagation, strides,
-                              padding_right_bottom, ksize, pooling_type,
+                              padding_left_top, padding_right_bottom, ksize,
-                              mkldnn_engine, ceil_mode, is_test);
+                              pooling_type, mkldnn_engine, ceil_mode, is_test);
 
       // save pool_pd into global device context to be referred in backward path
       if (!is_test) dev_ctx.SetBlob(key_pool_pd, pool_pd);
@@ -203,7 +208,8 @@ class PoolMKLDNNOpKernel : public paddle::framework::OpKernel<T> {
  private:
   std::unique_ptr<mkldnn::pooling_forward::primitive_desc> CreatePrimitiveDesc(
       const mkldnn::memory::desc& src, const mkldnn::memory::desc& dst,
-      const std::vector<int>& stride, const std::vector<int>& padding_left_top,
+      const mkldnn::prop_kind& propagation, const std::vector<int>& stride,
+      const std::vector<int>& padding_left_top,
       const std::vector<int>& padding_right_bot, const std::vector<int>& kernel,
       const std::string& pooling_type, const mkldnn::engine& engine,
       bool ceil_mode, bool is_test) const {
@@ -411,6 +417,9 @@ class PoolMKLDNNGradOpKernel : public paddle::framework::OpKernel<T> {
 namespace ops = paddle::operators;
 
 REGISTER_OP_KERNEL(pool2d, MKLDNN, ::paddle::platform::CPUPlace,
-                   ops::PoolMKLDNNOpKernel<float>);
+                   ops::PoolMKLDNNOpKernel<float>,
+                   ops::PoolMKLDNNOpKernel<int8_t>,
+                   ops::PoolMKLDNNOpKernel<uint8_t>);
+
 REGISTER_OP_KERNEL(pool2d_grad, MKLDNN, ::paddle::platform::CPUPlace,
                    ops::PoolMKLDNNGradOpKernel<float>);

python/paddle/fluid/tests/unittests/test_pool2d_int8_mkldnn_op.py

@@ -0,0 +1,110 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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.
+
+from __future__ import print_function
+from __future__ import division
+
+import unittest
+import numpy as np
+
+import paddle.fluid.core as core
+from op_test import OpTest
+from test_pool2d_op import TestPool2D_Op, avg_pool2D_forward_naive, max_pool2D_forward_naive
+
+
+class TestPool2dMKLDNNInt8_Op(TestPool2D_Op):
+    def init_kernel_type(self):
+        self.use_mkldnn = True
+
+    def init_data_type(self):
+        self.dtype = np.int8
+
+    def setUp(self):
+        TestPool2D_Op.setUp(self)
+        assert self.dtype in [np.int8, np.uint8
+                              ], 'Dtype should be int8 or uint8'
+
+    def test_check_output(self):
+        self.check_output_with_place(core.CPUPlace(), atol=1e-5)
+
+    def test_check_grad(self):
+        pass
+
+
+class TestCase1Avg(TestPool2dMKLDNNInt8_Op):
+    def init_test_case(self):
+        self.shape = [2, 3, 7, 7]
+        self.ksize = [3, 3]
+        self.strides = [1, 1]
+        self.paddings = [0, 0]
+
+    def init_global_pool(self):
+        self.global_pool = False
+
+
+class TestCase2Avg(TestPool2dMKLDNNInt8_Op):
+    def init_test_case(self):
+        self.shape = [2, 3, 7, 7]
+        self.ksize = [3, 3]
+        self.strides = [1, 1]
+        self.paddings = [1, 1]
+
+    def init_global_pool(self):
+        self.global_pool = False
+
+
+class TestCase0Max(TestPool2dMKLDNNInt8_Op):
+    def init_pool_type(self):
+        self.pool_type = "max"
+        self.pool2D_forward_naive = max_pool2D_forward_naive
+
+
+class TestCase1Max(TestCase1Avg):
+    def init_pool_type(self):
+        self.pool_type = "max"
+        self.pool2D_forward_naive = max_pool2D_forward_naive
+
+
+class TestCase2Max(TestCase2Avg):
+    def init_pool_type(self):
+        self.pool_type = "max"
+        self.pool2D_forward_naive = max_pool2D_forward_naive
+
+
+def create_test_s8_u8_class(parent):
+    class TestS8Case(parent):
+        def init_data_type(self):
+            self.dtype = np.int8
+
+    class TestU8Case(parent):
+        def init_data_type(self):
+            self.dtype = np.uint8
+
+    cls_name_s8 = "{0}_{1}".format(parent.__name__, "mkldnn_s8")
+    cls_name_u8 = "{0}_{1}".format(parent.__name__, "mkldnn_u8")
+    TestS8Case.__name__ = cls_name_s8
+    TestU8Case.__name__ = cls_name_u8
+    globals()[cls_name_s8] = TestS8Case
+    globals()[cls_name_u8] = TestU8Case
+
+
+create_test_s8_u8_class(TestPool2dMKLDNNInt8_Op)
+create_test_s8_u8_class(TestCase1Avg)
+create_test_s8_u8_class(TestCase2Avg)
+create_test_s8_u8_class(TestCase0Max)
+create_test_s8_u8_class(TestCase1Max)
+create_test_s8_u8_class(TestCase2Max)
+
+if __name__ == '__main__':
+    unittest.main()

python/paddle/fluid/tests/unittests/test_pool2d_mkldnn_op.py

@@ -18,35 +18,22 @@ import unittest
 from test_pool2d_op import TestPool2D_Op, TestCase1, TestCase2, TestCase3, TestCase4, TestCase5
 
 
-class TestMKLDNNCase1(TestPool2D_Op):
+def create_test_mkldnn_class(parent):
-    def init_kernel_type(self):
+    class TestMKLDNNCase(parent):
-        self.use_mkldnn = True
+        def init_kernel_type(self):
-
+            self.use_mkldnn = True
-
+
-class TestMKLDNNCase2(TestCase1):
+    cls_name = "{0}_{1}".format(parent.__name__, "MKLDNNOp")
-    def init_kernel_type(self):
+    TestMKLDNNCase.__name__ = cls_name
-        self.use_mkldnn = True
+    globals()[cls_name] = TestMKLDNNCase
-
+
-
+
-class TestMKLDNNCase3(TestCase2):
+create_test_mkldnn_class(TestPool2D_Op)
-    def init_kernel_type(self):
+create_test_mkldnn_class(TestCase1)
-        self.use_mkldnn = True
+create_test_mkldnn_class(TestCase2)
-
+create_test_mkldnn_class(TestCase3)
-
+create_test_mkldnn_class(TestCase4)
-class TestMKLDNNCase4(TestCase3):
+create_test_mkldnn_class(TestCase5)
-    def init_kernel_type(self):
-        self.use_mkldnn = True
-
-
-class TestMKLDNNCase5(TestCase4):
-    def init_kernel_type(self):
-        self.use_mkldnn = True
-
-
-class TestMKLDNNCase6(TestCase5):
-    def init_kernel_type(self):
-        self.use_mkldnn = True
-
 
 if __name__ == '__main__':
     unittest.main()

python/paddle/fluid/tests/unittests/test_pool2d_op.py

@@ -115,7 +115,7 @@ class TestPool2D_Op(OpTest):
         self.op_type = "pool2d"
         self.use_cudnn = False
         self.use_mkldnn = False
-        self.dtype = np.float32
+        self.init_data_type()
         self.init_test_case()
         self.init_global_pool()
         self.init_kernel_type()
@@ -177,6 +177,9 @@ class TestPool2D_Op(OpTest):
     def init_kernel_type(self):
         pass
 
+    def init_data_type(self):
+        self.dtype = np.float32
+
     def init_pool_type(self):
         self.pool_type = "avg"
         self.pool2D_forward_naive = avg_pool2D_forward_naive