operator.cc 13.0 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/shape_inference.h"
Q
Qiao Longfei 已提交
19 20 21 22

namespace paddle {
namespace framework {

Q
qijun 已提交
23
template <>
24
Eigen::DefaultDevice& ExecutionContext::GetEigenDevice<
Q
qijun 已提交
25
    platform::CPUPlace, Eigen::DefaultDevice>() const {
26
  return *device_context_.GetEigenDevice<platform::CPUPlace>();
Q
qijun 已提交
27 28
}

29
#ifdef PADDLE_WITH_CUDA
Q
qijun 已提交
30
template <>
31
Eigen::GpuDevice&
32
ExecutionContext::GetEigenDevice<platform::GPUPlace, Eigen::GpuDevice>() const {
33
  return *device_context_.GetEigenDevice<platform::GPUPlace>();
Q
qijun 已提交
34 35 36
}
#endif

37
std::string OperatorBase::Input(const std::string& name) const {
Y
Yu Yang 已提交
38
  auto& ins = Inputs(name);
Y
Yu Yang 已提交
39
  PADDLE_ENFORCE_LE(ins.size(), 1UL,
40 41
                    "Operator %s's input %s should contain only one variable.",
                    type_, name);
Y
Yu Yang 已提交
42
  return ins.empty() ? kEmptyVarName : ins[0];
Y
Yan Chunwei 已提交
43 44
}

Y
Yu Yang 已提交
45 46
const std::vector<std::string>& OperatorBase::Inputs(
    const std::string& name) const {
Y
Yu Yang 已提交
47
  auto it = inputs_.find(name);
48 49
  PADDLE_ENFORCE(it != inputs_.end(), "Operator %s does not have the input %s.",
                 type_, name);
Y
Yu Yang 已提交
50
  return it->second;
Y
Yan Chunwei 已提交
51 52
}

53
std::string OperatorBase::Output(const std::string& name) const {
Y
Yu Yang 已提交
54
  auto& outs = Outputs(name);
Y
Yu Yang 已提交
55
  PADDLE_ENFORCE_LE(outs.size(), 1UL,
56 57
                    "Operator %s's output %s should contain only one variable.",
                    type_, name);
Y
Yu Yang 已提交
58
  return outs.empty() ? kEmptyVarName : outs[0];
Y
Yan Chunwei 已提交
59 60
}

Y
Yu Yang 已提交
61 62
const std::vector<std::string>& OperatorBase::Outputs(
    const std::string& name) const {
Y
Yu Yang 已提交
63
  auto it = outputs_.find(name);
64 65
  PADDLE_ENFORCE(it != outputs_.end(),
                 "Operator %s does not have an output called %s.", type_, name);
Y
Yu Yang 已提交
66
  return it->second;
Y
Yan Chunwei 已提交
67 68
}

Q
Qiao Longfei 已提交
69 70
std::string OperatorBase::DebugString() const {
  std::stringstream ss;
Y
Yu Yang 已提交
71
  ss << "Op(" << type_ << "), inputs:{";
Y
Yu Yang 已提交
72 73
  for (auto it = inputs_.begin(); it != inputs_.end();) {
    auto& input = *it;
Y
Yu Yang 已提交
74 75 76 77 78 79
    ss << input.first << "[";
    for (size_t i = 0; i < input.second.size(); ++i) {
      ss << input.second[i];
      if (i != input.second.size() - 1) {
        ss << ", ";
      }
80
    }
Y
Yu Yang 已提交
81
    ss << "]";
Y
Yu Yang 已提交
82 83
    ++it;
    if (it != inputs_.end()) {
84 85
      ss << ", ";
    }
Q
Qiao Longfei 已提交
86
  }
Y
Yu Yang 已提交
87
  ss << "}, outputs:{";
Y
Yu Yang 已提交
88 89
  for (auto it = outputs_.begin(); it != outputs_.end();) {
    auto& output = *it;
Y
Yu Yang 已提交
90 91 92 93 94 95
    ss << output.first << "[";
    for (size_t i = 0; i < output.second.size(); ++i) {
      ss << output.second[i];
      if (i != output.second.size() - 1) {
        ss << ", ";
      }
96
    }
Y
Yu Yang 已提交
97
    ss << "]";
Y
Yu Yang 已提交
98 99
    ++it;
    if (it != outputs_.end()) {
100 101
      ss << ", ";
    }
Q
Qiao Longfei 已提交
102
  }
Y
Yu Yang 已提交
103
  ss << "}.";
Q
Qiao Longfei 已提交
104 105 106
  return ss.str();
}

D
dongzhihong 已提交
107 108
void OperatorBase::Rename(const std::string& old_name,
                          const std::string& new_name) {
Y
Yu Yang 已提交
109 110 111 112 113 114 115
  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 已提交
116 117
}

Y
Yu Yang 已提交
118
OperatorBase::OperatorBase(const std::string& type,
Y
Yu Yang 已提交
119 120
                           const VariableNameMap& inputs,
                           const VariableNameMap& outputs,
Y
Yu Yang 已提交
121 122
                           const AttributeMap& attrs)
    : type_(type), inputs_(inputs), outputs_(outputs), attrs_(attrs) {
123 124
  GenerateTemporaryNames();
  CheckAllInputOutputSet();
Y
Yu Yang 已提交
125
}
126

Q
qijun 已提交
127 128 129 130 131 132 133 134 135
std::vector<std::string> OperatorBase::InputVars() const {
  std::vector<std::string> 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 已提交
136 137 138 139 140 141 142 143 144 145
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 已提交
146
  auto& info = OpInfoMap::Instance().Get(Type());
Y
Yu Yang 已提交
147 148

  // get all OpProto::Var for outputs
Y
Yu Yang 已提交
149
  for (auto& o : info.Proto().outputs()) {
Y
Yu Yang 已提交
150 151 152 153 154 155 156 157 158
    // 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 已提交
159 160
}

161 162 163
void OperatorBase::CheckAllInputOutputSet() const {
  auto& info_map = OpInfoMap::Instance();
  auto* op_info = info_map.GetNullable(Type());
Y
Yu Yang 已提交
164
  if (op_info == nullptr || op_info->proto_ == nullptr) return;
165 166 167

  for (auto& in : op_info->Proto().inputs()) {
    PADDLE_ENFORCE(inputs_.find(in.name()) != inputs_.end(),
Y
Yu Yang 已提交
168
                   "Type %s's input %s is not set", Type(), in.name());
169 170 171 172
  }

  for (auto& out : op_info->Proto().outputs()) {
    PADDLE_ENFORCE(outputs_.find(out.name()) != outputs_.end(),
Y
Yu Yang 已提交
173
                   "Type %s's output %s is not set", Type(), out.name());
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
  }
}

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 已提交
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
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;
}

214
template <>
215
const Tensor* ExecutionContext::Input<Tensor>(const std::string& name) const {
216
  auto* var = InputVar(name);
217
  return var == nullptr ? nullptr : GetTensorFromVar(var);
218 219 220
}

template <>
221
const std::vector<const Tensor*> ExecutionContext::MultiInput<Tensor>(
222 223 224 225
    const std::string& name) const {
  auto names = op().Inputs(name);
  std::vector<const Tensor*> res;
  res.reserve(names.size());
226 227 228 229 230
  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);
                 });
231 232 233 234
  return res;
}

template <>
235
Tensor* ExecutionContext::Output<Tensor>(const std::string& name) const {
236
  auto var = OutputVar(name);
Q
QI JUN 已提交
237
  return var == nullptr ? nullptr : GetMutableTensorFromVar(var);
238 239 240
}

template <>
241
std::vector<Tensor*> ExecutionContext::MultiOutput<Tensor>(
242 243 244 245
    const std::string& name) const {
  auto names = op().Outputs(name);
  std::vector<Tensor*> res;
  res.reserve(names.size());
246 247
  std::transform(names.begin(), names.end(), std::back_inserter(res),
                 [&](const std::string& sub_name) {
248 249
                   auto var = scope_.FindVar(sub_name);
                   return var == nullptr ? nullptr
Q
QI JUN 已提交
250
                                         : GetMutableTensorFromVar(var);
251
                 });
252 253 254
  return res;
}

255 256 257 258 259 260 261
std::ostream& operator<<(std::ostream& os,
                         const OperatorWithKernel::OpKernelKey& kernel_key) {
  os << "place[" << kernel_key.place_ << "]:data_type[" << kernel_key.data_type_
     << "]";
  return os;
}

Y
Yu Yang 已提交
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
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;
}

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 341 342 343 344 345 346 347 348 349 350 351 352 353
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 已提交
354 355 356 357 358 359 360 361 362 363 364 365 366 367
  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());
  }

368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
 private:
  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.");
    }
  }

  const OperatorBase& op_;
  const Scope& scope_;
};

void OperatorWithKernel::Run(const Scope& scope,
                             const platform::DeviceContext& dev_ctx) const {
  VLOG(3) << "Running operator " << this->Type();
  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 已提交
407 408
    PADDLE_THROW(
        "There are no kernels which are registered in the %s operator.", type_);
409 410 411 412 413 414 415 416
  }

  // check if op[type] have kernel for kernel_key
  OpKernelMap& kernels = kernels_iter->second;
  auto kernel_key = OpKernelKey(IndicateDataType(ctx), dev_ctx);
  auto kernel_iter = kernels.find(kernel_key);

  if (kernel_iter == kernels.end()) {
Y
Yu Yang 已提交
417
    PADDLE_THROW("The operator %s does not support %s", type_, kernel_key);
418 419 420 421 422
  }

  kernel_iter->second->Compute(ctx);
}

Q
Qiao Longfei 已提交
423
}  // namespace framework
L
liaogang 已提交
424
}  // namespace paddle