From 74478de5c6377035a0ad5cbebe35a4f4776e0927 Mon Sep 17 00:00:00 2001 From: eclipsess Date: Fri, 29 Jun 2018 17:55:29 +0800 Subject: [PATCH] conflict --- src/common/types.cpp | 9 +- src/common/types.h | 4 +- src/framework/operator.h | 8 +- src/operators/feed_op.h | 2 +- src/operators/fetch_op.h | 2 +- src/operators/fusion_conv_add.cpp | 4 +- src/operators/fusion_conv_add.h | 12 +- src/operators/fusion_conv_add_bn_relu_op.cpp | 63 +++++++- src/operators/fusion_conv_add_bn_relu_op.h | 107 ++++++++++++- src/operators/fusion_fc_op.cpp | 4 +- src/operators/kernel/arm/batchnorm_kernel.cpp | 2 +- src/operators/kernel/arm/box_coder_kernel.cpp | 2 +- src/operators/kernel/arm/concat_kernel.cpp | 2 +- .../kernel/arm/conv_add_bn_relu_kernel.cpp | 69 +++++++- .../kernel/arm/conv_add_relu_kernel.cpp | 3 +- src/operators/kernel/arm/conv_kernel.cpp | 2 +- .../kernel/arm/depthwise_conv_kernel.cpp | 2 +- .../kernel/arm/elementwise_add_kernel.cpp | 3 +- src/operators/kernel/arm/fusion_fc_kernel.cpp | 2 +- src/operators/kernel/arm/lrn_kernel.cpp | 2 +- src/operators/kernel/arm/mul_kernel.cpp | 2 +- .../kernel/arm/multiclass_nms_kernel.cpp | 3 +- src/operators/kernel/arm/pool_kernel.cpp | 2 +- src/operators/kernel/arm/prior_box_kernel.cpp | 2 +- src/operators/kernel/arm/relu_kernel.cpp | 2 +- src/operators/kernel/arm/reshape_kernel.cpp | 2 +- src/operators/kernel/arm/sigmoid_kernel.cpp | 2 +- src/operators/kernel/arm/softmax_kernel.cpp | 2 +- src/operators/kernel/arm/transpose_kernel.cpp | 2 +- src/operators/kernel/batchnorm_kernel.h | 2 +- src/operators/kernel/box_coder_kernel.h | 2 +- .../central-arm-func/batchnorm_arm_func.h | 9 +- .../central-arm-func/conv_add_bn_relu_func.h | 149 +++++++++++++++++- src/operators/kernel/concat_kernel.h | 2 +- .../kernel/conv_add_bn_relu_kernel.h | 24 +-- src/operators/kernel/conv_add_kernel.h | 2 +- src/operators/kernel/conv_add_relu_kernel.h | 2 +- src/operators/kernel/conv_kernel.h | 2 +- src/operators/kernel/depthwise_conv_kernel.h | 2 +- src/operators/kernel/elementwise_add_kernel.h | 2 +- src/operators/kernel/fpga/conv_kernel.cpp | 2 +- src/operators/kernel/fusion_fc_kernel.h | 2 +- src/operators/kernel/lrn_kernel.h | 2 +- .../kernel/mali/batchnorm_kernel.cpp | 2 +- src/operators/kernel/mali/conv_kernel.cpp | 2 +- src/operators/kernel/mul_kernel.h | 2 +- src/operators/kernel/multiclass_nms_kernel.h | 2 +- src/operators/kernel/pool_kernel.h | 2 +- src/operators/kernel/prior_box_kernel.h | 2 +- src/operators/kernel/relu_kernel.h | 2 +- src/operators/kernel/reshape_kernel.h | 2 +- src/operators/kernel/sigmoid_kernel.h | 2 +- src/operators/kernel/softmax_kernel.h | 2 +- src/operators/kernel/transpose_kernel.h | 2 +- src/operators/math/depthwiseconv3x3s1p1.cpp | 119 ++++++++++---- src/operators/math/depthwiseconv3x3s1p1.h | 3 +- src/operators/op_param.h | 91 +++++++++++ tools/op.cmake | 3 + 58 files changed, 636 insertions(+), 129 deletions(-) diff --git a/src/common/types.cpp b/src/common/types.cpp index a6f32762d3..d1647ab235 100644 --- a/src/common/types.cpp +++ b/src/common/types.cpp @@ -23,8 +23,9 @@ const std::string G_OP_TYPE_BOX_CODER = "box_coder"; const std::string G_OP_TYPE_CONCAT = "concat"; const std::string G_OP_TYPE_ELEMENTWISE_ADD = "elementwise_add"; const std::string G_OP_TYPE_FUSION_CONV_ADD_RELU = "fusion_conv_add_relu"; -const std::string G_OP_TYPE_FC = "fc"; -const std::string G_OP_TYPE_CONV_ADD = "conv_add"; +const std::string G_OP_TYPE_FUSION_CONV_ADD_BN_RELU = "fusion_conv_add_bn_relu"; +const std::string G_OP_TYPE_FC = "fusion_fc"; +const std::string G_OP_TYPE_FUSION_CONV_ADD = "fusion_conv_add"; const std::string G_OP_TYPE_LRN = "lrn"; const std::string G_OP_TYPE_MUL = "mul"; const std::string G_OP_TYPE_MULTICLASS_NMS = "multiclass_nms"; @@ -44,7 +45,7 @@ std::unordered_map< std::string, std::pair, std::vector>> op_input_output_key = { {G_OP_TYPE_CONV, {{"Input"}, {"Output"}}}, - {G_OP_TYPE_CONV_ADD, {{"Input"}, {"Out"}}}, + {G_OP_TYPE_FUSION_CONV_ADD, {{"Input"}, {"Out"}}}, {G_OP_TYPE_RELU, {{"X"}, {"Out"}}}, {G_OP_TYPE_SOFTMAX, {{"X"}, {"Out"}}}, {G_OP_TYPE_MUL, {{"X"}, {"Out"}}}, @@ -59,6 +60,8 @@ std::unordered_map< {G_OP_TYPE_TRANSPOSE, {{"X"}, {"Out"}}}, {G_OP_TYPE_BOX_CODER, {{"PriorBox", "PriorBoxVar", "TargetBox"}, {"OutputBox"}}}, + {G_OP_TYPE_FUSION_CONV_ADD_BN_RELU, + {{"Input"}, {"Out"}}}, {G_OP_TYPE_PRIOR_BOX, {{"Image", "Input"}, {"Boxes", "Variances"}}}, {G_OP_TYPE_MULTICLASS_NMS, {{"BBoxes", "Scores"}, {"Out"}}}, {G_OP_TYPE_FC, {{"X", "Y", "Z"}, {"Out"}}}, diff --git a/src/common/types.h b/src/common/types.h index 49f0c49a58..9134ebe356 100644 --- a/src/common/types.h +++ b/src/common/types.h @@ -79,7 +79,9 @@ extern const std::string G_OP_TYPE_CONCAT; extern const std::string G_OP_TYPE_ELEMENTWISE_ADD; extern const std::string G_OP_TYPE_FUSION_CONV_ADD_RELU; extern const std::string G_OP_TYPE_FC; -extern const std::string G_OP_TYPE_CONV_ADD; +extern const std::string G_OP_TYPE_FUSION_CONV_ADD; +extern const std::string G_OP_TYPE_FUSION_CONV_ADD_BN_RELU; + extern const std::string G_OP_TYPE_LRN; extern const std::string G_OP_TYPE_MUL; extern const std::string G_OP_TYPE_MULTICLASS_NMS; diff --git a/src/framework/operator.h b/src/framework/operator.h index c68744a676..793551b0cd 100644 --- a/src/framework/operator.h +++ b/src/framework/operator.h @@ -63,7 +63,7 @@ class OperatorBase { std::vector GetOutKeys() const; virtual void RunImpl() const = 0; - virtual void Init() const = 0; + virtual void Init() = 0; /* * @b op 运算所需的输入, 如上一层的输出结果、卷积核 * */ @@ -117,8 +117,8 @@ class OperatorWithKernel : public OperatorBase { virtual void InferShape() const = 0; - void Init() const { - PADDLE_MOBILE_ENFORCE(kernel_.Init(param_), " %s kernel init failed", + void Init() { + PADDLE_MOBILE_ENFORCE(kernel_.Init(¶m_), " %s kernel init failed", this->type_.c_str()); } @@ -146,7 +146,7 @@ class OpKernelBase { } #endif virtual void Compute(const P ¶) const = 0; - virtual bool Init(const P ¶) const { return true; }; + virtual bool Init(P *para) { return true; }; virtual ~OpKernelBase() = default; private: diff --git a/src/operators/feed_op.h b/src/operators/feed_op.h index bd5fd8cb32..8753bfa937 100644 --- a/src/operators/feed_op.h +++ b/src/operators/feed_op.h @@ -32,7 +32,7 @@ class FeedOp : public framework::OperatorBase { param_(inputs, outputs, attrs, *scope) {} void RunImpl() const { param_.Out()->ShareDataWith(*param_.InputX()); } - void Init() const {} + void Init() {} void InferShape() const { auto out_dims = param_.Out()->dims(); diff --git a/src/operators/fetch_op.h b/src/operators/fetch_op.h index 4b3680b583..b46093e18e 100644 --- a/src/operators/fetch_op.h +++ b/src/operators/fetch_op.h @@ -33,7 +33,7 @@ class FetchOp : public framework::OperatorBase { param_(inputs, outputs, attrs, *scope) {} void RunImpl() const { param_.Out()->ShareDataWith(*param_.InputX()); } - void Init() const {} + void Init() {} void InferShape() const { auto x_dims = param_.InputX()->dims(); diff --git a/src/operators/fusion_conv_add.cpp b/src/operators/fusion_conv_add.cpp index 4c01603509..731bb66cb0 100644 --- a/src/operators/fusion_conv_add.cpp +++ b/src/operators/fusion_conv_add.cpp @@ -50,8 +50,8 @@ template class FusionConvAddOp; namespace ops = paddle_mobile::operators; #ifdef PADDLE_MOBILE_CPU -USE_OP_CPU(conv_add); -REGISTER_OPERATOR_CPU(conv_add, ops::FusionConvAddOp); +USE_OP_CPU(fusion_conv_add); +REGISTER_OPERATOR_CPU(fusion_conv_add, ops::FusionConvAddOp); #endif #ifdef PADDLE_MOBILE_MALI_GPU USE_OP_MALI_GPU(conv_add); diff --git a/src/operators/fusion_conv_add.h b/src/operators/fusion_conv_add.h index 89262cc508..e9677b33de 100644 --- a/src/operators/fusion_conv_add.h +++ b/src/operators/fusion_conv_add.h @@ -42,7 +42,7 @@ class FusionConvAddMatcher : public framework::FusionOpMatcher { {{G_OP_TYPE_ELEMENTWISE_ADD, {{"Y", "Y"}}}}, removed_nodes); } - std::string Type() { return G_OP_TYPE_CONV_ADD; } + std::string Type() { return G_OP_TYPE_FUSION_CONV_ADD; } }; template @@ -68,11 +68,11 @@ class FusionConvAddOp : public framework::OperatorWithKernel< #ifdef PADDLE_MOBILE_CPU -#ifndef CONV_ADD_REGISTER -static framework::FusionOpRegistrar convadd_registrar( - new FusionConvAddMatcher()); -#define CONV_ADD_REGISTER -#endif +//#ifndef CONV_ADD_REGISTER +//static framework::FusionOpRegistrar convadd_registrar( +// new FusionConvAddMatcher()); +//#define CONV_ADD_REGISTER +//#endif #endif diff --git a/src/operators/fusion_conv_add_bn_relu_op.cpp b/src/operators/fusion_conv_add_bn_relu_op.cpp index 5a92eca45a..63d0b23444 100644 --- a/src/operators/fusion_conv_add_bn_relu_op.cpp +++ b/src/operators/fusion_conv_add_bn_relu_op.cpp @@ -1,4 +1,61 @@ -// -// Created by Yang,Sui on 2018/6/28. -// +/* 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. */ + +#ifdef FUSION_CONVADDBNRELU_OP + +#include "operators/fusion_conv_add_bn_relu_op.h" +#include "operators/math/conv_func.h" + +namespace paddle_mobile { +namespace operators { + +template +void FusionConvAddBNReluOp::InferShape() const { + auto in_dims = this->param_.Input()->dims(); + auto filter_dims = this->param_.Filter()->dims(); + const std::vector &strides = this->param_.Strides(); + std::vector paddings = this->param_.Paddings(); + int groups = this->param_.Groups(); + std::vector dilations = this->param_.Dilations(); + + PADDLE_MOBILE_ENFORCE((in_dims.size() == filter_dims.size() && + dilations.size() == paddings.size() && + paddings.size() == strides.size()), + "ConvParam is not suitable"); + + std::vector output_shape({in_dims[0], filter_dims[0]}); + for (size_t i = 0; i < strides.size(); ++i) { + output_shape.push_back( + math::ConvOutputSize(in_dims[i + 2], filter_dims[i + 2], dilations[i], + paddings[i], strides[i])); + } + + framework::DDim ddim = framework::make_ddim(output_shape); + this->param_.Output()->Resize(ddim); +} +template class FusionConvAddBNReluOp; +} // namespace operators +} // namespace paddle_mobile + +namespace ops = paddle_mobile::operators; +#ifdef PADDLE_MOBILE_CPU +USE_OP_CPU(fusion_conv_add_bn_relu); +REGISTER_OPERATOR_CPU(fusion_conv_add_bn_relu, ops::FusionConvAddBNReluOp); +#endif +#ifdef PADDLE_MOBILE_MALI_GPU +#endif +#ifdef PADDLE_MOBILE_FPGA +#endif + +#endif diff --git a/src/operators/fusion_conv_add_bn_relu_op.h b/src/operators/fusion_conv_add_bn_relu_op.h index e265906cb7..0091e30f58 100644 --- a/src/operators/fusion_conv_add_bn_relu_op.h +++ b/src/operators/fusion_conv_add_bn_relu_op.h @@ -1,8 +1,103 @@ -// -// Created by Yang,Sui on 2018/6/28. -// +/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. -#ifndef PADDLE_MOBILE_FUSION_CONV_ADD_BN_RELU_OP_H -#define PADDLE_MOBILE_FUSION_CONV_ADD_BN_RELU_OP_H +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 -#endif //PADDLE_MOBILE_FUSION_CONV_ADD_BN_RELU_OP_H + 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. */ + +#define FUSION_CONVADDBNRELU_OP +#ifdef FUSION_CONVADDBNRELU_OP + +#pragma once + +#include +#include +#include "framework/operator.h" +#include "framework/program/program-optimize/fusion_op_register.h" +#include "op_param.h" +#include "operators/kernel/conv_add_bn_relu_kernel.h" + +namespace paddle_mobile { +namespace operators { +using std::string; +using std::vector; +class FusionConvAddBNReluMatcher : public framework::FusionOpMatcher { + public: + FusionConvAddBNReluMatcher() { + node_ = framework::Node(G_OP_TYPE_CONV); + node_ > std::make_shared(G_OP_TYPE_ELEMENTWISE_ADD) > + std::make_shared(G_OP_TYPE_BATCHNORM) > + std::make_shared(G_OP_TYPE_RELU); + } + + void FolderNodes( + framework::Node *node, + std::vector> *removed_nodes) { + vector> origin_descs = + node->OpDescs(node_.Depth()); + node->Folder(node_.Depth(), Type(), + { {G_OP_TYPE_ELEMENTWISE_ADD, {{"Y", "Y"}}}, + {G_OP_TYPE_BATCHNORM, {{"Scale", "Scale"}, + {"Mean", "Mean"}, + {"Bias", "Bias"}, + {"Variance", "Variance"}}}}, removed_nodes); + } + + std::string Type() { return G_OP_TYPE_FUSION_CONV_ADD_BN_RELU; } +}; + +template +class FusionConvAddBNReluOp + : public framework::OperatorWithKernel< + DeviceType, FusionConvAddBNReluParam, + operators::ConvAddBNReluKernel> { + public: + FusionConvAddBNReluOp(const string &type, const VariableNameMap &inputs, + const VariableNameMap &outputs, + const framework::AttributeMap &attrs, + std::shared_ptr scope) + : framework::OperatorWithKernel< + DeviceType, FusionConvAddBNReluParam, + operators::ConvAddBNReluKernel>( + type, inputs, outputs, attrs, scope) {} + + using framework::OperatorWithKernel< + DeviceType, FusionConvAddBNReluParam, + operators::ConvAddBNReluKernel>::OperatorWithKernel; + void InferShape() const override; + + protected: +}; + +#ifdef PADDLE_MOBILE_CPU +//#ifndef FUSION_CONV_ADD_BN_RELU_REGISTER +//static framework::FusionOpRegistrar fusion_conv_add_bn_relu_registrar( +// new FusionConvAddBNReluMatcher()); +//#define FUSION_CONV_ADD_BN_RELU_REGISTER +//#endif +#endif + +#ifdef PADDLE_MOBILE_MALI_GPU + +#ifndef FUSION_CONV_ADD_BN_RELU_REGISTER +static framework::FusionOpRegistrar fusion_conv_add_bn_relu_registrar( + new FusionConvAddBNReluMatcher()); +#define FUSION_CONV_ADD_BN_RELU_REGISTER +#endif + +#endif + +#ifdef PADDLE_MOBILE_FPGA +#endif + +} // namespace operators +} // namespace paddle_mobile + +#endif diff --git a/src/operators/fusion_fc_op.cpp b/src/operators/fusion_fc_op.cpp index fae5613488..2e591b678c 100644 --- a/src/operators/fusion_fc_op.cpp +++ b/src/operators/fusion_fc_op.cpp @@ -55,8 +55,8 @@ template class FusionFcOp; namespace ops = paddle_mobile::operators; #ifdef PADDLE_MOBILE_CPU -USE_OP_CPU(fc); -REGISTER_OPERATOR_CPU(fc, ops::FusionFcOp); +USE_OP_CPU(fusion_fc); +REGISTER_OPERATOR_CPU(fusion_fc, ops::FusionFcOp); #endif #ifdef PADDLE_MOBILE_MALI_GPU USE_OP_MALI_GPU(fc); diff --git a/src/operators/kernel/arm/batchnorm_kernel.cpp b/src/operators/kernel/arm/batchnorm_kernel.cpp index 964bf71f45..dcc2039185 100644 --- a/src/operators/kernel/arm/batchnorm_kernel.cpp +++ b/src/operators/kernel/arm/batchnorm_kernel.cpp @@ -21,7 +21,7 @@ namespace paddle_mobile { namespace operators { template <> -bool BatchNormKernel::Init(const BatchNormParam ¶) const { +bool BatchNormKernel::Init(BatchNormParam *param) const { return true; } diff --git a/src/operators/kernel/arm/box_coder_kernel.cpp b/src/operators/kernel/arm/box_coder_kernel.cpp index df0a75f357..0a08205262 100644 --- a/src/operators/kernel/arm/box_coder_kernel.cpp +++ b/src/operators/kernel/arm/box_coder_kernel.cpp @@ -111,7 +111,7 @@ void DecodeCenterSize(const framework::Tensor& target_box, } template <> -bool BoxCoderKernel::Init(const BoxCoderParam& para) const { +bool BoxCoderKernel::Init(BoxCoderParam* param) const { return true; } diff --git a/src/operators/kernel/arm/concat_kernel.cpp b/src/operators/kernel/arm/concat_kernel.cpp index 0312047b8e..112d104ea1 100644 --- a/src/operators/kernel/arm/concat_kernel.cpp +++ b/src/operators/kernel/arm/concat_kernel.cpp @@ -53,7 +53,7 @@ class ConcatFunctor { }; template <> -bool ConcatKernel::Init(const ConcatParam ¶) const { +bool ConcatKernel::Init(ConcatParam *param) const { return true; } diff --git a/src/operators/kernel/arm/conv_add_bn_relu_kernel.cpp b/src/operators/kernel/arm/conv_add_bn_relu_kernel.cpp index 5a92eca45a..b514b44f43 100644 --- a/src/operators/kernel/arm/conv_add_bn_relu_kernel.cpp +++ b/src/operators/kernel/arm/conv_add_bn_relu_kernel.cpp @@ -1,4 +1,67 @@ -// -// Created by Yang,Sui on 2018/6/28. -// +/* 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. */ + +#ifdef FUSION_CONVADDBNRELU_OP + +#include "operators/kernel/conv_add_bn_relu_kernel.h" +#include "operators/kernel/central-arm-func/conv_add_bn_relu_func.h" + +namespace paddle_mobile { +namespace operators { + +template <> +bool ConvAddBNReluKernel::Init( + FusionConvAddBNReluParam *param) const { + const Tensor *mean = (*param).InputMean(); + const Tensor *variance = (*param).InputVariance(); + const Tensor *scale = (*param).InputScale(); + const Tensor *bias = (*param).InputBias(); + const float epsilon = (*param).Epsilon(); + + auto mean_ptr = mean->data(); + auto variance_ptr = variance->data(); + auto scale_ptr = scale->data(); + auto bias_ptr = bias->data(); + + const int C = mean->numel(); + float inv_std_ptr[C]; + for (int i = 0; i < C; i++) { + inv_std_ptr[i] = + 1 / static_cast(pow((variance_ptr[i] + epsilon), 0.5)); + } + Tensor *new_scale = new Tensor(); + Tensor *new_bias = new Tensor(); + auto new_scale_ptr = new_scale->mutable_data({C}); + auto new_bias_ptr = new_bias->mutable_data({C}); + for (int i = 0; i < C; i++) { + new_scale_ptr[i] = inv_std_ptr[i] * scale_ptr[i]; + new_bias_ptr[i] = bias_ptr[i] - mean_ptr[i] * inv_std_ptr[i] * scale_ptr[i]; + } + std::cout << "yes" << std::endl; + (*param).SetNewScale(new_scale); + (*param).SetNewBias(new_bias); + return true; +} + +template <> +void ConvAddBNReluKernel::Compute( + const FusionConvAddBNReluParam ¶m) const { + ConvAddBNReluCompute(param); +} +template class ConvAddBNReluKernel; + +} // namespace operators +} // namespace paddle_mobile + +#endif diff --git a/src/operators/kernel/arm/conv_add_relu_kernel.cpp b/src/operators/kernel/arm/conv_add_relu_kernel.cpp index d3c04179b3..6fa5ce44af 100644 --- a/src/operators/kernel/arm/conv_add_relu_kernel.cpp +++ b/src/operators/kernel/arm/conv_add_relu_kernel.cpp @@ -21,8 +21,7 @@ namespace paddle_mobile { namespace operators { template <> -bool ConvAddReluKernel::Init( - const FusionConvAddReluParam ¶) const { +bool ConvAddReluKernel::Init(FusionConvAddReluParam *param) const { return true; } diff --git a/src/operators/kernel/arm/conv_kernel.cpp b/src/operators/kernel/arm/conv_kernel.cpp index 049425d88f..04e7c43b71 100644 --- a/src/operators/kernel/arm/conv_kernel.cpp +++ b/src/operators/kernel/arm/conv_kernel.cpp @@ -21,7 +21,7 @@ namespace paddle_mobile { namespace operators { template <> -bool ConvKernel::Init(const ConvParam ¶) const { +bool ConvKernel::Init(ConvParam *param) const { return true; } diff --git a/src/operators/kernel/arm/depthwise_conv_kernel.cpp b/src/operators/kernel/arm/depthwise_conv_kernel.cpp index 4cbfa23248..859622f063 100644 --- a/src/operators/kernel/arm/depthwise_conv_kernel.cpp +++ b/src/operators/kernel/arm/depthwise_conv_kernel.cpp @@ -21,7 +21,7 @@ namespace paddle_mobile { namespace operators { template <> -bool DepthwiseConvKernel::Init(const ConvParam ¶) const { +bool DepthwiseConvKernel::Init(ConvParam *param) const { return true; } diff --git a/src/operators/kernel/arm/elementwise_add_kernel.cpp b/src/operators/kernel/arm/elementwise_add_kernel.cpp index 2f5e26a37e..e1e1ee0ce8 100644 --- a/src/operators/kernel/arm/elementwise_add_kernel.cpp +++ b/src/operators/kernel/arm/elementwise_add_kernel.cpp @@ -27,8 +27,7 @@ struct AddFunctor { }; template <> -bool ElementwiseAddKernel::Init( - const ElementwiseAddParam ¶) const { +bool ElementwiseAddKernel::Init(ElementwiseAddParam *param) const { return true; } diff --git a/src/operators/kernel/arm/fusion_fc_kernel.cpp b/src/operators/kernel/arm/fusion_fc_kernel.cpp index 5fac70e407..0cc0601171 100644 --- a/src/operators/kernel/arm/fusion_fc_kernel.cpp +++ b/src/operators/kernel/arm/fusion_fc_kernel.cpp @@ -22,7 +22,7 @@ namespace paddle_mobile { namespace operators { template <> -bool FusionFcKernel::Init(const FusionFcParam ¶) const { +bool FusionFcKernel::Init(FusionFcParam *param) const { return true; } diff --git a/src/operators/kernel/arm/lrn_kernel.cpp b/src/operators/kernel/arm/lrn_kernel.cpp index 839c5ee95b..cf6057fd7f 100644 --- a/src/operators/kernel/arm/lrn_kernel.cpp +++ b/src/operators/kernel/arm/lrn_kernel.cpp @@ -22,7 +22,7 @@ namespace paddle_mobile { namespace operators { template <> -bool LrnKernel::Init(const LrnParam ¶) const { +bool LrnKernel::Init(LrnParam *param) const { return true; } diff --git a/src/operators/kernel/arm/mul_kernel.cpp b/src/operators/kernel/arm/mul_kernel.cpp index b3bb2b8075..54ed460ce7 100644 --- a/src/operators/kernel/arm/mul_kernel.cpp +++ b/src/operators/kernel/arm/mul_kernel.cpp @@ -22,7 +22,7 @@ namespace paddle_mobile { namespace operators { template <> -bool MulKernel::Init(const MulParam ¶) const { +bool MulKernel::Init(MulParam *param) const { return true; } diff --git a/src/operators/kernel/arm/multiclass_nms_kernel.cpp b/src/operators/kernel/arm/multiclass_nms_kernel.cpp index 67cf8197ca..a7d12d47b2 100644 --- a/src/operators/kernel/arm/multiclass_nms_kernel.cpp +++ b/src/operators/kernel/arm/multiclass_nms_kernel.cpp @@ -204,8 +204,7 @@ void MultiClassOutput(const Tensor& scores, const Tensor& bboxes, } template <> -bool MultiClassNMSKernel::Init( - const MultiClassNMSParam& para) const { +bool MultiClassNMSKernel::Init(MultiClassNMSParam* param) const { return true; } diff --git a/src/operators/kernel/arm/pool_kernel.cpp b/src/operators/kernel/arm/pool_kernel.cpp index 09162a13a4..3031b18999 100644 --- a/src/operators/kernel/arm/pool_kernel.cpp +++ b/src/operators/kernel/arm/pool_kernel.cpp @@ -36,7 +36,7 @@ inline void PoolBasic(std::string pooling_type, std::vector ksize, } template <> -bool PoolKernel::Init(const PoolParam ¶) const { +bool PoolKernel::Init(PoolParam *param) const { return true; } diff --git a/src/operators/kernel/arm/prior_box_kernel.cpp b/src/operators/kernel/arm/prior_box_kernel.cpp index 13939bc7bf..ac560dd919 100644 --- a/src/operators/kernel/arm/prior_box_kernel.cpp +++ b/src/operators/kernel/arm/prior_box_kernel.cpp @@ -27,7 +27,7 @@ struct ClipFunctor { }; template <> -bool PriorBoxKernel::Init(const PriorBoxParam ¶) const { +bool PriorBoxKernel::Init(PriorBoxParam *param) const { return true; } diff --git a/src/operators/kernel/arm/relu_kernel.cpp b/src/operators/kernel/arm/relu_kernel.cpp index 5bc485b77a..c0346ad722 100644 --- a/src/operators/kernel/arm/relu_kernel.cpp +++ b/src/operators/kernel/arm/relu_kernel.cpp @@ -26,7 +26,7 @@ struct ReluFunctor { }; template <> -bool ReluKernel::Init(const ReluParam ¶) const { +bool ReluKernel::Init(ReluParam *param) const { return true; } diff --git a/src/operators/kernel/arm/reshape_kernel.cpp b/src/operators/kernel/arm/reshape_kernel.cpp index 97364f9a3f..e492a98e59 100644 --- a/src/operators/kernel/arm/reshape_kernel.cpp +++ b/src/operators/kernel/arm/reshape_kernel.cpp @@ -20,7 +20,7 @@ namespace paddle_mobile { namespace operators { template <> -bool ReshapeKernel::Init(const ReshapeParam ¶) const { +bool ReshapeKernel::Init(ReshapeParam *param) const { return true; } diff --git a/src/operators/kernel/arm/sigmoid_kernel.cpp b/src/operators/kernel/arm/sigmoid_kernel.cpp index 3e87bfacc5..44bd48800d 100644 --- a/src/operators/kernel/arm/sigmoid_kernel.cpp +++ b/src/operators/kernel/arm/sigmoid_kernel.cpp @@ -72,7 +72,7 @@ void sigmoid(const Tensor *X, Tensor *Y) { } template <> -bool SigmoidKernel::Init(const SigmoidParam ¶) const { +bool SigmoidKernel::Init(SigmoidParam *param) const { return true; } diff --git a/src/operators/kernel/arm/softmax_kernel.cpp b/src/operators/kernel/arm/softmax_kernel.cpp index 8e966aa0af..7fe9007ebe 100644 --- a/src/operators/kernel/arm/softmax_kernel.cpp +++ b/src/operators/kernel/arm/softmax_kernel.cpp @@ -20,7 +20,7 @@ namespace paddle_mobile { namespace operators { template <> -bool SoftmaxKernel::Init(const SoftmaxParam ¶) const { +bool SoftmaxKernel::Init(SoftmaxParam *param) const { return true; } diff --git a/src/operators/kernel/arm/transpose_kernel.cpp b/src/operators/kernel/arm/transpose_kernel.cpp index a44ff22a2f..e43c42010f 100644 --- a/src/operators/kernel/arm/transpose_kernel.cpp +++ b/src/operators/kernel/arm/transpose_kernel.cpp @@ -35,7 +35,7 @@ namespace operators { // } template <> -bool TransposeKernel::Init(const TransposeParam& para) const { +bool TransposeKernel::Init(TransposeParam* param) const { return true; } diff --git a/src/operators/kernel/batchnorm_kernel.h b/src/operators/kernel/batchnorm_kernel.h index 6ef5329bc5..c143d08a3a 100644 --- a/src/operators/kernel/batchnorm_kernel.h +++ b/src/operators/kernel/batchnorm_kernel.h @@ -29,7 +29,7 @@ class BatchNormKernel : public framework::OpKernelBase { public: void Compute(const BatchNormParam ¶m) const; - bool Init(const BatchNormParam ¶) const; + bool Init(BatchNormParam *param) const; }; } // namespace operators diff --git a/src/operators/kernel/box_coder_kernel.h b/src/operators/kernel/box_coder_kernel.h index 4c4206f52b..7b98b0c10c 100644 --- a/src/operators/kernel/box_coder_kernel.h +++ b/src/operators/kernel/box_coder_kernel.h @@ -30,7 +30,7 @@ class BoxCoderKernel : public framework::OpKernelBase { public: void Compute(const BoxCoderParam& param) const; - bool Init(const BoxCoderParam& para) const; + bool Init(BoxCoderParam* param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/central-arm-func/batchnorm_arm_func.h b/src/operators/kernel/central-arm-func/batchnorm_arm_func.h index 2086265ec6..5813f39471 100644 --- a/src/operators/kernel/central-arm-func/batchnorm_arm_func.h +++ b/src/operators/kernel/central-arm-func/batchnorm_arm_func.h @@ -53,7 +53,7 @@ void BatchnormCompute(const BatchNormParam ¶m) { "C must equal to variance.numel()"); int HXW = H * W; - if (HXW > 32) { + if (0&&HXW > 32) { int NXC = N * C; float *inv_std_ptr = new float[NXC * 4]; float *volatile new_scale_ptr = new float[NXC * 4]; @@ -222,8 +222,15 @@ void BatchnormCompute(const BatchNormParam ¶m) { } } } + } } +// for(int i = 0; i < new_scale.numel(); i++){ +// std::cout << "new_scale " << new_scale_ptr[i] < +void ConvAddBNReluCompute(const FusionConvAddBNReluParam ¶m) { + const Tensor *input = param.Input(); + DLOG << "input: " << *input; + Tensor filter = *param.Filter(); + DLOG << "filter: " << filter; + Tensor bias = *param.Bias(); + DLOG << "bias: " << bias; + + Tensor new_bias = *param.NewBias(); + Tensor new_scale = *param.NewScale(); + auto new_bias_ptr = new_bias.data(); + auto new_scale_ptr = new_scale.data(); + // + // for(int i = 0; i < new_scale.numel(); i++){ + // std::cout << "new_scale " << new_scale_ptr[i] < strides = param.Strides(); + std::vector paddings = param.Paddings(); + std::vector dilations = param.Dilations(); + Tensor *output = param.Output(); + std::vector filter_shape_vec(framework::vectorize(filter.dims())); + + if (filter_shape_vec[2] == 3 && strides[0] == 1 && groups > 1) { + math::DepthwiseConv3x3s1p1(input, filter, output, &bias, 1, &new_scale, + &new_bias, 1, 1); + } else { + const int batch_size = static_cast(input->dims()[0]); + + math::expand_bias(bias, axis, output->dims()); + output->ShareDataWith(bias); + + std::vector output_shape_vec(framework::vectorize(output->dims())); + size_t data_dim = filter_shape_vec.size() - 2; + std::vector col_shape_vec(1 + 2 * data_dim); + col_shape_vec[0] = input->dims()[1] / groups; + for (size_t j = 0; j < data_dim; ++j) { + col_shape_vec[j + 1] = filter_shape_vec[j + 2]; + col_shape_vec[j + 1 + data_dim] = output_shape_vec[j + 2]; + } + framework::DDim col_shape(framework::make_ddim(col_shape_vec)); + + framework::DDim col_matrix_shape = + framework::flatten_to_2d(col_shape, data_dim + 1); + + bool is_expand = + math::IsExpand(filter_shape_vec, strides, paddings, dilations); + Tensor col; + Tensor col_matrix; + if (is_expand) { + col.mutable_data(col_shape); + col_matrix.ShareDataWith(col); + col_matrix.Resize(col_matrix_shape); + } + + framework::DDim input_shape = framework::slice_ddim( + input->dims(), 1, static_cast(input->dims().size())); + + framework::DDim filter_matrix_shape = {filter.dims()[0], + filter.numel() / filter.dims()[0]}; + filter.Resize(filter_matrix_shape); + framework::DDim output_matrix_shape = { + output->dims()[1], + output->numel() / (output->dims()[0] * output->dims()[1])}; + + // convolution operator: im2col(or vol2col) + gemm + int in_step = static_cast(input->dims()[1]) / groups; + int out_step = static_cast(output->dims()[1]) / groups; + + math::Vol2ColFunctor vol2col; + math::Im2ColFunctor im2col; + + for (int i = 0; i < batch_size; i++) { + Tensor in_batch = input->Slice(i, i + 1).Resize(input_shape); + Tensor out_batch = output->Slice(i, i + 1).Resize(output_matrix_shape); + + for (int g = 0; g < groups; g++) { + Tensor in_slice = in_batch.Slice(g * in_step, (g + 1) * in_step); + + if (!is_expand) { + col.ShareDataWith(in_slice); + col_matrix.ShareDataWith(col); + col_matrix.Resize(col_matrix_shape); + } else if (data_dim == 2U) { + // im2col + im2col(in_slice, dilations, strides, + std::vector{paddings[0], paddings[1], paddings[0], + paddings[1]}, + &col); + } else if (data_dim == 3U) { + // vol2col + vol2col(in_slice, dilations, strides, paddings, &col); + } + + // gemm + Tensor out_slice = out_batch.Slice(g * out_step, (g + 1) * out_step); + Tensor filter_slice = filter.Slice(g * out_step, (g + 1) * out_step); + math::matmul(filter_slice, false, col_matrix, false, + static_cast(1), &out_slice, + static_cast(1), false); + } + } + + auto output_ptr = output->data(); + for (int c = 0; c < output_matrix_shape[0]; c++){ + // int start = c * output_matrix_shape[1]; + for (int j = 0; j < output_matrix_shape[1]; j++){ + // output_ptr[start + j] = output_ptr[start +j]*new_scale_ptr[c]+new_bias_ptr[c]; + // output_ptr[start + j] = output_ptr[start+j]< 0 ? 0 : output_ptr[start +j]; + } + } + } +} +} // namespace operators +} // namespace paddle_mobile + +#endif diff --git a/src/operators/kernel/concat_kernel.h b/src/operators/kernel/concat_kernel.h index 6a7b7c6005..0c1f1666bb 100644 --- a/src/operators/kernel/concat_kernel.h +++ b/src/operators/kernel/concat_kernel.h @@ -27,7 +27,7 @@ template class ConcatKernel : public framework::OpKernelBase { public: void Compute(const ConcatParam ¶m) const; - bool Init(const ConcatParam ¶) const; + bool Init(ConcatParam *param) const; }; } // namespace operators diff --git a/src/operators/kernel/conv_add_bn_relu_kernel.h b/src/operators/kernel/conv_add_bn_relu_kernel.h index 9f0bca0f87..ab8773d9dc 100644 --- a/src/operators/kernel/conv_add_bn_relu_kernel.h +++ b/src/operators/kernel/conv_add_bn_relu_kernel.h @@ -14,7 +14,7 @@ limitations under the License. */ #pragma once -#ifdef FUSION_CONVADD_BN_RELU_OP +#ifdef FUSION_CONVADDBNRELU_OP #include #include "framework/ddim.h" @@ -26,20 +26,20 @@ limitations under the License. */ #include "operators/op_param.h" namespace paddle_mobile { - namespace operators { +namespace operators { - using framework::DDim; - using framework::OpKernelBase; +using framework::DDim; +using framework::OpKernelBase; - template - class ConvAddBNReluKernel - : public OpKernelBase { - public: - void Compute(const FusionConvAddBNReluParam ¶m) const; - bool Init(const FusionConvAddBNReluParam ¶) const; - }; +template +class ConvAddBNReluKernel + : public OpKernelBase { + public: + void Compute(const FusionConvAddBNReluParam ¶m) const; + bool Init(FusionConvAddBNReluParam *param) const; +}; - } // namespace operators +} // namespace operators } // namespace paddle_mobile #endif diff --git a/src/operators/kernel/conv_add_kernel.h b/src/operators/kernel/conv_add_kernel.h index fb161238fe..d396ca59d1 100644 --- a/src/operators/kernel/conv_add_kernel.h +++ b/src/operators/kernel/conv_add_kernel.h @@ -40,7 +40,7 @@ template class ConvAddKernel : public OpKernelBase { public: void Compute(const FusionConvAddParam ¶m) const; - bool Init(const FusionConvAddParam ¶) const; + bool Init(FusionConvAddParam *param) const; }; } // namespace operators diff --git a/src/operators/kernel/conv_add_relu_kernel.h b/src/operators/kernel/conv_add_relu_kernel.h index 9b86cd22e8..23862982fc 100644 --- a/src/operators/kernel/conv_add_relu_kernel.h +++ b/src/operators/kernel/conv_add_relu_kernel.h @@ -36,7 +36,7 @@ class ConvAddReluKernel : public OpKernelBase { public: void Compute(const FusionConvAddReluParam ¶m) const; - bool Init(const FusionConvAddReluParam ¶) const; + bool Init(FusionConvAddReluParam *param) const; }; } // namespace operators diff --git a/src/operators/kernel/conv_kernel.h b/src/operators/kernel/conv_kernel.h index 812ddd5a44..b2bcc3e0c2 100644 --- a/src/operators/kernel/conv_kernel.h +++ b/src/operators/kernel/conv_kernel.h @@ -32,7 +32,7 @@ template class ConvKernel : public OpKernelBase { public: void Compute(const ConvParam ¶m) const; - bool Init(const ConvParam ¶) const; + bool Init(ConvParam *param) const; }; } // namespace operators diff --git a/src/operators/kernel/depthwise_conv_kernel.h b/src/operators/kernel/depthwise_conv_kernel.h index a8a8fb3386..075f633a07 100644 --- a/src/operators/kernel/depthwise_conv_kernel.h +++ b/src/operators/kernel/depthwise_conv_kernel.h @@ -31,7 +31,7 @@ template class DepthwiseConvKernel : public OpKernelBase { public: void Compute(const ConvParam ¶m) const; - bool Init(const ConvParam ¶) const; + bool Init(ConvParam *param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/elementwise_add_kernel.h b/src/operators/kernel/elementwise_add_kernel.h index fe6a0238dc..430c3e3fdf 100644 --- a/src/operators/kernel/elementwise_add_kernel.h +++ b/src/operators/kernel/elementwise_add_kernel.h @@ -30,7 +30,7 @@ class ElementwiseAddKernel : public framework::OpKernelBase { public: void Compute(const ElementwiseAddParam ¶m) const; - bool Init(const ElementwiseAddParam ¶) const; + bool Init(ElementwiseAddParam *param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/fpga/conv_kernel.cpp b/src/operators/kernel/fpga/conv_kernel.cpp index 30dd64fd14..126d593762 100644 --- a/src/operators/kernel/fpga/conv_kernel.cpp +++ b/src/operators/kernel/fpga/conv_kernel.cpp @@ -20,7 +20,7 @@ namespace paddle_mobile { namespace operators { template <> -bool ConvKernel::Init(const ConvParam ¶) const { +bool ConvKernel::Init(ConvParam *param) const { return true; } diff --git a/src/operators/kernel/fusion_fc_kernel.h b/src/operators/kernel/fusion_fc_kernel.h index c4e2b30176..149ddacf81 100644 --- a/src/operators/kernel/fusion_fc_kernel.h +++ b/src/operators/kernel/fusion_fc_kernel.h @@ -28,7 +28,7 @@ class FusionFcKernel : public framework::OpKernelBase { public: void Compute(const FusionFcParam& param) const; - bool Init(const FusionFcParam& para) const; + bool Init(FusionFcParam* param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/lrn_kernel.h b/src/operators/kernel/lrn_kernel.h index 40c48b3663..5cd600a947 100644 --- a/src/operators/kernel/lrn_kernel.h +++ b/src/operators/kernel/lrn_kernel.h @@ -170,7 +170,7 @@ template class LrnKernel : public framework::OpKernelBase { public: void Compute(const LrnParam ¶m) const; - bool Init(const LrnParam ¶) const; + bool Init(LrnParam *param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/mali/batchnorm_kernel.cpp b/src/operators/kernel/mali/batchnorm_kernel.cpp index ff27afc71c..0447361c0b 100644 --- a/src/operators/kernel/mali/batchnorm_kernel.cpp +++ b/src/operators/kernel/mali/batchnorm_kernel.cpp @@ -128,7 +128,7 @@ class AclBatchNormOp : public acl::ACLOperator { }; template <> -bool BatchNormKernel::Init(const BatchNormParam& param) const { +bool BatchNormKernel::Init(BatchNormParam *param) const { AclBatchNormOp* acl_op = reinterpret_cast*>(this->GetAclOp()); if (acl_op == nullptr) { diff --git a/src/operators/kernel/mali/conv_kernel.cpp b/src/operators/kernel/mali/conv_kernel.cpp index f3212cae97..687a53fbee 100644 --- a/src/operators/kernel/mali/conv_kernel.cpp +++ b/src/operators/kernel/mali/conv_kernel.cpp @@ -195,7 +195,7 @@ class AclConvOp : public acl::ACLOperator { }; template <> -bool ConvKernel::Init(const ConvParam& param) const { +bool ConvKernel::Init(ConvParam *param) const { AclConvOp* acl_op = reinterpret_cast*>(this->GetAclOp()); if (acl_op == nullptr) { diff --git a/src/operators/kernel/mul_kernel.h b/src/operators/kernel/mul_kernel.h index 81db202c2d..596e9f85c1 100644 --- a/src/operators/kernel/mul_kernel.h +++ b/src/operators/kernel/mul_kernel.h @@ -29,7 +29,7 @@ template class MulKernel : public framework::OpKernelBase { public: void Compute(const MulParam ¶m) const; - bool Init(const MulParam ¶) const; + bool Init(MulParam *param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/multiclass_nms_kernel.h b/src/operators/kernel/multiclass_nms_kernel.h index ca86604f2c..545a152f43 100644 --- a/src/operators/kernel/multiclass_nms_kernel.h +++ b/src/operators/kernel/multiclass_nms_kernel.h @@ -28,7 +28,7 @@ class MultiClassNMSKernel : public framework::OpKernelBase { public: void Compute(const MultiClassNMSParam& param) const; - bool Init(const MultiClassNMSParam& para) const; + bool Init(MultiClassNMSParam* param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/pool_kernel.h b/src/operators/kernel/pool_kernel.h index 3285f56cc0..f69123bdf4 100644 --- a/src/operators/kernel/pool_kernel.h +++ b/src/operators/kernel/pool_kernel.h @@ -28,7 +28,7 @@ template class PoolKernel : public OpKernelBase { public: void Compute(const PoolParam ¶m) const override; - bool Init(const PoolParam ¶) const; + bool Init(PoolParam *param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/prior_box_kernel.h b/src/operators/kernel/prior_box_kernel.h index 79fc630b8e..00681f4fc9 100644 --- a/src/operators/kernel/prior_box_kernel.h +++ b/src/operators/kernel/prior_box_kernel.h @@ -55,7 +55,7 @@ class PriorBoxKernel : public framework::OpKernelBase { public: void Compute(const PriorBoxParam& param) const; - bool Init(const PriorBoxParam& para) const; + bool Init(PriorBoxParam* param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/relu_kernel.h b/src/operators/kernel/relu_kernel.h index 2155c33811..8af8c1720a 100644 --- a/src/operators/kernel/relu_kernel.h +++ b/src/operators/kernel/relu_kernel.h @@ -27,7 +27,7 @@ template class ReluKernel : public framework::OpKernelBase { public: void Compute(const ReluParam& param) const; - bool Init(const ReluParam& para) const; + bool Init(ReluParam* param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/reshape_kernel.h b/src/operators/kernel/reshape_kernel.h index 364f5b0902..2350207b5f 100644 --- a/src/operators/kernel/reshape_kernel.h +++ b/src/operators/kernel/reshape_kernel.h @@ -71,7 +71,7 @@ template class ReshapeKernel : public framework::OpKernelBase { public: void Compute(const ReshapeParam& param) const; - bool Init(const ReshapeParam& para) const; + bool Init(ReshapeParam* param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/sigmoid_kernel.h b/src/operators/kernel/sigmoid_kernel.h index e9eaae5ad8..a1ff0afcbf 100644 --- a/src/operators/kernel/sigmoid_kernel.h +++ b/src/operators/kernel/sigmoid_kernel.h @@ -26,7 +26,7 @@ template class SigmoidKernel : public OpKernelBase { public: void Compute(const SigmoidParam& param) const override; - bool Init(const SigmoidParam& para) const; + bool Init(SigmoidParam* param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/softmax_kernel.h b/src/operators/kernel/softmax_kernel.h index a7a7666e32..81a3ab331a 100644 --- a/src/operators/kernel/softmax_kernel.h +++ b/src/operators/kernel/softmax_kernel.h @@ -29,7 +29,7 @@ template class SoftmaxKernel : public OpKernelBase { public: void Compute(const SoftmaxParam ¶m) const override; - bool Init(const SoftmaxParam ¶) const; + bool Init(SoftmaxParam *param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/transpose_kernel.h b/src/operators/kernel/transpose_kernel.h index 6526d97df9..7fe661d594 100644 --- a/src/operators/kernel/transpose_kernel.h +++ b/src/operators/kernel/transpose_kernel.h @@ -29,7 +29,7 @@ class TransposeKernel : public framework::OpKernelBase { public: void Compute(const TransposeParam& param) const; - bool Init(const TransposeParam& para) const; + bool Init(TransposeParam* param) const; }; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/math/depthwiseconv3x3s1p1.cpp b/src/operators/math/depthwiseconv3x3s1p1.cpp index 88cac51520..ae327c6885 100644 --- a/src/operators/math/depthwiseconv3x3s1p1.cpp +++ b/src/operators/math/depthwiseconv3x3s1p1.cpp @@ -14,6 +14,7 @@ limitations under the License. */ #include "operators/math/depthwiseconv3x3s1p1.h" #include +#include namespace paddle_mobile { namespace operators { @@ -22,11 +23,14 @@ namespace math { using framework::Tensor; void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, - Tensor bias, bool if_bias) { + Tensor *bias, bool if_bias, Tensor *new_scale, + Tensor *new_bias, bool if_bn, bool if_relu) { const float *input_data = input->data(); const float *filter_data = filter.data(); float *output_data = output->data(); - const float *bias_data = bias.data(); + const float *bias_data = bias->data(); + const float *newscale_data = new_scale->data(); + const float *newbias_data = new_bias->data(); const int h = static_cast(input->dims()[2]); const int w = static_cast(input->dims()[3]); @@ -36,6 +40,10 @@ void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, const int c = static_cast(input->dims()[1]); const int hxw = h * w; float32x4_t vbias = vdupq_n_f32(0.0); + float32x4_t vnewbias = vdupq_n_f32(0.0); + float32x4_t vnewscale = vdupq_n_f32(1.0); + float32x4_t vzero = vdupq_n_f32(0); + for (int b = 0; b < batch_size; ++b) { const float *filter_data_tmp = filter_data; @@ -43,7 +51,10 @@ void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, if (if_bias) { vbias = vdupq_n_f32(bias_data[j]); } - + if (if_bn) { + vnewbias = vdupq_n_f32(newbias_data[j]); + vnewscale = vdupq_n_f32(newscale_data[j]); + } int l_mid = l - 2; // l=1->l_mid=-1,l=2->l_mid=0 float w00 = filter_data_tmp[0]; float w01 = filter_data_tmp[1]; @@ -55,34 +66,55 @@ void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, float w21 = filter_data_tmp[7]; float w22 = filter_data_tmp[8]; - output_data[0] = w11 * input_data[0] + w12 * input_data[1] + - w21 * input_data[l] + w22 * input_data[l + 1] + - bias_data[j]; - output_data[l - 1] = w10 * input_data[l - 2] + w11 * input_data[l - 1] + - w20 * input_data[2 * l - 2] + - w21 * input_data[2 * l - 1] + bias_data[j]; - output_data[(l - 1) * l] = - w01 * input_data[(l - 2) * l] + w02 * input_data[(l - 2) * l + 1] + - w11 * input_data[(l - 1) * l] + w12 * input_data[(l - 1) * l + 1] + - bias_data[j]; - output_data[l * l - 1] = w00 * input_data[(l - 2) * (l + 1)] + - w01 * input_data[(l - 2) * (l + 1) + 1] + - w10 * input_data[l * l - 2] + - w11 * input_data[l * l - 1] + bias_data[j]; + output_data[0] =(w11 * input_data[0] + w12 * input_data[1] + w21 * input_data[l] + + w22 * input_data[l + 1] + bias_data[j]) * + newscale_data[j] + + newbias_data[j]; + output_data[l - 1] = (w10 * input_data[l - 2] + w11 * input_data[l - 1] + + w20 * input_data[2 * l - 2] + + w21 * input_data[2 * l - 1] + bias_data[j]) * + newscale_data[j] + + newbias_data[j]; + output_data[(l - 1) * l] = + (w01 * input_data[(l - 2) * l] + w02 * input_data[(l - 2) * l + 1] + + w11 * input_data[(l - 1) * l] + w12 * input_data[(l - 1) * l + 1] + + bias_data[j]) * + newscale_data[j] + + newbias_data[j]; + output_data[l * l - 1] = (w00 * input_data[(l - 2) * (l + 1)] + + w01 * input_data[(l - 2) * (l + 1) + 1] + + w10 * input_data[l * l - 2] + + w11 * input_data[l * l - 1] + bias_data[j]) * + newscale_data[j] + + newbias_data[j]; + if(if_relu){ + output_data[0] = output_data[0] < 0 ? 0 : output_data[0]; + output_data[l-1] = output_data[l-1] < 0 ? 0 : output_data[l-1]; + output_data[(l-1)*l] = output_data[(l-1)*l] < 0 ? 0 : output_data[(l-1)*l]; + output_data[l * l - 1] = output_data[l * l - 1] < 0 ? 0 : output_data[l * l - 1]; + } for (int i = 1; i < l - 1; ++i) { output_data[i * l] = - w01 * input_data[i * l - l] + w02 * input_data[i * l - l + 1] + - w11 * input_data[i * l] + w12 * input_data[i * l + 1] + - w21 * input_data[i * l + l] + w22 * input_data[i * l + l + 1] + - bias_data[j]; - output_data[i * l + l - 1] = w00 * input_data[i * l + l - 1 - l - 1] + - w01 * input_data[i * l + l - 1 - l] + - w10 * input_data[i * l + l - 1 - 1] + - w11 * input_data[i * l + l - 1] + - w20 * input_data[i * l + l - 1 + l - 1] + - w21 * input_data[i * l + l - 1 + l] + - bias_data[j]; + (w01 * input_data[i * l - l] + w02 * input_data[i * l - l + 1] + + w11 * input_data[i * l] + w12 * input_data[i * l + 1] + + w21 * input_data[i * l + l] + w22 * input_data[i * l + l + 1] + + bias_data[j]) * + newscale_data[j] + + newbias_data[j]; + output_data[i * l + l - 1] = + (w00 * input_data[i * l + l - 1 - l - 1] + + w01 * input_data[i * l + l - 1 - l] + + w10 * input_data[i * l + l - 1 - 1] + + w11 * input_data[i * l + l - 1] + + w20 * input_data[i * l + l - 1 + l - 1] + + w21 * input_data[i * l + l - 1 + l] + bias_data[j]) * + newscale_data[j] + + newbias_data[j]; + if(if_relu){ + output_data[i * l] = output_data[i * l] < 0 ? 0 : output_data[i * l]; + output_data[i * l + l - 1] = output_data[i * l + l - 1] < 0 ? 0 : output_data[i * l + l - 1]; + } } // top 1 row and bottom 1 row @@ -114,7 +146,10 @@ void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, out0 = vmlaq_n_f32(out0, tmp2, w21); out0 = vmlaq_n_f32(out0, tmp3, w22); out0 = vaddq_f32(out0, vbias); - + out0 = vmlaq_f32(vnewbias, vnewscale, out0); + if (if_relu) { + out0 = vmaxq_f32(out0, vzero); + } vst1q_f32(output_ptr, out0); in5 = vld1q_f32(input_tmp_end + 4); @@ -132,7 +167,10 @@ void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, out0 = vmlaq_n_f32(out0, tmp2, w11); out0 = vmlaq_n_f32(out0, tmp3, w12); out0 = vaddq_f32(out0, vbias); - + out0 = vmlaq_f32(vnewbias, vnewscale, out0); + if (if_relu) { + out0 = vmaxq_f32(out0, vzero); + } vst1q_f32(output_ptr + (l - 1) * l, out0); // can optimize to each 8 stride. @@ -161,7 +199,10 @@ void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, out0 = vmlaq_n_f32(out0, tmp2, w21); out0 = vmlaq_n_f32(out0, tmp3, w22); out0 = vaddq_f32(out0, vbias); - + out0 = vmlaq_f32(vnewbias, vnewscale, out0); + if (if_relu) { + out0 = vmaxq_f32(out0, vzero); + } for (int i = 0; i < c_mid; ++i) { if (i == 0) { vst1q_lane_f32(output_ptr + i, out0, 0); @@ -190,7 +231,10 @@ void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, out0 = vmlaq_n_f32(out0, tmp2, w11); out0 = vmlaq_n_f32(out0, tmp3, w12); out0 = vaddq_f32(out0, vbias); - + out0 = vmlaq_f32(vnewbias, vnewscale, out0); + if (if_relu) { + out0 = vmaxq_f32(out0, vzero); + } for (int i = 0; i < c_mid; ++i) { if (i == 0) { vst1q_lane_f32(output_ptr + (l - 1) * l + i, out0, 0); @@ -233,7 +277,10 @@ void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, out0 = vmlaq_n_f32(out0, tmp4, w21); out0 = vmlaq_n_f32(out0, tmp5, w22); out0 = vaddq_f32(out0, vbias); - + out0 = vmlaq_f32(vnewbias, vnewscale, out0); + if (if_relu) { + out0 = vmaxq_f32(out0, vzero); + } vst1q_f32(output_ptr, out0); output_ptr += 4; @@ -264,7 +311,10 @@ void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, out0 = vmlaq_n_f32(out0, tmp4, w21); out0 = vmlaq_n_f32(out0, tmp5, w22); out0 = vaddq_f32(out0, vbias); - + out0 = vmlaq_f32(vnewbias, vnewscale, out0); + if (if_relu) { + out0 = vmaxq_f32(out0, vzero); + } for (int i = 0; i < c_mid; ++i) { if (i == 0) { vst1q_lane_f32(output_ptr + i, out0, 0); @@ -282,6 +332,7 @@ void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, filter_data_tmp += 9; } } + } } // namespace math } // namespace operators diff --git a/src/operators/math/depthwiseconv3x3s1p1.h b/src/operators/math/depthwiseconv3x3s1p1.h index 019237a431..85b38a69fc 100644 --- a/src/operators/math/depthwiseconv3x3s1p1.h +++ b/src/operators/math/depthwiseconv3x3s1p1.h @@ -21,7 +21,8 @@ namespace math { using framework::Tensor; void DepthwiseConv3x3s1p1(const Tensor *input, Tensor filter, Tensor *output, - Tensor bias, bool if_bias); + Tensor *bias, bool if_bias, Tensor *new_scale, + Tensor *new_bias, bool if_bn, bool if_relu); } // namespace math } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/op_param.h b/src/operators/op_param.h index ad7de0ee44..7374d65daf 100644 --- a/src/operators/op_param.h +++ b/src/operators/op_param.h @@ -823,6 +823,10 @@ class FusionConvAddParam : public OpParam { const int &Groups() const { return groups; } + void Set(Tensor *t) {t_ = t;} + + const Tensor *Get() const {return t_;} + protected: Tensor *bias_; int axis_; @@ -833,6 +837,7 @@ class FusionConvAddParam : public OpParam { vector paddings_; vector dilations_; int groups; + Tensor *t_; }; Print &operator<<(Print &printer, const FusionConvAddParam &conv_param); @@ -848,5 +853,91 @@ class FusionConvAddReluParam : public FusionConvAddParam { }; #endif +#ifdef FUSION_CONVADDBNRELU_OP +class FusionConvAddBNReluParam : public OpParam { + public: + FusionConvAddBNReluParam(const VariableNameMap &inputs, + const VariableNameMap &outputs, + const AttributeMap &attrs, const Scope &scope) { + bias_ = InputYFrom(inputs, scope); + axis_ = GetAttr("axis", attrs); + filter_ = FilterFrom(inputs, scope); + input_ = InputFrom(inputs, scope); + output_ = OutFrom(outputs, scope); + strides_ = GetAttr>("strides", attrs); + paddings_ = GetAttr>("paddings", attrs); + dilations_ = GetAttr>("dilations", attrs); + groups = GetAttr("groups", attrs); + input_bias_ = InputBiasFrom(inputs, scope); + input_mean_ = InputMeanFrom(inputs, scope); + input_scale_ = InputScaleFrom(inputs, scope); + input_variance_ = InputVarianceFrom(inputs, scope); + epsilon_ = GetAttr("epsilon", attrs); + momentum_ = GetAttr("momentum", attrs); + is_test_ = GetAttr("is_test", attrs); + } + Tensor *Bias() const { return bias_; } + + const int &Axis() const { return axis_; } + + const Tensor *Input() const { return input_; } + + const Tensor *Filter() const { return filter_; } + + Tensor *Output() const { return output_; } + + const vector &Strides() const { return strides_; } + + const vector &Paddings() const { return paddings_; } + + const vector &Dilations() const { return dilations_; } + + const int &Groups() const { return groups; } + + const Tensor *InputBias() const { return input_bias_; } + + const Tensor *InputMean() const { return input_mean_; } + + const Tensor *InputScale() const { return input_scale_; } + + const Tensor *InputVariance() const { return input_variance_; } + + const float &Epsilon() const { return epsilon_; } + + const float &Momentum() const { return momentum_; } + + const bool &IsTest() const { return is_test_; } + + void SetNewScale(Tensor *new_scale) { new_scale_ = new_scale; } + + void SetNewBias(Tensor *new_bias) { new_bias_ = new_bias; } + + const Tensor *NewScale() const { return new_scale_; } + + const Tensor *NewBias() const { return new_bias_; } + + protected: + Tensor *bias_; + int axis_; + Tensor *input_; + Tensor *output_; + Tensor *filter_; + vector strides_; + vector paddings_; + vector dilations_; + int groups; + Tensor *input_bias_; + Tensor *input_mean_; + Tensor *input_scale_; + Tensor *input_variance_; + float epsilon_; + float momentum_; + bool is_test_; + Tensor *new_bias_; + Tensor *new_scale_; +}; + +Print &operator<<(Print &printer, const FusionConvAddParam &conv_param); +#endif } // namespace operators } // namespace paddle_mobile diff --git a/tools/op.cmake b/tools/op.cmake index 2eabac925f..c4346c21f9 100644 --- a/tools/op.cmake +++ b/tools/op.cmake @@ -22,6 +22,7 @@ elseif (NET EQUAL "mobilenet") set(BATCHNORM_OP ON) set(POOL_OP ON) set(RESHAPE_OP ON) + set(FUSION_CONVADDBNRELU_OP) elseif (NET EQUAL "yolo") set(BATCHNORM_OP ON) set(CONV_OP ON) @@ -64,6 +65,8 @@ else () set(SOFTMAX_OP ON) set(TRANSPOSE_OP ON) set(FUSION_CONVADD_RELU_OP ON) + set(FUSION_CONVADDBNRELU_OP ON) + # option(BATCHNORM_OP "" ON) # option(BOXCODER_OP "" ON) # option(CONCAT_OP "" ON) -- GitLab