diff --git a/src/framework/tensor.h b/src/framework/tensor.h index 8d9407e8ee25a4dadbee16713324f4afa90bb03f..797fcf5bffbe5e738fe352d1ca84602f0e5d86a0 100644 --- a/src/framework/tensor.h +++ b/src/framework/tensor.h @@ -257,10 +257,12 @@ class Tensor { struct FPGAArgs { float scale; - inline float *scale_pointer() const { return &scale; } + inline float *scale_pointer() { return &scale; } }; - const struct FPGAArgs &fpga_args() const { return fpgaArgs_; } + struct FPGAArgs fpga_args() const { + return fpgaArgs_; + } #endif private: diff --git a/src/operators/fusion_conv_add_bn_op.cpp b/src/operators/fusion_conv_add_bn_op.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5b61bf5d390cc2904a3f40f5400a5a3eec9a2dd5 --- /dev/null +++ b/src/operators/fusion_conv_add_bn_op.cpp @@ -0,0 +1,61 @@ +/* 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_CONVADDBN_OP + +#include "operators/fusion_conv_add_bn_op.h" +#include "operators/math/conv_func.h" + +namespace paddle_mobile { +namespace operators { + +template +void FusionConvAddBNOp::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); +} + +} // namespace operators +} // namespace paddle_mobile + +namespace ops = paddle_mobile::operators; +#ifdef PADDLE_MOBILE_CPU +REGISTER_OPERATOR_CPU(fusion_conv_add_bn, ops::FusionConvAddBNOp); +#endif +#ifdef PADDLE_MOBILE_MALI_GPU +#endif +#ifdef PADDLE_MOBILE_FPGA +REGISTER_OPERATOR_FPGA(fusion_conv_add_bn, ops::FusionConvAddBNOp); +#endif + +#endif diff --git a/src/operators/fusion_conv_add_bn_op.h b/src/operators/fusion_conv_add_bn_op.h new file mode 100644 index 0000000000000000000000000000000000000000..7a7f6b2bababd3f5d36d7b6faf60069567d45423 --- /dev/null +++ b/src/operators/fusion_conv_add_bn_op.h @@ -0,0 +1,115 @@ +/* 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_CONVADDBN_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_kernel.h" + +namespace paddle_mobile { +namespace operators { +using std::string; +using std::vector; +class FusionConvAddBNMatcher : public framework::FusionOpMatcher { + public: + FusionConvAddBNMatcher() { + node_ = framework::Node(G_OP_TYPE_CONV); + node_ > std::make_shared(G_OP_TYPE_ELEMENTWISE_ADD) > + std::make_shared(G_OP_TYPE_BATCHNORM); + } + + void FolderNodes( + framework::Node *node, + std::vector> *removed_nodes) { + 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; } +}; + +template +class FusionConvAddBNOp : public framework::OperatorWithKernel< + DeviceType, FusionConvAddBNParam, + operators::ConvAddBNKernel> { + public: + FusionConvAddBNOp(const string &type, const VariableNameMap &inputs, + const VariableNameMap &outputs, + const framework::AttributeMap &attrs, + std::shared_ptr scope) + : framework::OperatorWithKernel< + DeviceType, FusionConvAddBNParam, + operators::ConvAddBNKernel>(type, inputs, outputs, + attrs, scope) {} + + void InferShape() const override; + + protected: +}; + +#ifdef PADDLE_MOBILE_CPU + +#ifndef FUSION_CONV_ADD_BN_REGISTER +static framework::FusionOpRegistrar fusion_conv_add_bn_registrar( + new FusionConvAddBNMatcher()); +#define FUSION_CONV_ADD_BN_REGISTER +#endif + +#endif + +#ifdef PADDLE_MOBILE_MALI_GPU + +#ifndef FUSION_CONV_ADD_BN_REGISTER +static framework::FusionOpRegistrar fusion_conv_add_bn_registrar( + new FusionConvAddBNMatcher()); +#define FUSION_CONV_ADD_BN_REGISTER +#endif + +#endif + +#ifdef PADDLE_MOBILE_FPGA + +#ifndef FUSION_CONV_ADD_BN_REGISTER +static framework::FusionOpRegistrar fusion_conv_add_bn_registrar( + new FusionConvAddBNMatcher()); +#define FUSION_CONV_ADD_BN_REGISTER +#endif + +#endif + +} // namespace operators +} // namespace paddle_mobile + +#ifdef PADDLE_MOBILE_CPU +USE_OP_CPU(fusion_conv_add_bn); +#endif +#ifdef PADDLE_MOBILE_MALI_GPU +#endif +#ifdef PADDLE_MOBILE_FPGA +USE_OP_FPGA(fusion_conv_add_bn); +#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 16f4650a64ec0c363d5fa94ee27c15c73cf58a70..793634eec392fabe6c7399127ec9cb3e187697bc 100644 --- a/src/operators/fusion_conv_add_bn_relu_op.cpp +++ b/src/operators/fusion_conv_add_bn_relu_op.cpp @@ -55,6 +55,7 @@ REGISTER_OPERATOR_CPU(fusion_conv_add_bn_relu, ops::FusionConvAddBNReluOp); #ifdef PADDLE_MOBILE_MALI_GPU #endif #ifdef PADDLE_MOBILE_FPGA +REGISTER_OPERATOR_FPGA(fusion_conv_add_bn_relu, ops::FusionConvAddBNReluOp); #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 19e33465c06921e9a6a7beb77053f05a03a6c760..54e7e58f8af4111edd0b86c85bb1cffc87f5cd22 100644 --- a/src/operators/fusion_conv_add_bn_relu_op.h +++ b/src/operators/fusion_conv_add_bn_relu_op.h @@ -96,6 +96,13 @@ static framework::FusionOpRegistrar fusion_conv_add_bn_relu_registrar( #endif #ifdef PADDLE_MOBILE_FPGA + +#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 } // namespace operators @@ -107,6 +114,7 @@ USE_OP_CPU(fusion_conv_add_bn_relu); #ifdef PADDLE_MOBILE_MALI_GPU #endif #ifdef PADDLE_MOBILE_FPGA +USE_OP_FPGA(fusion_conv_add_bn_relu); #endif #endif diff --git a/src/operators/fusion_conv_add_relu_op.cpp b/src/operators/fusion_conv_add_relu_op.cpp index 18618886cccba08c7502b3e1d75fbba9b6916f56..99b770a6c5e3bc89024e467631e129b914f0bcec 100644 --- a/src/operators/fusion_conv_add_relu_op.cpp +++ b/src/operators/fusion_conv_add_relu_op.cpp @@ -54,6 +54,7 @@ REGISTER_OPERATOR_CPU(fusion_conv_add_relu, ops::FusionConvAddReluOp); #ifdef PADDLE_MOBILE_MALI_GPU #endif #ifdef PADDLE_MOBILE_FPGA +REGISTER_OPERATOR_FPGA(fusion_conv_add_relu, ops::FusionConvAddReluOp); #endif #endif diff --git a/src/operators/fusion_conv_add_relu_op.h b/src/operators/fusion_conv_add_relu_op.h index 50a4a2c7c64526c9a5dc1057829ed14f09357780..cda97ba1a342e5b9451fd8363643f638792e3579 100644 --- a/src/operators/fusion_conv_add_relu_op.h +++ b/src/operators/fusion_conv_add_relu_op.h @@ -75,6 +75,13 @@ class FusionConvAddReluOp : public framework::OperatorWithKernel< #ifdef PADDLE_MOBILE_MALI_GPU #endif #ifdef PADDLE_MOBILE_FPGA + +#ifndef CONV_ADD_RELU_REGISTER +#define CONV_ADD_RELU_REGISTER +static framework::FusionOpRegistrar fusion_conv_add_relu_registrar( + new FusionConvAddReluOpMatcher()); +#endif + #endif } // namespace operators @@ -86,6 +93,7 @@ USE_OP_CPU(fusion_conv_add_relu); #ifdef PADDLE_MOBILE_MALI_GPU #endif #ifdef PADDLE_MOBILE_FPGA +USE_OP_FPGA(fusion_conv_add_relu); #endif #endif diff --git a/src/operators/kernel/fpga/conv_kernel.cpp b/src/operators/kernel/conv_add_bn_kernel.h similarity index 54% rename from src/operators/kernel/fpga/conv_kernel.cpp rename to src/operators/kernel/conv_add_bn_kernel.h index dc537362a216983974bea325433c456136356fc8..cc11ef1d71f402f32b2da6490877626247884a44 100644 --- a/src/operators/kernel/fpga/conv_kernel.cpp +++ b/src/operators/kernel/conv_add_bn_kernel.h @@ -12,21 +12,31 @@ 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 CONV_OP +#pragma once -#include "operators/kernel/conv_kernel.h" +#ifdef FUSION_CONVADDBN_OP + +#include +#include "framework/ddim.h" +#include "framework/operator.h" +#include "operators/math/conv_func.h" +#include "operators/math/im2col.h" +#include "operators/math/math_function.h" +#include "operators/math/vol2col.h" +#include "operators/op_param.h" namespace paddle_mobile { namespace operators { -template <> -bool ConvKernel::Init(ConvParam *param) { - return true; -} +using framework::DDim; +using framework::OpKernelBase; -template <> -void ConvKernel::Compute(const ConvParam ¶m) const {} -template class ConvKernel; +template +class ConvAddBNKernel : public OpKernelBase { + public: + void Compute(const FusionConvAddBNParam ¶m) const; + bool Init(FusionConvAddBNParam *param); +}; } // namespace operators } // namespace paddle_mobile diff --git a/src/operators/kernel/fpga/conv_add_bn_kernel.cpp b/src/operators/kernel/fpga/conv_add_bn_kernel.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6f9da6bc1dde924e2c499bb2478d29a8d4a9e5d9 --- /dev/null +++ b/src/operators/kernel/fpga/conv_add_bn_kernel.cpp @@ -0,0 +1,94 @@ +/* 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_CONVADDBN_OP + +#include "operators/kernel/conv_add_bn_kernel.h" +#include "fpga/api/fpga_api.h" + +namespace paddle_mobile { +namespace operators { + +template <> +bool ConvAddBNKernel::Init(FusionConvAddBNParam *param) { + bool relu_enabled = false; + const Tensor *input = param->Input(); + auto input_ptr = input->data(); + const Tensor *bias = param->Bias(); + auto bias_ptr = bias->data(); + const Tensor *filter = param->Filter(); + auto filter_ptr = filter->data(); + Tensor *out = param->Output(); + auto out_ptr = out->mutable_data(); + auto bn_mean_ptr = param->InputMean()->data(); + auto bn_var_ptr = param->InputVariance()->data(); + auto bn_scale_ptr = param->InputScale()->data(); + auto bn_bias_ptr = param->InputBias()->data(); + const float epsilon = param->Epsilon(); + PADDLE_MOBILE_ENFORCE(input->dims()[1] == bias->dims()[0] && + bias->dims()[0] == param->InputBias()->dims()[0], + "Image channel should be equal to bias number"); + + const int channel = input->dims()[1]; + float *bs_ptr = (float *)fpga::fpga_malloc(2 * channel * sizeof(float)); + Tensor *new_scale = new Tensor(); + Tensor *new_bias = new Tensor(); + auto new_scale_ptr = new_scale->mutable_data({channel}); + auto new_bias_ptr = new_bias->mutable_data({channel}); + + for (int i = 0; i < channel; i++) { + new_scale_ptr[i] = bn_scale_ptr[i] / + static_cast(pow((bn_var_ptr[i] + epsilon), 0.5)); + new_bias_ptr[i] = + bn_bias_ptr[i] + (bias_ptr[i] - bn_mean_ptr[i]) * new_scale_ptr[i]; + bs_ptr[i * 2] = new_scale_ptr[i]; + bs_ptr[i * 2 + 1] = new_bias_ptr[i]; + } + param->SetNewScale(new_scale); + param->SetNewBias(new_bias); + + fpga::ConvArgs convArgs; + convArgs.relu_enabled = relu_enabled; + convArgs.filter_address = (void *)filter_ptr; + convArgs.filter_num = filter->dims()[0]; + convArgs.group_num = param->Groups(); + convArgs.sb_address = (void *)bs_ptr; + convArgs.kernel.stride_h = param->Strides()[0]; + convArgs.kernel.stride_w = param->Strides()[1]; + convArgs.kernel.height = filter->dims()[2]; + convArgs.kernel.width = filter->dims()[3]; + convArgs.image.address = (void *)input_ptr; + convArgs.image.channels = input->dims()[1]; + convArgs.image.height = input->dims()[2]; + convArgs.image.width = input->dims()[3]; + convArgs.image.pad_height = param->Paddings()[0]; + convArgs.image.pad_width = param->Paddings()[1]; + convArgs.image.scale_address = input->fpga_args().scale_pointer(); + convArgs.output.address = (void *)out_ptr; + convArgs.output.scale_address = out->fpga_args().scale_pointer(); + param->SetFpgaArgs(convArgs); + return true; +} + +template <> +void ConvAddBNKernel::Compute( + const FusionConvAddBNParam ¶m) const { + fpga::ComputeFpgaConv(param.FpgaArgs()); +} +template class ConvAddBNKernel; + +} // namespace operators +} // namespace paddle_mobile + +#endif diff --git a/src/operators/kernel/fpga/conv_add_bn_relu_kernel.cpp b/src/operators/kernel/fpga/conv_add_bn_relu_kernel.cpp new file mode 100644 index 0000000000000000000000000000000000000000..66a593df84c12f87371a9bde9f0aef514b392584 --- /dev/null +++ b/src/operators/kernel/fpga/conv_add_bn_relu_kernel.cpp @@ -0,0 +1,94 @@ +/* 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 "memory/t_malloc.h" + +namespace paddle_mobile { +namespace operators { + +template <> +bool ConvAddBNReluKernel::Init(FusionConvAddBNReluParam *param) { + bool relu_enabled = true; + const Tensor *input = param->Input(); + auto input_ptr = input->data(); + const Tensor *bias = param->Bias(); + auto bias_ptr = bias->data(); + const Tensor *filter = param->Filter(); + auto filter_ptr = filter->data(); + Tensor *out = param->Output(); + auto out_ptr = out->mutable_data(); + auto bn_mean_ptr = param->InputMean()->data(); + auto bn_var_ptr = param->InputVariance()->data(); + auto bn_scale_ptr = param->InputScale()->data(); + auto bn_bias_ptr = param->InputBias()->data(); + const float epsilon = param->Epsilon(); + PADDLE_MOBILE_ENFORCE(input->dims()[1] == bias->dims()[0] && + bias->dims()[0] == param->InputBias()->dims()[0], + "Image channel should be equal to bias number"); + + const int channel = input->dims()[1]; + float *bs_ptr = (float *)fpga::fpga_malloc(2 * channel * sizeof(float)); + Tensor *new_scale = new Tensor(); + Tensor *new_bias = new Tensor(); + auto new_scale_ptr = new_scale->mutable_data({channel}); + auto new_bias_ptr = new_bias->mutable_data({channel}); + + for (int i = 0; i < channel; i++) { + new_scale_ptr[i] = bn_scale_ptr[i] / + static_cast(pow((bn_var_ptr[i] + epsilon), 0.5)); + new_bias_ptr[i] = + bn_bias_ptr[i] + (bias_ptr[i] - bn_mean_ptr[i]) * new_scale_ptr[i]; + bs_ptr[i * 2] = new_scale_ptr[i]; + bs_ptr[i * 2 + 1] = new_bias_ptr[i]; + } + param->SetNewScale(new_scale); + param->SetNewBias(new_bias); + + fpga::ConvArgs convArgs; + convArgs.relu_enabled = relu_enabled; + convArgs.filter_address = (void *)filter_ptr; + convArgs.filter_num = filter->dims()[0]; + convArgs.group_num = param->Groups(); + convArgs.sb_address = (void *)bs_ptr; + convArgs.kernel.stride_h = param->Strides()[0]; + convArgs.kernel.stride_w = param->Strides()[1]; + convArgs.kernel.height = filter->dims()[2]; + convArgs.kernel.width = filter->dims()[3]; + convArgs.image.address = (void *)input_ptr; + convArgs.image.channels = input->dims()[1]; + convArgs.image.height = input->dims()[2]; + convArgs.image.width = input->dims()[3]; + convArgs.image.pad_height = param->Paddings()[0]; + convArgs.image.pad_width = param->Paddings()[1]; + convArgs.image.scale_address = input->fpga_args().scale_pointer(); + convArgs.output.address = (void *)out_ptr; + convArgs.output.scale_address = out->fpga_args().scale_pointer(); + param->SetFpgaArgs(convArgs); + return true; +} + +template <> +void ConvAddBNReluKernel::Compute( + const FusionConvAddBNReluParam ¶m) const { + fpga::ComputeFpgaConv(param.FpgaArgs()); +} +template class ConvAddBNReluKernel; + +} // namespace operators +} // namespace paddle_mobile + +#endif diff --git a/src/operators/kernel/fpga/conv_add_relu_kernel.cpp b/src/operators/kernel/fpga/conv_add_relu_kernel.cpp new file mode 100644 index 0000000000000000000000000000000000000000..9692bcef872f956e2cdbe82545b3ab4173bf1348 --- /dev/null +++ b/src/operators/kernel/fpga/conv_add_relu_kernel.cpp @@ -0,0 +1,78 @@ +/* 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_CONVADDRELU_OP + +#include "operators/kernel/conv_add_relu_kernel.h" +#include "common/enforce.h" + +namespace paddle_mobile { +namespace operators { + +template <> +bool ConvAddReluKernel::Init(FusionConvAddReluParam *param) { + bool relu_enabled = true; + const Tensor *input = param->Input(); + auto input_ptr = input->data(); + const Tensor *bias = param->Bias(); + auto bias_ptr = bias->data(); + const Tensor *filter = param->Filter(); + auto filter_ptr = filter->data(); + Tensor *out = param->Output(); + auto out_ptr = out->mutable_data(); + + PADDLE_MOBILE_ENFORCE(input->dims()[1] == bias->dims()[0], + "Image channel should be equal to bias number"); + int channel = input->dims()[1]; + float *bs_ptr = (float *)fpga::fpga_malloc(2 * channel * sizeof(float)); + for (int i = 0; i < channel; i++) { + bs_ptr[i * 2] = 1; + bs_ptr[i * 2 + 1] = bias_ptr[i]; + } + + fpga::ConvArgs convArgs; + convArgs.relu_enabled = relu_enabled; + convArgs.filter_address = (void *)filter_ptr; + convArgs.filter_num = filter->dims()[0]; + convArgs.group_num = param->Groups(); + convArgs.sb_address = (void *)bs_ptr; + convArgs.kernel.stride_h = param->Strides()[0]; + convArgs.kernel.stride_w = param->Strides()[1]; + convArgs.kernel.height = filter->dims()[2]; + convArgs.kernel.width = filter->dims()[3]; + convArgs.image.address = (void *)input_ptr; + convArgs.image.channels = input->dims()[1]; + convArgs.image.height = input->dims()[2]; + convArgs.image.width = input->dims()[3]; + + convArgs.image.pad_height = param->Paddings()[0]; + convArgs.image.pad_width = param->Paddings()[1]; + convArgs.image.scale_address = input->fpga_args().scale_pointer(); + convArgs.output.address = (void *)out_ptr; + convArgs.output.scale_address = out->fpga_args().scale_pointer(); + param->SetFpgaArgs(convArgs); + return true; +} + +template <> +void ConvAddReluKernel::Compute( + const FusionConvAddReluParam ¶m) const { + fpga::ComputeFpgaConv(param.FpgaArgs()); +} +template class ConvAddReluKernel; + +} // namespace operators +} // namespace paddle_mobile + +#endif diff --git a/src/operators/op_param.h b/src/operators/op_param.h index 88c1886ad7ade5960d1d8175a1b46e12363ca849..0821ab8c32a6ba232a673ddd100a4e7fe6475571 100644 --- a/src/operators/op_param.h +++ b/src/operators/op_param.h @@ -1136,7 +1136,7 @@ class FusionConvAddBNParam : public OpParam { const Tensor *Filter() const { return filter_; } - Tensor *OutputY() const { return output_y_; } + Tensor *Output() const { return output_y_; } const vector &Strides() const { return strides_; } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 8839079fecfdbefcdaff85354d3a6a8208af10ee..5072db53874e0becf1318a26633fb13cc33d07f4 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -21,6 +21,7 @@ elseif("resnet" IN_LIST NET) # gen test ADD_EXECUTABLE(test-resnet net/test_resnet.cpp test_helper.h test_include.h executor_for_test.h) target_link_libraries(test-resnet paddle-mobile) +elseif("FPGAnets" IN_LIST NET) else () # gen test