op_param.h 69.9 KB
Newer Older
W
wangliu 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
/* 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. */
朔-望's avatar
朔-望 已提交
14

15
#pragma once
朔-望's avatar
朔-望 已提交
16

E
eclipsess 已提交
17
#include <string>
W
wangliu 已提交
18
#include <vector>
L
liuruilong 已提交
19
#include "common/log.h"
朔-望's avatar
朔-望 已提交
20
#include "common/type_define.h"
N
nhzlx 已提交
21
#include "common/types.h"
朔-望's avatar
朔-望 已提交
22 23 24 25
#include "framework/lod_tensor.h"
#include "framework/scope.h"
#include "framework/tensor.h"
#include "framework/variable.h"
Z
zhangyang 已提交
26
#ifdef PADDLE_MOBILE_FPGA
H
hanbuhe 已提交
27
#include "fpga/api.h"
Z
zhangyang 已提交
28
#endif
朔-望's avatar
朔-望 已提交
29 30

namespace paddle_mobile {
朔-望's avatar
朔-望 已提交
31 32
namespace operators {

W
wangliu 已提交
33 34 35 36 37 38 39
using framework::Attribute;
using framework::AttributeMap;
using framework::LoDTensor;
using framework::Scope;
using framework::Tensor;
using std::string;
using std::vector;
朔-望's avatar
朔-望 已提交
40

N
nhzlx 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
template <typename Dtype>
struct DtypeTensorTrait {
  typedef void ptype;
  typedef void rtype;
};

template <>
struct DtypeTensorTrait<CPU> {
  // This is the type we obtained in variable.
  typedef framework::LoDTensor gtype;
  // This type will be the parent class type
  // or the same type.
  typedef framework::Tensor rtype;
};

template <>
struct DtypeTensorTrait<FPGA> {
  // This is the type we obtained in variable.
  typedef framework::LoDTensor gtype;
  // This type will be the parent class type
  // or the same type.
  typedef framework::Tensor rtype;
};

template <>
struct DtypeTensorTrait<GPU_MALI> {
  // This is the type we obtained in variable.
  typedef framework::LoDTensor gtype;
  // This type will be the parent class type
  // or the same type.
  typedef framework::Tensor rtype;
};

L
liuruilong 已提交
74
class OpParam {
朔-望's avatar
朔-望 已提交
75
 protected:
xiebaiyuan's avatar
xiebaiyuan 已提交
76 77 78 79
  template <typename T>
  static T *InputH0From(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("H0", inputs, scope);
  }
80 81 82 83 84
  template <typename T>
  static T *InputAlphaFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Alpha", inputs, scope);
  }

85 86 87 88 89 90 91 92 93
  template <typename T>
  static T *InputFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Input", inputs, scope);
  }

  template <typename T>
  static T *InputXFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("X", inputs, scope);
  }
94 95 96 97 98
  template <typename T>
  static T *InputOutSizeFrom(const VariableNameMap &inputs,
                             const Scope &scope) {
    return GetVarValue<T>("OutSize", inputs, scope);
  }
xiebaiyuan's avatar
xiebaiyuan 已提交
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125

  template <typename T>
  static T *InputWFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("W", inputs, scope);
  }

  template <typename T>
  static T *InputIdsFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Ids", inputs, scope);
  }

  template <typename T>
  static T *InputEmissionFrom(const VariableNameMap &inputs,
                              const Scope &scope) {
    return GetVarValue<T>("Emission", inputs, scope);
  }

  template <typename T>
  static T *InputTransitionFrom(const VariableNameMap &inputs,
                                const Scope &scope) {
    return GetVarValue<T>("Transition", inputs, scope);
  }
  template <typename T>
  static T *InputLabelFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Label", inputs, scope);
  }

126 127 128 129
  template <typename T>
  static T *InputXFrom1(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue1<T>("addX", inputs, scope);
  }
130 131 132 133 134 135

  template <typename T>
  static T *InputYFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Y", inputs, scope);
  }

136 137 138 139 140
  template <typename T>
  static T *InputYFrom1(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue1<T>("Y", inputs, scope);
  }

E
eclipsess 已提交
141 142 143 144 145
  template <typename T>
  static T *InputZFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Z", inputs, scope);
  }

146 147 148 149 150
  template <typename T>
  static T *InputBiasFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Bias", inputs, scope);
  }
  template <typename T>
xiebaiyuan's avatar
xiebaiyuan 已提交
151 152 153 154
  static T *InputWeightFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Weight", inputs, scope);
  }
  template <typename T>
155 156 157 158 159 160 161 162 163 164 165 166
  static T *InputVarianceFrom(const VariableNameMap &inputs,
                              const Scope &scope) {
    return GetVarValue<T>("Variance", inputs, scope);
  }
  template <typename T>
  static T *InputMeanFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Mean", inputs, scope);
  }
  template <typename T>
  static T *InputScaleFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Scale", inputs, scope);
  }
E
eclipsess 已提交
167 168 169 170
  template <typename T>
  static T *InputImageFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Image", inputs, scope);
  }
E
eclipsess 已提交
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
  template <typename T>
  static T *InputPriorBoxFrom(const VariableNameMap &inputs,
                              const Scope &scope) {
    return GetVarValue<T>("PriorBox", inputs, scope);
  }
  template <typename T>
  static T *InputPriorBoxVarFrom(const VariableNameMap &inputs,
                                 const Scope &scope) {
    return GetVarValue<T>("PriorBoxVar", inputs, scope);
  }
  // LoDTensor but now use Tensor
  template <typename T>
  static T *InputTargetBoxFrom(const VariableNameMap &inputs,
                               const Scope &scope) {
    return GetVarValue<T>("TargetBox", inputs, scope);
  }
187

E
eclipsess 已提交
188 189 190 191 192 193 194 195 196 197
  template <typename T>
  static T *InputBBoxesFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("BBoxes", inputs, scope);
  }

  template <typename T>
  static T *InputScoresFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Scores", inputs, scope);
  }

E
eclipsess 已提交
198 199 200 201
  template <typename T>
  static T *InputShapeFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Shape", inputs, scope);
  }
E
eclipsess 已提交
202

203
  template <typename T>
W
wangliu 已提交
204 205
  static vector<T *> InputMultiFrom(const VariableNameMap &inputs,
                                    const Scope &scope) {
206 207 208
    return GetMultiVarValue<T>("X", inputs, scope);
  }

xiebaiyuan's avatar
xiebaiyuan 已提交
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
  template <typename T>
  static T *OutputBatchGateFrom(const VariableNameMap &outputs,
                                const Scope &scope) {
    return GetVarValue<T>("BatchGate", outputs, scope);
  }

  template <typename T>
  static T *OutputViterbiPathFrom(const VariableNameMap &outputs,
                                  const Scope &scope) {
    return GetVarValue<T>("ViterbiPath", outputs, scope);
  }
  template <typename T>
  static T *OutputBatchResetHiddenPrevFrom(const VariableNameMap &outputs,
                                           const Scope &scope) {
    return GetVarValue<T>("BatchResetHiddenPrev", outputs, scope);
  }

  template <typename T>
  static T *OutputBatchHiddenFrom(const VariableNameMap &outputs,
                                  const Scope &scope) {
    return GetVarValue<T>("BatchHidden", outputs, scope);
  }

  template <typename T>
  static T *OutputHiddenFrom(const VariableNameMap &outputs,
                             const Scope &scope) {
    return GetVarValue<T>("Hidden", outputs, scope);
  }

238 239 240 241 242 243 244 245 246 247
  template <typename T>
  static T *OutputFrom(const VariableNameMap &outputs, const Scope &scope) {
    return GetVarValue<T>("Output", outputs, scope);
  }

  template <typename T>
  static T *OutFrom(const VariableNameMap &outputs, const Scope &scope) {
    return GetVarValue<T>("Out", outputs, scope);
  }

xiebaiyuan's avatar
xiebaiyuan 已提交
248 249 250 251 252 253
  template <typename T>
  static vector<T *> OutMultiFrom(const VariableNameMap &outputs,
                                  const Scope &scope) {
    return GetMultiVarValue<T>("Out", outputs, scope);
  }

254 255 256 257 258
  template <typename T>
  static T *OutputYFrom(const VariableNameMap &outputs, const Scope &scope) {
    return GetVarValue<T>("Y", outputs, scope);
  }

E
eclipsess 已提交
259 260 261 262 263 264
  template <typename T>
  static T *OutputBoxesFrom(const VariableNameMap &outputs,
                            const Scope &scope) {
    return GetVarValue<T>("Boxes", outputs, scope);
  }

E
eclipsess 已提交
265 266 267 268 269
  template <typename T>
  static T *OutputBoxFrom(const VariableNameMap &outputs, const Scope &scope) {
    return GetVarValue<T>("OutputBox", outputs, scope);
  }

E
eclipsess 已提交
270 271 272 273 274 275
  template <typename T>
  static T *OutputVariancesFrom(const VariableNameMap &outputs,
                                const Scope &scope) {
    return GetVarValue<T>("Variances", outputs, scope);
  }

276 277 278 279 280 281 282 283 284 285 286
  template <typename T>
  static T *MidOutFrom(const VariableNameMap &outputs, const Scope &scope) {
    return GetVarValue<T>("MidOut", outputs, scope);
  }

  template <typename T>
  static T *FilterFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Filter", inputs, scope);
  }

  template <typename T>
W
wangliu 已提交
287
  static const T GetAttr(const string &key, const AttributeMap &map) {
288 289 290
    return ((Attribute)map.at(key)).Get<T>();
  }

291 292 293 294
  static const bool HasAttr(const string &key, const AttributeMap &map) {
    return map.count(key) > 0;
  }

295
  template <typename T>
W
wangliu 已提交
296
  static T *GetVarValue(const string &key, const VariableNameMap &var_map,
297
                        const Scope &scope) {
W
wangliu 已提交
298 299
    PADDLE_MOBILE_ENFORCE(var_map.count(key) > 0,
                          "%s is not contained in var_map", key.c_str())
300 301 302 303 304 305
    auto var_vec = var_map.at(key);
    if (!var_vec.empty()) {
      auto var = scope.FindVar(var_vec[0]);
      return var->GetMutable<T>();
    } else {
      return nullptr;
朔-望's avatar
朔-望 已提交
306
    }
307
  }
朔-望's avatar
朔-望 已提交
308

309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
  static std::string getkey(const string &key, const VariableNameMap &var_map,
                            int index) {
    auto var_vec = var_map.at(key);
    return var_vec[index];
  }

  template <typename T>
  static T *GetVarValue1(const string &key, const VariableNameMap &var_map,
                         const Scope &scope) {
    PADDLE_MOBILE_ENFORCE(var_map.count(key) > 0,
                          "%s is not contained in var_map", key.c_str())
    auto var_vec = var_map.at(key);
    if (!var_vec.empty()) {
      auto var = scope.FindVar(var_vec[1]);
      return var->GetMutable<T>();
    } else {
      return nullptr;
    }
  }

329
  template <typename T>
W
wangliu 已提交
330 331 332
  static vector<T *> GetMultiVarValue(const string &key,
                                      const VariableNameMap &var_map,
                                      const Scope &scope) {
333 334
    auto var_vecs = var_map.at(key);
    assert(var_vecs.size() > 1);
W
wangliu 已提交
335
    vector<T *> var_res;
336 337 338
    for (auto &var_vec : var_vecs) {
      auto var = scope.FindVar(var_vec);
      var_res.push_back(var->GetMutable<T>());
朔-望's avatar
朔-望 已提交
339
    }
340 341
    return var_res;
  }
朔-望's avatar
朔-望 已提交
342 343
};

L
liuruilong 已提交
344
#ifdef CONV_OP
N
nhzlx 已提交
345
template <typename Dtype>
朔-望's avatar
朔-望 已提交
346
class ConvParam : OpParam {
N
nhzlx 已提交
347 348 349
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

朔-望's avatar
朔-望 已提交
350
 public:
351
  ConvParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
352
            const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
353 354 355
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_ = OutputFrom<GType>(outputs, scope);
W
wangliu 已提交
356 357 358
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
359 360
    groups = GetAttr<int>("groups", attrs);
  }
朔-望's avatar
朔-望 已提交
361

N
nhzlx 已提交
362
  const RType *Input() const { return input_; }
朔-望's avatar
朔-望 已提交
363

N
nhzlx 已提交
364
  RType *Filter() const { return filter_; }
朔-望's avatar
朔-望 已提交
365

N
nhzlx 已提交
366
  RType *Output() const { return output_; }
朔-望's avatar
朔-望 已提交
367

W
wangliu 已提交
368
  const vector<int> &Strides() const { return strides_; }
朔-望's avatar
朔-望 已提交
369

W
wangliu 已提交
370
  const vector<int> &Paddings() const { return paddings_; }
朔-望's avatar
朔-望 已提交
371

W
wangliu 已提交
372
  const vector<int> &Dilations() const { return dilations_; }
朔-望's avatar
朔-望 已提交
373

374
  const int &Groups() const { return groups; }
朔-望's avatar
朔-望 已提交
375

朔-望's avatar
朔-望 已提交
376
 private:
N
nhzlx 已提交
377 378 379
  RType *input_;
  RType *output_;
  RType *filter_;
W
wangliu 已提交
380 381 382
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
383
  int groups;
朔-望's avatar
朔-望 已提交
384
};
N
nhzlx 已提交
385 386
template <typename Dtype>
Print &operator<<(Print &printer, const ConvParam<Dtype> &conv_param);
L
liuruilong 已提交
387
#endif
朔-望's avatar
朔-望 已提交
388

N
nhzlx 已提交
389
template <typename Dtype>
朔-望's avatar
朔-望 已提交
390
class ElementwiseAddParam : OpParam {
N
nhzlx 已提交
391 392 393
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

朔-望's avatar
朔-望 已提交
394
 public:
395
  ElementwiseAddParam(const VariableNameMap &inputs,
396 397
                      const VariableNameMap &outputs, const AttributeMap &attrs,
                      const Scope &scope) {
N
nhzlx 已提交
398 399 400
    input_x_ = InputXFrom<GType>(inputs, scope);
    input_y_ = InputYFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
401 402 403
    axis_ = GetAttr<int>("axis", attrs);
  }

xiebaiyuan's avatar
xiebaiyuan 已提交
404
  const GType *InputX() const { return input_x_; }
405

xiebaiyuan's avatar
xiebaiyuan 已提交
406
  const GType *InputY() const { return input_y_; }
407

xiebaiyuan's avatar
xiebaiyuan 已提交
408
  GType *Out() const { return out_; }
409 410 411

  const int &Axis() const { return axis_; }

朔-望's avatar
朔-望 已提交
412
 private:
xiebaiyuan's avatar
xiebaiyuan 已提交
413 414 415
  GType *input_x_;
  GType *input_y_;
  GType *out_;
416
  int axis_;
Z
zhangyang 已提交
417 418 419
#ifdef PADDLE_MOBILE_FPGA

 private:
H
hanbuhe 已提交
420
  fpga::EWAddArgs fpga_EW_add_args;
Z
zhangyang 已提交
421 422

 public:
H
hanbuhe 已提交
423 424
  const fpga::EWAddArgs &FpgaArgs() const { return fpga_EW_add_args; }
  void SetFpgaArgs(const fpga::EWAddArgs &args) { fpga_EW_add_args = args; }
Z
zhangyang 已提交
425
#endif
朔-望's avatar
朔-望 已提交
426 427
};

428
#ifdef FUSION_ELEMENTWISEADDRELU_OP
N
nhzlx 已提交
429 430
template <typename Dtype>
using ElementwiseAddReluParam = ElementwiseAddParam<Dtype>;
L
liuruilong 已提交
431 432 433
#endif

#ifdef MUL_OP
N
nhzlx 已提交
434
template <typename Dtype>
朔-望's avatar
朔-望 已提交
435
class MulParam : OpParam {
N
nhzlx 已提交
436 437 438
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

朔-望's avatar
朔-望 已提交
439
 public:
440
  MulParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
441
           const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
442 443 444
    input_x_ = InputXFrom<GType>(inputs, scope);
    input_y_ = InputYFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
445 446 447
    x_num_col_dims_ = GetAttr<int>("x_num_col_dims", attrs);
    y_num_col_dims_ = GetAttr<int>("y_num_col_dims", attrs);
  }
朔-望's avatar
朔-望 已提交
448

xiebaiyuan's avatar
xiebaiyuan 已提交
449
  const GType *InputX() const { return input_x_; }
朔-望's avatar
朔-望 已提交
450

xiebaiyuan's avatar
xiebaiyuan 已提交
451
  const GType *InputY() const { return input_y_; }
朔-望's avatar
朔-望 已提交
452

xiebaiyuan's avatar
xiebaiyuan 已提交
453
  GType *Out() const { return out_; }
朔-望's avatar
朔-望 已提交
454

455
  const int &XNumColDims() const { return x_num_col_dims_; }
朔-望's avatar
朔-望 已提交
456

457
  const int &YNumColDims() const { return y_num_col_dims_; }
朔-望's avatar
朔-望 已提交
458

朔-望's avatar
朔-望 已提交
459
 private:
xiebaiyuan's avatar
xiebaiyuan 已提交
460 461 462
  GType *input_x_;
  GType *input_y_;
  GType *out_;
463 464
  int x_num_col_dims_;
  int y_num_col_dims_;
朔-望's avatar
朔-望 已提交
465
};
L
liuruilong 已提交
466
#endif
朔-望's avatar
朔-望 已提交
467

L
liuruilong 已提交
468
#ifdef CONCAT_OP
N
nhzlx 已提交
469
template <typename Dtype>
朔-望's avatar
朔-望 已提交
470
class ConcatParam : public OpParam {
N
nhzlx 已提交
471 472 473
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

朔-望's avatar
朔-望 已提交
474
 public:
475
  ConcatParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
476
              const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
477 478
    inputs_ = InputMultiFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
479 480
    axis_ = GetAttr<int>("axis", attrs);
  }
朔-望's avatar
朔-望 已提交
481

N
nhzlx 已提交
482
  vector<GType *> Inputs() const { return inputs_; }
朔-望's avatar
朔-望 已提交
483

xiebaiyuan's avatar
xiebaiyuan 已提交
484
  GType *Out() const { return out_; }
朔-望's avatar
朔-望 已提交
485

486
  const int &Axis() const { return axis_; }
朔-望's avatar
朔-望 已提交
487

朔-望's avatar
朔-望 已提交
488
 private:
N
nhzlx 已提交
489
  vector<GType *> inputs_;
xiebaiyuan's avatar
xiebaiyuan 已提交
490
  GType *out_;
491
  int axis_;
Z
zhangyang 已提交
492 493 494 495 496 497 498 499 500
#ifdef PADDLE_MOBILE_FPGA

 private:
  fpga::ConcatArgs fpga_concat_args;

 public:
  const fpga::ConcatArgs &FpgaArgs() const { return fpga_concat_args; }
  void SetFpgaArgs(const fpga::ConcatArgs &args) { fpga_concat_args = args; }
#endif
朔-望's avatar
朔-望 已提交
501
};
L
liuruilong 已提交
502
#endif
朔-望's avatar
朔-望 已提交
503

L
liuruilong 已提交
504
#ifdef LRN_OP
N
nhzlx 已提交
505
template <typename Dtype>
E
eclipsess 已提交
506
class LrnParam : public OpParam {
N
nhzlx 已提交
507 508 509
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

朔-望's avatar
朔-望 已提交
510
 public:
511
  LrnParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
512
           const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
513 514 515
    input_x_ = InputXFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
    mid_out_ = MidOutFrom<GType>(outputs, scope);
516 517 518 519
    n_ = GetAttr<int>("n", attrs);
    alpha_ = GetAttr<float>("alpha", attrs);
    beta_ = GetAttr<float>("beta", attrs);
    k_ = GetAttr<float>("k", attrs);
W
wangliu 已提交
520
    data_format_ = GetAttr<string>("data_format", attrs);
521
  }
E
eclipsess 已提交
522

N
nhzlx 已提交
523
  const RType *InputX() const { return input_x_; }
E
eclipsess 已提交
524

N
nhzlx 已提交
525
  RType *Out() const { return out_; }
E
eclipsess 已提交
526

N
nhzlx 已提交
527
  RType *MidOut() const { return mid_out_; }
E
eclipsess 已提交
528

529
  const int &N() const { return n_; }
E
eclipsess 已提交
530

531
  const float &Alpha() const { return alpha_; }
E
eclipsess 已提交
532

533
  const float &Beta() const { return beta_; }
E
eclipsess 已提交
534

535
  const float &K() const { return k_; }
E
eclipsess 已提交
536

W
wangliu 已提交
537
  const string &DataFormat() const { return data_format_; }
E
eclipsess 已提交
538

朔-望's avatar
朔-望 已提交
539
 private:
N
nhzlx 已提交
540 541 542
  RType *input_x_;
  RType *out_;
  RType *mid_out_;
543 544 545 546
  int n_;
  float alpha_;
  float beta_;
  float k_;
W
wangliu 已提交
547
  string data_format_;
E
eclipsess 已提交
548
};
L
liuruilong 已提交
549 550 551
#endif

#ifdef BATCHNORM_OP
N
nhzlx 已提交
552
template <typename Dtype>
E
eclipsess 已提交
553
class BatchNormParam : OpParam {
N
nhzlx 已提交
554 555 556
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

朔-望's avatar
朔-望 已提交
557
 public:
558
  BatchNormParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
559
                 const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
560 561 562 563 564 565
    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);
566 567
    epsilon_ = GetAttr<float>("epsilon", attrs);
    momentum_ = GetAttr<float>("momentum", attrs);
L
liuruilong 已提交
568
    //    is_test_ = GetAttr<bool>("is_test", attrs);
569
  }
E
eclipsess 已提交
570

N
nhzlx 已提交
571
  const RType *InputX() const { return input_x_; }
E
eclipsess 已提交
572

N
nhzlx 已提交
573
  RType *OutputY() const { return output_y_; }
E
eclipsess 已提交
574

N
nhzlx 已提交
575
  const RType *InputBias() const { return input_bias_; }
E
eclipsess 已提交
576

N
nhzlx 已提交
577
  const RType *InputMean() const { return input_mean_; }
E
eclipsess 已提交
578

N
nhzlx 已提交
579
  const RType *InputScale() const { return input_scale_; }
E
eclipsess 已提交
580

N
nhzlx 已提交
581
  const RType *InputVariance() const { return input_variance_; }
E
eclipsess 已提交
582

583
  const float &Epsilon() const { return epsilon_; }
E
eclipsess 已提交
584

585
  const float &Momentum() const { return momentum_; }
E
eclipsess 已提交
586

587
  const bool &IsTest() const { return is_test_; }
E
eclipsess 已提交
588

W
wangliu 已提交
589
  const string &DataFormat() const { return data_format_; }
E
eclipsess 已提交
590

朔-望's avatar
朔-望 已提交
591
 private:
N
nhzlx 已提交
592 593 594 595 596 597
  RType *input_x_;
  RType *output_y_;
  RType *input_bias_;
  RType *input_mean_;
  RType *input_scale_;
  RType *input_variance_;
598 599 600
  float epsilon_;
  float momentum_;
  bool is_test_;
W
wangliu 已提交
601
  string data_format_;
E
eclipsess 已提交
602
};
L
liuruilong 已提交
603 604 605
#endif

#ifdef POOL_OP
N
nhzlx 已提交
606
template <typename Dtype>
607
class PoolParam : public OpParam {
N
nhzlx 已提交
608 609 610
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

朔-望's avatar
朔-望 已提交
611
 public:
612
  PoolParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
613
            const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
614
    input_ = InputXFrom<GType>(inputs, scope);
615

N
nhzlx 已提交
616
    output_ = OutFrom<GType>(outputs, scope);
W
wangliu 已提交
617 618 619 620
    pooling_type_ = GetAttr<string>("pooling_type", attrs);
    ksize_ = GetAttr<vector<int>>("ksize", attrs);
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
621
    ceil_mode_ = GetAttr<bool>("ceil_mode", attrs);
622
    global_pooling_ = GetAttr<bool>("global_pooling", attrs);
623
  }
624

N
nhzlx 已提交
625
  const RType *Input() const { return input_; }
626

N
nhzlx 已提交
627
  RType *Output() const { return output_; }
628

W
wangliu 已提交
629
  const string &PoolingType() const { return pooling_type_; }
630

W
wangliu 已提交
631
  const vector<int> &Ksize() const { return ksize_; }
632

W
wangliu 已提交
633
  const vector<int> &Strides() const { return strides_; }
634

W
wangliu 已提交
635
  const vector<int> &Paddings() const { return paddings_; }
636

637
  bool isCeilMode() const { return ceil_mode_; }
638

Z
zhangyang 已提交
639
  bool isGlobalPooling() const { return global_pooling_; }
640

朔-望's avatar
朔-望 已提交
641
 private:
N
nhzlx 已提交
642 643
  RType *input_;
  RType *output_;
W
wangliu 已提交
644 645 646 647
  string pooling_type_;
  vector<int> ksize_;
  vector<int> strides_;
  vector<int> paddings_;
648
  bool ceil_mode_;
649
  bool global_pooling_ = false;
Z
zhangyang 已提交
650
#ifdef PADDLE_MOBILE_FPGA
651 652

 private:
H
hanbuhe 已提交
653
  fpga::PoolingArgs fpga_pool_args;
Z
zhangyang 已提交
654 655

 public:
H
hanbuhe 已提交
656 657
  const fpga::PoolingArgs &FpgaArgs() const { return fpga_pool_args; }
  void SetFpgaArgs(const fpga::PoolingArgs &args) { fpga_pool_args = args; }
Z
zhangyang 已提交
658
#endif
659
};
L
liuruilong 已提交
660 661 662
#endif

#ifdef PRIORBOX_OP
N
nhzlx 已提交
663
template <typename Dtype>
E
eclipsess 已提交
664
class PriorBoxParam : public OpParam {
N
nhzlx 已提交
665 666 667
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

E
eclipsess 已提交
668 669
 public:
  PriorBoxParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
670
                const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
671 672 673 674
    input_ = InputFrom<GType>(inputs, scope);
    input_image_ = InputImageFrom<GType>(inputs, scope);
    output_boxes_ = OutputBoxesFrom<GType>(outputs, scope);
    output_variances_ = OutputVariancesFrom<GType>(outputs, scope);
W
wangliu 已提交
675 676 677 678
    min_sizes_ = GetAttr<vector<float>>("min_sizes", attrs);
    max_sizes_ = GetAttr<vector<float>>("max_sizes", attrs);
    aspect_ratios_ = GetAttr<vector<float>>("aspect_ratios", attrs);
    variances_ = GetAttr<vector<float>>("variances", attrs);
E
eclipsess 已提交
679 680 681 682 683 684
    flip_ = GetAttr<bool>("flip", attrs);
    clip_ = GetAttr<bool>("clip", attrs);
    step_w_ = GetAttr<float>("step_w", attrs);
    step_h_ = GetAttr<float>("step_h", attrs);
    offset_ = GetAttr<float>("offset", attrs);
  }
N
nhzlx 已提交
685
  const RType *Input() const { return input_; }
E
eclipsess 已提交
686

N
nhzlx 已提交
687
  const RType *InputImage() const { return input_image_; }
E
eclipsess 已提交
688

N
nhzlx 已提交
689
  RType *OutputBoxes() const { return output_boxes_; }
E
eclipsess 已提交
690

N
nhzlx 已提交
691
  RType *OutputVariances() const { return output_variances_; }
E
eclipsess 已提交
692

W
wangliu 已提交
693
  const vector<float> &MinSizes() const { return min_sizes_; }
E
eclipsess 已提交
694

W
wangliu 已提交
695
  const vector<float> &MaxSizes() const { return max_sizes_; }
E
eclipsess 已提交
696

W
wangliu 已提交
697
  const vector<float> &AspectRatios() const { return aspect_ratios_; }
E
eclipsess 已提交
698

W
wangliu 已提交
699
  const vector<float> &Variances() const { return variances_; }
E
eclipsess 已提交
700 701 702 703 704 705 706 707 708 709 710 711

  const bool &Flip() const { return flip_; }

  const bool &Clip() const { return clip_; }

  const float &StepW() const { return step_w_; }

  const float &StepH() const { return step_h_; }

  const float &Offset() const { return offset_; }

 private:
N
nhzlx 已提交
712 713 714 715
  RType *input_;
  RType *input_image_;
  RType *output_boxes_;
  RType *output_variances_;
W
wangliu 已提交
716 717 718 719
  vector<float> min_sizes_;
  vector<float> max_sizes_;
  vector<float> aspect_ratios_;
  vector<float> variances_;
E
eclipsess 已提交
720 721 722 723 724 725
  bool flip_;
  bool clip_;
  float step_w_;
  float step_h_;
  float offset_;
};
L
liuruilong 已提交
726
#endif
E
eclipsess 已提交
727

L
liuruilong 已提交
728
#ifdef BOXCODER_OP
N
nhzlx 已提交
729
template <typename Dtype>
E
eclipsess 已提交
730
class BoxCoderParam : public OpParam {
N
nhzlx 已提交
731 732 733
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

E
eclipsess 已提交
734 735
 public:
  BoxCoderParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
736
                const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
737 738 739 740
    input_priorbox_ = InputPriorBoxFrom<GType>(inputs, scope);
    input_priorboxvar_ = InputPriorBoxVarFrom<GType>(inputs, scope);
    input_targetbox_ = InputTargetBoxFrom<GType>(inputs, scope);
    output_box_ = OutputBoxFrom<GType>(outputs, scope);
E
eclipsess 已提交
741 742
    code_type_ = GetAttr<std::string>("code_type", attrs);
  }
N
nhzlx 已提交
743
  const RType *InputPriorBox() const { return input_priorbox_; }
E
eclipsess 已提交
744

N
nhzlx 已提交
745
  const RType *InputPriorBoxVar() const { return input_priorboxvar_; }
E
eclipsess 已提交
746

N
nhzlx 已提交
747
  const RType *InputTargetBox() const { return input_targetbox_; }
E
eclipsess 已提交
748

N
nhzlx 已提交
749
  RType *OutputBox() const { return output_box_; }
E
eclipsess 已提交
750 751 752 753

  const std::string &CodeType() const { return code_type_; }

 private:
N
nhzlx 已提交
754 755 756 757
  RType *input_priorbox_;
  RType *input_priorboxvar_;
  RType *input_targetbox_;
  RType *output_box_;
E
eclipsess 已提交
758 759
  std::string code_type_;
};
L
liuruilong 已提交
760
#endif
W
wangliu 已提交
761

L
liuruilong 已提交
762
#ifdef SOFTMAX_OP
N
nhzlx 已提交
763
template <typename Dtype>
W
wangliu 已提交
764
class SoftmaxParam : public OpParam {
N
nhzlx 已提交
765 766 767
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

W
wangliu 已提交
768 769
 public:
  SoftmaxParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
770
               const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
771 772
    input_x_ = InputXFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
W
wangliu 已提交
773
  }
N
nhzlx 已提交
774 775
  const RType *InputX() const { return input_x_; }
  RType *Out() const { return out_; }
W
wangliu 已提交
776 777

 private:
N
nhzlx 已提交
778 779
  RType *input_x_;
  RType *out_;
H
hanbuhe 已提交
780 781 782 783

#ifdef PADDLE_MOBILE_FPGA

 private:
N
nhzlx 已提交
784
  std::shared_ptr<RType> float_input_x_;
H
hanbuhe 已提交
785 786 787
  fpga::BypassArgs fpga_bypass_args;

 public:
N
nhzlx 已提交
788
  RType *FloatInput() {
H
hanbuhe 已提交
789 790 791 792 793 794
    return float_input_x_ == nullptr ? input_x_ : float_input_x_.get();
  }
  void SetFloatInput(Tensor *input) { float_input_x_.reset(input); }
  const fpga::BypassArgs &FpgaArgs() const { return fpga_bypass_args; }
  void SetFpgaArgs(const fpga::BypassArgs &args) { fpga_bypass_args = args; }
#endif
W
wangliu 已提交
795
};
L
liuruilong 已提交
796
#endif
W
wangliu 已提交
797

L
liuruilong 已提交
798
#ifdef SIGMOID_OP
N
nhzlx 已提交
799
template <typename Dtype>
W
wangliu 已提交
800
class SigmoidParam : public OpParam {
N
nhzlx 已提交
801 802 803
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

W
wangliu 已提交
804 805
 public:
  SigmoidParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
806
               const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
807 808
    input_x_ = InputXFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
W
wangliu 已提交
809
  }
N
nhzlx 已提交
810 811
  const RType *InputX() const { return input_x_; }
  RType *Out() const { return out_; }
W
wangliu 已提交
812 813

 private:
N
nhzlx 已提交
814 815
  RType *input_x_;
  RType *out_;
W
wangliu 已提交
816
};
L
liuruilong 已提交
817 818 819
#endif

#ifdef MULTICLASSNMS_OP
N
nhzlx 已提交
820
template <typename Dtype>
E
eclipsess 已提交
821
class MultiClassNMSParam : public OpParam {
N
nhzlx 已提交
822 823 824
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

E
eclipsess 已提交
825 826 827 828
 public:
  MultiClassNMSParam(const VariableNameMap &inputs,
                     const VariableNameMap &outputs, const AttributeMap &attrs,
                     const Scope &scope) {
N
nhzlx 已提交
829 830 831
    input_bboxes_ = InputBBoxesFrom<GType>(inputs, scope);
    input_scores_ = InputScoresFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
E
eclipsess 已提交
832 833 834 835 836 837 838 839
    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);
    nms_threshold_ = GetAttr<float>("nms_threshold", attrs);
    nms_eta_ = GetAttr<float>("nms_eta", attrs);
    score_threshold_ = GetAttr<float>("score_threshold", attrs);
  }

N
nhzlx 已提交
840
  const RType *InputBBoxes() const { return input_bboxes_; }
E
eclipsess 已提交
841

N
nhzlx 已提交
842
  const RType *InputScores() const { return input_scores_; }
E
eclipsess 已提交
843

N
nhzlx 已提交
844
  RType *Out() const { return out_; }
E
eclipsess 已提交
845 846 847 848 849 850 851 852 853 854 855 856 857 858

  const int &BackGroundLabel() const { return background_label_; }

  const int &NMSTopK() const { return nms_top_k_; }

  const int &KeepTopK() const { return keep_top_k_; }

  const float &NMSThreshold() const { return nms_threshold_; }

  const float &NMSEta() const { return nms_eta_; }

  const float &ScoreThreshold() const { return score_threshold_; }

 private:
N
nhzlx 已提交
859 860 861
  RType *input_bboxes_;
  RType *input_scores_;
  RType *out_;
E
eclipsess 已提交
862 863 864 865 866 867 868
  int background_label_;
  int nms_top_k_;
  int keep_top_k_;
  float nms_threshold_;
  float nms_eta_;
  float score_threshold_;
};
L
liuruilong 已提交
869
#endif
W
wangliu 已提交
870

N
nhzlx 已提交
871
template <typename Dtype>
L
liuruilong 已提交
872
class FeedParam : public OpParam {
N
nhzlx 已提交
873 874 875
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

L
liuruilong 已提交
876 877
 public:
  FeedParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
L
liuruilong 已提交
878
            const AttributeMap &attrs, Scope *scope) {
N
nhzlx 已提交
879 880
    input_x_ = InputXFrom<GType>(inputs, *scope);
    out_ = OutFrom<GType>(outputs, *scope);
L
liuruilong 已提交
881
    auto var = scope->Var("batch_size");
W
wangliu 已提交
882
    batch_size = var->GetValue<int>();
L
liuruilong 已提交
883
  }
xiebaiyuan's avatar
xiebaiyuan 已提交
884 885
  const GType *InputX() const { return input_x_; }
  GType *Out() const { return out_; }
W
wangliu 已提交
886
  const int BatchSize() const { return batch_size; }
L
liuruilong 已提交
887

L
liuruilong 已提交
888
 private:
xiebaiyuan's avatar
xiebaiyuan 已提交
889 890
  GType *input_x_;
  GType *out_;
W
wangliu 已提交
891
  int batch_size;
L
liuruilong 已提交
892 893
};

N
nhzlx 已提交
894
template <typename Dtype>
L
liuruilong 已提交
895
class FetchParam : public OpParam {
N
nhzlx 已提交
896 897 898
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

L
liuruilong 已提交
899 900
 public:
  FetchParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
901
             const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
902 903
    input_x_ = InputXFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
L
liuruilong 已提交
904
  }
N
nhzlx 已提交
905 906
  const RType *InputX() const { return input_x_; }
  RType *Out() const { return out_; }
L
liuruilong 已提交
907

L
liuruilong 已提交
908
 private:
N
nhzlx 已提交
909 910
  RType *input_x_;
  RType *out_;
L
liuruilong 已提交
911 912
};

L
liuruilong 已提交
913
#ifdef TRANSPOSE_OP
N
nhzlx 已提交
914
template <typename Dtype>
E
eclipsess 已提交
915
class TransposeParam : public OpParam {
N
nhzlx 已提交
916 917 918
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

E
eclipsess 已提交
919 920 921
 public:
  TransposeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
                 const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
922 923
    input_x_ = InputXFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
E
eclipsess 已提交
924 925 926
    axis_ = GetAttr<vector<int>>("axis", attrs);
  }

N
nhzlx 已提交
927
  const RType *InputX() const { return input_x_; }
E
eclipsess 已提交
928

N
nhzlx 已提交
929
  RType *Out() const { return out_; }
E
eclipsess 已提交
930 931 932 933

  const vector<int> &Axis() const { return axis_; }

 private:
N
nhzlx 已提交
934 935
  RType *input_x_;
  RType *out_;
E
eclipsess 已提交
936 937
  vector<int> axis_;
};
L
liuruilong 已提交
938
#endif
E
eclipsess 已提交
939

xiebaiyuan's avatar
xiebaiyuan 已提交
940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
#ifdef LOOKUP_OP
template <typename Dtype>
class LookupParam : public OpParam {
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

 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);
    padding_idx_ = GetAttr<int64_t>("padding_idx", attrs);
  }

  const GType *InputW() const { return input_w_; }
  const GType *InputIds() const { return input_ids_; }
  GType *Out() const { return out_; }
  int64_t PaddingIdx() const { return padding_idx_; }

 private:
  GType *input_w_;
  GType *input_ids_;
  GType *out_;
  int64_t padding_idx_;
};
#endif

#ifdef CRF_OP
template <typename Dtype>
class CrfParam : public OpParam {
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

 public:
  //    {G_OP_TYPE_CRF, {{"Emission", "Transition", "Label"}, {"ViterbiPath"}}},

  CrfParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
           const AttributeMap &attrs, const Scope &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);
    //    padding_idx_ = GetAttr<int64_t>("padding_idx", attrs);
  }
  const GType *InputEmission() const { return input_emission_; }
  const GType *InputTransition() const { return input_transition_; }
  const GType *InputLabel() const { return input_label_; }
  GType *outputVBP() const { return output_viterbipath_; }
  //  const RType *InputIds() const { return input_ids_; }
  //  RType *Out() const { return out_; }
  //  int64_t PaddingIdx() const { return padding_idx_; }

 private:
  GType *input_emission_;
  GType *input_transition_;
  GType *input_label_;
  GType *output_viterbipath_;

  //  RType *input_ids_;
  //  RType *out_;
  //  int64_t padding_idx_;
};
#endif

L
liuruilong 已提交
1006
#ifdef RESHAPE_OP
N
nhzlx 已提交
1007
template <typename Dtype>
E
eclipsess 已提交
1008
class ReshapeParam : public OpParam {
N
nhzlx 已提交
1009 1010 1011
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

E
eclipsess 已提交
1012 1013 1014
 public:
  ReshapeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
               const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
1015 1016 1017
    input_x_ = InputXFrom<GType>(inputs, scope);
    input_shape_ = InputShapeFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
E
eclipsess 已提交
1018
    shape_ = GetAttr<vector<int>>("shape", attrs);
1019 1020 1021 1022 1023 1024 1025

    if (HasAttr("inplace", attrs)) {
      inplace_ = GetAttr<bool>("inplace", attrs);
    } else {
      inplace_ = false;
      DLOG << "ReshapeParam lost inplace params. maybe fluid updated";
    }
E
eclipsess 已提交
1026 1027
  }

N
nhzlx 已提交
1028
  const RType *InputX() const { return input_x_; }
E
eclipsess 已提交
1029

N
nhzlx 已提交
1030
  const RType *InputShape() const { return input_shape_; }
E
eclipsess 已提交
1031

N
nhzlx 已提交
1032
  RType *Out() const { return out_; }
E
eclipsess 已提交
1033 1034 1035 1036 1037 1038

  const vector<int> &Shape() const { return shape_; }

  const bool &Inplace() const { return inplace_; }

 private:
N
nhzlx 已提交
1039 1040 1041
  RType *input_x_;
  RType *input_shape_;
  RType *out_;
E
eclipsess 已提交
1042 1043 1044
  vector<int> shape_;
  bool inplace_;
};
L
liuruilong 已提交
1045
#endif
E
eclipsess 已提交
1046

T
Tian 已提交
1047
#ifdef SCALE_OP
N
nhzlx 已提交
1048
template <typename Dtype>
I
itminner 已提交
1049
class ScaleParam : public OpParam {
N
nhzlx 已提交
1050 1051 1052
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

I
itminner 已提交
1053 1054 1055
 public:
  ScaleParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
             const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
1056 1057 1058
    input_x_ = InputXFrom<GType>(inputs, scope);
    input_bias_ = InputBiasFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
I
itminner 已提交
1059 1060 1061 1062 1063 1064
    inplace_ = GetAttr<bool>("inplace", attrs);
    has_bias_ = GetAttr<bool>("has_bias", attrs);
    scales_ = GetAttr<vector<float>>("scales", attrs);
    biases_ = GetAttr<vector<float>>("biases", attrs);
  }

N
nhzlx 已提交
1065
  const RType *InputX() const { return input_x_; }
I
itminner 已提交
1066

N
nhzlx 已提交
1067
  const RType *InputBias() const { return input_bias_; }
I
itminner 已提交
1068

N
nhzlx 已提交
1069
  RType *Out() const { return out_; }
I
itminner 已提交
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079

  const bool &Inplace() const { return inplace_; }

  const bool &HasBias() const { return has_bias_; }

  const vector<float> &Scales() const { return scales_; }

  const vector<float> &Biases() const { return biases_; }

 private:
N
nhzlx 已提交
1080 1081 1082
  RType *input_x_;
  RType *input_bias_;
  RType *out_;
I
itminner 已提交
1083 1084 1085 1086 1087
  bool inplace_;
  bool has_bias_;
  vector<float> scales_;
  vector<float> biases_;
};
T
Tian 已提交
1088 1089 1090
#endif

#ifdef SLICE_OP
N
nhzlx 已提交
1091
template <typename Dtype>
I
itminner 已提交
1092
class SliceParam : public OpParam {
N
nhzlx 已提交
1093 1094 1095
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

I
itminner 已提交
1096 1097 1098
 public:
  SliceParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
             const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
1099 1100 1101
    input_x_ = InputXFrom<GType>(inputs, scope);
    input_shape_ = InputShapeFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
I
itminner 已提交
1102 1103 1104 1105 1106
    axis_ = GetAttr<int>("axis", attrs);
    slice_points_ = GetAttr<vector<int>>("slice_points", attrs);
    inplace_ = GetAttr<bool>("inplace", attrs);
  }

N
nhzlx 已提交
1107
  const RType *InputX() const { return input_x_; }
I
itminner 已提交
1108

N
nhzlx 已提交
1109
  const RType *InputShape() const { return input_shape_; }
I
itminner 已提交
1110

N
nhzlx 已提交
1111
  RType *Out() const { return out_; }
I
itminner 已提交
1112 1113 1114 1115 1116 1117 1118 1119

  const int &Axis() const { return axis_; }

  const vector<int> &SlicePoints() const { return slice_points_; }

  const bool &Inplace() const { return inplace_; }

 private:
N
nhzlx 已提交
1120 1121 1122
  RType *input_x_;
  RType *input_shape_;
  RType *out_;
I
itminner 已提交
1123 1124 1125 1126
  int axis_;
  vector<int> slice_points_;
  bool inplace_;
};
T
Tian 已提交
1127 1128 1129
#endif

#ifdef RESIZE_OP
N
nhzlx 已提交
1130
template <typename Dtype>
T
Tian 已提交
1131
class ResizeParam : public OpParam {
N
nhzlx 已提交
1132 1133 1134
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

I
itminner 已提交
1135 1136 1137
 public:
  ResizeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
              const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
1138 1139 1140
    input_x_ = InputXFrom<GType>(inputs, scope);
    input_shape_ = InputShapeFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
I
itminner 已提交
1141 1142 1143 1144 1145 1146
    is_pyramid_test_ = GetAttr<bool>("is_pyramid_test", attrs);
    height_ = GetAttr<int>("height", attrs);
    width_ = GetAttr<int>("width", attrs);
    out_height_scale_ = GetAttr<float>("out_height_scale", attrs);
    out_width_scale_ = GetAttr<float>("out_width_scale", attrs);
  }
T
Tian 已提交
1147

N
nhzlx 已提交
1148
  const RType *InputX() const { return input_x_; }
T
Tian 已提交
1149

N
nhzlx 已提交
1150
  const RType *InputShape() const { return input_shape_; }
T
Tian 已提交
1151

N
nhzlx 已提交
1152
  RType *Out() const { return out_; }
T
Tian 已提交
1153

I
itminner 已提交
1154
  const bool &IsPyramidTest() const { return is_pyramid_test_; }
T
Tian 已提交
1155

I
itminner 已提交
1156
  const int &Height() const { return height_; }
T
Tian 已提交
1157

I
itminner 已提交
1158
  const int &Width() const { return width_; }
T
Tian 已提交
1159

I
itminner 已提交
1160
  const float &OutHeightScale() const { return out_height_scale_; }
T
Tian 已提交
1161

I
itminner 已提交
1162
  const float &OutWidthScale() const { return out_width_scale_; }
T
Tian 已提交
1163

I
itminner 已提交
1164
 private:
N
nhzlx 已提交
1165 1166 1167
  RType *input_x_;
  RType *input_shape_;
  RType *out_;
I
itminner 已提交
1168 1169 1170 1171 1172
  bool is_pyramid_test_;
  int height_;
  int width_;
  float out_height_scale_;
  float out_width_scale_;
T
Tian 已提交
1173 1174 1175
};
#endif

L
liuruilong 已提交
1176
#ifdef RELU_OP
L
liuruilong 已提交
1177 1178 1179
/*
 * @b op 层实例化好这个 param 传递给 kernel 层使用
 * */
N
nhzlx 已提交
1180
template <typename Dtype>
E
eclipsess 已提交
1181
class ReluParam : public OpParam {
N
nhzlx 已提交
1182 1183 1184
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

E
eclipsess 已提交
1185 1186 1187
 public:
  ReluParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
            const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
1188 1189
    input_x_ = InputXFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
E
eclipsess 已提交
1190 1191
  }

N
nhzlx 已提交
1192
  const RType *InputX() const { return input_x_; }
E
eclipsess 已提交
1193

N
nhzlx 已提交
1194
  RType *Out() const { return out_; }
E
eclipsess 已提交
1195 1196

 private:
N
nhzlx 已提交
1197 1198
  RType *input_x_;
  RType *out_;
E
eclipsess 已提交
1199
};
L
liuruilong 已提交
1200
#endif
E
eclipsess 已提交
1201

T
Tian 已提交
1202
#ifdef PRELU_OP
N
nhzlx 已提交
1203
template <typename Dtype>
T
Tian 已提交
1204
class PReluParam : public OpParam {
N
nhzlx 已提交
1205 1206 1207
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

I
itminner 已提交
1208 1209 1210
 public:
  PReluParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
             const AttributeMap &attrs, const Scope &scope) {
1211
    DLOG << "PReluParam inputs before";
N
nhzlx 已提交
1212
    input_x_ = InputXFrom<GType>(inputs, scope);
N
nhzlx 已提交
1213
    alpha_ = InputAlphaFrom<GType>(inputs, scope);
1214
    framework::DDim dims = alpha_->dims();
N
nhzlx 已提交
1215
    out_ = OutFrom<GType>(outputs, scope);
1216 1217
    mode_ = GetAttr<std::string>("mode", attrs);
    DLOG << "PReluParam mode after" << mode_;
I
itminner 已提交
1218
  }
N
nhzlx 已提交
1219
  const RType *InputX() const { return input_x_; }
N
nhzlx 已提交
1220
  const RType *InputAlpha() const { return alpha_; }
N
nhzlx 已提交
1221
  RType *Out() const { return out_; }
1222
  const std::string &Mode() const { return mode_; }
T
Tian 已提交
1223

I
itminner 已提交
1224
 private:
N
nhzlx 已提交
1225 1226
  RType *input_x_;
  RType *out_;
N
nhzlx 已提交
1227
  RType *alpha_;
1228
  std::string mode_;
T
Tian 已提交
1229 1230 1231
};
#endif

N
nhzlx 已提交
1232
template <typename Dtype>
L
liuruilong 已提交
1233
class FusionFcParam : public OpParam {
N
nhzlx 已提交
1234 1235 1236
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

E
eclipsess 已提交
1237
 public:
L
liuruilong 已提交
1238
  FusionFcParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
L
liuruilong 已提交
1239
                const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
1240 1241 1242 1243
    input_x_ = InputXFrom<GType>(inputs, scope);
    input_y_ = InputYFrom<GType>(inputs, scope);
    input_z_ = InputZFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
E
eclipsess 已提交
1244 1245 1246 1247
    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);
  }
xiebaiyuan's avatar
xiebaiyuan 已提交
1248
  const GType *InputX() const { return input_x_; }
E
eclipsess 已提交
1249

N
nhzlx 已提交
1250
  const RType *InputY() const { return input_y_; }
E
eclipsess 已提交
1251

N
nhzlx 已提交
1252
  const RType *InputZ() const { return input_z_; }
E
eclipsess 已提交
1253

xiebaiyuan's avatar
xiebaiyuan 已提交
1254
  GType *Out() const { return out_; }
E
eclipsess 已提交
1255 1256 1257 1258 1259 1260 1261 1262

  const int &XNumColDims() const { return x_num_col_dims_; }

  const int &YNumColDims() const { return y_num_col_dims_; }

  const int &Axis() const { return axis_; }

 private:
xiebaiyuan's avatar
xiebaiyuan 已提交
1263
  GType *input_x_;
N
nhzlx 已提交
1264 1265
  RType *input_y_;
  RType *input_z_;
xiebaiyuan's avatar
xiebaiyuan 已提交
1266
  GType *out_;
E
eclipsess 已提交
1267 1268 1269
  int x_num_col_dims_;
  int y_num_col_dims_;
  int axis_;
Z
zhangyang 已提交
1270 1271 1272
#ifdef PADDLE_MOBILE_FPGA

 private:
Z
zhangyang 已提交
1273
  fpga::WrapperConvArgs fpga_conv_args;
Z
zhangyang 已提交
1274 1275

 public:
Z
zhangyang 已提交
1276 1277
  const fpga::WrapperConvArgs &FpgaArgs() const { return fpga_conv_args; }
  void SetFpgaArgs(const fpga::WrapperConvArgs &args) { fpga_conv_args = args; }
Z
zhangyang 已提交
1278
#endif
E
eclipsess 已提交
1279
};
1280 1281

#ifdef FUSION_FCRELU_OP
N
nhzlx 已提交
1282 1283
template <typename DeviceType>
using FusionFcReluParam = FusionFcParam<DeviceType>;
L
liuruilong 已提交
1284
#endif
E
eclipsess 已提交
1285

N
nhzlx 已提交
1286
template <typename Dtype>
L
liuruilong 已提交
1287
class FusionConvAddParam : public OpParam {
N
nhzlx 已提交
1288 1289 1290
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

W
wangliu 已提交
1291
 public:
L
liuruilong 已提交
1292
  FusionConvAddParam(const VariableNameMap &inputs,
L
liuruilong 已提交
1293 1294
                     const VariableNameMap &outputs, const AttributeMap &attrs,
                     const Scope &scope) {
N
nhzlx 已提交
1295
    bias_ = InputYFrom<GType>(inputs, scope);
W
wangliu 已提交
1296
    axis_ = GetAttr<int>("axis", attrs);
N
nhzlx 已提交
1297 1298 1299
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_ = OutFrom<GType>(outputs, scope);
W
wangliu 已提交
1300 1301 1302 1303 1304
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
    groups = GetAttr<int>("groups", attrs);
  }
N
nhzlx 已提交
1305
  RType *Bias() const { return bias_; }
W
wangliu 已提交
1306 1307 1308

  const int &Axis() const { return axis_; }

N
nhzlx 已提交
1309
  const RType *Input() const { return input_; }
W
wangliu 已提交
1310

N
nhzlx 已提交
1311
  const RType *Filter() const { return filter_; }
W
wangliu 已提交
1312

N
nhzlx 已提交
1313
  RType *Output() const { return output_; }
W
wangliu 已提交
1314 1315 1316 1317 1318 1319 1320 1321 1322

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

  const vector<int> &Dilations() const { return dilations_; }

  const int &Groups() const { return groups; }

L
liuruilong 已提交
1323
 protected:
N
nhzlx 已提交
1324
  RType *bias_;
W
wangliu 已提交
1325
  int axis_;
N
nhzlx 已提交
1326 1327 1328
  RType *input_;
  RType *output_;
  RType *filter_;
W
wangliu 已提交
1329 1330 1331 1332
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
  int groups;
Z
zhangyang 已提交
1333 1334 1335
#ifdef PADDLE_MOBILE_FPGA

 private:
Z
zhangyang 已提交
1336
  fpga::WrapperConvArgs fpga_conv_args;
Z
zhangyang 已提交
1337 1338

 public:
Z
zhangyang 已提交
1339 1340
  const fpga::WrapperConvArgs &FpgaArgs() const { return fpga_conv_args; }
  void SetFpgaArgs(const fpga::WrapperConvArgs &args) { fpga_conv_args = args; }
Z
zhangyang 已提交
1341
#endif
W
wangliu 已提交
1342 1343
};

N
nhzlx 已提交
1344 1345
template <typename Dtype>
Print &operator<<(Print &printer, const FusionConvAddParam<Dtype> &conv_param);
W
wangliu 已提交
1346

Z
zhangyang 已提交
1347
#ifdef FUSION_CONVADDRELU_OP
N
nhzlx 已提交
1348 1349
template <typename DeviceType>
class FusionConvAddReluParam : public FusionConvAddParam<DeviceType> {
L
liuruilong 已提交
1350
 public:
L
liuruilong 已提交
1351
  FusionConvAddReluParam(const VariableNameMap &inputs,
L
liuruilong 已提交
1352 1353
                         const VariableNameMap &outputs,
                         const AttributeMap &attrs, const Scope &scope)
N
nhzlx 已提交
1354
      : FusionConvAddParam<DeviceType>(inputs, outputs, attrs, scope) {}
L
liuruilong 已提交
1355 1356 1357
};
#endif

1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
#ifdef FUSION_CONVADDPRELU_OP
template <typename DeviceType>
class FusionConvAddPReluParam : public OpParam {
  typedef typename DtypeTensorTrait<DeviceType>::gtype GType;
  typedef typename DtypeTensorTrait<DeviceType>::rtype RType;

 public:
  FusionConvAddPReluParam(const VariableNameMap &inputs,
                          const VariableNameMap &outputs,
                          const AttributeMap &attrs, const Scope &scope) {
    alpha_ = InputAlphaFrom<GType>(inputs, scope);
    mode_ = GetAttr<std::string>("mode", attrs);
    framework::DDim dims = alpha_->dims();
    bias_ = InputYFrom<GType>(inputs, scope);
    axis_ = GetAttr<int>("axis", attrs);
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_ = OutFrom<GType>(outputs, scope);
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
    groups = GetAttr<int>("groups", attrs);
  }
  const RType *InputAlpha() const { return alpha_; }
  const std::string &Mode() const { return mode_; }
  RType *Bias() const { return bias_; }

  const int &Axis() const { return axis_; }

  const RType *Input() const { return input_; }

  const RType *Filter() const { return filter_; }

  RType *Output() const { return output_; }

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

  const vector<int> &Dilations() const { return dilations_; }

  const int &Groups() const { return groups; }

 protected:
  RType *bias_;
  int axis_;
  RType *input_;
  RType *output_;
  RType *filter_;
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
  int groups;
  RType *alpha_;
  std::string mode_;
#ifdef PADDLE_MOBILE_FPGA

 private:
Z
zhangyang 已提交
1416
  fpga::WrapperConvArgs fpga_conv_args;
1417 1418

 public:
Z
zhangyang 已提交
1419 1420
  const fpga::WrapperConvArgs &FpgaArgs() const { return fpga_conv_args; }
  void SetFpgaArgs(const fpga::WrapperConvArgs &args) { fpga_conv_args = args; }
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
#endif
};
#endif

#ifdef FUSION_CONVADDADDPRELU_OP
template <typename DeviceType>
class FusionConvAddAddPReluParam : public OpParam {
  typedef typename DtypeTensorTrait<DeviceType>::gtype GType;
  typedef typename DtypeTensorTrait<DeviceType>::rtype RType;

 public:
  FusionConvAddAddPReluParam(const VariableNameMap &inputs,
                             const VariableNameMap &outputs,
                             const AttributeMap &attrs, const Scope &scope) {
    bias1_ = InputYFrom1<GType>(inputs, scope);
    alpha_ = InputAlphaFrom<GType>(inputs, scope);
    mode_ = GetAttr<std::string>("mode", attrs);
    framework::DDim dims = alpha_->dims();
    bias_ = InputYFrom<GType>(inputs, scope);
    axis_ = GetAttr<int>("axis", attrs);
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_ = OutFrom<GType>(outputs, scope);
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
    groups = GetAttr<int>("groups", attrs);
    keyOutput_ = getkey("addOut", inputs, 0);
    keyX1_ = getkey("addX", inputs, 1);
    keyY1_ = getkey("Y", inputs, 1);
    if (keyX1_ == keyOutput_) {
      bias1_ = InputYFrom1<GType>(inputs, scope);
    } else if (keyY1_ == keyOutput_) {
      bias1_ = InputXFrom1<GType>(inputs, scope);
    }
  }
  const RType *InputAlpha() const { return alpha_; }
  const std::string &Mode() const { return mode_; }
  const RType *Bias1() const { return bias1_; }

  RType *Bias() const { return bias_; }

  const int &Axis() const { return axis_; }

  const RType *Input() const { return input_; }

  const RType *Filter() const { return filter_; }

  RType *Output() const { return output_; }

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

  const vector<int> &Dilations() const { return dilations_; }

  const int &Groups() const { return groups; }

 protected:
  RType *bias_;
  int axis_;
  RType *input_;
  RType *output_;
  RType *filter_;
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
  int groups;
  RType *alpha_;
  std::string mode_;
  RType *bias1_;
  std::string keyOutput_;
  std::string keyX1_;
  std::string keyY1_;
#ifdef PADDLE_MOBILE_FPGA

 private:
Z
zhangyang 已提交
1498
  fpga::WrapperConvArgs fpga_conv_args;
1499 1500

 public:
Z
zhangyang 已提交
1501 1502
  const fpga::WrapperConvArgs &FpgaArgs() const { return fpga_conv_args; }
  void SetFpgaArgs(const fpga::WrapperConvArgs &args) { fpga_conv_args = args; }
1503 1504 1505 1506
#endif
};
#endif

E
eclipsess 已提交
1507
#ifdef FUSION_CONVADDBNRELU_OP
N
nhzlx 已提交
1508
template <typename Dtype>
E
eclipsess 已提交
1509
class FusionConvAddBNReluParam : public OpParam {
N
nhzlx 已提交
1510 1511 1512
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

E
eclipsess 已提交
1513 1514 1515 1516
 public:
  FusionConvAddBNReluParam(const VariableNameMap &inputs,
                           const VariableNameMap &outputs,
                           const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
1517
    bias_ = InputYFrom<GType>(inputs, scope);
E
eclipsess 已提交
1518
    axis_ = GetAttr<int>("axis", attrs);
N
nhzlx 已提交
1519 1520 1521
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_ = OutFrom<GType>(outputs, scope);
E
eclipsess 已提交
1522 1523 1524 1525
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
    groups = GetAttr<int>("groups", attrs);
N
nhzlx 已提交
1526 1527 1528 1529
    input_bias_ = InputBiasFrom<GType>(inputs, scope);
    input_mean_ = InputMeanFrom<GType>(inputs, scope);
    input_scale_ = InputScaleFrom<GType>(inputs, scope);
    input_variance_ = InputVarianceFrom<GType>(inputs, scope);
E
eclipsess 已提交
1530 1531
    epsilon_ = GetAttr<float>("epsilon", attrs);
    momentum_ = GetAttr<float>("momentum", attrs);
L
liuruilong 已提交
1532
    //    is_test_ = GetAttr<bool>("is_test", attrs);
E
eclipsess 已提交
1533
  }
N
nhzlx 已提交
1534
  RType *Bias() const { return bias_; }
E
eclipsess 已提交
1535 1536 1537

  const int &Axis() const { return axis_; }

N
nhzlx 已提交
1538
  const RType *Input() const { return input_; }
E
eclipsess 已提交
1539

N
nhzlx 已提交
1540
  const RType *Filter() const { return filter_; }
E
eclipsess 已提交
1541

N
nhzlx 已提交
1542
  RType *Output() const { return output_; }
E
eclipsess 已提交
1543 1544 1545 1546 1547 1548 1549 1550 1551

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

  const vector<int> &Dilations() const { return dilations_; }

  const int &Groups() const { return groups; }

N
nhzlx 已提交
1552
  const RType *InputBias() const { return input_bias_; }
E
eclipsess 已提交
1553

N
nhzlx 已提交
1554
  const RType *InputMean() const { return input_mean_; }
E
eclipsess 已提交
1555

N
nhzlx 已提交
1556
  const RType *InputScale() const { return input_scale_; }
E
eclipsess 已提交
1557

N
nhzlx 已提交
1558
  const RType *InputVariance() const { return input_variance_; }
E
eclipsess 已提交
1559 1560 1561 1562 1563 1564 1565

  const float &Epsilon() const { return epsilon_; }

  const float &Momentum() const { return momentum_; }

  const bool &IsTest() const { return is_test_; }

N
nhzlx 已提交
1566
  void SetNewScale(RType *new_scale) { new_scale_ = new_scale; }
E
eclipsess 已提交
1567

N
nhzlx 已提交
1568
  void SetNewBias(RType *new_bias) { new_bias_ = new_bias; }
E
eclipsess 已提交
1569

N
nhzlx 已提交
1570
  const RType *NewScale() const { return new_scale_; }
E
eclipsess 已提交
1571

N
nhzlx 已提交
1572
  const RType *NewBias() const { return new_bias_; }
E
eclipsess 已提交
1573 1574

 protected:
N
nhzlx 已提交
1575
  RType *bias_;
E
eclipsess 已提交
1576
  int axis_;
N
nhzlx 已提交
1577 1578 1579
  RType *input_;
  RType *output_;
  RType *filter_;
E
eclipsess 已提交
1580 1581 1582 1583
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
  int groups;
N
nhzlx 已提交
1584 1585 1586 1587
  RType *input_bias_;
  RType *input_mean_;
  RType *input_scale_;
  RType *input_variance_;
E
eclipsess 已提交
1588 1589 1590
  float epsilon_;
  float momentum_;
  bool is_test_;
N
nhzlx 已提交
1591 1592
  RType *new_bias_;
  RType *new_scale_;
Z
zhangyang 已提交
1593 1594 1595
#ifdef PADDLE_MOBILE_FPGA

 private:
Z
zhangyang 已提交
1596
  fpga::WrapperConvArgs fpga_conv_args;
Z
zhangyang 已提交
1597 1598

 public:
Z
zhangyang 已提交
1599 1600
  const fpga::WrapperConvArgs &FpgaArgs() const { return fpga_conv_args; }
  void SetFpgaArgs(const fpga::WrapperConvArgs &args) { fpga_conv_args = args; }
1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
#endif
};
#endif

#ifdef FUSION_CONVBNADDRELU_OP
template <typename Dtype>
class FusionConvBNAddReluParam : public OpParam {
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

 public:
  FusionConvBNAddReluParam(const VariableNameMap &inputs,
                           const VariableNameMap &outputs,
                           const AttributeMap &attrs, const Scope &scope) {
    bias_ = InputYFrom<GType>(inputs, scope);
    axis_ = GetAttr<int>("axis", attrs);
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_ = OutFrom<GType>(outputs, scope);
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
    groups = GetAttr<int>("groups", attrs);
    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);
    keyBNY_ = getkey("BNY", inputs, 0);
    keyX_ = getkey("X", inputs, 0);
    keyY_ = getkey("Y", inputs, 0);
    if (keyX_ == keyBNY_) {
      bias_ = InputYFrom<GType>(inputs, scope);
    } else if (keyY_ == keyBNY_) {
      bias_ = InputXFrom<GType>(inputs, scope);
    }
    //    is_test_ = GetAttr<bool>("is_test", attrs);
  }
  RType *Bias() const { return bias_; }

  const int &Axis() const { return axis_; }

  const RType *Input() const { return input_; }

  const RType *Filter() const { return filter_; }

  RType *Output() const { return output_; }

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

  const vector<int> &Dilations() const { return dilations_; }

  const int &Groups() const { return groups; }

  const RType *InputBias() const { return input_bias_; }

  const RType *InputMean() const { return input_mean_; }

  const RType *InputScale() const { return input_scale_; }

  const RType *InputVariance() const { return input_variance_; }

  const float &Epsilon() const { return epsilon_; }

  const float &Momentum() const { return momentum_; }

  const bool &IsTest() const { return is_test_; }

  void SetNewScale(RType *new_scale) { new_scale_ = new_scale; }

  void SetNewBias(RType *new_bias) { new_bias_ = new_bias; }

  const RType *NewScale() const { return new_scale_; }

  const RType *NewBias() const { return new_bias_; }

 protected:
  RType *bias_;
  int axis_;
  RType *input_;
  RType *output_;
  RType *filter_;
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
  int groups;
  RType *input_bias_;
  RType *input_mean_;
  RType *input_scale_;
  RType *input_variance_;
  float epsilon_;
  float momentum_;
  bool is_test_;
  RType *new_bias_;
  RType *new_scale_;
  std::string keyBNY_;
  std::string keyX_;
  std::string keyY_;
#ifdef PADDLE_MOBILE_FPGA

 private:
Z
zhangyang 已提交
1705
  fpga::WrapperConvArgs fpga_conv_args;
1706 1707

 public:
Z
zhangyang 已提交
1708 1709
  const fpga::WrapperConvArgs &FpgaArgs() const { return fpga_conv_args; }
  void SetFpgaArgs(const fpga::WrapperConvArgs &args) { fpga_conv_args = args; }
Z
zhangyang 已提交
1710
#endif
E
eclipsess 已提交
1711
};
1712
#endif
E
eclipsess 已提交
1713

Z
zhangyang 已提交
1714
#ifdef FUSION_CONVBN_OP
N
nhzlx 已提交
1715
template <typename Dtype>
Z
zhangyang 已提交
1716
class FusionConvBNParam : public OpParam {
N
nhzlx 已提交
1717 1718 1719
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

Z
zhangyang 已提交
1720 1721 1722 1723
 public:
  FusionConvBNParam(const VariableNameMap &inputs,
                    const VariableNameMap &outputs, const AttributeMap &attrs,
                    const Scope &scope) {
N
nhzlx 已提交
1724 1725 1726
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_y_ = OutputYFrom<GType>(outputs, scope);
Z
zhangyang 已提交
1727 1728 1729 1730
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
    groups = GetAttr<int>("groups", attrs);
N
nhzlx 已提交
1731 1732 1733 1734
    input_bias_ = InputBiasFrom<GType>(inputs, scope);
    input_mean_ = InputMeanFrom<GType>(inputs, scope);
    input_scale_ = InputScaleFrom<GType>(inputs, scope);
    input_variance_ = InputVarianceFrom<GType>(inputs, scope);
Z
zhangyang 已提交
1735 1736 1737 1738 1739
    epsilon_ = GetAttr<float>("epsilon", attrs);
    momentum_ = GetAttr<float>("momentum", attrs);
    //    is_test_ = GetAttr<bool>("is_test", attrs);
  }

N
nhzlx 已提交
1740
  const RType *Input() const { return input_; }
Z
zhangyang 已提交
1741

N
nhzlx 已提交
1742
  const RType *Filter() const { return filter_; }
Z
zhangyang 已提交
1743

N
nhzlx 已提交
1744
  RType *Output() const { return output_y_; }
Z
zhangyang 已提交
1745 1746 1747 1748 1749 1750 1751 1752 1753

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

  const vector<int> &Dilations() const { return dilations_; }

  const int &Groups() const { return groups; }

N
nhzlx 已提交
1754
  const RType *InputBias() const { return input_bias_; }
Z
zhangyang 已提交
1755

N
nhzlx 已提交
1756
  const RType *InputMean() const { return input_mean_; }
Z
zhangyang 已提交
1757

N
nhzlx 已提交
1758
  const RType *InputScale() const { return input_scale_; }
Z
zhangyang 已提交
1759

N
nhzlx 已提交
1760
  const RType *InputVariance() const { return input_variance_; }
Z
zhangyang 已提交
1761 1762 1763 1764 1765 1766 1767

  const float &Epsilon() const { return epsilon_; }

  const float &Momentum() const { return momentum_; }

  const bool &IsTest() const { return is_test_; }

N
nhzlx 已提交
1768
  void SetNewScale(RType *new_scale) { new_scale_ = new_scale; }
Z
zhangyang 已提交
1769

N
nhzlx 已提交
1770
  void SetNewBias(RType *new_bias) { new_bias_ = new_bias; }
Z
zhangyang 已提交
1771

N
nhzlx 已提交
1772
  const RType *NewScale() const { return new_scale_; }
Z
zhangyang 已提交
1773

N
nhzlx 已提交
1774
  const RType *NewBias() const { return new_bias_; }
Z
zhangyang 已提交
1775 1776

 protected:
N
nhzlx 已提交
1777 1778 1779
  RType *input_;
  RType *output_y_;
  RType *filter_;
Z
zhangyang 已提交
1780 1781 1782 1783
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
  int groups;
N
nhzlx 已提交
1784 1785 1786 1787
  RType *input_bias_;
  RType *input_mean_;
  RType *input_scale_;
  RType *input_variance_;
Z
zhangyang 已提交
1788 1789 1790
  float epsilon_;
  float momentum_;
  bool is_test_;
N
nhzlx 已提交
1791 1792
  RType *new_bias_;
  RType *new_scale_;
Z
zhangyang 已提交
1793 1794 1795
#ifdef PADDLE_MOBILE_FPGA

 private:
Z
zhangyang 已提交
1796
  fpga::WrapperConvArgs fpga_conv_args;
Z
zhangyang 已提交
1797 1798

 public:
Z
zhangyang 已提交
1799 1800
  const fpga::WrapperConvArgs &FpgaArgs() const { return fpga_conv_args; }
  void SetFpgaArgs(const fpga::WrapperConvArgs &args) { fpga_conv_args = args; }
Z
zhangyang 已提交
1801 1802 1803 1804
#endif
};
#endif

1805
#ifdef FUSION_CONVADDBN_OP
N
nhzlx 已提交
1806
template <typename Dtype>
1807
class FusionConvAddBNParam : public OpParam {
N
nhzlx 已提交
1808 1809 1810
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

1811 1812 1813 1814
 public:
  FusionConvAddBNParam(const VariableNameMap &inputs,
                       const VariableNameMap &outputs,
                       const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
1815
    bias_ = InputYFrom<GType>(inputs, scope);
1816
    axis_ = GetAttr<int>("axis", attrs);
N
nhzlx 已提交
1817 1818 1819
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_y_ = OutputYFrom<GType>(outputs, scope);
1820 1821 1822 1823
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
    groups = GetAttr<int>("groups", attrs);
N
nhzlx 已提交
1824 1825 1826 1827
    input_bias_ = InputBiasFrom<GType>(inputs, scope);
    input_mean_ = InputMeanFrom<GType>(inputs, scope);
    input_scale_ = InputScaleFrom<GType>(inputs, scope);
    input_variance_ = InputVarianceFrom<GType>(inputs, scope);
1828 1829 1830 1831
    epsilon_ = GetAttr<float>("epsilon", attrs);
    momentum_ = GetAttr<float>("momentum", attrs);
    //    is_test_ = GetAttr<bool>("is_test", attrs);
  }
N
nhzlx 已提交
1832
  RType *Bias() const { return bias_; }
1833 1834 1835

  const int &Axis() const { return axis_; }

N
nhzlx 已提交
1836
  const RType *Input() const { return input_; }
1837

N
nhzlx 已提交
1838
  const RType *Filter() const { return filter_; }
Z
zhangyang 已提交
1839

N
nhzlx 已提交
1840
  RType *Output() const { return output_y_; }
1841 1842 1843 1844 1845 1846 1847 1848 1849

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

  const vector<int> &Dilations() const { return dilations_; }

  const int &Groups() const { return groups; }

N
nhzlx 已提交
1850
  const RType *InputBias() const { return input_bias_; }
1851

N
nhzlx 已提交
1852
  const RType *InputMean() const { return input_mean_; }
1853

N
nhzlx 已提交
1854
  const RType *InputScale() const { return input_scale_; }
1855

N
nhzlx 已提交
1856
  const RType *InputVariance() const { return input_variance_; }
1857 1858 1859 1860 1861 1862 1863

  const float &Epsilon() const { return epsilon_; }

  const float &Momentum() const { return momentum_; }

  const bool &IsTest() const { return is_test_; }

N
nhzlx 已提交
1864
  void SetNewScale(RType *new_scale) { new_scale_ = new_scale; }
1865

N
nhzlx 已提交
1866
  void SetNewBias(RType *new_bias) { new_bias_ = new_bias; }
1867

N
nhzlx 已提交
1868
  const RType *NewScale() const { return new_scale_; }
1869

N
nhzlx 已提交
1870
  const RType *NewBias() const { return new_bias_; }
1871 1872

 protected:
N
nhzlx 已提交
1873
  RType *bias_;
1874
  int axis_;
N
nhzlx 已提交
1875 1876 1877
  RType *input_;
  RType *output_y_;
  RType *filter_;
1878 1879 1880 1881
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
  int groups;
N
nhzlx 已提交
1882 1883 1884 1885
  RType *input_bias_;
  RType *input_mean_;
  RType *input_scale_;
  RType *input_variance_;
1886 1887 1888
  float epsilon_;
  float momentum_;
  bool is_test_;
N
nhzlx 已提交
1889 1890
  RType *new_bias_;
  RType *new_scale_;
Z
zhangyang 已提交
1891 1892 1893
#ifdef PADDLE_MOBILE_FPGA

 private:
Z
zhangyang 已提交
1894
  fpga::WrapperConvArgs fpga_conv_args;
Z
zhangyang 已提交
1895 1896

 public:
Z
zhangyang 已提交
1897 1898
  const fpga::WrapperConvArgs &FpgaArgs() const { return fpga_conv_args; }
  void SetFpgaArgs(const fpga::WrapperConvArgs &args) { fpga_conv_args = args; }
Z
zhangyang 已提交
1899
#endif
1900
};
E
eclipsess 已提交
1901
#endif
Y
Yao,kun 已提交
1902

E
eclipsess 已提交
1903
#ifdef FUSION_DWCONVBNRELU_OP
N
nhzlx 已提交
1904
template <typename Dtype>
E
eclipsess 已提交
1905
class FusionDWConvBNReluParam : public OpParam {
N
nhzlx 已提交
1906 1907 1908
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

E
eclipsess 已提交
1909 1910 1911 1912
 public:
  FusionDWConvBNReluParam(const VariableNameMap &inputs,
                          const VariableNameMap &outputs,
                          const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
1913 1914 1915
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_ = OutFrom<GType>(outputs, scope);
E
eclipsess 已提交
1916 1917 1918 1919
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
    groups = GetAttr<int>("groups", attrs);
N
nhzlx 已提交
1920 1921 1922 1923
    input_bias_ = InputBiasFrom<GType>(inputs, scope);
    input_mean_ = InputMeanFrom<GType>(inputs, scope);
    input_scale_ = InputScaleFrom<GType>(inputs, scope);
    input_variance_ = InputVarianceFrom<GType>(inputs, scope);
E
eclipsess 已提交
1924 1925
    epsilon_ = GetAttr<float>("epsilon", attrs);
    momentum_ = GetAttr<float>("momentum", attrs);
1926
    //    is_test_ = GetAttr<bool>("is_test", attrs);
E
eclipsess 已提交
1927 1928
  }

N
nhzlx 已提交
1929
  const RType *Input() const { return input_; }
E
eclipsess 已提交
1930

N
nhzlx 已提交
1931
  const RType *Filter() const { return filter_; }
E
eclipsess 已提交
1932

N
nhzlx 已提交
1933
  RType *Output() const { return output_; }
E
eclipsess 已提交
1934 1935 1936 1937 1938 1939 1940 1941 1942

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

  const vector<int> &Dilations() const { return dilations_; }

  const int &Groups() const { return groups; }

N
nhzlx 已提交
1943
  const RType *InputBias() const { return input_bias_; }
E
eclipsess 已提交
1944

N
nhzlx 已提交
1945
  const RType *InputMean() const { return input_mean_; }
E
eclipsess 已提交
1946

N
nhzlx 已提交
1947
  const RType *InputScale() const { return input_scale_; }
E
eclipsess 已提交
1948

N
nhzlx 已提交
1949
  const RType *InputVariance() const { return input_variance_; }
E
eclipsess 已提交
1950 1951 1952 1953 1954 1955 1956

  const float &Epsilon() const { return epsilon_; }

  const float &Momentum() const { return momentum_; }

  const bool &IsTest() const { return is_test_; }

N
nhzlx 已提交
1957
  void SetNewScale(RType *new_scale) { new_scale_ = new_scale; }
E
eclipsess 已提交
1958

N
nhzlx 已提交
1959
  void SetNewBias(RType *new_bias) { new_bias_ = new_bias; }
E
eclipsess 已提交
1960

N
nhzlx 已提交
1961
  const RType *NewScale() const { return new_scale_; }
E
eclipsess 已提交
1962

N
nhzlx 已提交
1963
  const RType *NewBias() const { return new_bias_; }
E
eclipsess 已提交
1964 1965

 protected:
N
nhzlx 已提交
1966 1967 1968
  RType *input_;
  RType *output_;
  RType *filter_;
E
eclipsess 已提交
1969 1970 1971 1972
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
  int groups;
N
nhzlx 已提交
1973 1974 1975 1976
  RType *input_bias_;
  RType *input_mean_;
  RType *input_scale_;
  RType *input_variance_;
E
eclipsess 已提交
1977 1978 1979
  float epsilon_;
  float momentum_;
  bool is_test_;
N
nhzlx 已提交
1980 1981
  RType *new_bias_;
  RType *new_scale_;
E
eclipsess 已提交
1982 1983 1984 1985
};

#endif

1986
#ifdef FUSION_CONVBNRELU_OP
N
nhzlx 已提交
1987
template <typename Dtype>
1988
class FusionConvBNReluParam : public OpParam {
N
nhzlx 已提交
1989 1990 1991
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

1992 1993 1994 1995
 public:
  FusionConvBNReluParam(const VariableNameMap &inputs,
                        const VariableNameMap &outputs,
                        const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
1996 1997 1998
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_ = OutFrom<GType>(outputs, scope);
1999 2000 2001 2002 2003

    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
    groups = GetAttr<int>("groups", attrs);
N
nhzlx 已提交
2004 2005 2006 2007
    input_bias_ = InputBiasFrom<GType>(inputs, scope);
    input_mean_ = InputMeanFrom<GType>(inputs, scope);
    input_scale_ = InputScaleFrom<GType>(inputs, scope);
    input_variance_ = InputVarianceFrom<GType>(inputs, scope);
2008 2009 2010 2011 2012
    epsilon_ = GetAttr<float>("epsilon", attrs);
    momentum_ = GetAttr<float>("momentum", attrs);
    //    is_test_ = GetAttr<bool>("is_test", attrs);
  }

N
nhzlx 已提交
2013
  const RType *Input() const { return input_; }
2014

N
nhzlx 已提交
2015
  const RType *Filter() const { return filter_; }
2016

N
nhzlx 已提交
2017
  RType *Output() const { return output_; }
2018 2019 2020 2021 2022 2023 2024 2025 2026

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

  const vector<int> &Dilations() const { return dilations_; }

  const int &Groups() const { return groups; }

N
nhzlx 已提交
2027
  const RType *InputBias() const { return input_bias_; }
2028

N
nhzlx 已提交
2029
  const RType *InputMean() const { return input_mean_; }
2030

N
nhzlx 已提交
2031
  const RType *InputScale() const { return input_scale_; }
2032

N
nhzlx 已提交
2033
  const RType *InputVariance() const { return input_variance_; }
2034 2035 2036 2037 2038 2039 2040

  const float &Epsilon() const { return epsilon_; }

  const float &Momentum() const { return momentum_; }

  const bool &IsTest() const { return is_test_; }

N
nhzlx 已提交
2041
  void SetNewScale(RType *new_scale) { new_scale_ = new_scale; }
2042

N
nhzlx 已提交
2043
  void SetNewBias(RType *new_bias) { new_bias_ = new_bias; }
2044

N
nhzlx 已提交
2045
  const RType *NewScale() const { return new_scale_; }
2046

N
nhzlx 已提交
2047
  const RType *NewBias() const { return new_bias_; }
2048 2049

 protected:
N
nhzlx 已提交
2050 2051 2052
  RType *input_;
  RType *output_;
  RType *filter_;
2053 2054 2055 2056
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
  int groups;
N
nhzlx 已提交
2057 2058 2059 2060
  RType *input_bias_;
  RType *input_mean_;
  RType *input_scale_;
  RType *input_variance_;
2061 2062 2063
  float epsilon_;
  float momentum_;
  bool is_test_;
N
nhzlx 已提交
2064 2065
  RType *new_bias_;
  RType *new_scale_;
Z
zhangyang 已提交
2066 2067 2068
#ifdef PADDLE_MOBILE_FPGA

 private:
Z
zhangyang 已提交
2069
  fpga::WrapperConvArgs fpga_conv_args;
Z
zhangyang 已提交
2070 2071

 public:
Z
zhangyang 已提交
2072 2073
  const fpga::WrapperConvArgs &FpgaArgs() const { return fpga_conv_args; }
  void SetFpgaArgs(const fpga::WrapperConvArgs &args) { fpga_conv_args = args; }
Z
zhangyang 已提交
2074
#endif
2075 2076 2077
};
#endif

Y
Yao,kun 已提交
2078
#ifdef IM2SEQUENCE_OP
N
nhzlx 已提交
2079
template <typename Dtype>
Y
Yao,kun 已提交
2080
class Im2SequenceParam : public OpParam {
N
nhzlx 已提交
2081 2082 2083
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

Y
Yao,kun 已提交
2084 2085 2086 2087
 public:
  Im2SequenceParam(const VariableNameMap &inputs,
                   const VariableNameMap &outputs, const AttributeMap &attrs,
                   const Scope &scope) {
N
nhzlx 已提交
2088 2089
    input_x_ = InputXFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
Y
Yao,kun 已提交
2090 2091 2092 2093 2094
    kernels_ = GetAttr<vector<int>>("kernels", attrs);
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
  }

N
nhzlx 已提交
2095
  const RType *Input() const { return input_x_; }
Y
Yao,kun 已提交
2096

N
nhzlx 已提交
2097
  RType *Output() const { return out_; }
Y
Yao,kun 已提交
2098 2099 2100 2101 2102 2103 2104 2105

  const vector<int> &Kernels() const { return kernels_; }

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

 private:
N
nhzlx 已提交
2106 2107
  RType *input_x_;
  RType *out_;
Y
Yao,kun 已提交
2108 2109 2110 2111
  vector<int> kernels_;
  vector<int> strides_;
  vector<int> paddings_;
};
2112
#endif
Y
Yao,kun 已提交
2113

2114
#ifdef DROPOUT_OP
N
nhzlx 已提交
2115
template <typename Dtype>
Y
Yao,kun 已提交
2116
class DropoutParam : public OpParam {
N
nhzlx 已提交
2117 2118 2119
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

Y
Yao,kun 已提交
2120 2121 2122
 public:
  DropoutParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
               const AttributeMap &attrs, const Scope &scope) {
N
nhzlx 已提交
2123 2124
    input_x_ = InputXFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
Y
yangfei 已提交
2125 2126

    dropout_prob_ = GetAttr<float>("dropout_prob", attrs);
Y
Yao,kun 已提交
2127 2128
  }

N
nhzlx 已提交
2129
  const RType *InputX() const { return input_x_; }
Y
Yao,kun 已提交
2130

N
nhzlx 已提交
2131
  RType *Out() const { return out_; }
Y
Yao,kun 已提交
2132

Y
yangfei 已提交
2133 2134
  float DropoutProb() const { return dropout_prob_; }

Y
Yao,kun 已提交
2135
 private:
N
nhzlx 已提交
2136 2137
  RType *input_x_;
  RType *out_;
Y
yangfei 已提交
2138
  float dropout_prob_;
Y
Yao,kun 已提交
2139
};
2140
#endif
Y
Yao,kun 已提交
2141

L
liuruilong 已提交
2142
#ifdef CONV_TRANSPOSE
N
nhzlx 已提交
2143
template <typename Dtype>
L
liuruilong 已提交
2144
class ConvTransposeParam : public OpParam {
N
nhzlx 已提交
2145 2146 2147
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

L
liuruilong 已提交
2148 2149 2150 2151
 public:
  ConvTransposeParam(const VariableNameMap &inputs,
                     const VariableNameMap &outputs, const AttributeMap &attrs,
                     const Scope &scope) {
N
nhzlx 已提交
2152 2153 2154
    filter_ = FilterFrom<GType>(inputs, scope);
    input_ = InputFrom<GType>(inputs, scope);
    output_ = OutputFrom<GType>(outputs, scope);
L
liuruilong 已提交
2155 2156 2157 2158 2159 2160
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
    groups = GetAttr<int>("groups", attrs);
  }

N
nhzlx 已提交
2161
  const RType *Input() const { return input_; }
L
liuruilong 已提交
2162

N
nhzlx 已提交
2163
  const RType *Filter() const { return filter_; }
L
liuruilong 已提交
2164

N
nhzlx 已提交
2165
  RType *Output() const { return output_; }
L
liuruilong 已提交
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175

  const vector<int> &Strides() const { return strides_; }

  const vector<int> &Paddings() const { return paddings_; }

  const vector<int> &Dilations() const { return dilations_; }

  const int &Groups() const { return groups; }

 private:
N
nhzlx 已提交
2176 2177 2178
  RType *input_;
  RType *output_;
  RType *filter_;
L
liuruilong 已提交
2179 2180 2181 2182 2183 2184 2185
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
  int groups;
};
#endif

xiebaiyuan's avatar
xiebaiyuan 已提交
2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
#ifdef GRU_OP
template <typename Dtype>
class GruParam : public OpParam {
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;

 public:
  /**
   *
   * @param inputs
   * @param outputs
   * @param attrs
   * @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);
    output_batch_reset_hidden_prev_ =
        OutputBatchResetHiddenPrevFrom<GType>(outputs, scope);
    output_batch_hidden_ = OutputBatchHiddenFrom<GType>(outputs, scope);
    output_hidden_ = OutputHiddenFrom<GType>(outputs, scope);
    activation_ = GetAttr<std::string>("activation", attrs);
    gate_activation_ = GetAttr<std::string>("gate_activation", attrs);
    is_reverse_ = GetAttr<bool>("is_reverse", attrs);
  }
  const GType *InputInput() const { return input_input_; }
  const GType *InputWeight() const { return input_weight_; }
  const GType *InputH0() const { return input_h0_; }
  const GType *InputBias() const { return input_bias_; }
  const std::string &Activation() const { return activation_; }
  const std::string &GateActivation() const { return gate_activation_; }
  const bool &IsReverse() const { return is_reverse_; }

  GType *OutBatchGate() const { return output_batch_gate_; }
  GType *OutBatchResetHiddenPrev() const {
    return output_batch_reset_hidden_prev_;
  }
  GType *OutBatchHidden() const { return output_batch_hidden_; }
  GType *OutHidden() const { return output_hidden_; }

 private:
  GType *input_input_;
  GType *input_h0_;
  GType *input_bias_;
  GType *input_weight_;

  GType *output_batch_gate_;
  GType *output_batch_reset_hidden_prev_;
  GType *output_batch_hidden_;
  GType *output_hidden_;
  std::string activation_;
  std::string gate_activation_;
  bool is_reverse_;
};
#endif

2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
#ifdef FLATTEN_OP
template <typename Dtype>
class FlattenParam : public OpParam {
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

 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);
xiebaiyuan's avatar
xiebaiyuan 已提交
2257
    axis = GetAttr<int>("axis", attrs);
2258 2259 2260
  }
  const RType *InputX() const { return input_x_; }
  RType *Out() const { return out_; }
xiebaiyuan's avatar
xiebaiyuan 已提交
2261
  const int &Axis() const { return axis; }
2262 2263 2264 2265

 private:
  RType *input_x_;
  RType *out_;
xiebaiyuan's avatar
xiebaiyuan 已提交
2266
  int axis;
2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279
};
#endif

#ifdef SPLIT_OP
template <typename Dtype>
class SplitParam : public OpParam {
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

 public:
  SplitParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
             const AttributeMap &attrs, const Scope &scope) {
    input_x_ = InputXFrom<GType>(inputs, scope);
xiebaiyuan's avatar
xiebaiyuan 已提交
2280
    outs_ = OutMultiFrom<GType>(outputs, scope);
xiebaiyuan's avatar
xiebaiyuan 已提交
2281
    axis = GetAttr<int>("axis", attrs);
xiebaiyuan's avatar
xiebaiyuan 已提交
2282 2283 2284 2285 2286 2287
    num = GetAttr<int>("num", attrs);
    sections = GetAttr<std::vector<int>>("sections", attrs);

    //    for (int i = 0; i < outs_.size(); ++i) {
    //      out_ts_.push_back(*scope.FindVar(outs_[i])->GetMutable());
    //    }
2288 2289
  }
  const RType *InputX() const { return input_x_; }
xiebaiyuan's avatar
xiebaiyuan 已提交
2290 2291 2292 2293 2294
  std::vector<GType *> Outs() const { return outs_; }
  int Axis() const { return axis; }
  int Num() const { return num; }
  std::vector<int> Sections() const { return sections; }
  //  std::vector<GType> OutTs() const { return out_ts_; }
2295 2296 2297

 private:
  RType *input_x_;
xiebaiyuan's avatar
xiebaiyuan 已提交
2298
  std::vector<GType *> outs_;
xiebaiyuan's avatar
xiebaiyuan 已提交
2299
  int axis;
xiebaiyuan's avatar
xiebaiyuan 已提交
2300 2301 2302
  int num;
  std::vector<int> sections;
  //  std::vector<GType> out_ts_;
2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
};
#endif

#ifdef BILINEAR_INTERP_OP
template <typename Dtype>
class BilinearInterpParam : public OpParam {
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

 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);
xiebaiyuan's avatar
xiebaiyuan 已提交
2319 2320
    out_h_ = GetAttr<int>("out_h", attrs);
    out_w_ = GetAttr<int>("out_w", attrs);
2321 2322
  }
  const RType *InputX() const { return input_x_; }
xiebaiyuan's avatar
xiebaiyuan 已提交
2323
  const RType *InputOutPutSize() const { return input_outsize_; }
2324
  RType *Out() const { return out_; }
xiebaiyuan's avatar
xiebaiyuan 已提交
2325 2326
  int OutH() const { return out_h_; }
  int OutW() const { return out_w_; }
2327 2328 2329 2330 2331

 private:
  RType *input_x_;
  RType *input_outsize_;
  RType *out_;
xiebaiyuan's avatar
xiebaiyuan 已提交
2332 2333
  int out_h_;
  int out_w_;
2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348
};
#endif

#ifdef SHAPE_OP
template <typename Dtype>
class ShapeParam : public OpParam {
  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
  typedef typename DtypeTensorTrait<Dtype>::rtype RType;

 public:
  ShapeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
             const AttributeMap &attrs, const Scope &scope) {
    input_ = InputFrom<GType>(inputs, scope);
    out_ = OutFrom<GType>(outputs, scope);
  }
xiebaiyuan's avatar
xiebaiyuan 已提交
2349
  const RType *Input() const { return input_; }
2350 2351 2352 2353 2354 2355 2356 2357
  RType *Out() const { return out_; }

 private:
  RType *input_;
  RType *out_;
};
#endif

朔-望's avatar
朔-望 已提交
2358 2359
}  // namespace operators
}  // namespace paddle_mobile