operator.cc 13.9 KB
Newer Older
Q
Qiao Longfei 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/* 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. */

#include "paddle/framework/operator.h"
16
#include <algorithm>
T
tensor-tang 已提交
17
#include <atomic>
18
#include "paddle/framework/lod_tensor_array.h"
19
#include "paddle/framework/shape_inference.h"
20
#include "paddle/framework/var_type.h"
Q
Qiao Longfei 已提交
21 22 23 24

namespace paddle {
namespace framework {

25
std::string OperatorBase::Input(const std::string& name) const {
Y
Yu Yang 已提交
26
  auto& ins = Inputs(name);
Y
Yu Yang 已提交
27
  PADDLE_ENFORCE_LE(ins.size(), 1UL,
28 29
                    "Operator %s's input %s should contain only one variable.",
                    type_, name);
Y
Yu Yang 已提交
30
  return ins.empty() ? kEmptyVarName : ins[0];
Y
Yan Chunwei 已提交
31 32
}

Y
Yu Yang 已提交
33 34
const std::vector<std::string>& OperatorBase::Inputs(
    const std::string& name) const {
Y
Yu Yang 已提交
35
  auto it = inputs_.find(name);
36 37
  PADDLE_ENFORCE(it != inputs_.end(), "Operator %s does not have the input %s.",
                 type_, name);
Y
Yu Yang 已提交
38
  return it->second;
Y
Yan Chunwei 已提交
39 40
}

41
std::string OperatorBase::Output(const std::string& name) const {
Y
Yu Yang 已提交
42
  auto& outs = Outputs(name);
Y
Yu Yang 已提交
43
  PADDLE_ENFORCE_LE(outs.size(), 1UL,
44 45
                    "Operator %s's output %s should contain only one variable.",
                    type_, name);
Y
Yu Yang 已提交
46
  return outs.empty() ? kEmptyVarName : outs[0];
Y
Yan Chunwei 已提交
47 48
}

Y
Yu Yang 已提交
49 50
const std::vector<std::string>& OperatorBase::Outputs(
    const std::string& name) const {
Y
Yu Yang 已提交
51
  auto it = outputs_.find(name);
52 53
  PADDLE_ENFORCE(it != outputs_.end(),
                 "Operator %s does not have an output called %s.", type_, name);
Y
Yu Yang 已提交
54
  return it->second;
Y
Yan Chunwei 已提交
55 56
}

Q
Qiao Longfei 已提交
57 58
std::string OperatorBase::DebugString() const {
  std::stringstream ss;
Y
Yu Yang 已提交
59
  ss << "Op(" << type_ << "), inputs:{";
Y
Yu Yang 已提交
60 61
  for (auto it = inputs_.begin(); it != inputs_.end();) {
    auto& input = *it;
Y
Yu Yang 已提交
62 63 64 65 66 67
    ss << input.first << "[";
    for (size_t i = 0; i < input.second.size(); ++i) {
      ss << input.second[i];
      if (i != input.second.size() - 1) {
        ss << ", ";
      }
68
    }
Y
Yu Yang 已提交
69
    ss << "]";
Y
Yu Yang 已提交
70 71
    ++it;
    if (it != inputs_.end()) {
72 73
      ss << ", ";
    }
Q
Qiao Longfei 已提交
74
  }
Y
Yu Yang 已提交
75
  ss << "}, outputs:{";
Y
Yu Yang 已提交
76 77
  for (auto it = outputs_.begin(); it != outputs_.end();) {
    auto& output = *it;
Y
Yu Yang 已提交
78 79 80 81 82 83
    ss << output.first << "[";
    for (size_t i = 0; i < output.second.size(); ++i) {
      ss << output.second[i];
      if (i != output.second.size() - 1) {
        ss << ", ";
      }
84
    }
Y
Yu Yang 已提交
85
    ss << "]";
Y
Yu Yang 已提交
86 87
    ++it;
    if (it != outputs_.end()) {
88 89
      ss << ", ";
    }
Q
Qiao Longfei 已提交
90
  }
Y
Yu Yang 已提交
91
  ss << "}.";
Q
Qiao Longfei 已提交
92 93 94
  return ss.str();
}

D
dongzhihong 已提交
95 96
void OperatorBase::Rename(const std::string& old_name,
                          const std::string& new_name) {
Y
Yu Yang 已提交
97 98 99 100 101 102 103
  for (auto& input : inputs_) {
    std::replace(input.second.begin(), input.second.end(), old_name, new_name);
  }
  for (auto& output : outputs_) {
    std::replace(output.second.begin(), output.second.end(), old_name,
                 new_name);
  }
D
dongzhihong 已提交
104 105
}

Y
Yu Yang 已提交
106
OperatorBase::OperatorBase(const std::string& type,
Y
Yu Yang 已提交
107 108
                           const VariableNameMap& inputs,
                           const VariableNameMap& outputs,
Y
Yu Yang 已提交
109 110
                           const AttributeMap& attrs)
    : type_(type), inputs_(inputs), outputs_(outputs), attrs_(attrs) {
111 112
  GenerateTemporaryNames();
  CheckAllInputOutputSet();
Y
Yu Yang 已提交
113
}
114

Q
qijun 已提交
115 116
std::vector<std::string> OperatorBase::InputVars() const {
  std::vector<std::string> ret_val;
Y
Yu Yang 已提交
117
  for (auto& o : inputs_) {
Q
qijun 已提交
118 119 120 121 122 123
    ret_val.reserve(ret_val.size() + o.second.size());
    ret_val.insert(ret_val.end(), o.second.begin(), o.second.end());
  }
  return ret_val;
}

Y
Yu Yang 已提交
124 125 126 127 128 129 130 131 132 133
std::vector<std::string> OperatorBase::OutputVars(bool has_intermediate) const {
  std::vector<std::string> ret_val;
  if (has_intermediate) {
    // push all outputs into ret_val
    for (auto& o : outputs_) {
      ret_val.reserve(ret_val.size() + o.second.size());
      ret_val.insert(ret_val.end(), o.second.begin(), o.second.end());
    }
    return ret_val;
  }
Y
Yu Yang 已提交
134
  auto& info = OpInfoMap::Instance().Get(Type());
Y
Yu Yang 已提交
135 136

  // get all OpProto::Var for outputs
Y
Yu Yang 已提交
137
  for (auto& o : info.Proto().outputs()) {
Y
Yu Yang 已提交
138 139 140 141 142 143 144 145 146
    // ignore all intermediate output
    if (o.intermediate()) continue;
    auto out = outputs_.find(o.name());
    if (out != outputs_.end()) {
      ret_val.reserve(ret_val.size() + out->second.size());
      ret_val.insert(ret_val.end(), out->second.begin(), out->second.end());
    }
  }
  return ret_val;
D
dongzhihong 已提交
147 148
}

149 150 151
void OperatorBase::CheckAllInputOutputSet() const {
  auto& info_map = OpInfoMap::Instance();
  auto* op_info = info_map.GetNullable(Type());
Y
Yu Yang 已提交
152
  if (op_info == nullptr || op_info->proto_ == nullptr) return;
153 154 155

  for (auto& in : op_info->Proto().inputs()) {
    PADDLE_ENFORCE(inputs_.find(in.name()) != inputs_.end(),
Y
Yu Yang 已提交
156
                   "Type %s's input %s is not set", Type(), in.name());
157 158 159 160
  }

  for (auto& out : op_info->Proto().outputs()) {
    PADDLE_ENFORCE(outputs_.find(out.name()) != outputs_.end(),
Y
Yu Yang 已提交
161
                   "Type %s's output %s is not set", Type(), out.name());
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
  }
}

void OperatorBase::GenerateTemporaryNames() {
  static std::atomic<size_t> gUniqId(0UL);
  for (auto& output : outputs_) {
    for (auto& output_name : output.second) {
      if (output_name == kTempVarName) {
        output_name += type_;
        output_name += "@";
        output_name += std::to_string(gUniqId.fetch_add(1));
      }
    }
  }
}

Q
QI JUN 已提交
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
static const Tensor* GetTensorFromVar(const Variable* var) {
  const Tensor* t = nullptr;
  if (var->IsType<LoDTensor>()) {
    t = &(var->Get<LoDTensor>());
  } else if (var->IsType<SelectedRows>()) {
    t = &(var->Get<SelectedRows>().value());
  } else {
    PADDLE_THROW("Variable type must be LoDTensor/SelectedRows.");
  }
  return t;
}

static Tensor* GetMutableTensorFromVar(Variable* var) {
  Tensor* t = nullptr;
  if (var->IsType<LoDTensor>()) {
    t = var->GetMutable<LoDTensor>();
  } else if (var->IsType<SelectedRows>()) {
    t = var->GetMutable<SelectedRows>()->mutable_value();
  } else {
    PADDLE_THROW("Variable type must be LoDTensor/SelectedRows.");
  }
  return t;
}

202
template <>
203
const Tensor* ExecutionContext::Input<Tensor>(const std::string& name) const {
204
  auto* var = InputVar(name);
205
  return var == nullptr ? nullptr : GetTensorFromVar(var);
206 207 208
}

template <>
209
const std::vector<const Tensor*> ExecutionContext::MultiInput<Tensor>(
210 211 212 213
    const std::string& name) const {
  auto names = op().Inputs(name);
  std::vector<const Tensor*> res;
  res.reserve(names.size());
214 215 216 217 218
  std::transform(names.begin(), names.end(), std::back_inserter(res),
                 [&](const std::string& sub_name) {
                   auto var = scope_.FindVar(sub_name);
                   return var == nullptr ? nullptr : GetTensorFromVar(var);
                 });
219 220 221 222
  return res;
}

template <>
223
Tensor* ExecutionContext::Output<Tensor>(const std::string& name) const {
224
  auto var = OutputVar(name);
Q
QI JUN 已提交
225
  return var == nullptr ? nullptr : GetMutableTensorFromVar(var);
226 227 228
}

template <>
229
std::vector<Tensor*> ExecutionContext::MultiOutput<Tensor>(
230 231 232 233
    const std::string& name) const {
  auto names = op().Outputs(name);
  std::vector<Tensor*> res;
  res.reserve(names.size());
234 235
  std::transform(names.begin(), names.end(), std::back_inserter(res),
                 [&](const std::string& sub_name) {
236 237
                   auto var = scope_.FindVar(sub_name);
                   return var == nullptr ? nullptr
Q
QI JUN 已提交
238
                                         : GetMutableTensorFromVar(var);
239
                 });
240 241 242
  return res;
}

Y
Yu Yang 已提交
243
std::ostream& operator<<(std::ostream& os, const OpKernelType& kernel_key) {
244 245 246 247 248
  os << "place[" << kernel_key.place_ << "]:data_type[" << kernel_key.data_type_
     << "]";
  return os;
}

Y
Yu Yang 已提交
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
bool OpSupportGPU(const std::string& op_type) {
  auto& all_kernels = OperatorWithKernel::AllOpKernels();
  auto it = all_kernels.find(op_type);
  if (it == all_kernels.end()) {
    // All control operator must support GPU
    return true;
  }
  for (auto& kern_pair : it->second) {
    if (platform::is_gpu_place(kern_pair.first.place_)) {
      return true;
    }
  }
  return false;
}

264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
class RuntimeInferShapeContext : public InferShapeContext {
 public:
  RuntimeInferShapeContext(const OperatorBase& op, const Scope& scope)
      : op_(op), scope_(scope) {}

  bool HasInput(const std::string& name) const override {
    auto& ins = Inputs(name);
    size_t length = ins.size();
    if (length == 0) {
      return false;
    }
    PADDLE_ENFORCE_EQ(length, 1UL, "Input %s should have more than one inputs",
                      name);
    auto ipt = ins[0];
    auto* var = ipt == kEmptyVarName ? nullptr : scope_.FindVar(ipt);
    return var != nullptr;
  }

  bool HasOutput(const std::string& name) const override {
    auto& outs = Outputs(name);
    size_t length = outs.size();
    if (length == 0) {
      return false;
    }
    PADDLE_ENFORCE_EQ(length, 1UL, "Output %s should have more than one inputs",
                      name);
    auto ipt = outs[0];
    auto* var = ipt == kEmptyVarName ? nullptr : scope_.FindVar(ipt);
    return var != nullptr;
  }

  bool HasInputs(const std::string& name) const override {
    auto inputs = op_.Inputs(name);
    if (inputs.empty()) {
      return false;
    }
    for (auto& input : inputs) {
      if (scope_.FindVar(input) == nullptr) {
        return false;
      }
    }
    return true;
  }

  bool HasOutputs(const std::string& name) const override {
    auto outputs = op_.Outputs(name);
    if (outputs.empty()) {
      return false;
    }
    for (auto& output : outputs) {
      if (scope_.FindVar(output) == nullptr) {
        return false;
      }
    }
    return true;
  }

  DDim GetInputDim(const std::string& name) const override {
    return GetDim(op_.Input(name));
  }

  void SetOutputDim(const std::string& name, const DDim& dim) override {
    SetDim(op_.Output(name), dim);
  }

  AttrReader Attrs() const override { return AttrReader(op_.Attrs()); }

  const std::vector<std::string>& Inputs(
      const std::string& name) const override {
    return op_.Inputs(name);
  }

  const std::vector<std::string>& Outputs(
      const std::string& name) const override {
    return op_.Outputs(name);
  }

Q
Qiao Longfei 已提交
341 342 343 344 345 346 347 348 349 350 351 352 353 354
  void ShareLoD(const std::string& in, const std::string& out, size_t i = 0,
                size_t j = 0) const override {
    PADDLE_ENFORCE_LT(i, Inputs(in).size());
    PADDLE_ENFORCE_LT(j, Outputs(out).size());
    Variable* in_var = scope_.FindVar(Inputs(in)[i]);
    Variable* out_var = scope_.FindVar(Outputs(out)[j]);
    if (!in_var->IsType<LoDTensor>()) return;
    PADDLE_ENFORCE(out_var->IsType<LoDTensor>(),
                   "The %d-th output of Output(%s) must be LoDTensor.", j, out);
    auto in_tensor = in_var->Get<LoDTensor>();
    auto* out_tensor = out_var->GetMutable<LoDTensor>();
    out_tensor->set_lod(in_tensor.lod());
  }

355 356 357
  bool IsRuntime() const override { return true; }

 protected:
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
  DDim GetDim(const std::string& name) const override {
    Variable* var = scope_.FindVar(name);
    if (var->IsType<LoDTensor>()) {
      return var->Get<LoDTensor>().dims();
    } else if (var->IsType<SelectedRows>()) {
      return var->Get<SelectedRows>().GetCompleteDims();
    } else {
      PADDLE_THROW("Variable type must be LoDTensor/SelectedRows.");
    }
  }

  void SetDim(const std::string& name, const DDim& dim) override {
    Variable* var = scope_.FindVar(name);
    if (var->IsType<LoDTensor>()) {
      var->GetMutable<LoDTensor>()->Resize(dim);
    } else if (var->IsType<SelectedRows>()) {
      var->GetMutable<SelectedRows>()->set_height(dim[0]);
    } else {
      PADDLE_THROW("Variable type must be LoDTensor/SelectedRows.");
    }
  }

380
  proto::VarDesc::VarType GetVarType(const std::string& name) const override {
381 382 383 384 385
    auto* var = scope_.FindVar(name);
    return ToVarType(var->Type());
  }

 private:
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
  const OperatorBase& op_;
  const Scope& scope_;
};

void OperatorWithKernel::Run(const Scope& scope,
                             const platform::DeviceContext& dev_ctx) const {
  RuntimeInferShapeContext infer_shape_ctx(*this, scope);
  this->InferShape(&infer_shape_ctx);

  ExecutionContext ctx(*this, scope, dev_ctx);

  // check if op[type] has kernel registered.
  auto& all_op_kernels = AllOpKernels();
  auto kernels_iter = all_op_kernels.find(type_);
  if (kernels_iter == all_op_kernels.end()) {
Y
Yu Yang 已提交
401 402
    PADDLE_THROW(
        "There are no kernels which are registered in the %s operator.", type_);
403 404 405 406
  }

  // check if op[type] have kernel for kernel_key
  OpKernelMap& kernels = kernels_iter->second;
Y
Yu Yang 已提交
407
  auto kernel_key = GetKernelType(ctx);
408 409 410
  auto kernel_iter = kernels.find(kernel_key);

  if (kernel_iter == kernels.end()) {
Y
Yu Yang 已提交
411
    PADDLE_THROW("The operator %s does not support %s", type_, kernel_key);
412 413 414 415
  }

  kernel_iter->second->Compute(ctx);
}
Y
Yu Yang 已提交
416 417
OpKernelType OperatorWithKernel::GetKernelType(
    const ExecutionContext& ctx) const {
Q
QI JUN 已提交
418
  return OpKernelType(IndicateDataType(ctx), ctx.GetPlace());
Y
Yu Yang 已提交
419
}
420
proto::DataType OperatorWithKernel::IndicateDataType(
Y
Yu Yang 已提交
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
    const ExecutionContext& ctx) const {
  auto& scope = ctx.scope();
  int data_type = -1;
  for (auto& input : this->inputs_) {
    for (auto& ipt_name : input.second) {
      auto* var = scope.FindVar(ipt_name);
      if (var != nullptr) {
        const Tensor* t = nullptr;
        if (var->IsType<Tensor>()) {
          t = &var->Get<Tensor>();
        } else if (var->IsType<LoDTensor>()) {
          t = &var->Get<LoDTensor>();
        } else if (var->IsType<SelectedRows>()) {
          t = &(var->Get<SelectedRows>().value());
        }
        if (t != nullptr) {
          int tmp = static_cast<int>(ToDataType(t->type()));
          PADDLE_ENFORCE(tmp == data_type || data_type == -1,
                         "DataType of Paddle Op %s must be the same.", Type());
          data_type = tmp;
        }
      }
    }
  }
  PADDLE_ENFORCE(data_type != -1, "DataType should be indicated by input");
446
  return static_cast<proto::DataType>(data_type);
Y
Yu Yang 已提交
447
}
448

Q
Qiao Longfei 已提交
449
}  // namespace framework
L
liaogang 已提交
450
}  // namespace paddle