operator.cc 7.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>
Q
Qiao Longfei 已提交
18 19 20 21

namespace paddle {
namespace framework {

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

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

Q
Qiao Longfei 已提交
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
const Tensor* GetTensorFromVar(const Variable* var) {
  if (var->IsType<LoDTensor>()) {
    return &var->Get<LoDTensor>();
  }
  PADDLE_ENFORCE(var->IsType<Tensor>(),
                 "The Input must be LoDTensor or Tensor.");
  return &var->Get<Tensor>();
}

Tensor* GetTensorFromVar(Variable* var) {
  if (var->IsType<LoDTensor>()) {
    return var->GetMutable<LoDTensor>();
  }
  PADDLE_ENFORCE(var->IsType<Tensor>(),
                 "The Input must be LoDTensor or Tensor.");
  return var->GetMutable<Tensor>();
}

54
std::string OperatorBase::Input(const std::string& name) const {
Y
Yu Yang 已提交
55
  auto& ins = Inputs(name);
Y
Yu Yang 已提交
56 57 58 59
  PADDLE_ENFORCE_LE(ins.size(), 1UL,
                    "Op %s input %s should contain only one variable", type_,
                    name);
  return ins.empty() ? kEmptyVarName : ins[0];
Y
Yan Chunwei 已提交
60 61
}

Y
Yu Yang 已提交
62 63
const std::vector<std::string>& OperatorBase::Inputs(
    const std::string& name) const {
Y
Yu Yang 已提交
64 65 66 67
  auto it = inputs_.find(name);
  PADDLE_ENFORCE(it != inputs_.end(), "Op %s do not have input %s", type_,
                 name);
  return it->second;
Y
Yan Chunwei 已提交
68 69
}

70
std::string OperatorBase::Output(const std::string& name) const {
Y
Yu Yang 已提交
71
  auto& outs = Outputs(name);
Y
Yu Yang 已提交
72 73 74 75
  PADDLE_ENFORCE_LE(outs.size(), 1UL,
                    "Op %s output %s should contain only one variable", type_,
                    name);
  return outs.empty() ? kEmptyVarName : outs[0];
Y
Yan Chunwei 已提交
76 77
}

Y
Yu Yang 已提交
78 79
const std::vector<std::string>& OperatorBase::Outputs(
    const std::string& name) const {
Y
Yu Yang 已提交
80
  auto it = outputs_.find(name);
S
superjom 已提交
81 82
  PADDLE_ENFORCE(it != outputs_.end(), "Op %s does not have output called %s",
                 type_, name);
Y
Yu Yang 已提交
83
  return it->second;
Y
Yan Chunwei 已提交
84 85
}

Q
Qiao Longfei 已提交
86 87
std::string OperatorBase::DebugString() const {
  std::stringstream ss;
Y
Yu Yang 已提交
88
  ss << "Op(" << type_ << "), inputs:{";
Y
Yu Yang 已提交
89 90
  for (auto it = inputs_.begin(); it != inputs_.end();) {
    auto& input = *it;
Y
Yu Yang 已提交
91 92 93 94 95 96
    ss << input.first << "[";
    for (size_t i = 0; i < input.second.size(); ++i) {
      ss << input.second[i];
      if (i != input.second.size() - 1) {
        ss << ", ";
      }
97
    }
Y
Yu Yang 已提交
98
    ss << "]";
Y
Yu Yang 已提交
99 100
    ++it;
    if (it != inputs_.end()) {
101 102
      ss << ", ";
    }
Q
Qiao Longfei 已提交
103
  }
Y
Yu Yang 已提交
104
  ss << "}, outputs:{";
Y
Yu Yang 已提交
105 106
  for (auto it = outputs_.begin(); it != outputs_.end();) {
    auto& output = *it;
Y
Yu Yang 已提交
107 108 109 110 111 112
    ss << output.first << "[";
    for (size_t i = 0; i < output.second.size(); ++i) {
      ss << output.second[i];
      if (i != output.second.size() - 1) {
        ss << ", ";
      }
113
    }
Y
Yu Yang 已提交
114
    ss << "]";
Y
Yu Yang 已提交
115 116
    ++it;
    if (it != outputs_.end()) {
117 118
      ss << ", ";
    }
Q
Qiao Longfei 已提交
119
  }
Y
Yu Yang 已提交
120
  ss << "}.";
Q
Qiao Longfei 已提交
121 122 123
  return ss.str();
}

D
dongzhihong 已提交
124 125
void OperatorBase::Rename(const std::string& old_name,
                          const std::string& new_name) {
Y
Yu Yang 已提交
126 127 128 129 130 131 132
  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 已提交
133 134
}

Y
Yu Yang 已提交
135
OperatorBase::OperatorBase(const std::string& type,
Y
Yu Yang 已提交
136 137
                           const VariableNameMap& inputs,
                           const VariableNameMap& outputs,
Y
Yu Yang 已提交
138 139
                           const AttributeMap& attrs)
    : type_(type), inputs_(inputs), outputs_(outputs), attrs_(attrs) {
140 141
  GenerateTemporaryNames();
  CheckAllInputOutputSet();
Y
Yu Yang 已提交
142
}
143

Q
qijun 已提交
144 145 146 147 148 149 150 151 152
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 已提交
153 154 155 156 157 158 159 160 161 162
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 已提交
163
  auto& info = OpInfoMap::Instance().Get(Type());
Y
Yu Yang 已提交
164 165

  // get all OpProto::Var for outputs
Y
Yu Yang 已提交
166
  for (auto& o : info.Proto().outputs()) {
Y
Yu Yang 已提交
167 168 169 170 171 172 173 174 175
    // 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 已提交
176 177
}

178 179 180
void OperatorBase::CheckAllInputOutputSet() const {
  auto& info_map = OpInfoMap::Instance();
  auto* op_info = info_map.GetNullable(Type());
Y
Yu Yang 已提交
181
  if (op_info == nullptr || op_info->proto_ == nullptr) return;
182 183 184

  for (auto& in : op_info->Proto().inputs()) {
    PADDLE_ENFORCE(inputs_.find(in.name()) != inputs_.end(),
Y
Yu Yang 已提交
185
                   "Type %s's input %s is not set", Type(), in.name());
186 187 188 189
  }

  for (auto& out : op_info->Proto().outputs()) {
    PADDLE_ENFORCE(outputs_.find(out.name()) != outputs_.end(),
Y
Yu Yang 已提交
190
                   "Type %s's output %s is not set", Type(), out.name());
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
  }
}

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

207
template <>
208
const Tensor* ExecutionContext::Input<Tensor>(const std::string& name) const {
209
  auto* var = InputVar(name);
210
  return var == nullptr ? nullptr : GetTensorFromVar(var);
211 212 213
}

template <>
214
const std::vector<const Tensor*> ExecutionContext::MultiInput<Tensor>(
215 216 217 218
    const std::string& name) const {
  auto names = op().Inputs(name);
  std::vector<const Tensor*> res;
  res.reserve(names.size());
219 220 221 222 223
  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);
                 });
224 225 226 227
  return res;
}

template <>
228
Tensor* ExecutionContext::Output<Tensor>(const std::string& name) const {
229 230
  auto var = OutputVar(name);
  return var == nullptr ? nullptr : var->GetMutable<LoDTensor>();
231 232 233
}

template <>
234
std::vector<Tensor*> ExecutionContext::MultiOutput<Tensor>(
235 236 237 238
    const std::string& name) const {
  auto names = op().Outputs(name);
  std::vector<Tensor*> res;
  res.reserve(names.size());
239 240
  std::transform(names.begin(), names.end(), std::back_inserter(res),
                 [&](const std::string& sub_name) {
241 242 243
                   auto var = scope_.FindVar(sub_name);
                   return var == nullptr ? nullptr
                                         : var->GetMutable<LoDTensor>();
244
                 });
245 246 247
  return res;
}

248 249 250 251 252 253 254
std::ostream& operator<<(std::ostream& os,
                         const OperatorWithKernel::OpKernelKey& kernel_key) {
  os << "place[" << kernel_key.place_ << "]:data_type[" << kernel_key.data_type_
     << "]";
  return os;
}

Q
Qiao Longfei 已提交
255
}  // namespace framework
L
liaogang 已提交
256
}  // namespace paddle