Skip to content

P
Paddle-Lite

PaddlePaddle / Paddle-Lite

通知 338
Star 4
Fork 1
P
Paddle-Lite
提交 93a1705a 编写于 作者: L liuruilong
浏览文件
操作

put tensor when kernel init in scope

上级 abab2bf9
隐藏空白更改
内联 并排
Showing with 450 addition and 353 deletion
src/framework/operator.h
浏览文件 @ 93a1705a
......@@ -103,7 +103,7 @@ class OperatorWithKernel : public OperatorBase<Dtype> {
const VariableNameMap &outputs, const AttributeMap &attrs,
std::shared_ptr<Scope> scope)
: OperatorBase<Dtype>(type, inputs, outputs, attrs, scope),
param_(inputs, outputs, attrs, *scope) {
param_(inputs, outputs, attrs, scope.get()) {
#ifdef PADDLE_MOBILE_CL
kernel_.InitCLHelper(scope->GetCLScpoe());
#endif
......
src/operators/fill_constant_op.h
浏览文件 @ 93a1705a
......@@ -35,7 +35,7 @@ class FillConstantOp : public framework::OperatorBase<DeviceType> {
std::shared_ptr<framework::Scope> scope)
: framework::OperatorBase<DeviceType>(type, inputs, outputs, attrs,
scope),
param_(inputs, outputs, attrs, *scope) {}
param_(inputs, outputs, attrs, scope.get()) {}
void RunImpl() {
auto data_type =
static_cast<_PaddleMobile__Framework__Proto__VarType__Type>(
......
src/operators/kernel/arm/conv_add_bn_relu_kernel.cpp
浏览文件 @ 93a1705a
......@@ -41,8 +41,11 @@ bool ConvAddBNReluKernel<CPU, float>::Init(
inv_std_ptr[i] =
1 / static_cast<float>(pow((variance_ptr[i] + epsilon), 0.5));
}
Tensor *new_scale = new Tensor();
Tensor *new_bias = new Tensor();
// 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_ptr = new_scale->mutable_data<float>({C});
auto new_bias_ptr = new_bias->mutable_data<float>({C});
for (int i = 0; i < C; i++) {
......
src/operators/kernel/arm/conv_bn_relu_kernel.cpp
浏览文件 @ 93a1705a
......@@ -42,8 +42,8 @@ bool ConvBNReluKernel<CPU, float>::Init(FusionConvBNReluParam<CPU> *param) {
inv_std_ptr[i] =
1 / static_cast<float>(pow((variance_ptr[i] + epsilon), 0.5));
}
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_ptr = new_scale->mutable_data<float>({C});
auto new_bias_ptr = new_bias->mutable_data<float>({C});
for (int i = 0; i < C; i++) {
......
src/operators/kernel/detection_kernel.h
浏览文件 @ 93a1705a
......@@ -27,12 +27,14 @@ class AnchorGeneratorParam : public OpParam {
public:
AnchorGeneratorParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = OpParam::GetVarValue<framework::LoDTensor>("Input", inputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ =
OpParam::GetVarValue<framework::LoDTensor>("Input", inputs, *scope);
output_anchors_ =
OpParam::GetVarValue<framework::LoDTensor>("Anchors", outputs, scope);
output_variances_ =
OpParam::GetVarValue<framework::LoDTensor>("Variances", outputs, scope);
OpParam::GetVarValue<framework::LoDTensor>("Anchors", outputs, *scope);
output_variances_ = OpParam::GetVarValue<framework::LoDTensor>(
"Variances", outputs, *scope);
anchor_sizes_ = OpParam::GetAttr<std::vector<float>>("anchor_sizes", attrs);
aspect_ratios_ =
......@@ -64,22 +66,23 @@ template <typename Dtype>
class ProposalParam : public OpParam {
public:
ProposalParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
scores_ =
OpParam::GetVarValue<framework::LoDTensor>("Scores", inputs, scope);
bbox_deltas_ =
OpParam::GetVarValue<framework::LoDTensor>("BboxDeltas", inputs, scope);
OpParam::GetVarValue<framework::LoDTensor>("Scores", inputs, *scope);
bbox_deltas_ = OpParam::GetVarValue<framework::LoDTensor>("BboxDeltas",
inputs, *scope);
im_info_ =
OpParam::GetVarValue<framework::LoDTensor>("ImInfo", inputs, scope);
OpParam::GetVarValue<framework::LoDTensor>("ImInfo", inputs, *scope);
anchors_ =
OpParam::GetVarValue<framework::LoDTensor>("Anchors", inputs, scope);
OpParam::GetVarValue<framework::LoDTensor>("Anchors", inputs, *scope);
variances_ =
OpParam::GetVarValue<framework::LoDTensor>("Variances", inputs, scope);
OpParam::GetVarValue<framework::LoDTensor>("Variances", inputs, *scope);
rpn_rois_ =
OpParam::GetVarValue<framework::LoDTensor>("RpnRois", outputs, scope);
OpParam::GetVarValue<framework::LoDTensor>("RpnRois", outputs, *scope);
rpn_probs_ = OpParam::GetVarValue<framework::LoDTensor>("RpnRoiProbs",
outputs, scope);
outputs, *scope);
pre_nms_topn_ = OpParam::GetAttr<int>("pre_nms_topN", attrs);
post_nms_topn_ = OpParam::GetAttr<int>("post_nms_topN", attrs);
......@@ -117,11 +120,13 @@ template <typename Dtype>
class PSRoiPoolParam : public OpParam {
public:
PSRoiPoolParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = OpParam::GetVarValue<framework::LoDTensor>("X", inputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = OpParam::GetVarValue<framework::LoDTensor>("X", inputs, *scope);
input_rois_ =
OpParam::GetVarValue<framework::LoDTensor>("ROIs", inputs, scope);
output_ = OpParam::GetVarValue<framework::LoDTensor>("Out", outputs, scope);
OpParam::GetVarValue<framework::LoDTensor>("ROIs", inputs, *scope);
output_ =
OpParam::GetVarValue<framework::LoDTensor>("Out", outputs, *scope);
output_channels_ = OpParam::GetAttr<int>("output_channels", attrs);
pooled_height_ = OpParam::GetAttr<int>("pooled_height", attrs);
......@@ -152,11 +157,13 @@ class RoiPerspectiveParam : public OpParam {
public:
RoiPerspectiveParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_x_ = OpParam::GetVarValue<framework::LoDTensor>("X", inputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = OpParam::GetVarValue<framework::LoDTensor>("X", inputs, *scope);
input_rois_ =
OpParam::GetVarValue<framework::LoDTensor>("ROIs", inputs, scope);
output_ = OpParam::GetVarValue<framework::LoDTensor>("Out", outputs, scope);
OpParam::GetVarValue<framework::LoDTensor>("ROIs", inputs, *scope);
output_ =
OpParam::GetVarValue<framework::LoDTensor>("Out", outputs, *scope);
spatial_scale_ = OpParam::GetAttr<float>("spatial_scale", attrs);
transformed_height_ = OpParam::GetAttr<int>("transformed_height", attrs);
......
src/operators/kernel/while_kernel.h
浏览文件 @ 93a1705a
......@@ -25,10 +25,13 @@ template <typename Dtype>
class WhileParam : public OpParam {
public:
WhileParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
: inputs_(inputs), outputs_(outputs), scope_(scope) {
const AttributeMap &attrs, Scope *scope)
: inputs_(inputs),
outputs_(outputs),
scope_(*scope),
OpParam(inputs, outputs, attrs, scope) {
cond_ =
OpParam::GetVarValue<framework::LoDTensor>("Condition", inputs, scope);
OpParam::GetVarValue<framework::LoDTensor>("Condition", inputs, *scope);
sub_block_ = OpParam::GetAttr<int>("sub_block", attrs);
}
......
src/operators/op_param.h
浏览文件 @ 93a1705a
......@@ -69,6 +69,30 @@ struct DtypeTensorTrait<GPU_CL> {
#endif
class OpParam {
public:
OpParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, Scope *scope) {
scope_pointer_ = scope;
inputs_ = inputs;
}
template <typename T>
T *CreateNewScale() {
std::string scale_key = Getkey("Scale", inputs_, 0);
auto var = scope_pointer_->Var(scale_key + "_new");
return var->GetMutable<T>();
}
template <typename T>
T *CreateNewBiase() {
std::string biase_key = Getkey("Bias", inputs_, 0);
auto var = scope_pointer_->Var(biase_key + "_new");
return var->GetMutable<T>();
}
VariableNameMap inputs_;
Scope *scope_pointer_ = nullptr;
protected:
template <typename T>
static T *InputH0From(const VariableNameMap &inputs, const Scope &scope) {
......@@ -359,8 +383,10 @@ class OpParam {
}
}
static std::string getkey(const string &key, const VariableNameMap &var_map,
static std::string Getkey(const string &key, const VariableNameMap &var_map,
int index) {
PADDLE_MOBILE_ENFORCE(var_map.count(key) > index,
"%s is not contained in var_map", key.c_str())
auto var_vec = var_map.at(key);
return var_vec[index];
}
......@@ -414,11 +440,12 @@ class ConvParam : public OpParam {
public:
ConvParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
filter_ = OpParam::FilterFrom<GType>(inputs, scope);
input_ = OpParam::InputFrom<GType>(inputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
filter_ = OpParam::FilterFrom<GType>(inputs, *scope);
input_ = OpParam::InputFrom<GType>(inputs, *scope);
if (outputs.count("Output")) {
output_ = OpParam::OutputFrom<GType>(outputs, scope);
output_ = OpParam::OutputFrom<GType>(outputs, *scope);
}
strides_ = OpParam::GetAttr<vector<int>>("strides", attrs);
paddings_ = OpParam::GetAttr<vector<int>>("paddings", attrs);
......@@ -500,17 +527,18 @@ template <typename Dtype>
Print &operator<<(Print &printer, const ConvParam<Dtype> &conv_param);
template <typename Dtype>
class ElementwiseAddParam : OpParam {
class ElementwiseAddParam : public OpParam {
typedef typename DtypeTensorTrait<Dtype>::gtype GType;
typedef typename DtypeTensorTrait<Dtype>::rtype RType;
public:
ElementwiseAddParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_y_ = InputYFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_y_ = InputYFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
axis_ = GetAttr<int>("axis", attrs);
}
......@@ -540,17 +568,18 @@ class ElementwiseAddParam : OpParam {
#ifdef ELEMENTWISEMUL_OP
template <typename Dtype>
class ElementwiseMulParam : OpParam {
class ElementwiseMulParam : public OpParam {
typedef typename DtypeTensorTrait<Dtype>::gtype GType;
typedef typename DtypeTensorTrait<Dtype>::rtype RType;
public:
ElementwiseMulParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_y_ = InputYFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_y_ = InputYFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
axis_ = GetAttr<int>("axis", attrs);
}
......@@ -577,17 +606,18 @@ using ElementwiseAddReluParam = ElementwiseAddParam<Dtype>;
#ifdef ELEMENTWISESUB_OP
template <typename Dtype>
class ElementwiseSubParam : OpParam {
class ElementwiseSubParam : public OpParam {
typedef typename DtypeTensorTrait<Dtype>::gtype GType;
typedef typename DtypeTensorTrait<Dtype>::rtype RType;
public:
ElementwiseSubParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_y_ = InputYFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_y_ = InputYFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
axis_ = GetAttr<int>("axis", attrs);
}
......@@ -609,16 +639,17 @@ class ElementwiseSubParam : OpParam {
#ifdef MUL_OP
template <typename Dtype>
class MulParam : OpParam {
class MulParam : public OpParam {
typedef typename DtypeTensorTrait<Dtype>::gtype GType;
typedef typename DtypeTensorTrait<Dtype>::rtype RType;
public:
MulParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_y_ = InputYFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_y_ = InputYFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
x_num_col_dims_ = GetAttr<int>("x_num_col_dims", attrs);
y_num_col_dims_ = GetAttr<int>("y_num_col_dims", attrs);
}
......@@ -650,9 +681,10 @@ class ConcatParam : public OpParam {
public:
ConcatParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
inputs_ = InputMultiFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
inputs_ = InputMultiFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
axis_ = GetAttr<int>("axis", attrs);
}
......@@ -686,11 +718,12 @@ class SumParam : public OpParam {
public:
SumParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
inputs_vars_ = InputMultiVarsFrom(inputs, scope);
out_var_ = OutVarFrom(outputs, scope);
inputs_ = InputMultiFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
inputs_vars_ = InputMultiVarsFrom(inputs, *scope);
out_var_ = OutVarFrom(outputs, *scope);
inputs_ = InputMultiFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
}
vector<Variable *> InputsVars() const { return inputs_vars_; }
......@@ -717,10 +750,11 @@ class LrnParam : public OpParam {
public:
LrnParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
mid_out_ = MidOutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
mid_out_ = MidOutFrom<GType>(outputs, *scope);
n_ = GetAttr<int>("n", attrs);
alpha_ = GetAttr<float>("alpha", attrs);
beta_ = GetAttr<float>("beta", attrs);
......@@ -758,16 +792,17 @@ class LrnParam : public OpParam {
#ifdef NORM_OP
template <typename Dtype>
class NormParam : OpParam {
class NormParam : public OpParam {
typedef typename DtypeTensorTrait<Dtype>::gtype GType;
typedef typename DtypeTensorTrait<Dtype>::rtype RType;
public:
NormParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
output_norm_ = OutputNormFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
output_norm_ = OutputNormFrom<GType>(outputs, *scope);
epsilon_ = GetAttr<float>("epsilon", attrs);
axis_ = GetAttr<int>("axis", attrs);
}
......@@ -793,19 +828,20 @@ class NormParam : OpParam {
#ifdef BATCHNORM_OP
template <typename Dtype>
class BatchNormParam : OpParam {
class BatchNormParam : public OpParam {
typedef typename DtypeTensorTrait<Dtype>::gtype GType;
typedef typename DtypeTensorTrait<Dtype>::rtype RType;
public:
BatchNormParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
output_y_ = OutputYFrom<GType>(outputs, scope);
input_bias_ = InputBiasFrom<GType>(inputs, scope);
input_mean_ = InputMeanFrom<GType>(inputs, scope);
input_scale_ = InputScaleFrom<GType>(inputs, scope);
input_variance_ = InputVarianceFrom<GType>(inputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
output_y_ = OutputYFrom<GType>(outputs, *scope);
input_bias_ = InputBiasFrom<GType>(inputs, *scope);
input_mean_ = InputMeanFrom<GType>(inputs, *scope);
input_scale_ = InputScaleFrom<GType>(inputs, *scope);
input_variance_ = InputVarianceFrom<GType>(inputs, *scope);
epsilon_ = GetAttr<float>("epsilon", attrs);
momentum_ = GetAttr<float>("momentum", attrs);
// is_test_ = GetAttr<bool>("is_test", attrs);
......@@ -863,10 +899,11 @@ class PoolParam : public OpParam {
public:
PoolParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = InputXFrom<GType>(inputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = InputXFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, scope);
output_ = OutFrom<GType>(outputs, *scope);
pooling_type_ = GetStringAttr("pooling_type", attrs);
ksize_ = GetAttr<vector<int>>("ksize", attrs);
strides_ = GetAttr<vector<int>>("strides", attrs);
......@@ -920,11 +957,12 @@ class PriorBoxParam : public OpParam {
public:
PriorBoxParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = InputFrom<GType>(inputs, scope);
input_image_ = InputImageFrom<GType>(inputs, scope);
output_boxes_ = OutputBoxesFrom<GType>(outputs, scope);
output_variances_ = OutputVariancesFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = InputFrom<GType>(inputs, *scope);
input_image_ = InputImageFrom<GType>(inputs, *scope);
output_boxes_ = OutputBoxesFrom<GType>(outputs, *scope);
output_variances_ = OutputVariancesFrom<GType>(outputs, *scope);
min_sizes_ = GetAttr<vector<float>>("min_sizes", attrs);
max_sizes_ = GetAttr<vector<float>>("max_sizes", attrs);
aspect_ratios_ = GetAttr<vector<float>>("aspect_ratios", attrs);
......@@ -998,11 +1036,12 @@ class BoxCoderParam : public OpParam {
public:
BoxCoderParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_priorbox_ = InputPriorBoxFrom<GType>(inputs, scope);
input_priorboxvar_ = InputPriorBoxVarFrom<GType>(inputs, scope);
input_targetbox_ = InputTargetBoxFrom<GType>(inputs, scope);
output_box_ = OutputBoxFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_priorbox_ = InputPriorBoxFrom<GType>(inputs, *scope);
input_priorboxvar_ = InputPriorBoxVarFrom<GType>(inputs, *scope);
input_targetbox_ = InputTargetBoxFrom<GType>(inputs, *scope);
output_box_ = OutputBoxFrom<GType>(outputs, *scope);
code_type_ = GetStringAttr("code_type", attrs);
}
const RType *InputPriorBox() const { return input_priorbox_; }
......@@ -1032,9 +1071,10 @@ class SoftmaxParam : public OpParam {
public:
SoftmaxParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
}
const GType *InputX() const { return input_x_; }
GType *Out() const { return out_; }
......@@ -1068,9 +1108,10 @@ class SigmoidParam : public OpParam {
public:
SigmoidParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
}
const RType *InputX() const { return input_x_; }
RType *Out() const { return out_; }
......@@ -1099,10 +1140,11 @@ class MultiClassNMSParam : public OpParam {
public:
MultiClassNMSParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_bboxes_ = InputBBoxesFrom<GType>(inputs, scope);
input_scores_ = InputScoresFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_bboxes_ = InputBBoxesFrom<GType>(inputs, *scope);
input_scores_ = InputScoresFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
background_label_ = GetAttr<int>("background_label", attrs);
nms_top_k_ = GetAttr<int>("nms_top_k", attrs);
keep_top_k_ = GetAttr<int>("keep_top_k", attrs);
......@@ -1151,9 +1193,10 @@ class PolygonBoxTransformParam : public OpParam {
public:
PolygonBoxTransformParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = InputFrom<GType>(inputs, scope);
output_ = OutputFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = InputFrom<GType>(inputs, *scope);
output_ = OutputFrom<GType>(outputs, *scope);
}
const RType *Input() const { return input_; }
RType *Output() const { return output_; }
......@@ -1171,16 +1214,17 @@ 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) {
#ifdef PADDLE_MOBILE_FPGA
static int feed_num = 0;
auto new_name = std::string("feed") + std::to_string(feed_num++);
const_cast<VariableNameMap &>(inputs).at("X") = {string(new_name)};
#endif
input_x_ = InputXFrom<LoDTensor>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
auto var = scope.FindVar("batch_size");
input_x_ = InputXFrom<LoDTensor>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
auto var = scope->FindVar("batch_size");
batch_size = var->GetValue<int>();
}
const LoDTensor *InputX() const { return input_x_; }
......@@ -1200,14 +1244,15 @@ 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) {
#ifdef PADDLE_MOBILE_FPGA
static int fetch_num = 0;
auto new_name = std::string("fetch") + std::to_string(fetch_num++);
const_cast<VariableNameMap &>(outputs).at("Out") = {string(new_name)};
#endif
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom(outputs, scope);
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom(outputs, *scope);
}
const RType *InputX() const { return input_x_; }
......@@ -1237,9 +1282,10 @@ class FillConstantParam : public OpParam {
public:
FillConstantParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
out_var_ = OutVarFrom(outputs, scope);
out_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
out_var_ = OutVarFrom(outputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
dtype_ = GetAttr<int>("dtype", attrs);
shape_ = GetAttr<vector<int>>("shape", attrs);
value_ = GetAttr<float>("value", attrs);
......@@ -1272,9 +1318,10 @@ class TransposeParam : public OpParam {
public:
TransposeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
axis_ = GetAttr<vector<int>>("axis", attrs);
}
......@@ -1299,10 +1346,11 @@ class Transpose2Param : public OpParam {
public:
Transpose2Param(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
output_xshape_ = OutputXShapeFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
output_xshape_ = OutputXShapeFrom<GType>(outputs, *scope);
axis_ = GetAttr<vector<int>>("axis", attrs);
}
......@@ -1330,10 +1378,11 @@ class LookupParam : public OpParam {
public:
LookupParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_w_ = InputWFrom<GType>(inputs, scope);
input_ids_ = InputIdsFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_w_ = InputWFrom<GType>(inputs, *scope);
input_ids_ = InputIdsFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
padding_idx_ = GetAttr<int64_t>("padding_idx", attrs);
}
......@@ -1360,12 +1409,13 @@ class CrfParam : public OpParam {
// {G_OP_TYPE_CRF, {{"Emission", "Transition", "Label"}, {"ViterbiPath"}}},
CrfParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
// todo crf params
input_emission_ = InputEmissionFrom<GType>(inputs, scope);
input_transition_ = InputTransitionFrom<GType>(inputs, scope);
input_label_ = InputLabelFrom<GType>(inputs, scope);
output_viterbipath_ = OutputViterbiPathFrom<GType>(outputs, scope);
input_emission_ = InputEmissionFrom<GType>(inputs, *scope);
input_transition_ = InputTransitionFrom<GType>(inputs, *scope);
input_label_ = InputLabelFrom<GType>(inputs, *scope);
output_viterbipath_ = OutputViterbiPathFrom<GType>(outputs, *scope);
// padding_idx_ = GetAttr<int64_t>("padding_idx", attrs);
}
const GType *InputEmission() const { return input_emission_; }
......@@ -1396,10 +1446,11 @@ class ReshapeParam : public OpParam {
public:
ReshapeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_shape_ = InputShapeFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_shape_ = InputShapeFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
shape_ = GetAttr<vector<int>>("shape", attrs);
if (HasAttr("inplace", attrs)) {
......@@ -1437,11 +1488,12 @@ class Reshape2Param : public OpParam {
public:
Reshape2Param(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_shape_ = InputShapeFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
output_xshape_ = OutputXShapeFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_shape_ = InputShapeFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
output_xshape_ = OutputXShapeFrom<GType>(outputs, *scope);
shape_ = GetAttr<vector<int>>("shape", attrs);
if (HasAttr("inplace", attrs)) {
inplace_ = GetAttr<bool>("inplace", attrs);
......@@ -1480,10 +1532,11 @@ class ScaleParam : public OpParam {
public:
ScaleParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_bias_ = InputBiasFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_bias_ = InputBiasFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
inplace_ = GetAttr<bool>("inplace", attrs);
has_bias_ = GetAttr<bool>("has_bias", attrs);
scales_ = GetAttr<vector<float>>("scales", attrs);
......@@ -1523,9 +1576,10 @@ class SliceParam : public OpParam {
public:
SliceParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = InputFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = InputFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
axes_ = GetAttr<std::vector<int>>("axes", attrs);
starts_ = GetAttr<std::vector<int>>("starts", attrs);
......@@ -1549,10 +1603,11 @@ class ResizeParam : public OpParam {
public:
ResizeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_shape_ = InputShapeFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_shape_ = InputShapeFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
is_pyramid_test_ = GetAttr<bool>("is_pyramid_test", attrs);
height_ = GetAttr<int>("height", attrs);
width_ = GetAttr<int>("width", attrs);
......@@ -1599,9 +1654,10 @@ class ReluParamBase : public OpParam {
public:
ReluParamBase(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
}
const RType *InputX() const { return input_x_; }
......@@ -1641,9 +1697,10 @@ class TanhParam : public OpParam {
public:
TanhParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
}
const RType *InputX() const { return input_x_; }
RType *Out() const { return out_; }
......@@ -1676,12 +1733,13 @@ class PReluParam : public OpParam {
public:
PReluParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
DLOG << "PReluParam inputs before";
input_x_ = InputXFrom<GType>(inputs, scope);
alpha_ = InputAlphaFrom<GType>(inputs, scope);
input_x_ = InputXFrom<GType>(inputs, *scope);
alpha_ = InputAlphaFrom<GType>(inputs, *scope);
framework::DDim dims = alpha_->dims();
out_ = OutFrom<GType>(outputs, scope);
out_ = OutFrom<GType>(outputs, *scope);
mode_ = GetStringAttr("mode", attrs);
DLOG << "PReluParam mode after" << mode_;
}
......@@ -1705,11 +1763,12 @@ class FusionFcParam : public OpParam {
public:
FusionFcParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_y_ = InputYFrom<GType>(inputs, scope);
input_z_ = InputZFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_y_ = InputYFrom<GType>(inputs, *scope);
input_z_ = InputZFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
x_num_col_dims_ = GetAttr<int>("x_num_col_dims", attrs);
y_num_col_dims_ = GetAttr<int>("y_num_col_dims", attrs);
axis_ = GetAttr<int>("axis", attrs);
......@@ -1760,11 +1819,11 @@ class FusionConvAddParam : public ConvParam<Dtype> {
public:
FusionConvAddParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope)
Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
bias_ = OpParam::InputYFrom<GType>(inputs, scope);
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
output_ = OpParam::OutFrom<GType>(outputs, scope);
output_ = OpParam::OutFrom<GType>(outputs, *scope);
}
RType *Bias() const { return bias_; }
......@@ -1787,7 +1846,7 @@ class FusionConvAddReluParam : public FusionConvAddParam<DeviceType> {
public:
FusionConvAddReluParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: FusionConvAddParam<DeviceType>(inputs, outputs, attrs, scope) {}
};
#endif
......@@ -1801,14 +1860,14 @@ class FusionConvAddPReluParam : public ConvParam<Dtype> {
public:
FusionConvAddPReluParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
alpha_ = OpParam::InputAlphaFrom<GType>(inputs, scope);
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);
output_ = OpParam::OutFrom<GType>(outputs, scope);
output_ = OpParam::OutFrom<GType>(outputs, *scope);
}
const RType *InputAlpha() const { return alpha_; }
const std::string &Mode() const { return mode_; }
......@@ -1834,22 +1893,22 @@ class FusionConvAddAddPReluParam : public ConvParam<Dtype> {
public:
FusionConvAddAddPReluParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
bias1_ = OpParam::InputYFrom1<GType>(inputs, scope);
alpha_ = OpParam::InputAlphaFrom<GType>(inputs, scope);
bias1_ = OpParam::InputYFrom1<GType>(inputs, *scope);
alpha_ = OpParam::InputAlphaFrom<GType>(inputs, *scope);
mode_ = OpParam::GetStringAttr("mode", attrs);
framework::DDim dims = alpha_->dims();
bias_ = OpParam::InputYFrom<GType>(inputs, scope);
output_ = OpParam::OutFrom<GType>(outputs, scope);
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
output_ = OpParam::OutFrom<GType>(outputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
keyOutput_ = OpParam::getkey("addOut", inputs, 0);
keyX1_ = OpParam::getkey("addX", inputs, 1);
keyY1_ = OpParam::getkey("Y", inputs, 1);
keyOutput_ = OpParam::Getkey("addOut", inputs, 0);
keyX1_ = OpParam::Getkey("addX", inputs, 1);
keyY1_ = OpParam::Getkey("Y", inputs, 1);
if (keyX1_ == keyOutput_) {
bias1_ = OpParam::InputYFrom1<GType>(inputs, scope);
bias1_ = OpParam::InputYFrom1<GType>(inputs, *scope);
} else if (keyY1_ == keyOutput_) {
bias1_ = OpParam::InputXFrom1<GType>(inputs, scope);
bias1_ = OpParam::InputXFrom1<GType>(inputs, *scope);
}
}
const RType *InputAlpha() const { return alpha_; }
......@@ -1883,15 +1942,15 @@ class FusionConvAddBNReluParam : public ConvParam<Dtype> {
public:
FusionConvAddBNReluParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
bias_ = OpParam::InputYFrom<GType>(inputs, scope);
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
output_ = OpParam::OutFrom<GType>(outputs, 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);
output_ = OpParam::OutFrom<GType>(outputs, *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);
// is_test_ = OpParam::GetAttr<bool>("is_test", attrs);
......@@ -1949,24 +2008,24 @@ class FusionConvBNAddReluParam : public ConvParam<Dtype> {
public:
FusionConvBNAddReluParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
bias_ = OpParam::InputYFrom<GType>(inputs, scope);
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
output_ = OpParam::OutFrom<GType>(outputs, 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);
output_ = OpParam::OutFrom<GType>(outputs, *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);
keyX_ = OpParam::getkey("X", inputs, 0);
keyY_ = OpParam::getkey("Y", inputs, 0);
keyBNY_ = OpParam::Getkey("BNY", inputs, 0);
keyX_ = OpParam::Getkey("X", inputs, 0);
keyY_ = OpParam::Getkey("Y", inputs, 0);
if (keyX_ == keyBNY_) {
bias_ = OpParam::InputYFrom<GType>(inputs, scope);
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
} else if (keyY_ == keyBNY_) {
bias_ = OpParam::InputXFrom<GType>(inputs, scope);
bias_ = OpParam::InputXFrom<GType>(inputs, *scope);
}
// is_test_ = OpParam::GetAttr<bool>("is_test", attrs);
}
......@@ -2026,13 +2085,13 @@ class FusionConvBNParam : public ConvParam<Dtype> {
public:
FusionConvBNParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope)
Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
output_y_ = OpParam::OutputYFrom<GType>(outputs, 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);
output_y_ = OpParam::OutputYFrom<GType>(outputs, *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);
// is_test_ = OpParam::GetAttr<bool>("is_test", attrs);
......@@ -2084,15 +2143,15 @@ class FusionConvAddBNParam : public ConvParam<Dtype> {
public:
FusionConvAddBNParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
bias_ = OpParam::InputYFrom<GType>(inputs, scope);
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
output_y_ = OpParam::OutputYFrom<GType>(outputs, 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);
output_y_ = OpParam::OutputYFrom<GType>(outputs, *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);
// is_test_ = OpParam::GetAttr<bool>("is_test", attrs);
......@@ -2150,13 +2209,13 @@ class FusionDWConvBNReluParam : public ConvParam<Dtype> {
public:
FusionDWConvBNReluParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
output_ = OpParam::OutFrom<GType>(outputs, 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);
output_ = OpParam::OutFrom<GType>(outputs, *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);
// is_test_ = OpParam::GetAttr<bool>("is_test", attrs);
......@@ -2209,13 +2268,13 @@ class FusionConvBNReluParam : public ConvParam<Dtype> {
public:
FusionConvBNReluParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: ConvParam<Dtype>(inputs, outputs, attrs, scope) {
output_ = OpParam::OutFrom<GType>(outputs, 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);
output_ = OpParam::OutFrom<GType>(outputs, *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);
// is_test_ = OpParam::GetAttr<bool>("is_test", attrs);
......@@ -2267,9 +2326,10 @@ class Im2SequenceParam : public OpParam {
public:
Im2SequenceParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
kernels_ = GetAttr<vector<int>>("kernels", attrs);
strides_ = GetAttr<vector<int>>("strides", attrs);
paddings_ = GetAttr<vector<int>>("paddings", attrs);
......@@ -2302,9 +2362,10 @@ class DropoutParam : public OpParam {
public:
DropoutParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
dropout_prob_ = GetAttr<float>("dropout_prob", attrs);
}
......@@ -2330,12 +2391,13 @@ class ConvTransposeParam : public OpParam {
public:
ConvTransposeParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
filter_ = FilterFrom<GType>(inputs, scope);
input_ = InputFrom<GType>(inputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
filter_ = FilterFrom<GType>(inputs, *scope);
input_ = InputFrom<GType>(inputs, *scope);
// output_ = OutputFrom<GType>(outputs, scope);
if (outputs.count("Output")) {
output_ = OpParam::OutputFrom<GType>(outputs, scope);
output_ = OpParam::OutputFrom<GType>(outputs, *scope);
}
strides_ = GetAttr<vector<int>>("strides", attrs);
paddings_ = GetAttr<vector<int>>("paddings", attrs);
......@@ -2393,11 +2455,11 @@ class FusionDeconvAddParam : public ConvTransposeParam<Dtype> {
public:
FusionDeconvAddParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: ConvTransposeParam<Dtype>(inputs, outputs, attrs, scope) {
bias_ = OpParam::InputYFrom<GType>(inputs, scope);
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
output_ = OpParam::OutFrom<GType>(outputs, scope);
output_ = OpParam::OutFrom<GType>(outputs, *scope);
}
RType *Bias() const { return bias_; }
......@@ -2425,13 +2487,13 @@ class FusionDeconvAddBNParam : public ConvTransposeParam<Dtype> {
public:
FusionDeconvAddBNParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: ConvTransposeParam<Dtype>(inputs, outputs, attrs, scope) {
output_ = OpParam::OutFrom<GType>(outputs, 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);
output_ = OpParam::OutFrom<GType>(outputs, *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);
// is_test_ = OpParam::GetAttr<bool>("is_test", attrs);
......@@ -2482,13 +2544,13 @@ class FusionDeconvAddBNReluParam : public ConvTransposeParam<Dtype> {
public:
FusionDeconvAddBNReluParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: ConvTransposeParam<Dtype>(inputs, outputs, attrs, scope) {
output_ = OpParam::OutFrom<GType>(outputs, 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);
output_ = OpParam::OutFrom<GType>(outputs, *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);
// is_test_ = OpParam::GetAttr<bool>("is_test", attrs);
......@@ -2550,17 +2612,18 @@ class GruParam : public OpParam {
* @param scope
* */
GruParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_input_ = InputFrom<GType>(inputs, scope);
input_h0_ = InputH0From<GType>(inputs, scope);
input_bias_ = InputBiasFrom<GType>(inputs, scope);
input_weight_ = InputWeightFrom<GType>(inputs, scope);
output_batch_gate_ = OutputBatchGateFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_input_ = InputFrom<GType>(inputs, *scope);
input_h0_ = InputH0From<GType>(inputs, *scope);
input_bias_ = InputBiasFrom<GType>(inputs, *scope);
input_weight_ = InputWeightFrom<GType>(inputs, *scope);
output_batch_gate_ = OutputBatchGateFrom<GType>(outputs, *scope);
output_batch_reset_hidden_prev_ =
OutputBatchResetHiddenPrevFrom<GType>(outputs, scope);
output_batch_hidden_ = OutputBatchHiddenFrom<GType>(outputs, scope);
output_hidden_ = OutputHiddenFrom<GType>(outputs, scope);
OutputBatchResetHiddenPrevFrom<GType>(outputs, *scope);
output_batch_hidden_ = OutputBatchHiddenFrom<GType>(outputs, *scope);
output_hidden_ = OutputHiddenFrom<GType>(outputs, *scope);
activation_ = GetStringAttr("activation", attrs);
gate_activation_ = GetStringAttr("gate_activation", attrs);
is_reverse_ = GetAttr<bool>("is_reverse", attrs);
......@@ -2603,16 +2666,17 @@ class GruUnitParam : public OpParam {
public:
GruUnitParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_input_ = InputFrom<GType>(inputs, scope);
input_hidden_prev_ = InputHiddenPrevFrom<GType>(inputs, scope);
input_bias_ = InputBiasFrom<GType>(inputs, scope);
input_weight_ = InputWeightFrom<GType>(inputs, scope);
output_gate_ = OutputGateFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_input_ = InputFrom<GType>(inputs, *scope);
input_hidden_prev_ = InputHiddenPrevFrom<GType>(inputs, *scope);
input_bias_ = InputBiasFrom<GType>(inputs, *scope);
input_weight_ = InputWeightFrom<GType>(inputs, *scope);
output_gate_ = OutputGateFrom<GType>(outputs, *scope);
output_reset_hidden_prev_ =
OutputResetHiddenPrevFrom<GType>(outputs, scope);
output_hidden_ = OutputHiddenFrom<GType>(outputs, scope);
OutputResetHiddenPrevFrom<GType>(outputs, *scope);
output_hidden_ = OutputHiddenFrom<GType>(outputs, *scope);
activation_ = GetAttr<int>("activation", attrs);
gate_activation_ = GetAttr<int>("gate_activation", attrs);
}
......@@ -2649,9 +2713,10 @@ class FlattenParam : public OpParam {
public:
FlattenParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
axis = GetAttr<int>("axis", attrs);
}
const RType *InputX() const { return input_x_; }
......@@ -2673,9 +2738,10 @@ class SplitParam : public OpParam {
public:
SplitParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
outs_ = OutMultiFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
outs_ = OutMultiFrom<GType>(outputs, *scope);
axis = GetAttr<int>("axis", attrs);
num = GetAttr<int>("num", attrs);
sections = GetAttr<std::vector<int>>("sections", attrs);
......@@ -2719,10 +2785,11 @@ class BilinearInterpParam : public OpParam {
public:
BilinearInterpParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_outsize_ = InputOutSizeFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_outsize_ = InputOutSizeFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
out_h_ = GetAttr<int>("out_h", attrs);
out_w_ = GetAttr<int>("out_w", attrs);
}
......@@ -2749,9 +2816,10 @@ class ShapeParam : public OpParam {
public:
ShapeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = InputFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = InputFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
}
const RType *Input() const { return input_; }
RType *Out() const { return out_; }
......@@ -2770,10 +2838,11 @@ class TopKParam : public OpParam {
public:
TopKParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = OpParam::GetVarValue<GType>("X", inputs, scope);
output_ = OpParam::GetVarValue<GType>("Out", outputs, scope);
indices_ = OpParam::GetVarValue<GType>("Indices", outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = OpParam::GetVarValue<GType>("X", inputs, *scope);
output_ = OpParam::GetVarValue<GType>("Out", outputs, *scope);
indices_ = OpParam::GetVarValue<GType>("Indices", outputs, *scope);
k_ = OpParam::GetAttr<int>("k", attrs);
}
......@@ -2793,9 +2862,10 @@ class CastParam : public OpParam {
public:
CastParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = OpParam::GetVarValue<GType>("X", inputs, scope);
output_ = OpParam::GetVarValue<GType>("Out", outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = OpParam::GetVarValue<GType>("X", inputs, *scope);
output_ = OpParam::GetVarValue<GType>("Out", outputs, *scope);
input_type_ = OpParam::GetAttr<int>("in_dtype", attrs);
output_type_ = OpParam::GetAttr<int>("out_dtype", attrs);
}
......@@ -2816,16 +2886,17 @@ class QuantizeParam : public OpParam {
public:
QuantizeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = InputXFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = InputXFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
// online
// scale = max(abs(x))
online_scale_ = OpParam::GetVarValue<GType>("OutScale", outputs, scope);
online_scale_ = OpParam::GetVarValue<GType>("OutScale", outputs, *scope);
// offline
if (inputs.count("InScale")) {
offline_ = true;
offline_scale_ = OpParam::GetVarValue<GType>("InScale", inputs, scope);
offline_scale_ = OpParam::GetVarValue<GType>("InScale", inputs, *scope);
}
// x = round(scale * x)
if (OpParam::HasAttr("round_type", attrs)) {
......@@ -2857,10 +2928,11 @@ class DequantizeParam : public OpParam {
public:
DequantizeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_ = InputXFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
activation_scale_ = OpParam::GetVarValue<GType>("Scale", inputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = InputXFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
activation_scale_ = OpParam::GetVarValue<GType>("Scale", inputs, *scope);
// dequantization is performed as x = x / static_scale / online_scale
if (OpParam::HasAttr("weight_scale", attrs)) {
weight_scale_ = OpParam::GetAttr<float>("weight_scale", attrs);
......@@ -2892,13 +2964,13 @@ class FusionDequantBNParam : public DequantizeParam<Dtype> {
public:
FusionDequantBNParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: DequantizeParam<Dtype>(inputs, outputs, attrs, scope) {
// batch norm params
bn_mean_ = OpParam::GetVarValue<GType>("BNMean", inputs, scope);
bn_variance_ = OpParam::GetVarValue<GType>("BNVariance", inputs, scope);
bn_scale_ = OpParam::GetVarValue<GType>("BNScale", inputs, scope);
bn_bias_ = OpParam::GetVarValue<GType>("BNBias", inputs, scope);
bn_mean_ = OpParam::GetVarValue<GType>("BNMean", inputs, *scope);
bn_variance_ = OpParam::GetVarValue<GType>("BNVariance", inputs, *scope);
bn_scale_ = OpParam::GetVarValue<GType>("BNScale", inputs, *scope);
bn_bias_ = OpParam::GetVarValue<GType>("BNBias", inputs, *scope);
epsilon_ = OpParam::GetAttr<float>("epsilon", attrs);
}
......@@ -2924,11 +2996,11 @@ class FusionDequantAddBNParam : public FusionDequantBNParam<Dtype> {
public:
FusionDequantAddBNParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: FusionDequantBNParam<Dtype>(inputs, outputs, attrs, scope) {
// element wise add params
axis_ = OpParam::GetAttr<int>("axis", attrs);
bias_ = OpParam::InputYFrom<GType>(inputs, scope);
bias_ = OpParam::InputYFrom<GType>(inputs, *scope);
}
public:
......@@ -2947,14 +3019,14 @@ class FusionDequantAddBNQuantParam : public FusionDequantAddBNParam<Dtype> {
public:
FusionDequantAddBNQuantParam(const VariableNameMap &inputs,
const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope)
const AttributeMap &attrs, Scope *scope)
: FusionDequantAddBNParam<Dtype>(inputs, outputs, attrs, scope) {
// scale output
online_scale_ = OpParam::GetVarValue<GType>("OutScale", outputs, scope);
online_scale_ = OpParam::GetVarValue<GType>("OutScale", outputs, *scope);
// offline
if (inputs.count("InScale")) {
offline_ = true;
offline_scale_ = OpParam::GetVarValue<GType>("InScale", inputs, scope);
offline_scale_ = OpParam::GetVarValue<GType>("InScale", inputs, *scope);
}
// x = round(scale * x)
if (OpParam::HasAttr("round_type", attrs)) {
......@@ -2983,10 +3055,11 @@ class SequenceExpandParam : public OpParam {
public:
SequenceExpandParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_y_ = InputYFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_y_ = InputYFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
ref_level_ = -1;
if (OpParam::HasAttr("ref_level", attrs)) {
ref_level_ = OpParam::GetAttr<int>("ref_level", attrs);
......@@ -3010,9 +3083,10 @@ class SequencePoolParam : public OpParam {
public:
SequencePoolParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_ = InputXFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = InputXFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
pool_type_ = "MAX";
if (OpParam::HasAttr("pooltype", attrs)) {
pool_type_ = OpParam::GetStringAttr("pooltype", attrs);
......@@ -3034,12 +3108,13 @@ class LodResetParam : public OpParam {
public:
LodResetParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
input_y_ = nullptr;
if (inputs.count("Y")) {
input_y_ = InputYFrom<GType>(inputs, scope);
input_y_ = InputYFrom<GType>(inputs, *scope);
} else {
target_lod_ = OpParam::GetAttr<vector<int>>("target_lod", attrs);
}
......@@ -3061,10 +3136,11 @@ class CompareParam : public OpParam {
public:
CompareParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_y_ = InputYFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_y_ = InputYFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
axis_ = OpParam::GetAttr<int>("axis", attrs);
}
......@@ -3085,10 +3161,11 @@ class LogicalBinaryParam : public OpParam {
public:
LogicalBinaryParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
input_y_ = InputYFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
input_y_ = InputYFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
}
const GType *InputX() const { return input_x_; }
......@@ -3111,9 +3188,10 @@ class LogicalUnaryParam : public OpParam {
public:
LogicalUnaryParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
}
const GType *InputX() const { return input_x_; }
......@@ -3131,7 +3209,7 @@ class LogicalUnaryParam : public OpParam {
// public:
// WhileParam(const VariableNameMap &inputs,
// const VariableNameMap &outputs, const AttributeMap &attrs,
// const Scope &scope) {
// const Scope &scope) : OpParam(inputs, outputs, attrs, scope) {
// cond_ = OpParam::GetVarValue<framework::LoDTensor>("Condition", inputs,
// scope); block_desc_ = OpParam::GetAttr<framework::BlockDesc
// *>("sub_block", attrs);
......@@ -3149,11 +3227,12 @@ class WriteToArrayParam : public OpParam {
public:
WriteToArrayParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
input_ = OpParam::GetVarValue<framework::LoDTensor>("X", inputs, scope);
index_ = OpParam::GetVarValue<framework::LoDTensor>("I", inputs, scope);
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ = OpParam::GetVarValue<framework::LoDTensor>("X", inputs, *scope);
index_ = OpParam::GetVarValue<framework::LoDTensor>("I", inputs, *scope);
output_ =
OpParam::GetVarValue<framework::LoDTensorArray>("Out", outputs, scope);
OpParam::GetVarValue<framework::LoDTensorArray>("Out", outputs, *scope);
}
public:
......@@ -3169,11 +3248,13 @@ class ReadFromArrayParam : public OpParam {
public:
ReadFromArrayParam(const VariableNameMap &inputs,
const VariableNameMap &outputs, const AttributeMap &attrs,
const Scope &scope) {
Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_ =
OpParam::GetVarValue<framework::LoDTensorArray>("X", inputs, scope);
index_ = OpParam::GetVarValue<framework::LoDTensor>("I", inputs, scope);
output_ = OpParam::GetVarValue<framework::LoDTensor>("Out", outputs, scope);
OpParam::GetVarValue<framework::LoDTensorArray>("X", inputs, *scope);
index_ = OpParam::GetVarValue<framework::LoDTensor>("I", inputs, *scope);
output_ =
OpParam::GetVarValue<framework::LoDTensor>("Out", outputs, *scope);
}
public:
......@@ -3191,9 +3272,10 @@ class IsEmptyParam : public OpParam {
public:
IsEmptyParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
}
const GType *InputX() const { return input_x_; }
......@@ -3213,9 +3295,10 @@ class IncrementParam : public OpParam {
public:
IncrementParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
output_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
output_ = OutFrom<GType>(outputs, *scope);
step_ = OpParam::GetAttr<int>("step", attrs);
}
......@@ -3237,9 +3320,10 @@ class Pad2dParam : public OpParam {
public:
Pad2dParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
const AttributeMap &attrs, const Scope &scope) {
input_x_ = InputXFrom<GType>(inputs, scope);
out_ = OutFrom<GType>(outputs, scope);
const AttributeMap &attrs, Scope *scope)
: OpParam(inputs, outputs, attrs, scope) {
input_x_ = InputXFrom<GType>(inputs, *scope);
out_ = OutFrom<GType>(outputs, *scope);
}
const RType *InputX() const { return input_x_; }
RType *Out() const { return out_; }
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或