operator.h 15.1 KB
Newer Older
Q
Qiao Longfei 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.

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. */

#pragma once

D
dongzhihong 已提交
17
#include <algorithm>
Q
Qiao Longfei 已提交
18 19 20 21
#include <string>
#include <unordered_map>
#include <vector>

Y
Yu Yang 已提交
22
#include "op_info.h"
Y
Yi Wang 已提交
23
#include "paddle/framework/attribute.h"
Y
Yu Yang 已提交
24
#include "paddle/framework/framework.pb.h"
25
#include "paddle/framework/lod_tensor.h"
Q
qijun 已提交
26 27 28 29
#include "paddle/framework/scope.h"
#include "paddle/framework/tensor.h"
#include "paddle/platform/device_context.h"
#include "paddle/platform/place.h"
Y
Yu Yang 已提交
30
#include "paddle/platform/variant.h"
Q
qijun 已提交
31
#include "paddle/utils/Error.h"
Q
Qiao Longfei 已提交
32 33 34 35

namespace paddle {
namespace framework {

36
/// If a variable is a empty variable, that name will be used.
37
constexpr char kEmptyVarName[] = "@EMPTY@";
38 39 40

/// If a variable is a temporary variable, that name will be set in Python,
/// but it will be convert to a unique name in scope after OpCreator.
41
constexpr char kTempVarName[] = "@TEMP@";
42 43 44 45

/// If a variable's name has a certain suffix, it means that the
/// variable is the gradient of another varibale.
/// e.g. Variable "x@GRAD" is the gradient of varibale "x".
46
constexpr char kGradVarSuffix[] = "@GRAD";
47 48

/// Variables with this suffix are supposed to be filled up with zeros.
49
constexpr char kZeroVarSuffix[] = "@ZERO";
50 51 52 53 54

inline std::string GradVarName(const std::string& var_name) {
  return var_name + kGradVarSuffix;
}

Q
Qiao Longfei 已提交
55
class OperatorBase;
56 57
class InferShapeContext;
class ExecutionContext;
58

Q
Qiao Longfei 已提交
59 60 61 62 63 64 65 66
/**
 * OperatorBase has the basic element that Net will call to do computation.
 * Only CreateOperator from OpRegistry will new Operator directly. User
 * should always construct a proto message OpDesc and call
 * OpRegistry::CreateOp(op_desc) to get an Operator instance.
 */
class OperatorBase {
 public:
Y
Yu Yang 已提交
67 68
  OperatorBase(const std::string& type, const VariableNameMap& inputs,
               const VariableNameMap& outputs, const AttributeMap& attrs);
69

Q
Qiao Longfei 已提交
70 71 72
  virtual ~OperatorBase() {}

  template <typename T>
Y
Yu Yang 已提交
73
  inline const T& Attr(const std::string& name) const {
Q
Qiao Longfei 已提交
74 75 76 77 78
    PADDLE_ENFORCE(attrs_.count(name) != 0, "%s should be in AttributeMap",
                   name);
    return boost::get<T>(attrs_.at(name));
  }

79
  virtual std::string DebugString() const;
Q
Qiao Longfei 已提交
80 81 82

  /// InferShape infer the size of Variables used by this Operator with
  /// information inside scope
Y
Yu Yang 已提交
83
  virtual void InferShape(const Scope& scope) const = 0;
Q
Qiao Longfei 已提交
84 85

  /// Net will call this function to Run an op.
Y
Yu Yang 已提交
86
  virtual void Run(const Scope& scope,
Y
Yu Yang 已提交
87 88
                   const platform::DeviceContext& dev_ctx) const = 0;

Y
Yu Yang 已提交
89 90
  virtual bool IsNetOp() const { return false; }

91 92
  virtual bool SupportGPU() const { return false; }

D
dongzhihong 已提交
93 94 95
  /// rename inputs outputs name
  void Rename(const std::string& old_name, const std::string& new_name);

Y
Yu Yang 已提交
96 97
  const VariableNameMap& Inputs() const { return inputs_; }
  const VariableNameMap& Outputs() const { return outputs_; }
98

Y
Yu Yang 已提交
99
  //! Get a input with argument's name described in `op_proto`
100
  std::string Input(const std::string& name) const;
Y
Yu Yang 已提交
101
  //! Get a input which has multiple variables.
Y
Yu Yang 已提交
102
  const std::vector<std::string>& Inputs(const std::string& name) const;
Y
Yi Wang 已提交
103

Q
qijun 已提交
104 105
  std::vector<std::string> InputVars() const;

Y
Yu Yang 已提交
106
  //! Get a output with argument's name described in `op_proto`
107
  std::string Output(const std::string& name) const;
Y
Yu Yang 已提交
108 109
  //! Get an output which has multiple variables.
  //! TODO add a vector_view to prevent memory copy.
Y
Yu Yang 已提交
110
  const std::vector<std::string>& Outputs(const std::string& name) const;
Y
Yan Chunwei 已提交
111

Y
Yu Yang 已提交
112
  virtual std::vector<std::string> OutputVars(bool has_intermediate) const;
113

Q
qiaolongfei 已提交
114
  const std::string& Type() const { return type_; }
Q
qiaolongfei 已提交
115
  void SetType(const std::string& type) { type_ = type; }
Y
Yi Wang 已提交
116 117
  const AttributeMap& Attrs() const { return attrs_; }

Y
Yu Yang 已提交
118
  // Return a new operator instance, which is as same as this.
Y
Yu Yang 已提交
119 120
  // Use unique_ptr to prevent caller forget to delete this pointer.
  virtual std::unique_ptr<OperatorBase> Clone() const = 0;
Y
Yu Yang 已提交
121

Q
qiaolongfei 已提交
122
 protected:
Q
Qiao Longfei 已提交
123
  std::string type_;
D
dongzhihong 已提交
124
  // NOTE: in case of OpGrad, inputs_ contains:
Y
Yu Yang 已提交
125
  // I (Inputs)opear
D
dongzhihong 已提交
126 127
  // O (Outputs)
  // OG (Output Gradients)
Y
Yu Yang 已提交
128
  VariableNameMap inputs_;
Y
Yu Yang 已提交
129

D
dongzhihong 已提交
130 131
  // NOTE: in case of OpGrad, outputs_ contains
  // IG (Inputs Gradients)
Y
Yu Yang 已提交
132
  VariableNameMap outputs_;
Q
Qiao Longfei 已提交
133
  AttributeMap attrs_;
134 135 136 137

 private:
  void GenerateTemporaryNames();
  void CheckAllInputOutputSet() const;
Y
Yan Chunwei 已提交
138 139
};

Y
Yu Yang 已提交
140 141
// Macro for define a clone method.
// If you are writing an kernel operator, `Clone` will be defined when you
142
// register it. i.e. `Clone` method is not needed to define by yourself.
Y
Yu Yang 已提交
143
#define DEFINE_OP_CLONE_METHOD(cls)                       \
Y
Yu Yang 已提交
144
  std::unique_ptr<OperatorBase> Clone() const final {     \
Y
Yu Yang 已提交
145
    return std::unique_ptr<OperatorBase>(new cls(*this)); \
Y
Yu Yang 已提交
146
  }
Y
Yu Yang 已提交
147

Y
Yu Yang 已提交
148 149 150 151
// Macro for define a default constructor for Operator.
// You can also use
//   using PARENT_CLASS::PARENT_CLASS;
// to use parent's constructor.
Y
Yu Yang 已提交
152 153
#define DEFINE_OP_CONSTRUCTOR(cls, parent_cls)             \
  cls(const std::string& type,                             \
Y
Yu Yang 已提交
154 155 156
      const ::paddle::framework::VariableNameMap& inputs,  \
      const ::paddle::framework::VariableNameMap& outputs, \
      const paddle::framework::AttributeMap& attrs)        \
Y
Yu Yang 已提交
157
      : parent_cls(type, inputs, outputs, attrs) {}
Y
Yu Yang 已提交
158

159 160
class NOP : public OperatorBase {
 public:
161
  using OperatorBase::OperatorBase;
162 163 164
  void InferShape(const Scope& scope) const override {}
  void Run(const Scope& scope,
           const platform::DeviceContext& dev_ctx) const override {}
165 166 167
  std::unique_ptr<OperatorBase> Clone() const override {
    return std::unique_ptr<OperatorBase>(new NOP(*this));
  }
168 169
};

170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
// this class not only make proto but also init attribute checkers.
class OpProtoAndCheckerMaker {
 public:
  OpProtoAndCheckerMaker(OpProto* proto, OpAttrChecker* op_checker)
      : proto_(proto), op_checker_(op_checker) {}

  ~OpProtoAndCheckerMaker() {
    PADDLE_ENFORCE(validated_, "should call Validate after build");
  }

  void Validate();

 protected:
  struct VariableBuilder {
    OpProto::Var* var_;

    VariableBuilder& AsDuplicable() {
      var_->set_duplicable(true);
      return *this;
    }

    VariableBuilder& AsIntermediate() {
      var_->set_intermediate(true);
      return *this;
    }

196 197
    VariableBuilder& NotInGradient() {
      var_->set_not_in_gradient(true);
198 199 200 201 202 203 204 205 206 207 208 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
      return *this;
    }
  };

  VariableBuilder AddInput(const std::string& name, const std::string& comment);

  VariableBuilder AddOutput(const std::string& name,
                            const std::string& comment);

  template <typename T>
  TypedAttrChecker<T>& AddAttr(const std::string& name,
                               const std::string& comment,
                               bool generated = false) {
    auto* attr = proto_->add_attrs();
    attr->set_name(name);
    attr->set_comment(comment);
    attr->set_generated(generated);
    attr->set_type(AttrTypeID<T>());
    return op_checker_->AddAttrChecker<T>(name);
  }

  void AddComment(const std::string& comment) { proto_->set_comment(comment); }

 private:
  void CheckNoDuplicatedInOutAttrs();

  OpProto* proto_;
  OpAttrChecker* op_checker_;
  bool validated_{false};
};

class NOPMaker : public OpProtoAndCheckerMaker {
 public:
  NOPMaker(framework::OpProto* proto, framework::OpAttrChecker* op_checker)
      : OpProtoAndCheckerMaker(proto, op_checker) {}
};

235
class InferShapeContext {
Y
Yan Chunwei 已提交
236
 public:
237 238
  InferShapeContext(const OperatorBase& op, const Scope& scope)
      : op_(op), scope_(scope) {}
239

Q
qiaolongfei 已提交
240 241 242 243
  const OperatorBase& op() const { return op_; }

  const Scope& scope() const { return scope_; }

Q
qiaolongfei 已提交
244
  template <typename T>
Y
Yu Yang 已提交
245 246
  inline const T& Attr(const std::string& name) const {
    return op_.Attr<T>(name);
Q
qiaolongfei 已提交
247 248
  }

Y
Yu Yang 已提交
249
  size_t InputSize(const std::string& name) const {
Y
Yu Yang 已提交
250
    return op_.Inputs(name).size();
Y
Yan Chunwei 已提交
251 252
  }

Y
Yu Yang 已提交
253
  size_t OutputSize(const std::string& name) const {
Y
Yu Yang 已提交
254
    return op_.Outputs(name).size();
Y
Yan Chunwei 已提交
255 256
  }

257
  const Variable* InputVar(const std::string& name) const {
258
    auto ipt = op_.Input(name);
Y
Yu Yang 已提交
259
    return ipt == kEmptyVarName ? nullptr : scope_.FindVar(ipt);
Y
Yan Chunwei 已提交
260 261
  }

262
  Variable* OutputVar(const std::string& name) const {
263
    auto opt = op_.Output(name);
Y
Yu Yang 已提交
264
    return opt == kEmptyVarName ? nullptr : scope_.FindVar(opt);
Y
Yan Chunwei 已提交
265 266
  }

267 268
  const std::vector<const Variable*> MultiInputVar(
      const std::string& name) const {
Y
Yan Chunwei 已提交
269 270
    auto names = op_.Inputs(name);
    std::vector<const Variable*> res;
271
    res.reserve(names.size());
272 273
    std::transform(names.begin(), names.end(), std::back_inserter(res),
                   [this](const std::string& name) {
Y
Yu Yang 已提交
274 275
                     return name == kEmptyVarName ? nullptr
                                                  : scope_.FindVar(name);
276
                   });
Y
Yan Chunwei 已提交
277 278 279
    return res;
  }

280
  std::vector<const Variable*> MultiOutputVar(const std::string& name) const {
Y
Yan Chunwei 已提交
281 282
    auto names = op_.Outputs(name);
    std::vector<const Variable*> res;
283
    res.reserve(names.size());
284 285
    std::transform(names.begin(), names.end(), std::back_inserter(res),
                   [this](const std::string& name) {
Y
Yu Yang 已提交
286 287
                     return name == kEmptyVarName ? nullptr
                                                  : scope_.FindVar(name);
288
                   });
Y
Yan Chunwei 已提交
289 290 291
    return res;
  }

292 293
  template <typename T>
  const T* Input(const std::string& name) const {
Y
Yu Yang 已提交
294
    auto* var = InputVar(name);
295
    return var == nullptr ? nullptr : &var->Get<T>();
296 297 298 299
  }

  template <typename T>
  T* Output(const std::string& name) const {
300
    auto var = OutputVar(name);
301
    return var == nullptr ? nullptr : var->GetMutable<T>();
302 303 304 305 306 307 308 309
  }

  template <typename T>
  const std::vector<const T*> MultiInput(const std::string& name) const {
    auto names = op_.Inputs(name);
    std::vector<const T*> res;
    res.reserve(names.size());
    std::transform(names.begin(), names.end(), std::back_inserter(res),
310
                   [&](const std::string& sub_name) {
311
                     auto var = scope_.FindVar(sub_name);
312
                     return var == nullptr ? nullptr : &var->Get<T>();
313 314 315 316 317
                   });
    return res;
  }

  template <typename T>
318
  std::vector<T*> MultiOutput(const std::string& name) const {
319
    auto names = op_.Outputs(name);
320
    std::vector<T*> res;
321 322
    res.reserve(names.size());
    std::transform(names.begin(), names.end(), std::back_inserter(res),
323
                   [&](const std::string& sub_name) {
324
                     auto var = scope_.FindVar(sub_name);
325
                     return var == nullptr ? nullptr : var->GetMutable<T>();
326 327 328 329
                   });
    return res;
  }

330
  const Tensor* GetTensorFromVar(const Variable* var) const {
331
    if (var->IsType<LoDTensor>()) {
332
      return &var->Get<LoDTensor>();
333 334 335
    }
    PADDLE_ENFORCE(var->IsType<Tensor>(),
                   "The Input(%s) must be LoDTensor or Tensor.");
336
    return &var->Get<Tensor>();
337 338
  }

Q
qiaolongfei 已提交
339
 private:
340
  const OperatorBase& op_;
341
  const Scope& scope_;
342 343
};

344 345 346 347 348 349 350
template <>
const Tensor* InferShapeContext::Input<Tensor>(const std::string& name) const;

template <>
const std::vector<const Tensor*> InferShapeContext::MultiInput<Tensor>(
    const std::string& name) const;

351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
template <typename T>
struct EigenDeviceConverter;

template <>
struct EigenDeviceConverter<platform::CPUPlace> {
  using EigenDeviceType = Eigen::DefaultDevice;
};

#ifndef PADDLE_ONLY_CPU
template <>
struct EigenDeviceConverter<platform::GPUPlace> {
  using EigenDeviceType = Eigen::GpuDevice;
};
#endif

366
class ExecutionContext : public InferShapeContext {
367
 public:
368
  ExecutionContext(const OperatorBase& op, const Scope& scope,
369
                   const platform::DeviceContext& device_context)
370
      : InferShapeContext(op, scope), device_context_(device_context) {}
371

Q
qijun 已提交
372 373 374
  template <typename PlaceType,
            typename DeviceType =
                typename EigenDeviceConverter<PlaceType>::EigenDeviceType>
375
  DeviceType& GetEigenDevice() const;
Q
qijun 已提交
376

377
  platform::Place GetPlace() const { return device_context_.GetPlace(); }
Q
qijun 已提交
378

379
  const platform::DeviceContext& device_context() const {
Q
qijun 已提交
380
    return device_context_;
Q
qijun 已提交
381
  }
Q
qijun 已提交
382

383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
  // redefine Output function,
  // use Variable::Get instead of Variable::GetMutable
  template <typename T>
  T* Output(const std::string& name) const {
    auto var = OutputVar(name);
    return var == nullptr ? nullptr : const_cast<T*>(&var->Get<T>());
  }

  // redefine MultiOutput function.
  // use Variable::Get instead of Variable::GetMutable
  template <typename T>
  std::vector<T*> MultiOutput(const std::string& name) const {
    auto names = op().Outputs(name);
    std::vector<T*> res;
    res.reserve(names.size());
    std::transform(
        names.begin(), names.end(), std::back_inserter(res),
        [&](const std::string& sub_name) { return Output<T>(sub_name); });
    return res;
  }

404 405
 private:
  const platform::DeviceContext& device_context_;
Q
Qiao Longfei 已提交
406 407
};

408 409 410 411 412 413 414
template <>
Tensor* ExecutionContext::Output<Tensor>(const std::string& name) const;

template <>
std::vector<Tensor*> ExecutionContext::MultiOutput<Tensor>(
    const std::string& name) const;

Q
qijun 已提交
415 416
class OpKernel {
 public:
Q
qijun 已提交
417
  /**
418
   * ExecutionContext is the only parameter of Kernel Run function.
Q
qijun 已提交
419 420
   * Run will get input/output variables, state such as momentum and
   * device resource such as CUDA stream, cublas handle, etc. from
421
   * ExecutionContext. User should construct it before run the Operator.
Q
qijun 已提交
422 423
   */

424
  virtual void Compute(const ExecutionContext& context) const = 0;
Y
Yu Yang 已提交
425 426 427 428

  virtual ~OpKernel() {}
};

Q
Qiao Longfei 已提交
429 430
class OperatorWithKernel : public OperatorBase {
 public:
Y
Yu Yang 已提交
431 432
  struct OpKernelKey {
    platform::Place place_;
Q
Qiao Longfei 已提交
433

Y
Yu Yang 已提交
434
    OpKernelKey() = default;
L
liaogang 已提交
435
    explicit OpKernelKey(const platform::DeviceContext& dev_ctx) {
Y
Yu Yang 已提交
436 437 438
      place_ = dev_ctx.GetPlace();
    }

Q
qijun 已提交
439 440 441
    bool operator==(const OpKernelKey& o) const {
      return platform::places_are_same_class(place_, o.place_);
    }
Y
Yu Yang 已提交
442 443 444 445 446 447 448 449 450 451 452
  };

  struct OpKernelHash {
    std::hash<bool> hash_;
    size_t operator()(const OpKernelKey& key) const {
      return hash_(platform::is_gpu_place(key.place_));
    }
  };

  using OpKernelMap =
      std::unordered_map<OpKernelKey, std::unique_ptr<OpKernel>, OpKernelHash>;
Q
Qiao Longfei 已提交
453

Y
Yu Yang 已提交
454 455
  OperatorWithKernel(const std::string& type, const VariableNameMap& inputs,
                     const VariableNameMap& outputs, const AttributeMap& attrs)
Y
Yu Yang 已提交
456 457
      : OperatorBase(type, inputs, outputs, attrs) {}

458
  void InferShape(const Scope& scope) const override {
459
    InferShape(InferShapeContext(*this, scope));
460 461
  }

Y
Yu Yang 已提交
462
  void Run(const Scope& scope,
Y
Yu Yang 已提交
463
           const platform::DeviceContext& dev_ctx) const final {
Q
Qiao Longfei 已提交
464
    auto& opKernel = AllOpKernels().at(type_).at(OpKernelKey(dev_ctx));
465
    opKernel->Compute(ExecutionContext(*this, scope, dev_ctx));
Q
Qiao Longfei 已提交
466 467
  }

Y
Yu Yang 已提交
468 469 470 471
  static std::unordered_map<std::string /* op_type */, OpKernelMap>&
  AllOpKernels() {
    static std::unordered_map<std::string, OpKernelMap> g_all_op_kernels;
    return g_all_op_kernels;
Y
Yu Yang 已提交
472
  }
Y
Yan Chunwei 已提交
473

474 475 476 477 478 479
  bool SupportGPU() const override {
    OperatorWithKernel::OpKernelKey key;
    key.place_ = platform::GPUPlace();
    return OperatorWithKernel::AllOpKernels().at(type_).count(key) != 0;
  }

Y
Yu Yang 已提交
480
 protected:
481
  virtual void InferShape(const InferShapeContext& ctx) const = 0;
Q
Qiao Longfei 已提交
482 483 484 485
};

}  // namespace framework
}  // namespace paddle