From d1e67e86b760f8bffba62d237637ce792dd8d8c2 Mon Sep 17 00:00:00 2001 From: "xiaoli.liu@intel.com" Date: Wed, 12 Dec 2018 15:40:10 +0800 Subject: [PATCH] modify quantize and dequantize related files to fix mkldnn library check issue --- .../fluid/operators/dequantize_mkldnn_op.cc | 88 +++++++++++++ paddle/fluid/operators/dequantize_op.cc | 80 ++---------- paddle/fluid/operators/dequantize_op.h | 6 +- paddle/fluid/operators/quantize_mkldnn_op.cc | 96 ++++++++++++++ paddle/fluid/operators/quantize_op.cc | 118 ++++-------------- paddle/fluid/operators/quantize_op.h | 13 +- 6 files changed, 222 insertions(+), 179 deletions(-) create mode 100644 paddle/fluid/operators/dequantize_mkldnn_op.cc create mode 100644 paddle/fluid/operators/quantize_mkldnn_op.cc diff --git a/paddle/fluid/operators/dequantize_mkldnn_op.cc b/paddle/fluid/operators/dequantize_mkldnn_op.cc new file mode 100644 index 00000000000..c5ee8c69572 --- /dev/null +++ b/paddle/fluid/operators/dequantize_mkldnn_op.cc @@ -0,0 +1,88 @@ +/* Copyright (c) 2016 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. */ + + +#include "mkldnn.hpp" +#include "paddle/fluid/framework/tensor.h" +#include "paddle/fluid/platform/mkldnn_helper.h" +#include "paddle/fluid/operators/dequantize_op.h" +#include "paddle/fluid/framework/data_layout_transform.h" + +namespace paddle { +namespace operators { + +using mkldnn::memory; +using mkldnn::primitive; +using mkldnn::reorder; +using platform::to_void_cast; +using Tensor = framework::Tensor; +using framework::DataLayout; +using mkldnn::stream; +using platform::GetMKLDNNFormat; + +template +class DeQuantOpKernel : public framework::OpKernel { + public: + + void Compute(const framework::ExecutionContext& ctx) const override { + auto* input = ctx.Input("Input"); + auto scale_data = ctx.Attr("Scale"); + auto* output = ctx.Output("Output"); + auto& dev_ctx = + ctx.template device_context(); + const auto& engine = dev_ctx.GetEngine(); + + const T* input_data = input->data(); + float* output_data = output->mutable_data(ctx.GetPlace()); + std::vector reorder_scale = {1.0f / scale_data}; + + std::vector pipeline; + std::vector src_tz = paddle::framework::vectorize2int(input->dims()); + std::vector dst_tz = paddle::framework::vectorize2int(output->dims()); + mkldnn::memory::data_type src_dt = paddle::framework::ToMKLDNNDataType(input->type()); + mkldnn::memory::format src_fmt = input->format(); + + mkldnn::primitive_attr attri; + int mask = 0; + attri.set_output_scales(mask, reorder_scale); + + auto src_md = platform::MKLDNNMemDesc( + {src_tz}, src_dt, src_fmt); + auto src_pd = mkldnn::memory::primitive_desc(src_md, engine); + auto src_memory = std::make_shared(src_pd, to_void_cast(input_data)); + std::shared_ptr src_memory_p = std::shared_ptr(new primitive::at(*src_memory)); + + auto dst_md = platform::MKLDNNMemDesc( + {dst_tz}, memory::data_type::f32, memory::format::nchw); + auto dst_pd = mkldnn::memory::primitive_desc(dst_md, engine); + auto dst_memory = mkldnn::memory(dst_pd, to_void_cast(output_data)); + + auto reorder_pd = std::shared_ptr( + new reorder::primitive_desc(src_pd, dst_pd, attri)); + auto reorder_p= std::shared_ptr(new reorder(*reorder_pd, *src_memory_p, dst_memory)); + pipeline.push_back(*reorder_p); + stream(stream::kind::eager).submit(pipeline).wait(); + + output->set_format(GetMKLDNNFormat(dst_memory)); + + } +}; + +} // namespace operators +} // namespace paddle + +namespace ops = paddle::operators; + +REGISTER_OP_KERNEL(dequantize, MKLDNN, ::paddle::platform::CPUPlace, + ops::DeQuantOpKernel); diff --git a/paddle/fluid/operators/dequantize_op.cc b/paddle/fluid/operators/dequantize_op.cc index 8fed7d6e3da..7ac664ae4c2 100644 --- a/paddle/fluid/operators/dequantize_op.cc +++ b/paddle/fluid/operators/dequantize_op.cc @@ -12,74 +12,16 @@ 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 "mkldnn.hpp" -#include "paddle/fluid/framework/tensor.h" -#include "paddle/fluid/platform/mkldnn_helper.h" #include "paddle/fluid/operators/dequantize_op.h" -#include "paddle/fluid/framework/data_layout_transform.h" +#ifdef PADDLE_WITH_MKLDNN +#include "paddle/fluid/platform/mkldnn_helper.h" +#endif namespace paddle { namespace operators { -using mkldnn::memory; -using mkldnn::primitive; -using mkldnn::reorder; -using platform::to_void_cast; -using Tensor = framework::Tensor; -using framework::DataLayout; -using mkldnn::stream; -using platform::GetMKLDNNFormat; - -template -class DeQuantOpKernel : public framework::OpKernel { - public: - - void Compute(const framework::ExecutionContext& ctx) const override { - auto* input = ctx.Input("Input"); - auto scale_data = ctx.Attr("Scale"); - auto* output = ctx.Output("Output"); - auto& dev_ctx = - ctx.template device_context(); - const auto& engine = dev_ctx.GetEngine(); - - const T* input_data = input->data(); - float* output_data = output->mutable_data(ctx.GetPlace()); - std::vector reorder_scale = {1.0f / scale_data}; - - std::vector pipeline; - std::vector src_tz = paddle::framework::vectorize2int(input->dims()); - std::vector dst_tz = paddle::framework::vectorize2int(output->dims()); - mkldnn::memory::data_type src_dt = paddle::framework::ToMKLDNNDataType(input->type()); - mkldnn::memory::format src_fmt = input->format(); - - mkldnn::primitive_attr attri; - int mask = 0; - attri.set_output_scales(mask, reorder_scale); - - auto src_md = platform::MKLDNNMemDesc( - {src_tz}, src_dt, src_fmt); - auto src_pd = mkldnn::memory::primitive_desc(src_md, engine); - auto src_memory = std::make_shared(src_pd, to_void_cast(input_data)); - std::shared_ptr src_memory_p = std::shared_ptr(new primitive::at(*src_memory)); - - auto dst_md = platform::MKLDNNMemDesc( - {dst_tz}, memory::data_type::f32, memory::format::nchw); - auto dst_pd = mkldnn::memory::primitive_desc(dst_md, engine); - auto dst_memory = mkldnn::memory(dst_pd, to_void_cast(output_data)); - - auto reorder_pd = std::shared_ptr( - new reorder::primitive_desc(src_pd, dst_pd, attri)); - auto reorder_p= std::shared_ptr(new reorder(*reorder_pd, *src_memory_p, dst_memory)); - pipeline.push_back(*reorder_p); - stream(stream::kind::eager).submit(pipeline).wait(); - - output->set_format(GetMKLDNNFormat(dst_memory)); - - } -}; - -framework::OpKernelType DeQuantOp::GetExpectedKernelType(const framework::ExecutionContext& ctx) const { +framework::OpKernelType DeQuantOp::GetExpectedKernelType( + const framework::ExecutionContext& ctx) const { framework::LibraryType library_{framework::LibraryType::kPlain}; std::string data_format = ctx.Attr("data_format"); framework::DataLayout layout_ = framework::StringToDataLayout(data_format); @@ -93,13 +35,15 @@ framework::OpKernelType DeQuantOp::GetExpectedKernelType(const framework::Execut #endif return framework::OpKernelType( - framework::ToDataType(ctx.Input("Input")->type()),ctx.GetPlace(),layout_, library_); + framework::ToDataType(ctx.Input("Input")->type()), + ctx.GetPlace(), layout_, library_); } void DeQuantOpMaker::Make() { AddInput("Input","input data"); AddOutput("Output","output data"); - AddAttr("Scale","scale data").SetDefault({1.0f}); + AddAttr("Scale","scale data") + .SetDefault({1.0f}); AddComment(R"DOC(This op will quantize data from INT8 to FP32)DOC"); } @@ -108,7 +52,5 @@ void DeQuantOpMaker::Make() { namespace ops = paddle::operators; -REGISTER_OPERATOR(dequantize, ops::DeQuantOp, ops::DeQuantOpMaker, paddle::framework::DefaultGradOpDescMaker); - -REGISTER_OP_KERNEL(dequantize, MKLDNN, ::paddle::platform::CPUPlace, ops::DeQuantOpKernel, ops::DeQuantOpKernel); - +REGISTER_OPERATOR(dequantize, ops::DeQuantOp, ops::DeQuantOpMaker, + paddle::framework::DefaultGradOpDescMaker); diff --git a/paddle/fluid/operators/dequantize_op.h b/paddle/fluid/operators/dequantize_op.h index b0d42311af6..75c27a06c21 100644 --- a/paddle/fluid/operators/dequantize_op.h +++ b/paddle/fluid/operators/dequantize_op.h @@ -28,15 +28,14 @@ class DeQuantOp : public framework::OperatorWithKernel { public: using framework::OperatorWithKernel::OperatorWithKernel; - void InferShape(framework::InferShapeContext* ctx) const override{ + void InferShape(framework::InferShapeContext* ctx) const override { ctx->SetOutputDim("Output", ctx->GetInputDim("Input")); ctx->ShareLoD("Input", /*->*/ "Output"); - } + } protected: framework::OpKernelType GetExpectedKernelType( const framework::ExecutionContext& ctx) const override; - }; class DeQuantOpMaker : public framework::OpProtoAndCheckerMaker { @@ -53,4 +52,3 @@ class DeQuantGradOp : public framework::OperatorWithKernel { } // namespace operators } // namespace paddle - diff --git a/paddle/fluid/operators/quantize_mkldnn_op.cc b/paddle/fluid/operators/quantize_mkldnn_op.cc new file mode 100644 index 00000000000..274c410d9fd --- /dev/null +++ b/paddle/fluid/operators/quantize_mkldnn_op.cc @@ -0,0 +1,96 @@ +/* Copyright (c) 2016 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. */ + + +#include "mkldnn.hpp" +#include "paddle/fluid/framework/tensor.h" +#include "paddle/fluid/platform/mkldnn_helper.h" +#include "paddle/fluid/operators/quantize_op.h" + +namespace paddle { +namespace operators { + +using mkldnn::memory; +using mkldnn::primitive; +using mkldnn::reorder; +using platform::to_void_cast; +using Tensor = framework::Tensor; +using framework::DataLayout; +using mkldnn::stream; +using platform::GetMKLDNNFormat; + +template +class QuantOpKernel : public framework::OpKernel { + public: + void Compute(const framework::ExecutionContext& ctx) const override { + auto* input = ctx.Input("Input"); + auto scale_data = ctx.Attr("Scale"); + auto* output = ctx.Output("Output"); + auto& dev_ctx = + ctx.template device_context(); + const auto& engine = dev_ctx.GetEngine(); + + std::vector pipeline; + std::vector src_tz = paddle::framework::vectorize2int(input->dims()); + std::vector dst_tz = paddle::framework::vectorize2int(output->dims()); + + const T* input_data = input->data(); + + mkldnn::primitive_attr attri; + int mask = 0; + attri.set_output_scales(mask, {scale_data}); + + auto src_md = platform::MKLDNNMemDesc( + {src_tz}, memory::data_type::f32, input->format()); + auto src_pd = mkldnn::memory::primitive_desc(src_md, engine); + auto src_memory = std::make_shared(src_pd, to_void_cast(input_data)); + std::shared_ptr src_memory_p = std::shared_ptr(new primitive::at(*src_memory)); + + bool is_negative = ctx.Attr("is_negative_input"); + mkldnn::memory::primitive_desc dst_pd; + std::shared_ptr dst_memory; + if (is_negative) { + int8_t* output_data = output->mutable_data(ctx.GetPlace()); + auto dst_md = platform::MKLDNNMemDesc( + {dst_tz}, memory::data_type::s8, memory::format::nhwc); + dst_pd = mkldnn::memory::primitive_desc(dst_md, engine); + dst_memory.reset(new mkldnn::memory(dst_pd, to_void_cast(output_data))); + } else { + uint8_t* output_data = output->mutable_data(ctx.GetPlace()); + auto dst_md = platform::MKLDNNMemDesc( + {dst_tz}, memory::data_type::u8, memory::format::nhwc); + dst_pd = mkldnn::memory::primitive_desc(dst_md, engine); + dst_memory.reset(new mkldnn::memory(dst_pd, to_void_cast(output_data))); + } + + auto reorder_pd = std::shared_ptr( + new reorder::primitive_desc(src_pd, dst_pd, attri)); + auto reorder_p= std::shared_ptr(new reorder(*reorder_pd, *src_memory_p, *dst_memory)); + + pipeline.push_back(*reorder_p); + stream(stream::kind::eager).submit(pipeline).wait(); + + output->set_layout(DataLayout::kMKLDNN); + output->set_format(GetMKLDNNFormat(*dst_memory)); + } +}; + +} // namespace operators +} // namespace paddle +namespace ops = paddle::operators; + +//TODO Support FP32->S8 quantization. + +REGISTER_OP_KERNEL(quantize, MKLDNN, ::paddle::platform::CPUPlace, + ops::QuantOpKernel); diff --git a/paddle/fluid/operators/quantize_op.cc b/paddle/fluid/operators/quantize_op.cc index aba7ad51d0a..9cf29ea330d 100644 --- a/paddle/fluid/operators/quantize_op.cc +++ b/paddle/fluid/operators/quantize_op.cc @@ -1,92 +1,27 @@ /* Copyright (c) 2016 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. */ -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 "mkldnn.hpp" -#include "paddle/fluid/framework/tensor.h" -#include "paddle/fluid/platform/mkldnn_helper.h" #include "paddle/fluid/operators/quantize_op.h" +#ifdef PADDLE_WITH_MKLDNN +#include "paddle/fluid/platform/mkldnn_helper.h" +#endif namespace paddle { namespace operators { -using mkldnn::memory; -using mkldnn::primitive; -using mkldnn::reorder; -using platform::to_void_cast; -using Tensor = framework::Tensor; -using framework::DataLayout; -using mkldnn::stream; -using platform::GetMKLDNNFormat; - -template -class QuantOpKernel : public framework::OpKernel { - public: - void Compute(const framework::ExecutionContext& ctx) const override { - auto* input = ctx.Input("Input"); - auto scale_data = ctx.Attr("Scale"); - auto* output = ctx.Output("Output"); - auto& dev_ctx = - ctx.template device_context(); - const auto& engine = dev_ctx.GetEngine(); - - std::vector pipeline; - std::vector src_tz = paddle::framework::vectorize2int(input->dims()); - std::vector dst_tz = paddle::framework::vectorize2int(output->dims()); - - const T* input_data = input->data(); - - mkldnn::primitive_attr attri; - int mask = 0; - attri.set_output_scales(mask, {scale_data}); - - auto src_md = platform::MKLDNNMemDesc( - {src_tz}, memory::data_type::f32, input->format()); - auto src_pd = mkldnn::memory::primitive_desc(src_md, engine); - auto src_memory = std::make_shared(src_pd, to_void_cast(input_data)); - std::shared_ptr src_memory_p = std::shared_ptr(new primitive::at(*src_memory)); - - bool is_negative = ctx.Attr("is_negative_input"); - mkldnn::memory::primitive_desc dst_pd; - std::shared_ptr dst_memory; - if (is_negative) { - int8_t* output_data = output->mutable_data(ctx.GetPlace()); - auto dst_md = platform::MKLDNNMemDesc( - {dst_tz}, memory::data_type::s8, memory::format::nhwc); - dst_pd = mkldnn::memory::primitive_desc(dst_md, engine); - dst_memory.reset(new mkldnn::memory(dst_pd, to_void_cast(output_data))); - } else { - uint8_t* output_data = output->mutable_data(ctx.GetPlace()); - auto dst_md = platform::MKLDNNMemDesc( - {dst_tz}, memory::data_type::u8, memory::format::nhwc); - dst_pd = mkldnn::memory::primitive_desc(dst_md, engine); - dst_memory.reset(new mkldnn::memory(dst_pd, to_void_cast(output_data))); - } - - auto reorder_pd = std::shared_ptr( - new reorder::primitive_desc(src_pd, dst_pd, attri)); - auto reorder_p= std::shared_ptr(new reorder(*reorder_pd, *src_memory_p, *dst_memory)); - - pipeline.push_back(*reorder_p); - stream(stream::kind::eager).submit(pipeline).wait(); - - output->set_layout(DataLayout::kMKLDNN); - output->set_format(GetMKLDNNFormat(*dst_memory)); - } -}; - -framework::OpKernelType QuantOp::GetExpectedKernelType(const framework::ExecutionContext& ctx) const { +framework::OpKernelType QuantOp::GetExpectedKernelType( + const framework::ExecutionContext& ctx) const { framework::LibraryType library_{framework::LibraryType::kPlain}; std::string data_format = ctx.Attr("data_format"); framework::DataLayout layout_ = framework::StringToDataLayout(data_format); @@ -100,13 +35,13 @@ framework::OpKernelType QuantOp::GetExpectedKernelType(const framework::Executio #endif return framework::OpKernelType( - framework::ToDataType(ctx.Input("Input")->type()),ctx.GetPlace(),layout_, library_); + framework::ToDataType(ctx.Input("Input")->type()), + ctx.GetPlace(), layout_, library_); } - void QuantOpMaker::Make() { - AddInput("Input","input data"); - AddOutput("Output","output data"); + AddInput("Input", "input data"); + AddOutput("Output", "output data"); AddAttr("is_negative_input", "(bool, default false) Only used in mkldnn INT8 kernel") .SetDefault(false); @@ -119,12 +54,5 @@ void QuantOpMaker::Make() { } // namespace paddle namespace ops = paddle::operators; -//TODO Support FP32->S8 quantization. - -REGISTER_OPERATOR(quantize, ops::QuantOp, ops::QuantOpMaker, paddle::framework::DefaultGradOpDescMaker); - -REGISTER_OP_KERNEL(quantize, MKLDNN, ::paddle::platform::CPUPlace, ops::QuantOpKernel); - - - - +REGISTER_OPERATOR(quantize, ops::QuantOp, ops::QuantOpMaker, + paddle::framework::DefaultGradOpDescMaker); diff --git a/paddle/fluid/operators/quantize_op.h b/paddle/fluid/operators/quantize_op.h index 4763f523ecb..091306e4637 100644 --- a/paddle/fluid/operators/quantize_op.h +++ b/paddle/fluid/operators/quantize_op.h @@ -28,28 +28,19 @@ class QuantOp : public framework::OperatorWithKernel { public: using framework::OperatorWithKernel::OperatorWithKernel; - void InferShape(framework::InferShapeContext* ctx) const override{ + void InferShape(framework::InferShapeContext* ctx) const override { ctx->SetOutputDim("Output", ctx->GetInputDim("Input")); ctx->ShareLoD("Input", /*->*/ "Output"); - } + } protected: framework::OpKernelType GetExpectedKernelType( const framework::ExecutionContext& ctx) const override; - }; class QuantOpMaker : public framework::OpProtoAndCheckerMaker { public: void Make() override; -//void Make() { -// AddInput("Input","input"); -// AddInput("Scale","scale..."); -// AddOutput("Output","output"); -//} }; - - } // namespace operators } // namespace paddle - -- GitLab