op_param.h 23.0 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 21 22 23 24 25 26
#include "common/type_define.h"
#include "framework/lod_tensor.h"
#include "framework/scope.h"
#include "framework/tensor.h"
#include "framework/variable.h"

namespace paddle_mobile {
朔-望's avatar
朔-望 已提交
27 28
namespace operators {

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

class OpParam : PaddleMobileObject {
朔-望's avatar
朔-望 已提交
38
 protected:
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
  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);
  }

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

E
eclipsess 已提交
54 55 56 57 58
  template <typename T>
  static T *InputZFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Z", inputs, scope);
  }

59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
  template <typename T>
  static T *InputBiasFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Bias", inputs, scope);
  }
  template <typename T>
  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 已提交
76 77 78 79
  template <typename T>
  static T *InputImageFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Image", inputs, scope);
  }
E
eclipsess 已提交
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
  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);
  }
96

E
eclipsess 已提交
97 98 99 100 101 102 103 104 105 106
  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 已提交
107 108 109 110
  template <typename T>
  static T *InputShapeFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Shape", inputs, scope);
  }
E
eclipsess 已提交
111

112
  template <typename T>
W
wangliu 已提交
113 114
  static vector<T *> InputMultiFrom(const VariableNameMap &inputs,
                                    const Scope &scope) {
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
    return GetMultiVarValue<T>("X", inputs, scope);
  }

  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);
  }

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

E
eclipsess 已提交
133 134 135 136 137 138
  template <typename T>
  static T *OutputBoxesFrom(const VariableNameMap &outputs,
                            const Scope &scope) {
    return GetVarValue<T>("Boxes", outputs, scope);
  }

E
eclipsess 已提交
139 140 141 142 143
  template <typename T>
  static T *OutputBoxFrom(const VariableNameMap &outputs, const Scope &scope) {
    return GetVarValue<T>("OutputBox", outputs, scope);
  }

E
eclipsess 已提交
144 145 146 147 148 149
  template <typename T>
  static T *OutputVariancesFrom(const VariableNameMap &outputs,
                                const Scope &scope) {
    return GetVarValue<T>("Variances", outputs, scope);
  }

150 151 152 153 154 155 156 157 158 159 160
  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 已提交
161
  static const T GetAttr(const string &key, const AttributeMap &map) {
162 163 164 165
    return ((Attribute)map.at(key)).Get<T>();
  }

  template <typename T>
W
wangliu 已提交
166
  static T *GetVarValue(const string &key, const VariableNameMap &var_map,
167 168 169 170 171 172 173 174 175
                        const Scope &scope) {
    auto var_vec = var_map.at(key);
    if (!var_vec.empty()) {
      //      std::cout << " get var value -- " << var_vec[0] <<
      //      std::endl;
      auto var = scope.FindVar(var_vec[0]);
      return var->GetMutable<T>();
    } else {
      return nullptr;
朔-望's avatar
朔-望 已提交
176
    }
177
  }
朔-望's avatar
朔-望 已提交
178

179
  template <typename T>
W
wangliu 已提交
180 181 182
  static vector<T *> GetMultiVarValue(const string &key,
                                      const VariableNameMap &var_map,
                                      const Scope &scope) {
183 184
    auto var_vecs = var_map.at(key);
    assert(var_vecs.size() > 1);
W
wangliu 已提交
185
    vector<T *> var_res;
186 187 188
    for (auto &var_vec : var_vecs) {
      auto var = scope.FindVar(var_vec);
      var_res.push_back(var->GetMutable<T>());
朔-望's avatar
朔-望 已提交
189
    }
190 191
    return var_res;
  }
朔-望's avatar
朔-望 已提交
192 193 194
};

class ConvParam : OpParam {
朔-望's avatar
朔-望 已提交
195
 public:
196 197 198
  ConvParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
            const framework::AttributeMap &attrs,
            const framework::Scope &scope) {
W
wangliu 已提交
199
    filter_ = FilterFrom<LoDTensor>(inputs, scope);
W
wangliu 已提交
200 201
    input_ = InputFrom<LoDTensor>(inputs, scope);
    output_ = OutputFrom<LoDTensor>(outputs, scope);
W
wangliu 已提交
202 203 204
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
205 206
    groups = GetAttr<int>("groups", attrs);
  }
朔-望's avatar
朔-望 已提交
207

208
  const Tensor *Input() const { return input_; }
朔-望's avatar
朔-望 已提交
209

E
eclipsess 已提交
210
  const Tensor *Filter() const { return filter_; }
朔-望's avatar
朔-望 已提交
211

212
  Tensor *Output() const { return output_; }
朔-望's avatar
朔-望 已提交
213

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

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

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

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

朔-望's avatar
朔-望 已提交
222
 private:
223 224
  Tensor *input_;
  Tensor *output_;
E
eclipsess 已提交
225
  Tensor *filter_;
W
wangliu 已提交
226 227 228
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
229
  int groups;
朔-望's avatar
朔-望 已提交
230 231 232 233 234
};

Print &operator<<(Print &printer, const ConvParam &conv_param);

class ElementwiseAddParam : OpParam {
朔-望's avatar
朔-望 已提交
235
 public:
236 237 238 239
  ElementwiseAddParam(const VariableNameMap &inputs,
                      const VariableNameMap &outputs,
                      const framework::AttributeMap &attrs,
                      const framework::Scope &scope) {
W
wangliu 已提交
240 241 242
    input_x_ = InputXFrom<framework::LoDTensor>(inputs, scope);
    input_y_ = InputYFrom<framework::LoDTensor>(inputs, scope);
    out_ = OutFrom<framework::LoDTensor>(outputs, scope);
243 244 245 246 247 248 249 250 251 252 253
    axis_ = GetAttr<int>("axis", attrs);
  }

  const Tensor *InputX() const { return input_x_; }

  const Tensor *InputY() const { return input_y_; }

  Tensor *Out() const { return out_; }

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

朔-望's avatar
朔-望 已提交
254
 private:
255 256 257 258
  Tensor *input_x_;
  Tensor *input_y_;
  Tensor *out_;
  int axis_;
朔-望's avatar
朔-望 已提交
259 260 261
};

class MulParam : OpParam {
朔-望's avatar
朔-望 已提交
262
 public:
263 264 265
  MulParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
           const framework::AttributeMap &attrs,
           const framework::Scope &scope) {
W
wangliu 已提交
266 267 268
    input_x_ = InputXFrom<framework::LoDTensor>(inputs, scope);
    input_y_ = InputYFrom<framework::LoDTensor>(inputs, scope);
    out_ = OutFrom<framework::LoDTensor>(outputs, scope);
269 270 271
    x_num_col_dims_ = GetAttr<int>("x_num_col_dims", attrs);
    y_num_col_dims_ = GetAttr<int>("y_num_col_dims", attrs);
  }
朔-望's avatar
朔-望 已提交
272

273
  const Tensor *InputX() const { return input_x_; }
朔-望's avatar
朔-望 已提交
274

275
  const Tensor *InputY() const { return input_y_; }
朔-望's avatar
朔-望 已提交
276

277
  Tensor *Out() const { return out_; }
朔-望's avatar
朔-望 已提交
278

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

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

朔-望's avatar
朔-望 已提交
283
 private:
284 285 286 287 288
  Tensor *input_x_;
  Tensor *input_y_;
  Tensor *out_;
  int x_num_col_dims_;
  int y_num_col_dims_;
朔-望's avatar
朔-望 已提交
289 290 291
};

class ConcatParam : public OpParam {
朔-望's avatar
朔-望 已提交
292
 public:
293 294 295
  ConcatParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
              const framework::AttributeMap &attrs,
              const framework::Scope &scope) {
W
wangliu 已提交
296 297
    inputs_ = InputMultiFrom<LoDTensor>(inputs, scope);
    out_ = OutFrom<framework::LoDTensor>(outputs, scope);
298 299
    axis_ = GetAttr<int>("axis", attrs);
  }
朔-望's avatar
朔-望 已提交
300

W
wangliu 已提交
301
  vector<LoDTensor *> Inputs() const { return inputs_; }
朔-望's avatar
朔-望 已提交
302

303
  Tensor *Out() const { return out_; }
朔-望's avatar
朔-望 已提交
304

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

朔-望's avatar
朔-望 已提交
307
 private:
W
wangliu 已提交
308
  vector<LoDTensor *> inputs_;
309 310
  Tensor *out_;
  int axis_;
朔-望's avatar
朔-望 已提交
311 312
};

E
eclipsess 已提交
313
class LrnParam : public OpParam {
朔-望's avatar
朔-望 已提交
314
 public:
315 316 317
  LrnParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
           const framework::AttributeMap &attrs,
           const framework::Scope &scope) {
W
wangliu 已提交
318 319 320
    input_x_ = InputXFrom<framework::LoDTensor>(inputs, scope);
    out_ = OutFrom<framework::LoDTensor>(outputs, scope);
    mid_out_ = MidOutFrom<framework::LoDTensor>(outputs, scope);
321 322 323 324
    n_ = GetAttr<int>("n", attrs);
    alpha_ = GetAttr<float>("alpha", attrs);
    beta_ = GetAttr<float>("beta", attrs);
    k_ = GetAttr<float>("k", attrs);
W
wangliu 已提交
325
    data_format_ = GetAttr<string>("data_format", attrs);
326
  }
E
eclipsess 已提交
327

328
  const Tensor *InputX() const { return input_x_; }
E
eclipsess 已提交
329

330
  Tensor *Out() const { return out_; }
E
eclipsess 已提交
331

332
  Tensor *MidOut() const { return mid_out_; }
E
eclipsess 已提交
333

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

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

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

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

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

朔-望's avatar
朔-望 已提交
344
 private:
345 346 347 348 349 350 351
  Tensor *input_x_;
  Tensor *out_;
  Tensor *mid_out_;
  int n_;
  float alpha_;
  float beta_;
  float k_;
W
wangliu 已提交
352
  string data_format_;
E
eclipsess 已提交
353
};
E
eclipsess 已提交
354
class BatchNormParam : OpParam {
朔-望's avatar
朔-望 已提交
355
 public:
356 357 358
  BatchNormParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
                 const framework::AttributeMap &attrs,
                 const framework::Scope &scope) {
W
wangliu 已提交
359 360 361 362 363 364
    input_x_ = InputXFrom<framework::LoDTensor>(inputs, scope);
    output_y_ = OutputYFrom<framework::LoDTensor>(outputs, scope);
    input_bias_ = InputBiasFrom<framework::LoDTensor>(inputs, scope);
    input_mean_ = InputMeanFrom<framework::LoDTensor>(inputs, scope);
    input_scale_ = InputScaleFrom<framework::LoDTensor>(inputs, scope);
    input_variance_ = InputVarianceFrom<framework::LoDTensor>(inputs, scope);
365 366 367 368
    epsilon_ = GetAttr<float>("epsilon", attrs);
    momentum_ = GetAttr<float>("momentum", attrs);
    is_test_ = GetAttr<bool>("is_test", attrs);
  }
E
eclipsess 已提交
369

370
  const Tensor *InputX() const { return input_x_; }
E
eclipsess 已提交
371

372
  Tensor *OutputY() const { return output_y_; }
E
eclipsess 已提交
373

374
  const Tensor *InputBias() const { return input_bias_; }
E
eclipsess 已提交
375

376
  const Tensor *InputMean() const { return input_mean_; }
E
eclipsess 已提交
377

378
  const Tensor *InputScale() const { return input_scale_; }
E
eclipsess 已提交
379

380
  const Tensor *InputVariance() const { return input_variance_; }
E
eclipsess 已提交
381

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

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

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

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

朔-望's avatar
朔-望 已提交
390
 private:
391 392 393 394 395 396 397 398 399
  Tensor *input_x_;
  Tensor *output_y_;
  Tensor *input_bias_;
  Tensor *input_mean_;
  Tensor *input_scale_;
  Tensor *input_variance_;
  float epsilon_;
  float momentum_;
  bool is_test_;
W
wangliu 已提交
400
  string data_format_;
E
eclipsess 已提交
401
};
402
class PoolParam : public OpParam {
朔-望's avatar
朔-望 已提交
403
 public:
404 405 406
  PoolParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
            const framework::AttributeMap &attrs,
            const framework::Scope &scope) {
W
wangliu 已提交
407
    input_ = InputXFrom<framework::LoDTensor>(inputs, scope);
408

W
wangliu 已提交
409
    output_ = OutFrom<framework::LoDTensor>(outputs, scope);
W
wangliu 已提交
410 411 412 413
    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);
414 415 416
    ceil_mode_ = GetAttr<bool>("ceil_mode", attrs);
    gloabal_pooling_ = GetAttr<bool>("global_pooling", attrs);
  }
417

418
  const Tensor *Input() const { return input_; }
419

420
  Tensor *Output() const { return output_; }
421

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

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

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

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

430
  bool isCeilMode() const { return ceil_mode_; }
431

432
  bool isGlobalPooling() const { return gloabal_pooling_; }
433

朔-望's avatar
朔-望 已提交
434
 private:
435 436
  Tensor *input_;
  Tensor *output_;
W
wangliu 已提交
437 438 439 440
  string pooling_type_;
  vector<int> ksize_;
  vector<int> strides_;
  vector<int> paddings_;
441 442
  bool ceil_mode_;
  bool gloabal_pooling_ = false;
443 444
};

E
eclipsess 已提交
445 446 447 448 449
class PriorBoxParam : public OpParam {
 public:
  PriorBoxParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
                const framework::AttributeMap &attrs,
                const framework::Scope &scope) {
W
wangliu 已提交
450 451 452 453 454
    input_ = InputFrom<framework::LoDTensor>(inputs, scope);
    input_image_ = InputImageFrom<framework::LoDTensor>(inputs, scope);
    output_boxes_ = OutputBoxesFrom<framework::LoDTensor>(outputs, scope);
    output_variances_ =
        OutputVariancesFrom<framework::LoDTensor>(outputs, scope);
W
wangliu 已提交
455 456 457 458
    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 已提交
459 460 461 462 463 464 465 466 467 468 469 470 471 472
    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);
  }
  const Tensor *Input() const { return input_; }

  const Tensor *InputImage() const { return input_image_; }

  Tensor *OutputBoxes() const { return output_boxes_; }

  Tensor *OutputVariances() const { return output_variances_; }

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

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

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

W
wangliu 已提交
479
  const vector<float> &Variances() const { return variances_; }
E
eclipsess 已提交
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495

  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:
  Tensor *input_;
  Tensor *input_image_;
  Tensor *output_boxes_;
  Tensor *output_variances_;
W
wangliu 已提交
496 497 498 499
  vector<float> min_sizes_;
  vector<float> max_sizes_;
  vector<float> aspect_ratios_;
  vector<float> variances_;
E
eclipsess 已提交
500 501 502 503 504 505
  bool flip_;
  bool clip_;
  float step_w_;
  float step_h_;
  float offset_;
};
E
eclipsess 已提交
506 507 508 509 510 511

class BoxCoderParam : public OpParam {
 public:
  BoxCoderParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
                const framework::AttributeMap &attrs,
                const framework::Scope &scope) {
W
wangliu 已提交
512 513 514 515 516
    input_priorbox_ = InputPriorBoxFrom<framework::LoDTensor>(inputs, scope);
    input_priorboxvar_ =
        InputPriorBoxVarFrom<framework::LoDTensor>(inputs, scope);
    input_targetbox_ = InputTargetBoxFrom<framework::LoDTensor>(inputs, scope);
    output_box_ = OutputBoxFrom<framework::LoDTensor>(outputs, scope);
E
eclipsess 已提交
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
    code_type_ = GetAttr<std::string>("code_type", attrs);
  }
  const Tensor *InputPriorBox() const { return input_priorbox_; }

  const Tensor *InputPriorBoxVar() const { return input_priorboxvar_; }

  const Tensor *InputTargetBox() const { return input_targetbox_; }

  Tensor *OutputBox() const { return output_box_; }

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

 private:
  Tensor *input_priorbox_;
  Tensor *input_priorboxvar_;
  Tensor *input_targetbox_;
  Tensor *output_box_;
  std::string code_type_;
};
W
wangliu 已提交
536 537 538 539 540 541

class SoftmaxParam : public OpParam {
 public:
  SoftmaxParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
               const framework::AttributeMap &attrs,
               const framework::Scope &scope) {
W
wangliu 已提交
542 543
    input_x_ = InputXFrom<framework::LoDTensor>(inputs, scope);
    out_ = OutFrom<framework::LoDTensor>(outputs, scope);
W
wangliu 已提交
544 545 546 547 548 549 550 551
  }
  const Tensor *InputX() const { return input_x_; }
  Tensor *Out() const { return out_; }

 private:
  Tensor *input_x_;
  Tensor *out_;
};
W
wangliu 已提交
552 553 554 555 556 557

class SigmoidParam : public OpParam {
 public:
  SigmoidParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
               const framework::AttributeMap &attrs,
               const framework::Scope &scope) {
W
wangliu 已提交
558 559
    input_x_ = InputXFrom<framework::LoDTensor>(inputs, scope);
    out_ = OutFrom<framework::LoDTensor>(outputs, scope);
W
wangliu 已提交
560 561 562 563 564 565 566 567
  }
  const Tensor *InputX() const { return input_x_; }
  Tensor *Out() const { return out_; }

 private:
  Tensor *input_x_;
  Tensor *out_;
};
E
eclipsess 已提交
568 569 570 571 572
class MultiClassNMSParam : public OpParam {
 public:
  MultiClassNMSParam(const VariableNameMap &inputs,
                     const VariableNameMap &outputs, const AttributeMap &attrs,
                     const Scope &scope) {
W
wangliu 已提交
573 574 575
    input_bboxes_ = InputBBoxesFrom<LoDTensor>(inputs, scope);
    input_scores_ = InputScoresFrom<LoDTensor>(inputs, scope);
    out_ = OutFrom<LoDTensor>(outputs, scope);
E
eclipsess 已提交
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612
    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);
  }

  const Tensor *InputBBoxes() const { return input_bboxes_; }

  const Tensor *InputScores() const { return input_scores_; }

  Tensor *Out() const { return out_; }

  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:
  Tensor *input_bboxes_;
  Tensor *input_scores_;
  Tensor *out_;
  int background_label_;
  int nms_top_k_;
  int keep_top_k_;
  float nms_threshold_;
  float nms_eta_;
  float score_threshold_;
};
W
wangliu 已提交
613

L
liuruilong 已提交
614 615 616
class FeedParam : public OpParam {
 public:
  FeedParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
W
wangliu 已提交
617 618 619 620 621
            const framework::AttributeMap &attrs, framework::Scope &scope) {
    input_x_ = InputXFrom<framework::LoDTensor>(inputs, scope);
    out_ = OutFrom<framework::LoDTensor>(outputs, scope);
    auto var = scope.Var("batch_size");
    batch_size = var->GetValue<int>();
L
liuruilong 已提交
622 623 624
  }
  const Tensor *InputX() const { return input_x_; }
  Tensor *Out() const { return out_; }
W
wangliu 已提交
625
  const int BatchSize() const { return batch_size; }
L
liuruilong 已提交
626

L
liuruilong 已提交
627 628 629
 private:
  Tensor *input_x_;
  Tensor *out_;
W
wangliu 已提交
630
  int batch_size;
L
liuruilong 已提交
631 632 633 634 635
};

class FetchParam : public OpParam {
 public:
  FetchParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
L
liuruilong 已提交
636 637
             const framework::AttributeMap &attrs,
             const framework::Scope &scope) {
W
wangliu 已提交
638 639
    input_x_ = InputXFrom<framework::LoDTensor>(inputs, scope);
    out_ = OutFrom<framework::LoDTensor>(outputs, scope);
L
liuruilong 已提交
640 641 642
  }
  const Tensor *InputX() const { return input_x_; }
  Tensor *Out() const { return out_; }
L
liuruilong 已提交
643

L
liuruilong 已提交
644 645 646 647 648
 private:
  Tensor *input_x_;
  Tensor *out_;
};

E
eclipsess 已提交
649 650 651 652
class TransposeParam : public OpParam {
 public:
  TransposeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
                 const AttributeMap &attrs, const Scope &scope) {
W
wangliu 已提交
653 654
    input_x_ = InputXFrom<LoDTensor>(inputs, scope);
    out_ = OutFrom<LoDTensor>(outputs, scope);
E
eclipsess 已提交
655 656 657 658 659 660 661 662 663 664 665 666 667 668
    axis_ = GetAttr<vector<int>>("axis", attrs);
  }

  const Tensor *InputX() const { return input_x_; }

  Tensor *Out() const { return out_; }

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

 private:
  Tensor *input_x_;
  Tensor *out_;
  vector<int> axis_;
};
E
eclipsess 已提交
669

E
eclipsess 已提交
670 671 672 673
class ReshapeParam : public OpParam {
 public:
  ReshapeParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
               const AttributeMap &attrs, const Scope &scope) {
W
wangliu 已提交
674 675 676
    input_x_ = InputXFrom<LoDTensor>(inputs, scope);
    input_shape_ = InputShapeFrom<LoDTensor>(inputs, scope);
    out_ = OutFrom<LoDTensor>(outputs, scope);
E
eclipsess 已提交
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
    shape_ = GetAttr<vector<int>>("shape", attrs);
    inplace_ = GetAttr<bool>("inplace", attrs);
  }

  const Tensor *InputX() const { return input_x_; }

  const Tensor *InputShape() const { return input_shape_; }

  Tensor *Out() const { return out_; }

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

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

 private:
  Tensor *input_x_;
  Tensor *input_shape_;
  Tensor *out_;
  vector<int> shape_;
  bool inplace_;
};
E
eclipsess 已提交
698

L
liuruilong 已提交
699 700 701
/*
 * @b op 层实例化好这个 param 传递给 kernel 层使用
 * */
E
eclipsess 已提交
702 703 704 705
class ReluParam : public OpParam {
 public:
  ReluParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
            const AttributeMap &attrs, const Scope &scope) {
W
wangliu 已提交
706 707
    input_x_ = InputXFrom<LoDTensor>(inputs, scope);
    out_ = OutFrom<LoDTensor>(outputs, scope);
E
eclipsess 已提交
708 709 710 711 712 713 714 715 716 717 718
  }

  const Tensor *InputX() const { return input_x_; }

  Tensor *Out() const { return out_; }

 private:
  Tensor *input_x_;
  Tensor *out_;
};

E
eclipsess 已提交
719 720 721 722
class FushionFcParam : public OpParam {
 public:
  FushionFcParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
                 const AttributeMap &attrs, const Scope &scope) {
E
eclipsess 已提交
723 724 725 726
    input_x_ = InputXFrom<LoDTensor>(inputs, scope);
    input_y_ = InputYFrom<LoDTensor>(inputs, scope);
    input_z_ = InputZFrom<LoDTensor>(inputs, scope);
    out_ = OutFrom<LoDTensor>(outputs, scope);
E
eclipsess 已提交
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
    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);
  }
  const Tensor *InputX() const { return input_x_; }

  const Tensor *InputY() const { return input_y_; }

  const Tensor *InputZ() const { return input_z_; }

  Tensor *Out() const { return out_; }

  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:
  Tensor *input_x_;
  Tensor *input_y_;
  Tensor *input_z_;
  Tensor *out_;
  int x_num_col_dims_;
  int y_num_col_dims_;
  int axis_;
};

朔-望's avatar
朔-望 已提交
755 756
}  // namespace operators
}  // namespace paddle_mobile