提交 5b229a61 编写于 作者: H hjchen2

update

上级 82f57756
......@@ -116,8 +116,6 @@ const char *G_OP_TYPE_FUSION_DECONV_ADD_BN_RELU = "fusion_deconv_add_bn_relu";
const char *G_OP_TYPE_FUSION_DECONV_ADD_BN = "fusion_deconv_add_bn";
const char *G_OP_TYPE_FUSION_DECONV_BN_RELU = "fusion_deconv_bn_relu";
const char *G_OP_TYPE_PAD2D = "pad2d";
std::unordered_map<
std::string, std::pair<std::vector<std::string>, std::vector<std::string>>>
op_input_output_key = {
......
......@@ -15,7 +15,6 @@ limitations under the License. */
#pragma once
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
......@@ -81,7 +80,6 @@ class OperatorBase {
}
#ifdef PADDLE_MOBILE_FPGA
void InsertTensors();
void ChangeNameMap(string key, std::vector<string> value);
#endif
protected:
......@@ -98,35 +96,15 @@ class OperatorBase {
template <typename Dtype, typename ParamType, typename KernelType>
class OperatorWithKernel : public OperatorBase<Dtype> {
public:
#ifndef PADDLE_MOBILE_FPGA1
OperatorWithKernel(const std::string &type, const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
framework::Scope *scope)
: OperatorBase<Dtype>(type, inputs, outputs, attrs, scope),
param_(inputs, outputs, attrs, scope.get()) {
param_(inputs, outputs, attrs, scope) {
#ifdef PADDLE_MOBILE_CL
kernel_.InitCLHelper(scope->GetCLScpoe());
#endif
}
#else
OperatorWithKernel(const std::string &type, const VariableNameMap inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
std::shared_ptr<Scope> scope)
: OperatorBase<Dtype>(type, inputs, outputs, attrs, scope) {
static int feed_num = 0;
static int fetch_num = 0;
if (type == "feed") {
auto new_name = string("feed") + std::to_string(feed_num++);
auto var = scope->Var(new_name);
(const_cast<VariableNameMap &>(inputs)).at("X") = {string(new_name)};
} else if (type == "fetch") {
auto new_name = string("fetch") + std::to_string(fetch_num++);
auto var = scope->Var(new_name);
(const_cast<VariableNameMap &>(outputs)).at("Out") = {string(new_name)};
}
param_ = ParamType(inputs, outputs, attrs, *scope);
}
#endif
virtual void RunImpl() { this->kernel_.Compute(this->param_); }
virtual void InferShape() const = 0;
......
......@@ -34,7 +34,7 @@ class FillConstantOp : public framework::OperatorBase<DeviceType> {
const framework::AttributeMap attrs, framework::Scope *scope)
: framework::OperatorBase<DeviceType>(type, inputs, outputs, attrs,
scope),
param_(inputs, outputs, attrs, scope.get()) {}
param_(inputs, outputs, attrs, scope) {}
void RunImpl() {
auto data_type =
static_cast<_PaddleMobile__Framework__Proto__VarType__Type>(
......
/* 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 CONV_OP
#include "operators/kernel/conv_kernel.h"
#include "operators/kernel/central-arm-func/conv_arm_func.h"
namespace paddle_mobile {
namespace operators {
template <>
bool ConvKernel<CPU, float>::Init(ConvParam<CPU> *param) {
bool conv3x3 = param->Filter()->dims()[2] == param->Filter()->dims()[3] &&
param->Filter()->dims()[2] == 3;
bool conv5x5 = param->Filter()->dims()[2] == param->Filter()->dims()[3] &&
param->Filter()->dims()[2] == 5;
bool depth3x3 = conv3x3 && param->Groups() == param->Input()->dims()[1] &&
param->Input()->dims()[1] == param->Output()->dims()[1];
bool depth5x5 = conv5x5 && param->Groups() == param->Input()->dims()[1] &&
param->Input()->dims()[1] == param->Output()->dims()[1];
if (param->Filter()->type() == typeid(int8_t)) {
#ifndef __aarch64__
if (depth3x3 && param->Strides()[0] < 3 &&
param->Strides()[0] == param->Strides()[1]) {
param->ExecMode() = ConvParam<CPU>::EXEC_DEPTHWISE3x3_INT8;
} else if (depth5x5 && param->Strides()[0] < 2 &&
param->Strides()[0] == param->Strides()[1]) {
param->ExecMode() = ConvParam<CPU>::EXEC_DEPTHWISE5x5_INT8;
} else {
#endif // __aarch64__
param->ExecMode() = ConvParam<CPU>::EXEC_GEMM_INT8;
#ifndef __aarch64__
}
#endif // __aarch64__
} else {
if (depth3x3 && param->Strides()[0] == param->Strides()[1] &&
param->Strides()[0] == 1 && param->Paddings()[0] == 1 &&
param->Paddings()[0] == param->Paddings()[1]) {
param->ExecMode() = ConvParam<CPU>::EXEC_DEPTHWISE3x3S1P1_FLOAT;
} else if (depth3x3 && param->Strides()[0] == param->Strides()[1] &&
param->Strides()[0] == 2 && param->Paddings()[0] == 0 &&
param->Paddings()[0] == param->Paddings()[1]) {
param->ExecMode() = ConvParam<CPU>::EXEC_DEPTHWISE3x3S2P0_FLOAT;
} else if (depth3x3 && param->Strides()[0] == param->Strides()[1] &&
param->Strides()[0] == 2 && param->Paddings()[0] == 1 &&
param->Paddings()[0] == param->Paddings()[1]) {
param->ExecMode() = ConvParam<CPU>::EXEC_DEPTHWISE3x3S2P1_FLOAT;
} else if (depth3x3) {
param->ExecMode() = ConvParam<CPU>::EXEC_DEPTHWISE3x3_FLOAT;
#ifndef __aarch64__
} else if (depth5x5 && param->Strides()[0] == param->Strides()[1] &&
param->Strides()[0] == 1) {
param->ExecMode() = ConvParam<CPU>::EXEC_DEPTHWISE5x5_FLOAT;
} else if (conv3x3 && param->Strides()[0] == param->Strides()[1] &&
param->Dilations()[0] == param->Dilations()[1] &&
param->Strides()[0] == 1 && param->Dilations()[0] == 1 &&
param->Output()->dims()[1] >= 16 &&
param->Input()->dims()[1] >= 16 &&
param->Input()->dims()[2] <= 140 /* refered from ncnn */) {
param->ExecMode() = ConvParam<CPU>::EXEC_WINOGRAD3X3_FLOAT;
// transform weight
param->transformed_filter_ = new framework::Tensor;
operators::math::winograd_transform_weight<8, 3>(
*param->Filter(), param->transformed_filter_);
#endif
} else {
param->ExecMode() = ConvParam<CPU>::EXEC_GEMM_FLOAT;
}
}
return true;
}
template <>
void ConvKernel<CPU, float>::Compute(const ConvParam<CPU> &param) {
switch (param.ExecMode()) {
case ConvParam<CPU>::EXEC_GEMM_INT8:
GemmConv<int8_t, int32_t>(param);
break;
#ifndef __aarch64__
case ConvParam<CPU>::EXEC_DEPTHWISE3x3_INT8:
DepthwiseConv3x3<int8_t, int32_t>(param);
break;
case ConvParam<CPU>::EXEC_DEPTHWISE5x5_INT8:
DepthwiseConv5x5<int8_t, int32_t>(param);
break;
#endif // __aarch64__
case ConvParam<CPU>::EXEC_DEPTHWISE3x3S1P1_FLOAT:
math::DepthwiseConv3x3s1p1(param.Input(), param.Filter(), param.Output(),
nullptr, false, false);
break;
case ConvParam<CPU>::EXEC_DEPTHWISE3x3S2P1_FLOAT:
math::DepthwiseConv3x3s2p1v2(param.Input(), param.Filter(),
param.Output(), nullptr, false, false);
break;
case ConvParam<CPU>::EXEC_DEPTHWISE3x3S2P0_FLOAT:
math::DepthwiseConv3x3s2p0(param.Input(), param.Filter(), param.Output(),
nullptr, false, false);
break;
case ConvParam<CPU>::EXEC_DEPTHWISE3x3_FLOAT:
math::DepthwiseConv3x3(param.Input(), param.Strides(), param.Paddings(),
param.Filter(), nullptr, param.Output(), false);
break;
#ifndef __aarch64__
case ConvParam<CPU>::EXEC_DEPTHWISE5x5_FLOAT:
DepthwiseConv5x5<float, float>(param);
break;
case ConvParam<CPU>::EXEC_WINOGRAD3X3_FLOAT:
WinogradConv3x3<8, 3>(param);
break;
#endif // __aarch64__
case ConvParam<CPU>::EXEC_GEMM_FLOAT:
GemmConv<float, float>(param);
break;
default:
PADDLE_MOBILE_THROW_EXCEPTION("Invalid convolution execute mode %d",
param.ExecMode());
}
}
template class ConvKernel<CPU, float>;
} // namespace operators
} // namespace paddle_mobile
#endif
......@@ -45,8 +45,8 @@ bool ConvAddBNReluKernel<CPU, float>::Init(
}
// Tensor *new_scale = new Tensor();
// Tensor *new_bias = new Tensor();
Tensor *new_scale = param->CreateNewScale<Tensor>();
Tensor *new_bias = param->CreateNewBiase<Tensor>();
auto *new_scale = param->CreateNewScale<framework::LoDTensor>();
auto *new_bias = param->CreateNewBiase<framework::LoDTensor>();
auto new_scale_ptr = new_scale->mutable_data<float>({C});
auto new_bias_ptr = new_bias->mutable_data<float>({C});
......
......@@ -43,8 +43,9 @@ bool ConvBNAddReluKernel<CPU, float>::Init(
inv_std_ptr[i] =
1 / static_cast<float>(pow((variance_ptr[i] + epsilon), 0.5));
}
LoDTensor *new_scale = new LoDTensor();
LoDTensor *new_bias = new LoDTensor();
auto *new_scale = param->CreateNewScale<framework::LoDTensor>();
auto *new_bias = param->CreateNewBiase<framework::LoDTensor>();
auto new_scale_ptr = new_scale->mutable_data<float>({C});
auto new_bias_ptr = new_bias->mutable_data<float>({C});
for (int i = 0; i < C; i++) {
......
......@@ -43,8 +43,8 @@ bool ConvBNReluKernel<CPU, float>::Init(FusionConvBNReluParam<CPU> *param) {
1 / static_cast<float>(pow((variance_ptr[i] + epsilon), 0.5));
}
Tensor *new_scale = param->CreateNewScale<Tensor>();
Tensor *new_bias = param->CreateNewBiase<Tensor>();
auto *new_scale = param->CreateNewScale<framework::LoDTensor>();
auto *new_bias = param->CreateNewBiase<framework::LoDTensor>();
auto new_scale_ptr = new_scale->mutable_data<float>({C});
auto new_bias_ptr = new_bias->mutable_data<float>({C});
for (int i = 0; i < C; i++) {
......
......@@ -27,15 +27,16 @@ class BeamSearchDecodeParam : public OpParam {
public:
BeamSearchDecodeParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
ids_ =
OpParam::GetVarValue<framework::LoDTensorArray>("Ids", inputs, scope);
OpParam::GetVarValue<framework::LoDTensorArray>("Ids", inputs, *scope);
scores_ = OpParam::GetVarValue<framework::LoDTensorArray>("Scores", inputs,
scope);
*scope);
sentence_ids_ = OpParam::GetVarValue<framework::LoDTensor>("SentenceIds",
outputs, scope);
outputs, *scope);
sentence_scores_ = OpParam::GetVarValue<framework::LoDTensor>(
"SentenceScores", outputs, scope);
"SentenceScores", outputs, *scope);
beam_size_ = OpParam::GetAttr<int>("beam_size", attrs);
end_id_ = OpParam::GetAttr<int>("end_id", attrs);
}
......
......@@ -29,16 +29,18 @@ template <typename Dtype>
class BeamSearchParam : public OpParam {
public:
BeamSearchParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
pre_ids_ = GET_VAR_AS_LOD_TENSOR("pre_ids", inputs, scope);
pre_scores_ = GET_VAR_AS_LOD_TENSOR("pre_scores", inputs, scope);
ids_ = GET_VAR_AS_LOD_TENSOR("ids", inputs, scope);
scores_ = GET_VAR_AS_LOD_TENSOR("scores", inputs, scope);
selected_ids_ = GET_VAR_AS_LOD_TENSOR("selected_ids", outputs, scope);
selected_scores_ = GET_VAR_AS_LOD_TENSOR("selected_scores", outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
pre_ids_ = GET_VAR_AS_LOD_TENSOR("pre_ids", inputs, *scope);
pre_scores_ = GET_VAR_AS_LOD_TENSOR("pre_scores", inputs, *scope);
ids_ = GET_VAR_AS_LOD_TENSOR("ids", inputs, *scope);
scores_ = GET_VAR_AS_LOD_TENSOR("scores", inputs, *scope);
selected_ids_ = GET_VAR_AS_LOD_TENSOR("selected_ids", outputs, *scope);
selected_scores_ =
GET_VAR_AS_LOD_TENSOR("selected_scores", outputs, *scope);
if (outputs.count("parent_idx")) {
parent_idx_ = GET_VAR_AS_LOD_TENSOR("parent_idx", outputs, scope);
parent_idx_ = GET_VAR_AS_LOD_TENSOR("parent_idx", outputs, *scope);
} else {
parent_idx_ = new framework::Tensor();
}
......
......@@ -29,9 +29,10 @@ template <typename Dtype>
class OnehotParam : public OpParam {
public:
OnehotParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = GET_VAR_AS_LOD_TENSOR("X", inputs, scope);
output_ = GET_VAR_AS_LOD_TENSOR("Out", outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = GET_VAR_AS_LOD_TENSOR("X", inputs, *scope);
output_ = GET_VAR_AS_LOD_TENSOR("Out", outputs, *scope);
depth_ = OpParam::GetAttr<int>("depth", attrs);
dtype_ = OpParam::GetAttr<int>("dtype", attrs);
......
......@@ -28,9 +28,11 @@ template <typename Dtype>
class Pad2DParam : public OpParam {
public:
Pad2DParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = OpParam::GetVarValue<framework::LoDTensor>("X", inputs, scope);
output_ = OpParam::GetVarValue<framework::LoDTensor>("Out", outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = OpParam::GetVarValue<framework::LoDTensor>("X", inputs, *scope);
output_ =
OpParam::GetVarValue<framework::LoDTensor>("Out", outputs, *scope);
paddings_ = OpParam::GetAttr<std::vector<int>>("paddings", attrs);
pad_value_ = OpParam::GetAttr<float>("pad_value", attrs);
mode_ = OpParam::GetStringAttr("mode", attrs);
......
......@@ -26,13 +26,10 @@ class WhileParam : public OpParam {
public:
WhileParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, Scope *scope)
: inputs_(inputs),
outputs_(outputs),
scope_(*scope),
OpParam(inputs, outputs, attrs, scope) {
: scope_(scope), OpParam(inputs, outputs, attrs, scope) {
cond_ =
OpParam::GetVarValue<framework::LoDTensor>("Condition", inputs, *scope);
sub_block_ = OpParam::GetAttr<int>("sub_block", attrs);
sub_block_ = OpParam::GetAttr<framework::BlockDesc *>("sub_block", attrs);
}
public:
......
......@@ -1222,12 +1222,12 @@ class FeedParam : public OpParam {
public:
FeedParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<framework::LoDTensorArray>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
input_x_ = InputXFrom<framework::LoDTensorArray>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
col_ = GetAttr<int>("col", attrs);
auto var = scope.FindVar("batch_size");
auto var = scope->FindVar("batch_size");
batch_size = var->GetValue<int>();
}
const framework::LoDTensorArray *InputX() const { return input_x_; }
......@@ -1249,10 +1249,10 @@ class FetchParam : public OpParam {
public:
FetchParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<framework::LoDTensor>(inputs, scope);
out_ = OutFrom<framework::LoDTensorArray>(outputs, scope);
input_x_ = InputXFrom<framework::LoDTensor>(inputs, *scope);
out_ = OutFrom<framework::LoDTensorArray>(outputs, *scope);
col_ = GetAttr<int>("col", attrs);
}
......@@ -1821,7 +1821,7 @@ class FusionConvAddParam : public ConvParam<Dtype> {
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
this->output_ = OpParam::OutFrom<GType>(outputs, scope);
this->output_ = OpParam::OutFrom<GType>(outputs, *scope);
}
GType *Bias() const { return bias_; }
......@@ -1862,7 +1862,7 @@ class FusionConvAddPReluParam : public ConvParam<Dtype> {
framework::DDim dims = alpha_->dims();
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
this->output_ = OpParam::OutFrom<GType>(outputs, scope);
this->output_ = OpParam::OutFrom<GType>(outputs, *scope);
}
const GType *InputAlpha() const { return alpha_; }
const std::string &Mode() const { return mode_; }
......@@ -1892,7 +1892,7 @@ class FusionConvAddAddPReluParam : public ConvParam<Dtype> {
alpha_ = OpParam::InputAlphaFrom<GType>(inputs, *scope);
mode_ = OpParam::GetStringAttr("mode", attrs);
framework::DDim dims = alpha_->dims();
bias_ = OpParam::InputYFrom<GType>(inputs, scope);
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
keyOutput_ = OpParam::Getkey("addOut", inputs, 0);
keyX1_ = OpParam::Getkey("addX", inputs, 1);
......@@ -1902,7 +1902,7 @@ class FusionConvAddAddPReluParam : public ConvParam<Dtype> {
} else if (keyY1_ == keyOutput_) {
bias1_ = OpParam::InputXFrom1<GType>(inputs, *scope);
}
this->output_ = OpParam::OutFrom<GType>(outputs, scope);
this->output_ = OpParam::OutFrom<GType>(outputs, *scope);
}
const GType *InputAlpha() const { return alpha_; }
const std::string &Mode() const { return mode_; }
......@@ -1937,13 +1937,13 @@ class FusionConvAddBNReluParam : public ConvParam<Dtype> {
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, scope);
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, *scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, *scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, *scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, *scope);
epsilon_ = OpParam::GetAttr<float>("epsilon", attrs);
momentum_ = OpParam::GetAttr<float>("momentum", attrs);
this->output_ = OpParam::OutFrom<GType>(outputs, scope);
this->output_ = OpParam::OutFrom<GType>(outputs, *scope);
}
GType *Bias() const { return bias_; }
......@@ -1996,10 +1996,10 @@ class FusionConvBNAddReluParam : public ConvParam<Dtype> {
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, scope);
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, *scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, *scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, *scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, *scope);
epsilon_ = OpParam::GetAttr<float>("epsilon", attrs);
momentum_ = OpParam::GetAttr<float>("momentum", attrs);
keyBNY_ = OpParam::Getkey("BNY", inputs, 0);
......@@ -2010,7 +2010,7 @@ class FusionConvBNAddReluParam : public ConvParam<Dtype> {
} else if (keyY_ == keyBNY_) {
bias_ = OpParam::InputXFrom<GType>(inputs, *scope);
}
this->output_ = OpParam::OutFrom<GType>(outputs, scope);
this->output_ = OpParam::OutFrom<GType>(outputs, *scope);
}
GType *Bias() const { return bias_; }
......@@ -2064,13 +2064,13 @@ class FusionConvBNParam : public ConvParam<Dtype> {
const VariableNameMap &outputs, const AttributeMap &attrs,
Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, scope);
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, *scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, *scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, *scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, *scope);
epsilon_ = OpParam::GetAttr<float>("epsilon", attrs);
momentum_ = OpParam::GetAttr<float>("momentum", attrs);
this->output_ = OpParam::OutputYFrom<GType>(outputs, scope);
this->output_ = OpParam::OutputYFrom<GType>(outputs, *scope);
}
const GType *InputBias() const { return input_bias_; }
......@@ -2118,13 +2118,13 @@ class FusionConvAddBNParam : public ConvParam<Dtype> {
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, scope);
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, *scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, *scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, *scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, *scope);
epsilon_ = OpParam::GetAttr<float>("epsilon", attrs);
momentum_ = OpParam::GetAttr<float>("momentum", attrs);
this->output_ = OpParam::OutputYFrom<GType>(outputs, scope);
this->output_ = OpParam::OutputYFrom<GType>(outputs, *scope);
}
GType *Bias() const { return bias_; }
......@@ -2175,13 +2175,13 @@ class FusionDWConvBNReluParam : public ConvParam<Dtype> {
const VariableNameMap &outputs,
const AttributeMap &attrs, Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, scope);
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, *scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, *scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, *scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, *scope);
epsilon_ = OpParam::GetAttr<float>("epsilon", attrs);
momentum_ = OpParam::GetAttr<float>("momentum", attrs);
this->output_ = OpParam::OutFrom<GType>(outputs, scope);
this->output_ = OpParam::OutFrom<GType>(outputs, *scope);
}
const GType *InputBias() const { return input_bias_; }
......@@ -2228,13 +2228,13 @@ class FusionConvBNReluParam : public ConvParam<Dtype> {
const VariableNameMap &outputs,
const AttributeMap &attrs, Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, scope);
input_bias_ = OpParam::InputBiasFrom<GType>(inputs, *scope);
input_mean_ = OpParam::InputMeanFrom<GType>(inputs, *scope);
input_scale_ = OpParam::InputScaleFrom<GType>(inputs, *scope);
input_variance_ = OpParam::InputVarianceFrom<GType>(inputs, *scope);
epsilon_ = OpParam::GetAttr<float>("epsilon", attrs);
momentum_ = OpParam::GetAttr<float>("momentum", attrs);
this->output_ = OpParam::OutFrom<GType>(outputs, scope);
this->output_ = OpParam::OutFrom<GType>(outputs, *scope);
}
const GType *InputBias() const { return input_bias_; }
......@@ -3285,10 +3285,10 @@ class IncrementParam : public OpParam {
public:
IncrementParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
input_x_ = InputXFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
step_ = OpParam::GetAttr<float>("step", attrs);
}
......
/* 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 PAD2D_OP
#include "operators/pad2d.h"
namespace paddle_mobile {
namespace operators {
template <typename Dtype, typename T>
void Pad2DOp<Dtype, T>::InferShape() const {
auto input_dims = this->param_.input_->dims();
const auto &paddings = this->param_.paddings_;
PADDLE_MOBILE_ENFORCE(paddings.size() == 4,
"Size of paddings should be equal to 4.");
input_dims[2] += paddings[0] + paddings[1];
input_dims[3] += paddings[2] + paddings[3];
this->param_.output_->Resize(input_dims);
}
} // namespace operators
} // namespace paddle_mobile
namespace ops = paddle_mobile::operators;
#ifdef PADDLE_MOBILE_CPU
REGISTER_OPERATOR_CPU(pad2d, ops::Pad2DOp);
#endif
#endif // PAD2D_OP
/* 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 PAD2D_OP
#pragma once
#include <string>
#include "framework/operator.h"
#include "operators/kernel/pad2d_kernel.h"
#include "operators/op_param.h"
namespace paddle_mobile {
namespace operators {
DECLARE_OPERATOR(Pad2D, Pad2DParam, Pad2DKernel);
} // namespace operators
} // namespace paddle_mobile
#endif // PAD2D_OP
......@@ -19,14 +19,15 @@ namespace paddle_mobile {
namespace operators {
template <typename Dtype, typename T>
void Pad2dOp<Dtype, T>::InferShape() const {
auto input_dims = this->param_.InputX()->dims();
auto input_n = input_dims[0];
auto input_c = input_dims[1];
auto input_h = input_dims[2];
auto input_w = input_dims[3];
this->param_.Out()->Resize({input_n, input_c, input_h + 1, input_w + 1});
void Pad2DOp<Dtype, T>::InferShape() const {
auto input_dims = this->param_.input_->dims();
const auto &paddings = this->param_.paddings_;
PADDLE_MOBILE_ENFORCE(paddings.size() == 4,
"Size of paddings should be equal to 4.");
input_dims[2] += paddings[0] + paddings[1];
input_dims[3] += paddings[2] + paddings[3];
this->param_.output_->Resize(input_dims);
}
} // namespace operators
......@@ -34,10 +35,7 @@ void Pad2dOp<Dtype, T>::InferShape() const {
namespace ops = paddle_mobile::operators;
#ifdef PADDLE_MOBILE_CPU
REGISTER_OPERATOR_CPU(pad2d, ops::Pad2dOp);
#endif
#ifdef PADDLE_MOBILE_FPGA
REGISTER_OPERATOR_FPGA(pad2d, ops::Pad2dOp);
REGISTER_OPERATOR_CPU(pad2d, ops::Pad2DOp);
#endif
#endif
#endif // PAD2D_OP
......@@ -17,33 +17,16 @@ limitations under the License. */
#pragma once
#include <string>
#include "framework/operator.h"
#include "operators/kernel/pad2d_kernel.h"
#include "operators/op_param.h"
namespace paddle_mobile {
namespace operators {
using framework::AttributeMap;
using framework::OperatorWithKernel;
using framework::Scope;
using std::string;
template <typename DeviceType, typename T>
class Pad2dOp
: public OperatorWithKernel<DeviceType, Pad2dParam<DeviceType>,
operators::Pad2dKernel<DeviceType, T>> {
public:
Pad2dOp(const string &type, const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
std::shared_ptr<Scope> scope)
: OperatorWithKernel<DeviceType, Pad2dParam<DeviceType>,
operators::Pad2dKernel<DeviceType, T>>(
type, inputs, outputs, attrs, scope) {}
void InferShape() const override;
private:
};
DECLARE_OPERATOR(Pad2D, Pad2DParam, Pad2DKernel);
} // namespace operators
} // namespace paddle_mobile
#endif
#endif // PAD2D_OP
......@@ -20,11 +20,11 @@ limitations under the License. */
void load_images(const char *image_dir, const char *images_list,
std::vector<std::string> *image_names,
std::vector<std::pair<int, int>> *image_shapes) {
int height, width;
int channel, height, width;
std::string filename;
std::ifstream if_list(images_list, std::ios::in);
while (!if_list.eof()) {
if_list >> height >> width >> filename;
if_list >> channel >> height >> width >> filename;
image_shapes->push_back(std::make_pair(height, width));
image_names->push_back(filename);
}
......@@ -32,20 +32,25 @@ void load_images(const char *image_dir, const char *images_list,
}
int main(int argc, char **argv) {
if (argc < 4) {
std::cerr << "Usage: ./test_ocr model_dir image_dir images_list."
<< std::endl;
if (argc < 5) {
std::cerr
<< "Usage: ./test_ocr model_dir image_dir images_list output_name."
<< std::endl;
return 1;
}
char *model_dir = argv[1];
char *image_dir = argv[2];
char *images_list = argv[3];
char *output_name = argv[4];
paddle_mobile::PaddleMobile<paddle_mobile::CPU> paddle_mobile;
paddle_mobile.SetThreadNum(8);
paddle_mobile.SetThreadNum(1);
auto isok = paddle_mobile.Load(std::string(model_dir) + "/model",
std::string(model_dir) + "/params", true,
false, 1, true);
// auto isok = paddle_mobile.Load(std::string(model_dir), false,
// false, 1, true);
DLOG << "pass init model";
std::vector<std::string> image_names;
std::vector<std::pair<int, int>> image_shapes;
......@@ -55,7 +60,7 @@ int main(int argc, char **argv) {
for (int i = 0; i < image_names.size(); i++) {
std::string file_name = image_names[i];
std::vector<float> input_vec;
std::vector<int64_t> dims{1, 1, 48, 512};
std::vector<int64_t> dims{1, 3, 48, 512};
dims[2] = image_shapes[i].first;
dims[3] = image_shapes[i].second;
// load input image
......@@ -64,23 +69,24 @@ int main(int argc, char **argv) {
std::cerr << "shape = [" << dims[0] << ", " << dims[1] << ", " << dims[2]
<< ", " << dims[3] << "]" << std::endl;
GetInput<float>(img_path, &input_vec, dims);
framework::Tensor input(input_vec, framework::make_ddim(dims));
// framework::Tensor input(input_vec, framework::make_ddim(dims));
// predict
paddle_mobile.Predict(input);
auto output_topk = paddle_mobile.Fetch("top_k_1.tmp_0");
auto output_indices = paddle_mobile.Fetch("cast_68.tmp_0");
// for (int j = 0; j < 10000; ++j) {
auto time3 = paddle_mobile::time();
paddle_mobile.Predict(input_vec, dims);
auto output_topk = paddle_mobile.Fetch(output_name);
auto time4 = paddle_mobile::time();
std::cerr << "average predict elapsed: "
<< paddle_mobile::time_diff(time3, time4) << "ms" << std::endl;
// }
// print result
std::cerr << file_name << std::endl;
std::cerr << output_name << std::endl;
std::cerr << output_topk->data<float>()[0];
for (int j = 1; j < output_topk->numel(); ++j) {
std::cerr << " " << output_topk->data<float>()[j];
}
std::cerr << std::endl;
std::cerr << output_indices->data<float>()[0];
for (int j = 1; j < output_indices->numel(); ++j) {
std::cerr << " " << output_indices->data<float>()[j];
}
std::cerr << std::endl;
}
return 0;
}
......@@ -624,6 +624,7 @@ if (BEAM_SEARCH_OP)
endif()
if (BEAM_SEARCH_DECODE_OP)
add_definitions(-DBEAM_SEARCH_DECODE_OP)
endif()
if (FUSION_DECONVADDBNRELU_OP)
add_definitions(-DFUSION_DECONVADDBNRELU_OP)
endif()
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册