op_param.h 17.3 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 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
  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);
  }

  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 已提交
71 72 73 74
  template <typename T>
  static T *InputImageFrom(const VariableNameMap &inputs, const Scope &scope) {
    return GetVarValue<T>("Image", inputs, scope);
  }
E
eclipsess 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
  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);
  }
91 92

  template <typename T>
W
wangliu 已提交
93 94
  static vector<T *> InputMultiFrom(const VariableNameMap &inputs,
                                    const Scope &scope) {
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
    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 已提交
113 114 115 116 117 118
  template <typename T>
  static T *OutputBoxesFrom(const VariableNameMap &outputs,
                            const Scope &scope) {
    return GetVarValue<T>("Boxes", outputs, scope);
  }

E
eclipsess 已提交
119 120 121 122 123
  template <typename T>
  static T *OutputBoxFrom(const VariableNameMap &outputs, const Scope &scope) {
    return GetVarValue<T>("OutputBox", outputs, scope);
  }

E
eclipsess 已提交
124 125 126 127 128 129
  template <typename T>
  static T *OutputVariancesFrom(const VariableNameMap &outputs,
                                const Scope &scope) {
    return GetVarValue<T>("Variances", outputs, scope);
  }

130 131 132 133 134 135 136 137 138 139 140
  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 已提交
141
  static const T GetAttr(const string &key, const AttributeMap &map) {
142 143 144 145
    return ((Attribute)map.at(key)).Get<T>();
  }

  template <typename T>
W
wangliu 已提交
146
  static T *GetVarValue(const string &key, const VariableNameMap &var_map,
147 148 149 150 151 152 153 154 155
                        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
朔-望 已提交
156
    }
157
  }
朔-望's avatar
朔-望 已提交
158

159
  template <typename T>
W
wangliu 已提交
160 161 162
  static vector<T *> GetMultiVarValue(const string &key,
                                      const VariableNameMap &var_map,
                                      const Scope &scope) {
163 164
    auto var_vecs = var_map.at(key);
    assert(var_vecs.size() > 1);
W
wangliu 已提交
165
    vector<T *> var_res;
166 167 168
    for (auto &var_vec : var_vecs) {
      auto var = scope.FindVar(var_vec);
      var_res.push_back(var->GetMutable<T>());
朔-望's avatar
朔-望 已提交
169
    }
170 171
    return var_res;
  }
朔-望's avatar
朔-望 已提交
172 173 174
};

class ConvParam : OpParam {
朔-望's avatar
朔-望 已提交
175
 public:
176 177 178
  ConvParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
            const framework::AttributeMap &attrs,
            const framework::Scope &scope) {
W
wangliu 已提交
179 180 181 182 183 184
    filter_ = FilterFrom<LoDTensor>(inputs, scope);
    input_ = InputFrom<Tensor>(inputs, scope);
    output_ = OutputFrom<Tensor>(outputs, scope);
    strides_ = GetAttr<vector<int>>("strides", attrs);
    paddings_ = GetAttr<vector<int>>("paddings", attrs);
    dilations_ = GetAttr<vector<int>>("dilations", attrs);
185 186
    groups = GetAttr<int>("groups", attrs);
  }
朔-望's avatar
朔-望 已提交
187

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

190
  const LoDTensor *Filter() const { return filter_; }
朔-望's avatar
朔-望 已提交
191

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

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

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

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

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

朔-望's avatar
朔-望 已提交
202
 private:
203 204 205
  Tensor *input_;
  Tensor *output_;
  LoDTensor *filter_;
W
wangliu 已提交
206 207 208
  vector<int> strides_;
  vector<int> paddings_;
  vector<int> dilations_;
209
  int groups;
朔-望's avatar
朔-望 已提交
210 211 212 213 214
};

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

class ElementwiseAddParam : OpParam {
朔-望's avatar
朔-望 已提交
215
 public:
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
  ElementwiseAddParam(const VariableNameMap &inputs,
                      const VariableNameMap &outputs,
                      const framework::AttributeMap &attrs,
                      const framework::Scope &scope) {
    input_x_ = InputXFrom<framework::Tensor>(inputs, scope);
    input_y_ = InputYFrom<framework::Tensor>(inputs, scope);
    out_ = OutFrom<framework::Tensor>(outputs, scope);
    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
朔-望 已提交
234
 private:
235 236 237 238
  Tensor *input_x_;
  Tensor *input_y_;
  Tensor *out_;
  int axis_;
朔-望's avatar
朔-望 已提交
239 240 241
};

class MulParam : OpParam {
朔-望's avatar
朔-望 已提交
242
 public:
243 244 245 246 247 248 249 250 251
  MulParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
           const framework::AttributeMap &attrs,
           const framework::Scope &scope) {
    input_x_ = InputXFrom<framework::Tensor>(inputs, scope);
    input_y_ = InputYFrom<framework::Tensor>(inputs, scope);
    out_ = OutFrom<framework::Tensor>(outputs, scope);
    x_num_col_dims_ = GetAttr<int>("x_num_col_dims", attrs);
    y_num_col_dims_ = GetAttr<int>("y_num_col_dims", attrs);
  }
朔-望's avatar
朔-望 已提交
252

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

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

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

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

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

朔-望's avatar
朔-望 已提交
263
 private:
264 265 266 267 268
  Tensor *input_x_;
  Tensor *input_y_;
  Tensor *out_;
  int x_num_col_dims_;
  int y_num_col_dims_;
朔-望's avatar
朔-望 已提交
269 270 271
};

class ConcatParam : public OpParam {
朔-望's avatar
朔-望 已提交
272
 public:
273 274 275 276 277 278 279
  ConcatParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
              const framework::AttributeMap &attrs,
              const framework::Scope &scope) {
    inputs_ = InputMultiFrom<framework::Tensor>(inputs, scope);
    out_ = OutFrom<framework::Tensor>(outputs, scope);
    axis_ = GetAttr<int>("axis", attrs);
  }
朔-望's avatar
朔-望 已提交
280

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

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

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

朔-望's avatar
朔-望 已提交
287
 private:
W
wangliu 已提交
288
  vector<Tensor *> inputs_;
289 290
  Tensor *out_;
  int axis_;
朔-望's avatar
朔-望 已提交
291 292
};

E
eclipsess 已提交
293
class LrnParam : public OpParam {
朔-望's avatar
朔-望 已提交
294
 public:
295 296 297 298 299 300 301 302 303 304
  LrnParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
           const framework::AttributeMap &attrs,
           const framework::Scope &scope) {
    input_x_ = InputXFrom<framework::Tensor>(inputs, scope);
    out_ = OutFrom<framework::Tensor>(outputs, scope);
    mid_out_ = MidOutFrom<framework::Tensor>(outputs, scope);
    n_ = GetAttr<int>("n", attrs);
    alpha_ = GetAttr<float>("alpha", attrs);
    beta_ = GetAttr<float>("beta", attrs);
    k_ = GetAttr<float>("k", attrs);
W
wangliu 已提交
305
    data_format_ = GetAttr<string>("data_format", attrs);
306
  }
E
eclipsess 已提交
307

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

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

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

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

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

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

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

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

朔-望's avatar
朔-望 已提交
324
 private:
325 326 327 328 329 330 331
  Tensor *input_x_;
  Tensor *out_;
  Tensor *mid_out_;
  int n_;
  float alpha_;
  float beta_;
  float k_;
W
wangliu 已提交
332
  string data_format_;
E
eclipsess 已提交
333
};
E
eclipsess 已提交
334
class BatchNormParam : OpParam {
朔-望's avatar
朔-望 已提交
335
 public:
336 337 338 339 340 341 342 343 344 345 346 347 348
  BatchNormParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
                 const framework::AttributeMap &attrs,
                 const framework::Scope &scope) {
    input_x_ = InputXFrom<framework::Tensor>(inputs, scope);
    output_y_ = OutputYFrom<framework::Tensor>(outputs, scope);
    input_bias_ = InputBiasFrom<framework::Tensor>(inputs, scope);
    input_mean_ = InputMeanFrom<framework::Tensor>(inputs, scope);
    input_scale_ = InputScaleFrom<framework::Tensor>(inputs, scope);
    input_variance_ = InputVarianceFrom<framework::Tensor>(inputs, scope);
    epsilon_ = GetAttr<float>("epsilon", attrs);
    momentum_ = GetAttr<float>("momentum", attrs);
    is_test_ = GetAttr<bool>("is_test", attrs);
  }
E
eclipsess 已提交
349

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

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

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

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

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

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

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

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

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

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

朔-望's avatar
朔-望 已提交
370
 private:
371 372 373 374 375 376 377 378 379
  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 已提交
380
  string data_format_;
E
eclipsess 已提交
381
};
382
class PoolParam : public OpParam {
朔-望's avatar
朔-望 已提交
383
 public:
384 385 386 387 388 389
  PoolParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
            const framework::AttributeMap &attrs,
            const framework::Scope &scope) {
    input_ = InputXFrom<framework::Tensor>(inputs, scope);

    output_ = OutFrom<framework::Tensor>(outputs, scope);
W
wangliu 已提交
390 391 392 393
    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);
394 395 396
    ceil_mode_ = GetAttr<bool>("ceil_mode", attrs);
    gloabal_pooling_ = GetAttr<bool>("global_pooling", attrs);
  }
397

398
  const Tensor *Input() const { return input_; }
399

400
  Tensor *Output() const { return output_; }
401

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

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

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

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

410
  bool isCeilMode() const { return ceil_mode_; }
411

412
  bool isGlobalPooling() const { return gloabal_pooling_; }
413

朔-望's avatar
朔-望 已提交
414
 private:
415 416
  Tensor *input_;
  Tensor *output_;
W
wangliu 已提交
417 418 419 420
  string pooling_type_;
  vector<int> ksize_;
  vector<int> strides_;
  vector<int> paddings_;
421 422
  bool ceil_mode_;
  bool gloabal_pooling_ = false;
423 424
};

E
eclipsess 已提交
425 426 427 428 429 430 431 432 433
class PriorBoxParam : public OpParam {
 public:
  PriorBoxParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
                const framework::AttributeMap &attrs,
                const framework::Scope &scope) {
    input_ = InputFrom<framework::Tensor>(inputs, scope);
    input_image_ = InputImageFrom<framework::Tensor>(inputs, scope);
    output_boxes_ = OutputBoxesFrom<framework::Tensor>(outputs, scope);
    output_variances_ = OutputVariancesFrom<framework::Tensor>(outputs, scope);
W
wangliu 已提交
434 435 436 437
    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 已提交
438 439 440 441 442 443 444 445 446 447 448 449 450 451
    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 已提交
452
  const vector<float> &MinSizes() const { return min_sizes_; }
E
eclipsess 已提交
453

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

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

W
wangliu 已提交
458
  const vector<float> &Variances() const { return variances_; }
E
eclipsess 已提交
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474

  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 已提交
475 476 477 478
  vector<float> min_sizes_;
  vector<float> max_sizes_;
  vector<float> aspect_ratios_;
  vector<float> variances_;
E
eclipsess 已提交
479 480 481 482 483 484
  bool flip_;
  bool clip_;
  float step_w_;
  float step_h_;
  float offset_;
};
E
eclipsess 已提交
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513

class BoxCoderParam : public OpParam {
 public:
  BoxCoderParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
                const framework::AttributeMap &attrs,
                const framework::Scope &scope) {
    input_priorbox_ = InputPriorBoxFrom<framework::Tensor>(inputs, scope);
    input_priorboxvar_ = InputPriorBoxVarFrom<framework::Tensor>(inputs, scope);
    input_targetbox_ = InputTargetBoxFrom<framework::Tensor>(inputs, scope);
    output_box_ = OutputBoxFrom<framework::Tensor>(outputs, scope);
    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 已提交
514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530

class SoftmaxParam : public OpParam {
 public:
  SoftmaxParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
               const framework::AttributeMap &attrs,
               const framework::Scope &scope) {
    input_x_ = InputXFrom<framework::Tensor>(inputs, scope);
    out_ = OutFrom<framework::Tensor>(outputs, scope);
  }
  const Tensor *InputX() const { return input_x_; }
  Tensor *Out() const { return out_; }

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

L
liuruilong 已提交
531 532 533
class FeedParam : public OpParam {
 public:
  FeedParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
L
liuruilong 已提交
534 535
            const framework::AttributeMap &attrs,
            const framework::Scope &scope) {
L
liuruilong 已提交
536 537 538 539 540
    input_x_ = InputXFrom<framework::Tensor>(inputs, scope);
    out_ = OutFrom<framework::Tensor>(outputs, scope);
  }
  const Tensor *InputX() const { return input_x_; }
  Tensor *Out() const { return out_; }
L
liuruilong 已提交
541

L
liuruilong 已提交
542 543 544 545 546 547 548 549
 private:
  Tensor *input_x_;
  Tensor *out_;
};

class FetchParam : public OpParam {
 public:
  FetchParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
L
liuruilong 已提交
550 551
             const framework::AttributeMap &attrs,
             const framework::Scope &scope) {
L
liuruilong 已提交
552 553 554 555 556
    input_x_ = InputXFrom<framework::Tensor>(inputs, scope);
    out_ = OutFrom<framework::Tensor>(outputs, scope);
  }
  const Tensor *InputX() const { return input_x_; }
  Tensor *Out() const { return out_; }
L
liuruilong 已提交
557

L
liuruilong 已提交
558 559 560 561 562
 private:
  Tensor *input_x_;
  Tensor *out_;
};

朔-望's avatar
朔-望 已提交
563 564
}  // namespace operators
}  // namespace paddle_mobile