m53297601
/
Paddle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add dygraph execution context (#20157)

Browse Source 
* add_dygraph_execution_context

* add dygraph infershape context and execution context; test=develop

* fix imperative bug; test=develop

* remove inputs outputs interface from execution context,
because it have same function with inputNames;
test=develop

* remove tracer_test ctest; test=develop

* fix split op bug; test=develop

* fix unitests bug; test=develop

* fix distribute test bug; test=develop

* fix ngraph compile bug; test=develop

* fix grad maker bug; test=develop

* fix load op bugs; test=develop

* fix operator.cc construct bug; test=develop

* remove useless name find in operator; test=develop

* add tracer_test; test=develop

* fix concat, split bug; test=develop

* remove tracer_test unitest; test=develop

* fix attribute check bug; test=develop

* add test code to fix converage; test=develop

* remove useless code, change check backward input in engin; test=develop

* unlock var type infer shape;test=develop

* add ShareAllLoD api; test=develop

* add dygraph infershape context unitest; test=develop

* remove increase and decrease lod in dygraph; test=develop

* addd override; test=develop

* fix increase descrease lod; test=develop

* fix paddle_enforce; test=develop

* disable lod op dygraph check; test=develop

* fix paddle enforce error; test=develop

* add comment for op_registry and OperatorBase; test=develop

* optimize the comment of op_registry; test=develop

* fix format of comment; test=develop

* fix format of comment; test=develop

* optimize the format of comment; test=develop

* optimize the format of the comment; test=develop

* optimize comment of op_registry; test=develop
revert-21172-masked_select_api
hong 6 years ago committed by GitHub
parent a6b089c614
commit ac8546701d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
103 changed files with 1111 additions and 361 deletions
Show Stats Download Patch File Download Diff File

15
paddle/fluid/framework/attribute.h
Unescape View File

@ -220,7 +220,7 @@ class DefaultValueSetter {
public:
explicit DefaultValueSetter(T default_value)
: default_value_(default_value) {}
void operator()(T* value) const { *value = default_value_; }
const T& operator()() const { return default_value_; }
private:
T default_value_;
@ -259,7 +259,7 @@ class EnumInContainer {
// an attribute can have more than one limits
template <typename T>
class TypedAttrChecker {
typedef std::function<void(T*)> DefaultValueChecker;
typedef std::function<const T&()> DefaultValueChecker;
typedef std::function<void(const T&)> ValueChecker;
public:
@ -297,18 +297,17 @@ class TypedAttrChecker {
}
void operator()(AttributeMap* attr_map) const {
if (!attr_map->count(attr_name_)) {
auto it = attr_map->find(attr_name_);
if (it == attr_map->end()) {
// user do not set this attr
PADDLE_ENFORCE(!default_value_setter_.empty(),
"Attribute '%s' is required!", attr_name_);
// default_value_setter_ has no more than one element
T val;
(default_value_setter_[0])(&val);
(*attr_map)[attr_name_] = val;
attr_map->emplace(attr_name_, default_value_setter_[0]());
}
Attribute& attr = attr_map->at(attr_name_);
it = attr_map->find(attr_name_);
ExtractAttribute<T> extract_attr(attr_name_);
T* attr_value = extract_attr(attr);
T* attr_value = extract_attr(it->second);
for (const auto& checker : value_checkers_) {
checker(*attr_value);
}

2
paddle/fluid/framework/data_device_transform_test.cu
Unescape View File

@ -64,7 +64,7 @@ template <typename DeviceContext, typename T>
class TestKernel : public OpKernel<float> {
public:
void Compute(const ExecutionContext& ctx) const {
std::cout << ctx.op().DebugString() << std::endl;
std::cout << ctx.DebugString() << std::endl;
const Tensor* input = ctx.Input<Tensor>("input");

45
paddle/fluid/framework/op_desc.cc
Unescape View File

@ -47,18 +47,16 @@ class CompileTimeInferShapeContext : public InferShapeContext {
AttrReader Attrs() const override;
const std::vector<std::string> &Inputs(
const std::string &name) const override;
std::vector<std::string> Inputs(const std::string &name) const override;
const std::vector<std::string> &Outputs(
const std::string &name) const override;
std::vector<std::string> Outputs(const std::string &name) const override;
void ShareDim(const std::string &in, const std::string &out, size_t i = 0,
size_t j = 0) override {
PADDLE_ENFORCE_LT(i, Inputs(in).size());
PADDLE_ENFORCE_LT(j, Outputs(out).size());
const std::string &input_n = Inputs(in)[i];
const std::string &output_n = Outputs(out)[j];
std::string input_n = Inputs(in)[i];
std::string output_n = Outputs(out)[j];
PADDLE_ENFORCE(input_n != framework::kEmptyVarName, "The %s[%d] is @EMPTY@",
in, i);
@ -74,6 +72,33 @@ class CompileTimeInferShapeContext : public InferShapeContext {
SetDim(output_n, GetDim(input_n));
}
void ShareAllLoD(const std::string &in,
const std::string &out) const override {
auto &in_var_names = op_.Input(in);
auto &out_var_names = op_.Output(out);
PADDLE_ENFORCE_EQ(
in_var_names.size(), out_var_names.size(),
platform::errors::PreconditionNotMet(
"Op [%s]: Input var number shoule be equal with output var number",
op_.Type()));
for (size_t i = 0; i < in_var_names.size(); ++i) {
if (out_var_names[i] == framework::kEmptyVarName) {
continue;
}
auto *in_var = block_.FindVarRecursive(in_var_names[i]);
auto *out_var = block_.FindVarRecursive(out_var_names[i]);
if (in_var->GetType() != proto::VarType::LOD_TENSOR &&
in_var->GetType() != proto::VarType::LOD_TENSOR_ARRAY) {
VLOG(3) << "input " << in << " is not LoDTensor or LoDTensorArray.";
return;
}
out_var->SetLoDLevel(in_var->GetLoDLevel());
}
}
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());
@ -173,7 +198,7 @@ class CompileTimeInferShapeContext : public InferShapeContext {
}
void SetOutputDim(const std::string &name, const DDim &dim) override {
auto &arg_names = Outputs(name);
auto arg_names = Outputs(name);
PADDLE_ENFORCE_EQ(arg_names.size(), 1UL,
"Output(%s) should hold one element, but now it holds %d",
name, arg_names.size());
@ -182,7 +207,7 @@ class CompileTimeInferShapeContext : public InferShapeContext {
void SetOutputsDim(const std::string &name,
const std::vector<DDim> &dims) override {
auto &names = Outputs(name);
auto names = Outputs(name);
SetDims(names, dims);
}
@ -789,12 +814,12 @@ AttrReader CompileTimeInferShapeContext::Attrs() const {
return AttrReader(op_.GetAttrMap());
}
const std::vector<std::string> &CompileTimeInferShapeContext::Inputs(
std::vector<std::string> CompileTimeInferShapeContext::Inputs(
const std::string &name) const {
return op_.Input(name);
}
const std::vector<std::string> &CompileTimeInferShapeContext::Outputs(
std::vector<std::string> CompileTimeInferShapeContext::Outputs(
const std::string &name) const {
return op_.Output(name);
}

4
paddle/fluid/framework/op_registry.cc
Unescape View File

@ -21,9 +21,9 @@ namespace framework {
std::unique_ptr<OperatorBase> OpRegistry::CreateOp(
const std::string& type, const VariableNameMap& inputs,
const VariableNameMap& outputs, AttributeMap attrs) {
const VariableNameMap& outputs, AttributeMap attrs, bool attr_check) {
auto& info = OpInfoMap::Instance().Get(type);
if (info.Checker() != nullptr) {
if (attr_check && info.Checker() != nullptr) {
info.Checker()->Check(&attrs);
}
auto op = info.Creator()(type, inputs, outputs, attrs);

26
paddle/fluid/framework/op_registry.h
Unescape View File

@ -67,10 +67,34 @@ struct OperatorRegistrar : public Registrar {
class OpRegistry {
public:
/**
* @brief Return an OperatorBase constructed by type, inputs, outputs, attrs.
* In dygraph mode, inputs, output, attrs will be set to empty map to
* improve the execution efficiency of dygraph.
* Dygraph mode will use:
* framework::OpRegistry::CreateOp(type, {}, {}, {}, false).
*
* @param[str] type The operator type.
* @param[map] inputs Inputs map of the operator.
* @param[map] outputs Outputs map of the operator.
* @param[unordered_map] attrs Attributes map of the operator.
* @param[bool] attr_check
* Whether do the attribute check before OperatorBase construction.
* Default is true.
* Attr_check is used to control the check of attribute map.
* The check of attribute map have two purposes:
* 1. check whether the attribute item is valid or not.
* 2. add attribute item which has default value
* if it is not in attrs.
* In dygraph mode, attrs is an empty unordered_map,
* attr_check is set to false, otherwise it will be failed
* when check function called.
*/
static std::unique_ptr<OperatorBase> CreateOp(const std::string& type,
const VariableNameMap& inputs,
const VariableNameMap& outputs,
AttributeMap attrs);
AttributeMap attrs,
bool attr_check = true);
static std::unique_ptr<OperatorBase> CreateOp(const proto::OpDesc& op_desc);

82
paddle/fluid/framework/operator.cc
Unescape View File

@ -321,8 +321,14 @@ OperatorBase::OperatorBase(const std::string& type,
attrs_(attrs),
// NOTE(zjl): why op_info may be nullptr?
info_(OpInfoMap::Instance().GetNullable(type)) {
GenerateTemporaryNames();
CheckAllInputOutputSet();
// In dygraph mode, all the OperatorBase will be constructed by function:
// framework::OpRegistry::CreateOp(type, {}, {}, {}, false).
// Inputs, outputs and attrs will be set to empty map
// to improve the execution efficiency of dygraph.
if (inputs_.size() > 0 || outputs_.size() > 0) {
GenerateTemporaryNames();
CheckAllInputOutputSet();
}
}
std::vector<std::string> OperatorBase::InputVars() const {
@ -457,15 +463,14 @@ const Tensor* ExecutionContext::Input<Tensor>(const std::string& name) const {
template <>
const std::vector<const Tensor*> ExecutionContext::MultiInput<Tensor>(
const std::string& name) const {
auto it = ctx_.inputs.find(name);
if (it == ctx_.inputs.end()) {
auto vars = MultiInputVar(name);
if (vars.size() == 0) {
return {};
}
const std::vector<Variable*>& vars = it->second;
std::vector<const Tensor*> res;
res.reserve(vars.size());
std::transform(vars.begin(), vars.end(), std::back_inserter(res),
[&](Variable* var) -> const Tensor* {
[&](const Variable* var) -> const Tensor* {
if (var == nullptr) return nullptr;
PADDLE_ENFORCE(
var->IsType<LoDTensor>(),
@ -484,11 +489,11 @@ Tensor* ExecutionContext::Output<Tensor>(const std::string& name) const {
template <>
std::vector<Tensor*> ExecutionContext::MultiOutput<Tensor>(
const std::string& name) const {
auto it = ctx_.outputs.find(name);
if (it == ctx_.outputs.end()) {
auto vars = MultiOutputVar(name);
if (vars.size() == 0) {
return {};
}
const std::vector<Variable*>& vars = it->second;
std::vector<Tensor*> res;
res.reserve(vars.size());
std::transform(vars.begin(), vars.end(), std::back_inserter(res),
@ -580,13 +585,11 @@ class RuntimeInferShapeContext : public InferShapeContext {
AttrReader Attrs() const override { return AttrReader(op_.Attrs()); }
const std::vector<std::string>& Inputs(
const std::string& name) const override {
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 {
std::vector<std::string> Outputs(const std::string& name) const override {
return op_.Outputs(name);
}
@ -622,6 +625,51 @@ class RuntimeInferShapeContext : public InferShapeContext {
}
}
void ShareAllLoD(const std::string& in,
const std::string& out) const override {
auto in_it = ctx_.inputs.find(in);
auto out_it = ctx_.outputs.find(out);
PADDLE_ENFORCE_NE(in_it, ctx_.inputs.end(),
platform::errors::NotFound(
"Input [%s] found error in Op [%s]", in, op_.Type()));
PADDLE_ENFORCE_NE(
out_it, ctx_.outputs.end(),
platform::errors::NotFound("Output [%s] found error in Op [%s]", out,
op_.Type()));
auto& in_var_list = in_it->second;
auto& out_var_list = out_it->second;
PADDLE_ENFORCE_EQ(
in_var_list.size(), out_var_list.size(),
platform::errors::PreconditionNotMet(
"Op [%s]: Input var size should be equal with ouput var size",
op_.Type()));
auto& out_var_names = op_.Outputs(out);
for (size_t i = 0; i < in_var_list.size(); ++i) {
if (out_var_names[i] == framework::kEmptyVarName) {
continue;
}
Variable* in_var = in_var_list[i];
if (!in_var->IsType<LoDTensor>()) return;
Variable* out_var = out_var_list[i];
PADDLE_ENFORCE_EQ(out_var->IsType<LoDTensor>(), true,
platform::errors::PreconditionNotMet(
"The %d-th output of Output(%s) must be LoDTensor.",
i, out_var_names[i]));
auto& in_tensor = in_var->Get<LoDTensor>();
auto* out_tensor = out_var->GetMutable<LoDTensor>();
out_tensor->set_lod(in_tensor.lod());
#ifdef PADDLE_WITH_MKLDNN
if (in_tensor.layout() != DataLayout::kMKLDNN)
#endif
out_tensor->set_layout(in_tensor.layout());
}
}
void ShareLoD(const std::string& in, const std::string& out, size_t i = 0,
size_t j = 0) const override {
auto in_it = ctx_.inputs.find(in);
@ -1138,7 +1186,7 @@ void OperatorWithKernel::ParseInputDataType(
proto::VarType::Type* data_type) const {
proto::VarType::Type dafault_data_type =
static_cast<proto::VarType::Type>(-1);
const std::vector<const Variable*> vars = ctx.MultiInputVar(name);
const std::vector<Variable*> vars = ctx.MultiInputVar(name);
for (size_t i = 0; i < vars.size(); ++i) {
const Variable* var = vars[i];
if (var != nullptr) {
@ -1156,7 +1204,7 @@ void OperatorWithKernel::ParseInputDataType(
platform::errors::InvalidArgument(
"The Tensor in the %s Op's Input Variable %s(%s) is "
"not initialized.",
Type(), name, ctx.Inputs(name).at(i)));
Type(), name, ctx.InputNames(name).at(i)));
proto::VarType::Type tmp = t->type();
PADDLE_ENFORCE(
tmp == *data_type || *data_type == dafault_data_type,
@ -1177,8 +1225,8 @@ proto::VarType::Type OperatorWithKernel::IndicateDataType(
proto::VarType::Type dafault_data_type =
static_cast<proto::VarType::Type>(-1);
proto::VarType::Type data_type = dafault_data_type;
for (auto& input : ctx.Context().inputs) {
ParseInputDataType(ctx, input.first, &data_type);
for (auto& input : ctx.InNameList()) {
ParseInputDataType(ctx, input, &data_type);
}
PADDLE_ENFORCE_NE(data_type, dafault_data_type,
"DataType should be indicated by input Variable.");

85
paddle/fluid/framework/operator.h
Unescape View File

@ -238,35 +238,57 @@ class ExecutionContext {
device_context_(device_context),
ctx_(ctx),
kernel_configs_(configs) {}
virtual ~ExecutionContext() {}
const OperatorBase& op() const { return op_; }
virtual std::string InputName(const std::string& name) const {
return op_.Input(name);
}
virtual std::vector<std::string> InputNames(const std::string& name) const {
return op_.Inputs(name);
}
virtual std::string OutputName(const std::string& name) const {
return op_.Output(name);
}
virtual std::vector<std::string> OutputNames(const std::string& name) const {
return op_.Outputs(name);
}
virtual bool HasAttr(const std::string& name) const {
return op_.HasAttr(name);
}
virtual const AttributeMap& Attrs() const { return op_.Attrs(); }
const std::string& Type() const { return op_.Type(); }
const Scope& scope() const { return scope_; }
template <typename T>
inline const T& Attr(const std::string& name) const {
return op_.Attr<T>(name);
return boost::get<T>(GetAttr(name));
}
bool HasAttr(const std::string& name) const { return op_.HasAttr(name); }
virtual const Attribute& GetAttr(const std::string& name) const {
return op_.Attrs().at(name);
}
bool HasInput(const std::string& name) const;
virtual bool HasInput(const std::string& name) const;
bool HasOutput(const std::string& name) const;
virtual bool HasOutput(const std::string& name) const;
size_t InputSize(const std::string& name) const {
virtual size_t InputSize(const std::string& name) const {
return op_.Inputs(name).size();
}
size_t OutputSize(const std::string& name) const {
virtual size_t OutputSize(const std::string& name) const {
return op_.Outputs(name).size();
}
const Variable* InputVar(const std::string& name) const;
virtual const Variable* InputVar(const std::string& name) const;
Variable* OutputVar(const std::string& name) const;
virtual Variable* OutputVar(const std::string& name) const;
const std::vector<const Variable*> MultiInputVar(
virtual const std::vector<Variable*> MultiInputVar(
const std::string& name) const {
auto it = ctx_.inputs.find(name);
if (it == ctx_.inputs.end()) {
@ -275,8 +297,7 @@ class ExecutionContext {
return {it->second.begin(), it->second.end()};
}
std::vector<Variable*> MultiOutputVar(const std::string& name) const {
auto names = op_.Outputs(name);
virtual std::vector<Variable*> MultiOutputVar(const std::string& name) const {
auto it = ctx_.outputs.find(name);
if (it == ctx_.outputs.end()) {
return {};
@ -284,6 +305,17 @@ class ExecutionContext {
return it->second;
}
virtual std::vector<std::string> InNameList() const {
std::vector<std::string> vec_temp;
vec_temp.reserve(ctx_.inputs.size());
for (auto& input : ctx_.inputs) {
vec_temp.push_back(input.first);
}
return vec_temp;
}
template <typename T>
const T* Input(const std::string& name) const {
auto* var = InputVar(name);
@ -298,15 +330,14 @@ class ExecutionContext {
template <typename T>
const std::vector<const T*> MultiInput(const std::string& name) const {
auto it = ctx_.inputs.find(name);
if (it == ctx_.inputs.end()) {
auto vars = MultiInputVar(name);
if (vars.size() == 0) {
return {};
}
const std::vector<Variable*>& vars = it->second;
std::vector<const T*> res;
res.reserve(vars.size());
std::transform(vars.begin(), vars.end(), std::back_inserter(res),
[&](Variable* var) -> const T* {
[&](const Variable* var) -> const T* {
return var == nullptr ? nullptr : &var->Get<T>();
});
return res;
@ -314,17 +345,19 @@ class ExecutionContext {
template <typename T>
std::vector<T*> MultiOutput(const std::string& name) const {
auto it = ctx_.outputs.find(name);
if (it == ctx_.outputs.end()) {
auto vars = MultiOutputVar(name);
if (vars.size() == 0) {
return {};
}
const std::vector<Variable*>& vars = it->second;
std::vector<T*> res;
res.reserve(vars.size());
std::transform(vars.begin(), vars.end(), std::back_inserter(res),
[&](Variable* var) -> T* {
return var == nullptr ? nullptr : var->GetMutable<T>();
});
return res;
}
@ -347,16 +380,6 @@ class ExecutionContext {
}
#endif
//! Get actual name vector for this input.
const std::vector<std::string>& Inputs(const std::string& name) const {
return op_.Inputs(name);
}
//! Get actual name vector for this output.
const std::vector<std::string>& Outputs(const std::string& name) const {
return op_.Outputs(name);
}
template <typename T, typename DevContext>
Tensor AllocateTmpTensor(const framework::DDim& dim,
const DevContext& dev_ctx) const {
@ -385,7 +408,9 @@ class ExecutionContext {
return *boost::get<std::shared_ptr<T>>((*kernel_configs_)[idx]);
}
const RuntimeContext& Context() const { return ctx_; }
const RuntimeContext Context() const { return ctx_; }
std::string DebugString() const { return op_.DebugString(); }
private:
const OperatorBase& op_;

53
paddle/fluid/framework/operator_test.cc
Unescape View File

@ -135,10 +135,10 @@ template <typename T1, typename T2>
class CPUKernelTest : public OpKernel<float> {
public:
void Compute(const ExecutionContext& ctx) const {
std::cout << ctx.op().DebugString() << std::endl;
std::cout << ctx.DebugString() << std::endl;
cpu_kernel_run_num++;
ASSERT_EQ(ctx.op().Input("x"), "IN1");
ASSERT_EQ(ctx.op().Output("y"), "OUT1");
ASSERT_EQ(ctx.InputName("x"), "IN1");
ASSERT_EQ(ctx.OutputName("y"), "OUT1");
}
};
@ -146,10 +146,10 @@ template <typename T1, typename T2>
class CPUKernel2Test : public OpKernel<float> {
public:
void Compute(const ExecutionContext& ctx) const {
std::cout << ctx.op().DebugString() << std::endl;
std::cout << ctx.DebugString() << std::endl;
cpu_kernel2_run_num++;
ASSERT_EQ(ctx.op().Input("x"), "IN1");
ASSERT_EQ(ctx.op().Output("y"), "OUT1");
ASSERT_EQ(ctx.InputName("x"), "IN1");
ASSERT_EQ(ctx.OutputName("y"), "OUT1");
}
};
@ -172,7 +172,7 @@ class OpKernelTestMultiInputsProtoAndCheckerMaker
class CPUKernalMultiInputsTest : public OpKernel<float> {
public:
void Compute(const ExecutionContext& ctx) const {
auto xs = ctx.op().Inputs("xs");
auto xs = ctx.InputNames("xs");
ASSERT_EQ(xs.size(), 3UL);
ASSERT_EQ(xs[0], "x0");
ASSERT_EQ(xs[1], "x1");
@ -196,10 +196,10 @@ class CPUKernalMultiInputsTest : public OpKernel<float> {
auto outTensor0 = ctx.MultiOutput<Tensor>("ys");
ASSERT_EQ(outTensor0.size(), 2U);
auto k = ctx.op().Input("k");
auto k = ctx.InputName("k");
ASSERT_EQ(k, "k0");
auto ys = ctx.op().Outputs("ys");
auto ys = ctx.OutputNames("ys");
ASSERT_EQ(ys.size(), 2UL);
ASSERT_EQ(ys[0], "y0");
ASSERT_EQ(ys[1], "y1");
@ -496,6 +496,41 @@ TEST(IndicateVarDataTypeTest, other) {
ASSERT_TRUE(caught);
}
TEST(ExecutionContextAttrAndInOut, new_api) {
paddle::framework::InitDevices(true);
paddle::framework::proto::OpDesc op_desc;
op_desc.set_type("test_operator");
BuildVar("input", {"IN1"}, op_desc.add_inputs());
BuildVar("output", {"OUT1"}, op_desc.add_outputs());
auto attr = op_desc.mutable_attrs()->Add();
attr->set_name("scale");
attr->set_type(paddle::framework::proto::AttrType::FLOAT);
attr->set_f(3.14);
paddle::platform::CPUPlace cpu_place;
paddle::framework::Scope scope;
auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
auto* var = scope.Var("OUT1");
var->GetMutable<paddle::framework::LoDTensorArray>();
paddle::platform::DeviceContextPool& pool =
paddle::platform::DeviceContextPool::Instance();
auto* dev_ctx = pool.Get(cpu_place);
paddle::framework::RuntimeContext ctx({}, {});
paddle::framework::ExecutionContext exe_context(*(op.get()), scope, *dev_ctx,
ctx, nullptr);
ASSERT_EQ(exe_context.InputSize("input"), 1u);
ASSERT_EQ(exe_context.OutputSize("output"), 1u);
auto attr_map = exe_context.Attrs();
ASSERT_EQ(boost::get<float>(attr_map["scale"]), 3.14f);
ASSERT_EQ(exe_context.Type(), "test_operator");
}
namespace paddle {
namespace framework {

10
paddle/fluid/framework/shape_inference.h
Unescape View File

@ -54,16 +54,18 @@ class InferShapeContext {
const std::vector<DDim> &dims);
virtual AttrReader Attrs() const = 0;
virtual const std::vector<std::string> &Inputs(
const std::string &name) const = 0;
virtual const std::vector<std::string> &Outputs(
const std::string &name) const = 0;
virtual std::vector<std::string> Inputs(const std::string &name) const = 0;
virtual std::vector<std::string> Outputs(const std::string &name) const = 0;
virtual void ShareDim(const std::string &in, const std::string &out,
size_t i = 0, size_t j = 0) = 0;
virtual void ShareLoD(const std::string &in, const std::string &out,
size_t i = 0, size_t j = 0) const = 0;
// share the lod information of all the tensor from in to out.
// out_vars[i].lod = in_vars[i].lod
virtual void ShareAllLoD(const std::string &in,
const std::string &out) const = 0;
virtual int32_t GetLoDLevel(const std::string &in, size_t i = 0) const = 0;

6
paddle/fluid/imperative/engine.cc
Unescape View File

@ -152,8 +152,6 @@ void BasicEngine::PrepareDeps() {
q.pop();
VLOG(3) << "Checking grads of op " << cur_op->Type();
CheckBackwardInputs(cur_op);
SetBackwardOutputs(cur_op);
PrepareGradAccumulators(cur_op);
@ -189,6 +187,9 @@ void BasicEngine::Execute() {
OpBase* cur_op = q.front();
q.pop();
// CheckBackWardInput
CheckBackwardInputs(cur_op);
// Step 1: Run Backward
auto& bwd_ins = cur_op->GetInsMap();
auto& bwd_outs = cur_op->GetOutsMap();
@ -210,7 +211,6 @@ void BasicEngine::Execute() {
}
}
}
VLOG(3) << "Start to execute grad op " << cur_op->Type();
RunOp(cur_op, bwd_ins, tmp_outs, cur_op->place());
// Step 2: Sum Gradient

33
paddle/fluid/imperative/layer.cc
Unescape View File

@ -190,6 +190,7 @@ void VarBase::AddGradOps(const std::weak_ptr<OpBase>& op) {
void VarBase::ClearGradient() {
if (grad_var_) {
auto* grad_t = grad_var_->var_.GetMutable<framework::LoDTensor>();
if (grad_t->IsInitialized()) {
auto* dev_ctx =
platform::DeviceContextPool::Instance().Get(grad_t->place());
@ -241,18 +242,9 @@ OpBase::OpBase(size_t id, const std::string& type, const NameVarBaseMap& ins,
info.Checker()->Check(&attrs_);
}
auto input_name_map = CreateVarNameMap(info, type, ins, true);
auto output_name_map = CreateVarNameMap(info, type, outs, false);
op_ = framework::OpRegistry::CreateOp(type, std::move(input_name_map),
std::move(output_name_map), attrs);
VLOG(3) << "Construct Op: " << type << std::endl;
}
op_ = framework::OpRegistry::CreateOp(type, {}, {}, {}, false);
// create OpBase from opdesc
OpBase::OpBase(size_t id, const framework::OpDesc& op_desc,
const platform::Place& place)
: id_(id), op_(framework::OpRegistry::CreateOp(op_desc)), place_(place) {
VLOG(3) << "Construct Op: " << op_desc.Type() << std::endl;
VLOG(3) << "Construct Op: " << type << std::endl;
}
void OpBase::CreateOperatorBase() {
@ -260,11 +252,7 @@ void OpBase::CreateOperatorBase() {
if (info.Checker() != nullptr) {
info.Checker()->Check(&attrs_);
}
auto input_name_map = CreateVarNameMap(info, type_, ins_, true);
auto output_name_map = CreateVarNameMap(info, type_, outs_, false);
op_ = framework::OpRegistry::CreateOp(type_, std::move(input_name_map),
std::move(output_name_map), attrs_);
op_ = framework::OpRegistry::CreateOp(type_, {}, {}, {}, false);
}
void OpBase::Run(const NameVarBaseMap& ins, const NameVarBaseMap& outs) {
@ -272,10 +260,9 @@ void OpBase::Run(const NameVarBaseMap& ins, const NameVarBaseMap& outs) {
PADDLE_ENFORCE_NOT_NULL(op_kernel, "only support op with kernel");
auto& info = op_->Info();
if (info.infer_var_type_) {
RuntimeInferVarTypeContext infer_var_type_ctx(ins, &outs, op_->Attrs());
RuntimeInferVarTypeContext infer_var_type_ctx(ins, &outs, attrs_);
info.infer_var_type_(&infer_var_type_ctx);
}
// Initialize output var type
for (auto& var_pair : outs) {
for (auto& var : var_pair.second) {
@ -285,13 +272,11 @@ void OpBase::Run(const NameVarBaseMap& ins, const NameVarBaseMap& outs) {
VLOG(3) << "Running Op " << Type();
VLOG(5) << LayerDebugString(Type(), ins, outs);
auto runtime_ctx = PrepareRuntimeContext(ins, outs);
VLOG(6) << "start preparing op: " << Type();
auto prepared_op = PreparedOp::Prepare(runtime_ctx, *op_kernel, place(), ins);
framework::RuntimeContext runtime_ctx({}, {});
auto prepared_op =
PreparedOp::Prepare(ins, outs, *op_kernel, place(), &attrs_);
VLOG(6) << "finish preparing op: " << Type();
prepared_op.Run();
prepared_op.Run(&ins, &outs, &attrs_);
VLOG(4) << LayerDebugString(Type(), ins, outs);
}

476
paddle/fluid/imperative/layer.h
View File

File diff suppressed because it is too large Load Diff

28
paddle/fluid/imperative/prepared_operator.cc
Unescape View File

@ -70,10 +70,11 @@ PreparedOp::PreparedOp(const framework::OperatorBase& op,
dev_ctx_(dev_ctx),
kernel_configs_(kernel_configs) {}
PreparedOp PreparedOp::Prepare(const framework::RuntimeContext& ctx,
PreparedOp PreparedOp::Prepare(const NameVarBaseMap& ins,
const NameVarBaseMap& outs,
const framework::OperatorWithKernel& op,
platform::Place place,
const NameVarBaseMap& ins) {
const framework::AttributeMap* attrs) {
platform::DeviceContextPool& pool = platform::DeviceContextPool::Instance();
auto* dev_ctx = pool.Get(place);
@ -88,9 +89,9 @@ PreparedOp PreparedOp::Prepare(const framework::RuntimeContext& ctx,
auto& kernels = kernels_iter->second;
auto expected_kernel_key =
op.GetExpectedKernelType(framework::ExecutionContext(
op, framework::Scope(), *dev_ctx, ctx, nullptr));
framework::RuntimeContext ctx({}, {});
auto expected_kernel_key = op.GetExpectedKernelType(DygraphExecutionContext(
op, framework::Scope(), *dev_ctx, ctx, nullptr, ins, outs, attrs));
VLOG(3) << "expected_kernel_key:" << expected_kernel_key;
auto kernel_iter = kernels.find(expected_kernel_key);
@ -111,13 +112,20 @@ PreparedOp PreparedOp::Prepare(const framework::RuntimeContext& ctx,
return PreparedOp(op, ctx, kernel_iter->second, dev_ctx, kernel_configs);
}
void PreparedOp::Run() {
void PreparedOp::Run(const NameVarBaseMap* in, const NameVarBaseMap* out,
const framework::AttributeMap* attrs) {
// TODO(zjl): remove scope in dygraph
framework::Scope scope;
op_.RuntimeInferShape(scope, dev_ctx_->GetPlace(), ctx_);
VLOG(6) << "Finish Runtime infer shape";
func_(framework::ExecutionContext(op_, scope, *dev_ctx_, ctx_,
kernel_configs_));
DygraphInferShapeContext infer_shape_ctx(in, out, attrs);
framework::OperatorWithKernel* op_ker =
(framework::OperatorWithKernel*)(&op_);
op_ker->InferShape(&infer_shape_ctx);
func_(DygraphExecutionContext(op_, scope, *dev_ctx_, ctx_, kernel_configs_,
*in, *out, attrs));
}
} // namespace imperative

9
paddle/fluid/imperative/prepared_operator.h
Unescape View File

@ -30,13 +30,16 @@ const framework::Tensor* GetTensorFromVar(const framework::Variable& var);
class PreparedOp {
public:
static PreparedOp Prepare(const framework::RuntimeContext& ctx,
static PreparedOp Prepare(const NameVarBaseMap& ins,
const NameVarBaseMap& outs,
const framework::OperatorWithKernel& op,
platform::Place place, const NameVarBaseMap& ins);
platform::Place place,
const framework::AttributeMap* attrs);
inline platform::DeviceContext* GetDeviceContext() const { return dev_ctx_; }
void Run();
void Run(const NameVarBaseMap* in, const NameVarBaseMap* out,
const framework::AttributeMap* attrs);
static void PrepareData(const platform::Place& place,
const NameVarBaseMap& ins,

61
paddle/fluid/imperative/tests/test_layer.cc
Unescape View File

@ -148,6 +148,67 @@ TEST(test_layer, test_varbase_basic) {
}
// TODO(jiabin): Add more ut here for layer
TEST(test_layer, test_dygraph_execution_context) {
std::shared_ptr<imperative::VarBase> vin(
new imperative::VarBase(false, "vin"));
std::shared_ptr<imperative::VarBase> vout(
new imperative::VarBase(false, "vout"));
framework::OpDesc desc;
platform::CPUPlace place;
var_pair x_pair = var_pair("X", vb_vector(1, vin));
var_pair y_pair = var_pair("Y", vb_vector(1, vin));
var_pair out_pair = var_pair("Out", vb_vector(1, vout));
imperative::NameVarBaseMap ins = {x_pair, y_pair};
imperative::NameVarBaseMap outs = {out_pair};
framework::AttributeMap concat_att_map;
concat_att_map["axis"] = 1;
auto op = framework::OpRegistry::CreateOp("mul", {}, {}, {}, false);
paddle::platform::CPUPlace cpu_place;
paddle::platform::DeviceContextPool& pool =
paddle::platform::DeviceContextPool::Instance();
auto* dev_ctx = pool.Get(cpu_place);
paddle::framework::RuntimeContext ctx({}, {});
framework::Scope scope;
DygraphExecutionContext dy_exe_context(*(op.get()), scope, *dev_ctx, ctx,
nullptr, ins, outs, &concat_att_map);
ASSERT_EQ(dy_exe_context.InputSize("X"), 1u);
ASSERT_EQ(dy_exe_context.InputName("X"), "vin");
ASSERT_EQ(dy_exe_context.HasAttr("axis"), true);
auto attr_map = dy_exe_context.Attrs();
ASSERT_EQ(boost::get<int>(attr_map["axis"]), 1);
ASSERT_EQ(dy_exe_context.OutputSize("Out"), 1u);
ASSERT_EQ(dy_exe_context.HasOutput("Out"), true);
}
TEST(test_layer, test_dygraph_infershape_context) {
std::shared_ptr<imperative::VarBase> vin(
new imperative::VarBase(false, "vin"));
std::shared_ptr<imperative::VarBase> vout(
new imperative::VarBase(false, "vout"));
framework::OpDesc desc;
platform::CPUPlace place;
var_pair x_pair = var_pair("X", vb_vector(1, vin));
var_pair y_pair = var_pair("Y", vb_vector(1, vin));
var_pair out_pair = var_pair("Out", vb_vector(1, vout));
imperative::NameVarBaseMap ins = {x_pair, y_pair};
imperative::NameVarBaseMap outs = {out_pair};
framework::AttributeMap concat_att_map;
concat_att_map["axis"] = 1;
DygraphInferShapeContext infer_shape_ctx(&ins, &outs, &concat_att_map);
bool have_x = infer_shape_ctx.HasOutputs("Out");
ASSERT_EQ(have_x, true);
bool have_z = infer_shape_ctx.HasOutputs("Z");
ASSERT_EQ(have_z, false);
}
} // namespace imperative
} // namespace paddle

10
paddle/fluid/imperative/tests/test_prepare_op.cc
Unescape View File

@ -110,8 +110,8 @@ TEST(test_prepare_op, test_prepare_op) {
framework::OperatorWithKernel op("split", var_in_map, var_out_map,
split_attr_map);
framework::RuntimeContext ctx = PrepareRuntimeContext(ins, outs);
ASSERT_NO_FATAL_FAILURE(PreparedOp preparedOp =
PreparedOp::Prepare(ctx, op, place, ins));
ASSERT_NO_FATAL_FAILURE(PreparedOp preparedOp = PreparedOp::Prepare(
ins, outs, op, place, &split_attr_map));
}
const framework::Tensor* GetTensorFromVar(const framework::Variable& var);
@ -158,7 +158,8 @@ TEST(test_prepare_op, test_prepare_data) {
framework::RuntimeContext ctx = PrepareRuntimeContext(ins, outs);
// test if it can be transformed to GPU place
PreparedOp prepared_op = PreparedOp::Prepare(ctx, assign_op, gpu_place, ins);
PreparedOp prepared_op =
PreparedOp::Prepare(ins, outs, assign_op, gpu_place, &assign_attr_map);
for (const auto& name_pair : ins) {
for (const auto& vb : name_pair.second) {
ASSERT_TRUE(platform::is_same_place(
@ -201,7 +202,8 @@ TEST(test_prepare_op, test_prepare_data_same_place) {
framework::RuntimeContext ctx = PrepareRuntimeContext(ins, outs);
// test if it never transfered on GPU place
PreparedOp prepared_op = PreparedOp::Prepare(ctx, assign_op, cpu_place, ins);
PreparedOp prepared_op =
PreparedOp::Prepare(ins, outs, assign_op, cpu_place, &assign_attr_map);
for (const auto& name_pair : ins) {
for (const auto& vb : name_pair.second) {
ASSERT_TRUE(platform::is_same_place(

3
paddle/fluid/imperative/tracer.cc
Unescape View File

@ -82,10 +82,9 @@ static void PassStopGradient(const NameVarBaseMap& outs, bool generate_grad) {
void Tracer::TraceOp(const std::string& type, const NameVarBaseMap& ins,
const NameVarBaseMap& outs, framework::AttributeMap attrs,
const platform::Place& place, bool trace_backward) {
platform::RecordEvent event(type);
VLOG(1) << "Trace Op: " << type;
size_t op_id = GenerateUniqueId();
auto op = OpBase::Create(op_id, type, ins, outs, std::move(attrs), place);
auto op = OpBase::Create(op_id, type, ins, outs, attrs, place);
op->Run(ins, outs);
if (enable_program_desc_tracing_) {

56
paddle/fluid/operators/activation_op.h
Unescape View File

@ -62,11 +62,11 @@ inline void ExtractActivationTensor(const framework::ExecutionContext& context,
auto out_var = context.OutputVar("Out");
PADDLE_ENFORCE(x_var != nullptr,
"Cannot get input Variable X, variable name = %s",
context.op().Input("X"));
context.InputName("X"));
PADDLE_ENFORCE(out_var != nullptr,
"Cannot get output Variable Out, variable name = %s",
context.op().Output("Out"));
if (CanBeUsedBySelectedRows.count(context.op().Type())) {
context.OutputName("Out"));
if (CanBeUsedBySelectedRows.count(context.Type())) {
*X = paddle::framework::GetLoDTensorOrSelectedRowsValueFromVar(*x_var);
*Out = paddle::framework::GetMutableLoDTensorOrSelectedRowsValueFromVar(
out_var);
@ -77,7 +77,7 @@ inline void ExtractActivationTensor(const framework::ExecutionContext& context,
PADDLE_ENFORCE(*Out != nullptr,
"Cannot get output tensor Out, variable name = %s",
context.op().Output("Out"));
context.OutputName("Out"));
}
template <ActBwdOpFwdDeps kDepValue>
@ -93,18 +93,18 @@ inline void ExtractActivationGradTensor(
out_var = context.InputVar("Out");
PADDLE_ENFORCE(out_var != nullptr,
"Cannot get input Variable Out, variable name = %s",
context.op().Input("Out"));
context.InputName("Out"));
}
PADDLE_ENFORCE(out_grad_var != nullptr,
"Cannot get input Variable %s, variable name = %s",
framework::GradVarName("Out"),
context.op().Input(framework::GradVarName("Out")));
context.InputName(framework::GradVarName("Out")));
PADDLE_ENFORCE(x_grad_var != nullptr,
"Cannot get output Variable %s, variable name = %s",
framework::GradVarName("X"),
context.op().Output(framework::GradVarName("X")));
context.OutputName(framework::GradVarName("X")));
if (CanBeUsedBySelectedRows.count(context.op().Type())) {
if (CanBeUsedBySelectedRows.count(context.Type())) {
*dOut = paddle::framework::GetLoDTensorOrSelectedRowsValueFromVar(
*out_grad_var);
*dX = paddle::framework::GetMutableLoDTensorOrSelectedRowsValueFromVar(
@ -132,20 +132,20 @@ inline void ExtractActivationGradTensor(
PADDLE_ENFORCE(*dX != nullptr,
"Cannot get output tensor %s, variable name = %s",
framework::GradVarName("X"),
context.op().Output(framework::GradVarName("X")));
context.OutputName(framework::GradVarName("X")));
if (static_cast<int>(kDepValue) & static_cast<int>(kDepX)) {
auto x_var = context.InputVar("X");
PADDLE_ENFORCE(x_var != nullptr,
"Cannot get input tensor X, variable name = %s",
context.op().Input("X"));
if (CanBeUsedBySelectedRows.count(context.op().Type())) {
context.InputName("X"));
if (CanBeUsedBySelectedRows.count(context.Type())) {
*X = paddle::framework::GetLoDTensorOrSelectedRowsValueFromVar(*x_var);
} else {
*X = context.Input<framework::Tensor>("X");
}
} else {
VLOG(10) << " Inplace activation of Op : " << context.op().Type();
VLOG(10) << " Inplace activation of Op : " << context.Type();
*X = *dX;
}
}
@ -1273,8 +1273,8 @@ inline void ExtractActivationDoubleGradTensor(
auto ddo_var = ctx.OutputVar("DDOut");
PADDLE_ENFORCE(ddx_var != nullptr,
"Cannot get input Variable Out, variable name = %s",
ctx.op().Input("DDX"));
if (CanBeUsedBySelectedRows.count(ctx.op().Type())) {
ctx.InputName("DDX"));
if (CanBeUsedBySelectedRows.count(ctx.Type())) {
*ddX = paddle::framework::GetLoDTensorOrSelectedRowsValueFromVar(*ddx_var);
if (ddo_var) {
*ddOut = paddle::framework::GetMutableLoDTensorOrSelectedRowsValueFromVar(
@ -1288,15 +1288,15 @@ inline void ExtractActivationDoubleGradTensor(
}
PADDLE_ENFORCE(*ddX != nullptr,
"Cannot get output tensor DDX, variable name = %s",
ctx.op().Output("DDX"));
ctx.OutputName("DDX"));
if (static_cast<int>(kDepValue) & static_cast<int>(kDepX)) {
auto x_var = ctx.InputVar("X");
PADDLE_ENFORCE(x_var != nullptr,
"Cannot get input Variable Out, variable name = %s",
ctx.op().Input("X"));
ctx.InputName("X"));
auto dx_var = ctx.OutputVar("DX");
if (CanBeUsedBySelectedRows.count(ctx.op().Type())) {
if (CanBeUsedBySelectedRows.count(ctx.Type())) {
*X = paddle::framework::GetLoDTensorOrSelectedRowsValueFromVar(*x_var);
if (dx_var) {
*dX = paddle::framework::GetMutableLoDTensorOrSelectedRowsValueFromVar(
@ -1309,16 +1309,16 @@ inline void ExtractActivationDoubleGradTensor(
}
}
} else {
VLOG(10) << "Inplace activation of Op: " << ctx.op().Type();
VLOG(10) << "Inplace activation of Op: " << ctx.Type();
*X = *ddX;
}
if (static_cast<int>(kDepValue) & static_cast<int>(kDepOut)) {
auto out_var = ctx.InputVar("Out");
PADDLE_ENFORCE(out_var != nullptr,
"Cannot get input tensor Out, variable name = %s",
ctx.op().Input("Out"));
ctx.InputName("Out"));
auto dout_var = ctx.OutputVar("DOut");
if (CanBeUsedBySelectedRows.count(ctx.op().Type())) {
if (CanBeUsedBySelectedRows.count(ctx.Type())) {
*Out =
paddle::framework::GetLoDTensorOrSelectedRowsValueFromVar(*out_var);
if (dout_var) {
@ -1333,7 +1333,7 @@ inline void ExtractActivationDoubleGradTensor(
}
}
} else {
VLOG(10) << "Inplace activation of Op: " << ctx.op().Type();
VLOG(10) << "Inplace activation of Op: " << ctx.Type();
*Out = *ddX;
}
}
@ -1471,20 +1471,20 @@ inline void ExtractDoubleGradTensorWithInputDOut(
auto ddo_var = ctx.OutputVar("DDOut");
PADDLE_ENFORCE(ddx_var != nullptr,
"Cannot get input Variable Out, variable name = %s",
ctx.op().Input("DDX"));
ctx.InputName("DDX"));
*ddX = ctx.Input<framework::Tensor>("DDX");
if (ddo_var) {
*ddOut = ctx.Output<framework::Tensor>("DDOut");
}
PADDLE_ENFORCE(*ddX != nullptr,
"Cannot get output tensor DDX, variable name = %s",
ctx.op().Output("DDX"));
ctx.OutputName("DDX"));
// extract x(input), dx(output)
auto x_var = ctx.InputVar("X");
PADDLE_ENFORCE(x_var != nullptr,
"Cannot get input Variable Out, variable name = %s",
ctx.op().Input("X"));
ctx.InputName("X"));
auto dx_var = ctx.OutputVar("DX");
*X = ctx.Input<framework::Tensor>("X");
if (dx_var) {
@ -1537,20 +1537,20 @@ class SqrtDoubleGradKernel
auto ddo_var = ctx.OutputVar("DDOut");
PADDLE_ENFORCE(ddx_var != nullptr,
"Cannot get input Variable DDX, variable name = %s",
ctx.op().Input("DDX"));
ctx.InputName("DDX"));
ddX = ctx.Input<framework::Tensor>("DDX");
if (ddo_var) {
ddOut = ctx.Output<framework::Tensor>("DDOut");
}
PADDLE_ENFORCE(ddX != nullptr,
"Cannot get input Variable DDX, variable name = %s",
ctx.op().Input("DDX"));
ctx.InputName("DDX"));
// extract out(input), dout(output)
auto out_var = ctx.InputVar("Out");
PADDLE_ENFORCE(out_var != nullptr,
"Cannot get input Variable Out, variable name = %s",
ctx.op().Input("Out"));
ctx.InputName("Out"));
auto dout_var = ctx.OutputVar("DOut");
Out = ctx.Input<framework::Tensor>("Out");
if (dout_var) {
@ -1561,7 +1561,7 @@ class SqrtDoubleGradKernel
auto dx_var = ctx.InputVar("DX");
PADDLE_ENFORCE(dx_var != nullptr,
"Cannot get input Variable DX, variable name = %s",
ctx.op().Input("DX"));
ctx.InputName("DX"));
if (dx_var) {
dX = ctx.Input<framework::Tensor>("DX");
}

4
paddle/fluid/operators/coalesce_tensor_op.cc
Unescape View File

@ -27,8 +27,8 @@ template <typename DeviceContext, typename T>
class CoalesceTensorOpKernel : public framework::OpKernel<T> {
public:
void Compute(const framework::ExecutionContext &context) const override {
auto &in_var_names = context.Inputs("Input");
auto &out_var_names = context.Outputs("Output");
auto in_var_names = context.InputNames("Input");
auto out_var_names = context.OutputNames("Output");
auto &in_vars = context.MultiInputVar("Input");
auto out_vars = context.MultiOutputVar("Output");

18
paddle/fluid/operators/concat_op.cc
Unescape View File

@ -32,6 +32,7 @@ class ConcatOp : public framework::OperatorWithKernel {
void InferShape(framework::InferShapeContext *ctx) const override {
PADDLE_ENFORCE_GE(ctx->Inputs("X").size(), 1UL,
"Inputs(X) of ConcatOp should not be empty.");
PADDLE_ENFORCE_EQ(ctx->HasOutput("Out"), true,
"Output(Out) of ConcatOp should not be null.");
@ -152,17 +153,8 @@ class ConcatOpGrad : public framework::OperatorWithKernel {
auto in_x = "X";
auto out_x_g_n = framework::GradVarName(in_x);
ctx->SetOutputsDim(out_x_g_n, ctx->GetInputsDim(in_x));
auto &in_names = ctx->Inputs(in_x);
auto &out_names = ctx->Outputs(out_x_g_n);
PADDLE_ENFORCE_EQ(
in_names.size(), out_names.size(),
"The number of arguments in %s[%d] and %s[%d] is not equal.", in_x,
in_names.size(), out_x_g_n, out_names.size());
for (size_t i = 0; i < in_names.size(); ++i) {
if (out_names[i] != framework::kEmptyVarName) {
ctx->ShareLoD(in_x, out_x_g_n, i, i);
}
}
ctx->ShareAllLoD(in_x, out_x_g_n);
}
protected:
@ -197,7 +189,9 @@ class ConcatGradOpMaker : public framework::SingleGradOpMaker<T> {
std::unique_ptr<T> op(new T());
op->SetType("concat_grad");
op->SetInput("X", this->Input("X"));
op->SetInput("AxisTensor", this->Input("AxisTensor"));
if (this->HasInput("AxisTensor")) {
op->SetInput("AxisTensor", this->Input("AxisTensor"));
}
op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out"));
op->SetOutput(framework::GradVarName("X"), this->InputGrad("X", false));
op->SetAttrMap(this->Attrs());

2
paddle/fluid/operators/concat_op.h
Unescape View File

@ -139,7 +139,7 @@ class ConcatGradKernel : public framework::OpKernel<T> {
auto* out_grad =
ctx.Input<framework::Tensor>(framework::GradVarName("Out"));
auto ins = ctx.MultiInput<framework::LoDTensor>("X");
auto out_var_names = ctx.Outputs(framework::GradVarName("X"));
auto out_var_names = ctx.OutputNames(framework::GradVarName("X"));
auto outs =
ctx.MultiOutput<framework::LoDTensor>(framework::GradVarName("X"));

2
paddle/fluid/operators/conv_op.h
Unescape View File

@ -665,7 +665,7 @@ class GemmConvDoubleGradKernel : public framework::OpKernel<T> {
Tensor* dX = ctx.Output<Tensor>("DInput");
Tensor W = detail::Ref(ctx.Input<Tensor>("Filter"),
"Cannot find input Filter(%s) in scope)",
ctx.Inputs("Filter")[0]);
ctx.InputNames("Filter")[0]);
if (!ddY && !dW && !dX) return;
const int groups = ctx.Attr<int>("groups");

2
paddle/fluid/operators/cudnn_lstm_op.cu.cc
Unescape View File

@ -62,7 +62,7 @@ class CudnnLSTMGPUKernel : public framework::OpKernel<T> {
// multi-devices before the first running.
// use parent scope to make cache persistable
auto *scope = const_cast<framework::Scope *>(ctx.scope().parent());
auto cache_var_name = ctx.Inputs("Cache")[0];
auto cache_var_name = ctx.InputNames("Cache")[0];
cache_var = scope->Var(cache_var_name);
}
CudnnRNNCache *cudnn_rnn_cache = nullptr;

4
paddle/fluid/operators/cum_op.h
Unescape View File

@ -31,11 +31,11 @@ class CumKernel : public framework::OpKernel<typename Functor::ELEMENT_TYPE> {
void Compute(const framework::ExecutionContext& context) const override {
auto& X = detail::Ref(context.Input<framework::Tensor>("X"),
"Cannot get input tensor X, variable name = %s",
context.op().Input("X"));
context.InputName("X"));
auto& Out = detail::Ref(context.Output<framework::Tensor>("Out"),
"Cannot get output tensor Out, variable name = %s",
context.op().Output("Out"));
context.OutputName("Out"));
int axis = context.Attr<int>("axis");
bool exclusive = context.Attr<bool>("exclusive");
bool reverse = context.Attr<bool>("reverse");

4
paddle/fluid/operators/detection/generate_proposals_op.cc
Unescape View File

@ -295,10 +295,10 @@ class GenerateProposalsKernel : public framework::OpKernel<T> {
auto *im_info = context.Input<Tensor>("ImInfo");
auto anchors = detail::Ref(context.Input<Tensor>("Anchors"),
"Cannot find input Anchors(%s) in scope",
context.Inputs("Anchors")[0]);
context.InputNames("Anchors")[0]);
auto variances = detail::Ref(context.Input<Tensor>("Variances"),
"Cannot find input Variances(%s) in scope",
context.Inputs("Variances")[0]);
context.InputNames("Variances")[0]);
auto *rpn_rois = context.Output<LoDTensor>("RpnRois");
auto *rpn_roi_probs = context.Output<LoDTensor>("RpnRoiProbs");

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save